Apuntes

Apuntes de un
curso de
PROGRAMACIÓN Y
MÉTODOS
NUMÉRICOS
José Rogan C.
Víctor Muñoz G.
EDICIÓN 2009
Solo con fines educativos

Departamento de Fı́sica, Facultad de Ciencias, Universidad de Chile.
Las Palmeras 3425, Ñuñoa. Casilla 653, Correo 1, Santiago
fono: 562 978 7276 fax: 562 271 2973
e-mail: secretaria@fisica.ciencias.uchile.cl
Apuntes de un curso de
PROGRAMACIÓN Y MÉTODOS
NUMÉRICOS
Novena edición, revisión 090924-02
José Rogan C.
Vı́ctor Muñoz G.
ii
Agradecimientos:
Xavier Andrade.
Denisse Pastén.
De la promoción del 2004 a: Daniel Asenjo y Max Ramı́rez.
De la promoción del 2005 a: Alejandro Varas y Marı́a Daniela Cornejo.
De la promoción del 2006 a: Nicolás Verschueren y Paulina Chacón,
Sergio Valdivia y Elizabeth Villanueva.
De la promoción del 2007 a: Sebastián Godoy y Carola Cerda,
Rodrigo Pedrasa y Felipe Fuentes.
iv
Índice
I Computación. 1
1. Elementos del sistema operativo unix. 3
1.1. Introducción. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.2. Ingresando al sistema. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.2.1. Terminales. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.2.2. Login. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.2.3. Passwords. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.2.4. Cerrando la sesión. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.3. El Proyecto Debian. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.4. Archivos y directorios. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.5. Órdenes básicas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
1.5.1. Órdenes relacionadas con archivos. . . . . . . . . . . . . . . . . . . . . 9
1.5.2. Órdenes relacionadas con directorios. . . . . . . . . . . . . . . . . . . . 10
1.5.3. Visitando archivos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
1.5.4. Copiando, moviendo y borrando archivos. . . . . . . . . . . . . . . . . 11
1.5.5. Espacio de disco. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.5.6. Links. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.5.7. Protección de archivos. . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
1.5.8. Filtros. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
1.5.9. Otros usuarios y máquinas . . . . . . . . . . . . . . . . . . . . . . . . . 24
1.5.10. Utilitarios, fecha y calculadora . . . . . . . . . . . . . . . . . . . . . . . 24
1.5.11. Diferencias entre sistemas. . . . . . . . . . . . . . . . . . . . . . . . . . 25
1.6. Shells. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
1.6.1. Variables de entorno. . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
1.6.2. Redirección. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
1.6.3. Ejecución de comandos. . . . . . . . . . . . . . . . . . . . . . . . . . . 28
1.6.4. Aliases. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
1.6.5. La shell bash. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
1.6.6. Archivos de script. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
1.7. Ayuda y documentación. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
1.8. Procesos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
1.9. Editores. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
1.9.1. El editor vi. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
1.9.2. Editores modo emacs. . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
1.10. El sistema X Windows. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
v
vi ÍNDICE
1.11. Uso del ratón. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36

1.12. Internet. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
1.12.1. Acceso a la red. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
1.12.2. El correo electrónico. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
1.12.3. Ftp anonymous. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
1.12.4. WWW. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
1.13. Impresión. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
1.14. Compresión. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
2. Introducción a programación. 45
2.1. ¿Qué es programar? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
2.2. Lenguajes de programación. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
2.2.1. Código de Máquina binario. . . . . . . . . . . . . . . . . . . . . . . . . 45
2.2.2. Lenguaje de Ensamblador (Assembler). . . . . . . . . . . . . . . . . . . 46
2.2.3. Lenguaje de alto nivel. . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
2.2.4. Lenguajes interpretados. . . . . . . . . . . . . . . . . . . . . . . . . . . 47
2.2.5. Lenguajes especializados. . . . . . . . . . . . . . . . . . . . . . . . . . . 47
2.3. Lenguajes naturales y formales. . . . . . . . . . . . . . . . . . . . . . . . . . . 48
2.3.1. Lenguajes naturales. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
2.3.2. Lenguajes formales. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
2.4. Desarrollando programas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
2.5. La interfaz con el usuario. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
2.6. Sacar los errores de un programa. . . . . . . . . . . . . . . . . . . . . . . . . . 50
3. Una breve introducción a Python. 51

3.1. Python. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
3.1.1. Interactivo versus scripting. . . . . . . . . . . . . . . . . . . . . . . . . 51
3.1.2. Creando un script. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
3.2. Lenguaje Python. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
3.2.1. Algunos tipos básicos. . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
3.2.2. Imprimiendo en la misma lı́nea. . . . . . . . . . . . . . . . . . . . . . . 54
3.2.3. Imprimiendo un texto de varias lı́neas. . . . . . . . . . . . . . . . . . . 54
3.2.4. Variables. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
3.2.5. Asignación de variables. . . . . . . . . . . . . . . . . . . . . . . . . . . 55
3.2.6. Reciclando variables. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
3.2.7. Operaciones matemáticas. . . . . . . . . . . . . . . . . . . . . . . . . . 55
3.2.8. Operaciones con strings. . . . . . . . . . . . . . . . . . . . . . . . . . . 56
3.2.9. Composición. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
3.2.10. Comentarios. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
3.2.11. Entrada (input). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
3.3. Condicionales. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
3.3.1. Posibles condicionales. . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
3.3.2. El if. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
3.3.3. El if. . . else. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
3.3.4. El if...elif...else. . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
ÍNDICE vii
3.3.5. La palabra clave pass. . . . . . . . . . . . . . . . . . . . . . . . . . . . 59

3.3.6. Operadores lógicos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
3.3.7. Forma alternativa. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
3.4. Funciones Pre-hechas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
3.4.1. Algunas funciones incorporadas. . . . . . . . . . . . . . . . . . . . . . . 61
3.4.2. Algunas funciones del módulo math. . . . . . . . . . . . . . . . . . . . . 62
3.4.3. Algunas funciones del módulo string. . . . . . . . . . . . . . . . . . . 62
3.4.4. Algunas funciones del módulo random. . . . . . . . . . . . . . . . . . . 62
3.4.5. Algunos otros módulos y funciones. . . . . . . . . . . . . . . . . . . . . 62
3.5. Funciones hechas en casa. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
3.5.1. Receta para una función. . . . . . . . . . . . . . . . . . . . . . . . . . . 63
3.5.2. Variables globales. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
3.5.3. Pasando valores a la función. . . . . . . . . . . . . . . . . . . . . . . . 64
3.5.4. Valores por defecto de una función. . . . . . . . . . . . . . . . . . . . . 64
3.5.5. Argumentos claves. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
3.5.6. Documentación de una función, docstrings. . . . . . . . . . . . . . . . . 66
3.5.7. La palabra clave return. . . . . . . . . . . . . . . . . . . . . . . . . . . 66
3.5.8. Funciones que tienen un valor de retorno. . . . . . . . . . . . . . . . . . 67
3.5.9. Recursión. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
3.6. Iteraciones con while. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
3.7. Los strings. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
3.7.1. Índice negativos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
3.7.2. ¿Cuán largo es un string? . . . . . . . . . . . . . . . . . . . . . . . . . 69
3.7.3. Recorriendo un string. . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
3.7.4. Comparando strings. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
3.8. El ciclo for. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
3.8.1. El comando break. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
3.8.2. El comando else. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
3.9. Listas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
3.9.1. Rebanando listas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
3.9.2. Mutabilidad. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
3.9.3. Modificando listas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
3.9.4. Agregando a una lista. . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
3.9.5. Borrando items de una lista. . . . . . . . . . . . . . . . . . . . . . . . . 73
3.9.6. Operaciones con listas. . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
3.9.7. ¿Qué contiene una lista? . . . . . . . . . . . . . . . . . . . . . . . . . . 74
3.9.8. Un ciclo for y las listas. . . . . . . . . . . . . . . . . . . . . . . . . . . 74
3.9.9. Otros trucos con listas. . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
3.9.10. Generando listas de números. . . . . . . . . . . . . . . . . . . . . . . . 75
3.10. Tuplas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
3.11. Parámetros desde la lı́nea de comando. . . . . . . . . . . . . . . . . . . . . . . 75
3.12. Ejemplos de funciones: raı́z cuadrada y factorial. . . . . . . . . . . . . . . . . . 76
3.12.1. Raı́z cuadrada. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
3.12.2. Factorial. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
3.13. Trabajando con archivos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
viii ÍNDICE
3.13.1. Funciones del módulo os. . . . . . . . . . . . . . . . . . . . . . . . . . . 79

3.13.2. Funciones del módulo os.path. . . . . . . . . . . . . . . . . . . . . . . 80
3.13.3. Ejemplo de un código. . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
3.13.4. Abriendo un archivo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
3.13.5. Leyendo un archivo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
3.13.6. Escribiendo a un archivo. . . . . . . . . . . . . . . . . . . . . . . . . . . 81
3.13.7. Cerrando un archivo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
3.13.8. Archivos temporales. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
3.13.9. Ejemplo de lectura escritura. . . . . . . . . . . . . . . . . . . . . . . . . 81
3.14. Excepciones. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
3.15. Diccionarios. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
3.15.1. Editando un diccionario. . . . . . . . . . . . . . . . . . . . . . . . . . . 83
3.15.2. Un ejemplo de código, un menú. . . . . . . . . . . . . . . . . . . . . . . 84
3.15.3. Tuplas y diccionarios como argumentos. . . . . . . . . . . . . . . . . . 84
3.16. Modules y Shelve. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84
3.16.1. Partiendo el código. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
3.16.2. Creando un módulo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
3.16.3. Agregando un nuevo directorio al path. . . . . . . . . . . . . . . . . . . 85
3.16.4. Haciendo los módulos fáciles de usar. . . . . . . . . . . . . . . . . . . . 85
3.16.5. Usando un módulo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
3.16.6. Trucos con módulos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
3.16.7. Preservando la estructura de la información. . . . . . . . . . . . . . . . 87
3.16.8. ¿Cómo almacenar? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
3.16.9. Ejemplo de shelve. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
3.16.10.Otras funciones de shelve. . . . . . . . . . . . . . . . . . . . . . . . . . 87
3.17. Clases y métodos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
3.17.1. Clase de muestra LibretaNotas. . . . . . . . . . . . . . . . . . . . . . . 88
3.17.2. Valores por defecto. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
3.18. Sobrecarga de Operadores. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
3.18.1. Función driver. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
3.18.2. Atributos de las clases. . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
3.18.3. Ejemplo de clase vectores. . . . . . . . . . . . . . . . . . . . . . . . . . 91
3.19. Algunos módulos interesantes. . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
3.19.1. El módulo Numeric. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
3.20. El módulo Tkinter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
3.20.1. Elementos importantes en una ventana. . . . . . . . . . . . . . . . . . . 93
3.20.2. Ubicación de un elemento en la ventana. . . . . . . . . . . . . . . . . . 95
3.20.3. Atributos del master. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
3.20.4. Un ejemplo más elaborado. . . . . . . . . . . . . . . . . . . . . . . . . . 96
3.20.5. El módulo Visual. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
4. Una breve introducción a C++. 99

4.1. Estructura básica de un programa en C++. . . . . . . . . . . . . . . . . . . . 99
4.1.1. El programa más simple. . . . . . . . . . . . . . . . . . . . . . . . . . . 99
4.1.2. Definición de funciones. . . . . . . . . . . . . . . . . . . . . . . . . . . 100
ÍNDICE ix
4.1.3. Nombres de variables. . . . . . . . . . . . . . . . . . . . . . . . . . . . 102

4.1.4. Tipos de variables. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
4.1.5. Ingreso de datos desde el teclado. . . . . . . . . . . . . . . . . . . . . . 104
4.1.6. Operadores aritméticos. . . . . . . . . . . . . . . . . . . . . . . . . . . 105
4.1.7. Operadores relacionales. . . . . . . . . . . . . . . . . . . . . . . . . . . 105
4.1.8. Asignaciones. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
4.1.9. Conversión de tipos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106
4.2. Control de flujo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108
4.2.1. if, if... else, if... else if. . . . . . . . . . . . . . . . . . . . . . 108
4.2.2. Expresión condicional. . . . . . . . . . . . . . . . . . . . . . . . . . . . 110
4.2.3. switch. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110
4.2.4. for. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111
4.2.5. while. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
4.2.6. do... while. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114
4.2.7. goto. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114
4.3. Funciones. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114
4.3.1. Funciones tipo void. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114
4.3.2. return. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115
4.3.3. Funciones con parámetros. . . . . . . . . . . . . . . . . . . . . . . . . . 116
4.3.4. Parámetros por defecto. . . . . . . . . . . . . . . . . . . . . . . . . . . 120
4.3.5. Ejemplos de funciones: raı́z cuadrada y factorial. . . . . . . . . . . . . . 121
4.3.6. Alcance, visibilidad, tiempo de vida. . . . . . . . . . . . . . . . . . . . 123
4.3.7. Recursión. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126
4.3.8. Funciones internas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126
4.4. Punteros. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127
4.5. Matrices o arreglos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129
4.5.1. Declaración e inicialización. . . . . . . . . . . . . . . . . . . . . . . . . 129
4.5.2. Matrices como parámetros de funciones. . . . . . . . . . . . . . . . . . 130
4.5.3. Asignación dinámica. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131
4.5.4. Matrices multidimensionales. . . . . . . . . . . . . . . . . . . . . . . . . 132
4.5.5. Matrices de caracteres: cadenas (strings). . . . . . . . . . . . . . . . . . 133
4.6. Manejo de archivos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136
4.6.1. Archivos de salida. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136
4.6.2. Archivos de entrada. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139
4.6.3. Archivos de entrada y salida. . . . . . . . . . . . . . . . . . . . . . . . 140
4.7. main como función. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141
4.7.1. Tipo de retorno de la función main. . . . . . . . . . . . . . . . . . . . . 142
4.8. Clases. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143
4.8.1. Definición. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144
4.8.2. Miembros. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145
4.8.3. Miembros públicos y privados. . . . . . . . . . . . . . . . . . . . . . . . 145
4.8.4. Operador de selección (.). . . . . . . . . . . . . . . . . . . . . . . . . . 145
4.8.5. Implementación de funciones miembros. . . . . . . . . . . . . . . . . . 146
4.8.6. Constructor. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147
4.8.7. Destructor. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 148
x ÍNDICE
4.8.8. Arreglos de clases. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149

4.9. Sobrecarga. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149
4.9.1. Sobrecarga de funciones. . . . . . . . . . . . . . . . . . . . . . . . . . . 149
4.9.2. Sobrecarga de operadores. . . . . . . . . . . . . . . . . . . . . . . . . . 150
4.9.3. Coerción. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150
4.10. Herencia. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151
4.11. Ejemplo: la clase de los complejos. . . . . . . . . . . . . . . . . . . . . . . . . . 152
4.12. Compilación y debugging. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155
4.12.1. Compiladores. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155
5. Gráfica. 157
5.1. Visualización de archivos gráficos. . . . . . . . . . . . . . . . . . . . . . . . . . 157
5.2. Modificando imágenes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158
5.3. Conversión entre formatos gráficos. . . . . . . . . . . . . . . . . . . . . . . . . 158
5.4. Captura de pantalla. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159
5.5. Creando imágenes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159
5.6. Graficando funciones y datos. . . . . . . . . . . . . . . . . . . . . . . . . . . . 160
5.7. Graficando desde nuestros programas. . . . . . . . . . . . . . . . . . . . . . . . 161
6. El sistema de preparación de documentos TEX . 163

6.1. Introducción. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163
6.2. Archivos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163
6.3. Input básico. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 164
6.3.1. Estructura de un archivo. . . . . . . . . . . . . . . . . . . . . . . . . . 164
6.3.2. Caracteres. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 164
6.3.3. Comandos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165
6.3.4. Algunos conceptos de estilo. . . . . . . . . . . . . . . . . . . . . . . . . 165
6.3.5. Notas a pie de página. . . . . . . . . . . . . . . . . . . . . . . . . . . . 166
6.3.6. Fórmulas matemáticas. . . . . . . . . . . . . . . . . . . . . . . . . . . . 167
6.3.7. Comentarios. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 167
6.3.8. Estilo del documento. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 167
6.3.9. Argumentos de comandos. . . . . . . . . . . . . . . . . . . . . . . . . . 168
6.3.10. Tı́tulo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169
6.3.11. Secciones. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 170
6.3.12. Listas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 170
6.3.13. Tipos de letras. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171
6.3.14. Acentos y sı́mbolos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 172
6.3.15. Escritura de textos en castellano. . . . . . . . . . . . . . . . . . . . . . 173
6.4. Fórmulas matemáticas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 174
6.4.1. Sub y supraı́ndices. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 174
6.4.2. Fracciones. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 174
6.4.3. Raı́ces. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 175
6.4.4. Puntos suspensivos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 175
6.4.5. Letras griegas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 176
6.4.6. Letras caligráficas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 176
ÍNDICE xi
6.4.7. Sı́mbolos matemáticos. . . . . . . . . . . . . . . . . . . . . . . . . . . . 176

6.4.8. Funciones tipo logaritmo. . . . . . . . . . . . . . . . . . . . . . . . . . 178
6.4.9. Matrices. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 179
6.4.10. Acentos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 181
6.4.11. Texto en modo matemático. . . . . . . . . . . . . . . . . . . . . . . . . 182
6.4.12. Espaciado en modo matemático. . . . . . . . . . . . . . . . . . . . . . . 182
6.4.13. Fonts. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182
6.5. Tablas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 183
6.6. Referencias cruzadas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 183
6.7. Texto centrado o alineado a un costado. . . . . . . . . . . . . . . . . . . . . . 184
6.8. Algunas herramientas importantes . . . . . . . . . . . . . . . . . . . . . . . . . 185
6.8.1. babel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185
6.8.2. AMS-LATEX . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 186
6.8.3. fontenc . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189
6.8.4. enumerate . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189
6.8.5. Color. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189
6.9. Modificando el estilo de la página. . . . . . . . . . . . . . . . . . . . . . . . . . 190
6.9.1. Estilos de página. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 190
6.9.2. Corte de páginas y lı́neas. . . . . . . . . . . . . . . . . . . . . . . . . . 191
6.10. Figuras. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194
6.10.1. graphicx.sty . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 195
6.10.2. Ambiente figure. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 195
6.11. Cartas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197
6.12. LATEX y el formato pdf. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 199
6.13. Modificando LATEX. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 200
6.13.1. Definición de nuevos comandos. . . . . . . . . . . . . . . . . . . . . . . 200
6.13.2. Creación de nuevos paquetes y clases . . . . . . . . . . . . . . . . . . . 205
6.14. Errores y advertencias. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 212
6.14.1. Errores. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 212
6.14.2. Advertencias. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 215
II Métodos Numéricos. 217

7. Preliminares. 219
7.1. Programas y funciones. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 219
7.2. Errores numéricos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 231
7.2.1. Errores de escala. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 231
7.2.2. Errores de redondeo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 233
8. EDO: Métodos básicos. 235

8.1. Movimiento de un proyectil. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 235
8.1.1. Ecuaciones básicas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 235
8.1.2. Derivada avanzada. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 237
8.1.3. Método de Euler. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 238
xii ÍNDICE
8.1.4. Métodos de Euler-Cromer y de Punto Medio. . . . . . . . . . . . . . . 239

8.1.5. Errores locales, errores globales y elección del paso de tiempo. . . . . . 239
8.1.6. Programa de la pelota de baseball. . . . . . . . . . . . . . . . . . . . . . 240
8.2. Péndulo simple. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 242
8.2.2. Fórmulas para la derivada centrada. . . . . . . . . . . . . . . . . . . . . 244
8.2.3. Métodos del “salto de la rana” y de Verlet. . . . . . . . . . . . . . . . . 245
8.2.4. Programa de péndulo simple. . . . . . . . . . . . . . . . . . . . . . . . 248
8.3. Listado de los programas en python. . . . . . . . . . . . . . . . . . . . . . . . 252
8.3.1. balle.py . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 252
8.3.2. pendulo.py . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 254
8.4. Listado de los programas en c++. . . . . . . . . . . . . . . . . . . . . . . . . . 256
8.4.1. balle.cc . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 256
8.4.2. pendulo.cc . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 257
9. EDO II: Métodos Avanzados. 261

9.1. Órbitas de cometas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 261
9.1.2. Programa orbita. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 263
9.2. Métodos de Runge-Kutta. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 267
9.2.1. Runge-Kutta de segundo orden. . . . . . . . . . . . . . . . . . . . . . . 267
9.2.2. Fórmulas generales de Runge-Kutta. . . . . . . . . . . . . . . . . . . . 269
9.2.3. Runge-Kutta de cuarto orden. . . . . . . . . . . . . . . . . . . . . . . . 270
9.2.4. Pasando funciones a funciones. (Sólo c++) . . . . . . . . . . . . . . . . 271
9.3. Métodos adaptativos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 272
9.3.1. Programas con paso de tiempo adaptativo. . . . . . . . . . . . . . . . . 272
9.3.2. Función adaptativa de Runge-Kutta. . . . . . . . . . . . . . . . . . . . 273
9.4. Listados del programa. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 276
9.4.1. orbita.py . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 276
9.4.2. orbita.cc . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 281
9.4.3. vector4d.h . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 286
9.4.4. vector4d.cc . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 287
9.4.5. orbita2.cc . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 288
10.Resolviendo sistemas de ecuaciones. 293

10.1. Sistemas de ecuaciones lineales. . . . . . . . . . . . . . . . . . . . . . . . . . . 293
10.1.1. Estado estacionario de EDO. . . . . . . . . . . . . . . . . . . . . . . . . 293
10.1.2. Eliminación Gaussiana. . . . . . . . . . . . . . . . . . . . . . . . . . . . 294
10.1.3. Pivoteando. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 295
10.1.4. Determinantes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 297
10.1.5. Eliminación Gaussiana en Octave. . . . . . . . . . . . . . . . . . . . . . 297
10.1.6. Eliminación Gaussiana con C++ de objetos matriciales. . . . . . . . . 298
10.2. Matriz inversa. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 300
10.2.1. Matriz inversa y eliminación Gaussiana. . . . . . . . . . . . . . . . . . 300
10.2.2. Matrices singulares y patológicas. . . . . . . . . . . . . . . . . . . . . . 302
ÍNDICE xiii
10.2.3. Osciladores armónicos acoplados. . . . . . . . . . . . . . . . . . . . . . 303

10.3. Sistemas de ecuaciones no lineales. . . . . . . . . . . . . . . . . . . . . . . . . 304
10.3.1. Método de Newton en una variable. . . . . . . . . . . . . . . . . . . . . 304
10.3.2. Método de Newton multivariable. . . . . . . . . . . . . . . . . . . . . . 305
10.3.3. Programa del método de Newton. . . . . . . . . . . . . . . . . . . . . . 306
10.3.4. Continuación. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 307
10.4.1. Manejo de matrices en Python. . . . . . . . . . . . . . . . . . . . . . . 309
10.4.2. Programa newtn en Python. . . . . . . . . . . . . . . . . . . . . . . . . 309
10.4.3. Definición de la clase Matrix. . . . . . . . . . . . . . . . . . . . . . . . 310
10.4.4. Implementación de la clase Matrix. . . . . . . . . . . . . . . . . . . . . 311
10.4.5. Función de eliminación Gaussiana ge. . . . . . . . . . . . . . . . . . . . 315
10.4.6. Función para inversión de matrices inv. . . . . . . . . . . . . . . . . . 316
10.4.7. Programa newtn en Octave. . . . . . . . . . . . . . . . . . . . . . . . . 317
10.4.8. Programa newtn en c++. . . . . . . . . . . . . . . . . . . . . . . . . . 318
11.Análisis de datos. 321

11.1. Ajuste de curvas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 321
11.1.1. El calentamiento global. . . . . . . . . . . . . . . . . . . . . . . . . . . 321
11.1.2. Teorı́a general. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 322
11.1.3. Regresión lineal. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 323
11.1.4. Ajuste general lineal de mı́nimos cuadrados. . . . . . . . . . . . . . . . 326
11.1.5. Bondades del ajuste. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 327
12.Integración numérica básica 329

12.1. Definiciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 329
12.2. Regla trapezoidal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 330
12.3. Interpolación con datos equidistantes. . . . . . . . . . . . . . . . . . . . . . . . 331
12.4. Reglas de cuadratura . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 332
12.5. Integración de Romberg . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 334
12.6. Cuadratura de Gauss. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 336
12.7. Bibliografı́a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 338
12.8.1. Programa trapecio.py . . . . . . . . . . . . . . . . . . . . . . . . . . 339
12.8.2. Programa romberg.py . . . . . . . . . . . . . . . . . . . . . . . . . . . 340
12.8.3. Programa trapecio.cc . . . . . . . . . . . . . . . . . . . . . . . . . . 341
12.8.4. Programa romberg.cc . . . . . . . . . . . . . . . . . . . . . . . . . . . 342
III Apéndices. 345

A. Transferencia a diskettes. 347
B. Las shells csh y tcsh. 349

B.1. Comandos propios. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 349
B.2. Variables propias del shell. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 350
xiv ÍNDICE
C. Editores tipo emacs. 353
D. Una breve introducción a Octave/Matlab 361

D.1. Introducción . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 361
D.2. Interfase con el programa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 361
D.3. Tipos de variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 362
D.3.1. Escalares . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 362
D.3.2. Matrices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 362
D.3.3. Strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 364
D.3.4. Estructuras . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 364
D.4. Operadores básicos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 365
D.4.1. Operadores aritméticos . . . . . . . . . . . . . . . . . . . . . . . . . . . 365
D.4.2. Operadores relacionales . . . . . . . . . . . . . . . . . . . . . . . . . . . 366
D.4.3. Operadores lógicos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 366
D.4.4. El operador : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 366
D.4.5. Operadores de aparición preferente en scripts . . . . . . . . . . . . . . 367
D.5. Comandos matriciales básicos . . . . . . . . . . . . . . . . . . . . . . . . . . . 367
D.6. Comandos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 367
D.6.1. Comandos generales . . . . . . . . . . . . . . . . . . . . . . . . . . . . 367
D.6.2. Como lenguaje de programación . . . . . . . . . . . . . . . . . . . . . . 368
D.6.3. Matrices y variables elementales . . . . . . . . . . . . . . . . . . . . . . 371
D.6.4. Polinomios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 373
D.6.5. Álgebra lineal (matrices cuadradas) . . . . . . . . . . . . . . . . . . . . 374
D.6.6. Análisis de datos y transformada de Fourier . . . . . . . . . . . . . . . 374
D.6.7. Gráficos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 375
D.6.8. Strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 379
D.6.9. Manejo de archivos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 380
E. Asignación dinámica. 385

E.1. Arreglos dinámicos bidimensionales. . . . . . . . . . . . . . . . . . . . . . . . . 386
F. make y Makefile. 387

F.1. Un ejemplo sencillo en C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . 387
F.2. Creando un Makefile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 388
F.3. Un ejemplo con varias dependencias: LATEX . . . . . . . . . . . . . . . . . . . . 390
F.4. Variables del usuario y patrones . . . . . . . . . . . . . . . . . . . . . . . . . . 391
F.5. C++: Programando con más de un archivo fuente . . . . . . . . . . . . . . . . 393
F.6. Un ejemplo completo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 395
G. Herramientas básicas en el uso de L.A.M.P. 399

G.1. Objetivo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 399
G.2. Prerequisitos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 399
G.3. Breve referencia sobre paginas web. . . . . . . . . . . . . . . . . . . . . . . . . 399
G.3.1. Ejemplos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 400
G.4. Administrador de Bases de datos. . . . . . . . . . . . . . . . . . . . . . . . . . 401
G.5. Servidor Web. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 401
ÍNDICE xv
G.6. Páginas Básicas en html. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 401

G.6.1. Estructura de una página en html. . . . . . . . . . . . . . . . . . . . . . 402
G.6.2. Algo de estilo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 402
G.6.3. Formularios. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 405
G.7. MySql. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 408
G.7.1. Iniciando sesión. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 408
G.7.2. Creando una base de datos. . . . . . . . . . . . . . . . . . . . . . . . . 408
G.7.3. Creando tablas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 409
G.7.4. Interactuando con la Tabla. . . . . . . . . . . . . . . . . . . . . . . . . 409
G.8. Programación en PHP. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 412
G.8.1. Lenguaje PHP. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 412
G.8.2. Variables. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 413
G.8.3. Recuperando variables desde un formulario. . . . . . . . . . . . . . . . 413
G.8.4. Control de flujo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 414
G.8.5. Función require. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 415
G.8.6. Sesión. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 415
G.8.7. PHP interactuando con MySql. . . . . . . . . . . . . . . . . . . . . . . 417
G.9. Ejemplo Final. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 419
G.9.1. Paso I: Estructura de las tablas. . . . . . . . . . . . . . . . . . . . . . . 419
G.9.2. Paso II: árbol de páginas. . . . . . . . . . . . . . . . . . . . . . . . . . 420
G.10.Conclusiones. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 424
G.10.1.Mejoras al Ejemplo final. . . . . . . . . . . . . . . . . . . . . . . . . . . 425
G.11.Tabla de Colores en html. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 426
xvi ÍNDICE
Índice de figuras
6.1. Un sujeto caminando. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 196
7.1. Salida gráfica del programa interp. . . . . . . . . . . . . . . . . . . . . . . . . 226

7.2. Salida gráfica del programa interp. . . . . . . . . . . . . . . . . . . . . . . . . 229
7.3. Error absoluto ∆(h), ecuación (7.9), versus h para f (x) = x2 y x = 1. . . . . . 234
8.1. Trayectoria para un paso de tiempo con Euler. . . . . . . . . . . . . . . . . . . 239

8.2. Movimiento de proyectil sin aire. . . . . . . . . . . . . . . . . . . . . . . . . . 241
8.3. Movimiento de proyectil con aire. . . . . . . . . . . . . . . . . . . . . . . . . . 242
8.4. Método de Euler para θm = 10◦ . . . . . . . . . . . . . . . . . . . . . . . . . . . 250
8.5. Método de Euler con paso del tiempo más pequeño. . . . . . . . . . . . . . . . 250
8.6. Método de Verlet para θm = 10◦ . . . . . . . . . . . . . . . . . . . . . . . . . . 251
8.7. Método de Verlet para θm = 170◦ . . . . . . . . . . . . . . . . . . . . . . . . . . 251
9.1. Órbita elı́ptica alrededor del Sol. . . . . . . . . . . . . . . . . . . . . . . . . . . 262

9.2. Trayectoria y energı́a usando el método de Euler. . . . . . . . . . . . . . . . . 265
9.3. Trayectoria y energı́a usando el método de Euler-Cromer. . . . . . . . . . . . . 266
9.4. Trayectoria y energı́a usando el método de Euler-Cromer. . . . . . . . . . . . . 266
9.5. Trayectoria y energı́a con el paso de tiempo más pequeño en Euler-Cromer. . . 267
9.6. Trayectoria y energı́a usando el método de Runge-Kutta. . . . . . . . . . . . . 272
9.7. Trayectoria y energı́a usando el método de Runge-Kutta adaptativo. . . . . . . 275
9.8. Paso de tiempo en función de la distancia radial del Runge-Kutta adaptativo. 275
10.1. Sistema de bloques acoplados por resortes anclados entre paredes. . . . . . . . 303
10.2. Representación gráfica del método de Newton. . . . . . . . . . . . . . . . . . . 305
11.1. Dióxido de carbono medido en Hawai. . . . . . . . . . . . . . . . . . . . . . . . 322

11.2. Ajuste de datos a una curva. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 323
12.1. Subintervalos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 329

12.2. Sucesión de lı́neas rectas como curva aproximante. . . . . . . . . . . . . . . . . 330
12.3. Aproximaciones, (a) lineal, (b) cuadrática. . . . . . . . . . . . . . . . . . . . . 332
12.4. Regla trapezoidal versus cuadratura de Gauss . . . . . . . . . . . . . . . . . . 336
D.1. Gráfico simple. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 376

D.2. Curvas de contorno. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 377
D.3. Curvas de contorno. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 378
xvii
xviii ÍNDICE DE FIGURAS
G.1. Esquema de una tabla en html, utilizando los elementos de una matriz. . . . . 405
G.2. Los 256 colores posibles de desplegar en una página en html, con su respectivo
código. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 426
Parte I
Computación.
1
Capı́tulo 1
Elementos del sistema operativo unix.

versión revisada 7.1, 31 de Julio del 2007
1.1. Introducción.
En este capı́tulo se intentará dar los elementos básicos para poder trabajar en un am-
biente unix. Sin pretender cubrir todos los aspectos del mismo, nuestro interés se centra en
entregar las herramientas al lector para que pueda realizar los trabajos del curso bajo este
sistema operativo. Como comentario adicional, conscientemente se ha evitado la traducción
de gran parte de la terminologı́a técnica teniendo en mente que documentación disponible
se encuentre, por lo general, en inglés y nos interesa que el lector sea capaz de reconocer los
términos.
El sistema operativo unix es el más usado en investigación cientı́fica, tiene una larga
historia y muchas de sus ideas y métodos se encuentran presentes en otros sistemas operativos.
Algunas de las caracterı́sticas relevantes del unix moderno son:
Multitarea (Multitasking): Cada programa tiene asignado su propio “espacio” de me-

moria. Es imposible que un programa afecte a otro sin usar los servicios del sistema
operativo. Si dos programas escriben en la misma dirección de memoria cada uno man-
tiene su propia “idea” de su contenido.
Multiusuario: Más de una persona puede usar la máquina al mismo tiempo. Programas
de otros usuarios continúan ejecutándose a pesar de que un nuevo usuario entre a la
máquina.
Memoria grande, lineal y virtual: Un programa en una máquina de 32 Bits puede acceder
y usar direcciones hasta los 4 GB en una máquina de sólo 4 MB de RAM. El sistema
sólo asigna memoria auténtica cuando le hace falta, en caso de falta de memoria de
RAM, se utiliza el disco duro (swap).
Casi todo tipo de dispositivo puede ser accedido como un archivo.
Existen muchas aplicaciones diseñadas para trabajar desde la lı́nea de comandos. Además,
la mayorı́a de las aplicaciones permiten que la salida de una pueda ser la entrada de la
otra.
Permite compartir dispositivos (como disco duro) entre una red de máquinas.
3
4 CAPÍTULO 1. ELEMENTOS DEL SISTEMA OPERATIVO UNIX.
Por su naturaleza de multiusuario, nunca se deberı́a apagar impulsivamente una máquina

unix1 , ya que una máquina apagada sin razón puede matar trabajos de dı́as, perder los
últimos cambios de tus archivos e ir degradando el sistema de archivos en dispositivos como
el disco duro.
Entre los sistemas operativos unix actuales cabe destacar:
Linux fue originalmente desarrollado primero para computadores personales PCs ba-
sados en x86 de 32 bits (386 o superiores). Hoy Linux corre sobre Intel x86/IA64,
Motorola 68k, Sun SPARC, Alpha, Motorola/IBM PowerPC, Arm, MISP CPUs, HP
PA-RISC, IA-64, ibm S/390, AMD64, ppc64, Hitachi SuperH, armeb y arquitecturas
Renesas M32R.
SunOS2 : disponible para la familia 68K ası́ como para la familia sparc de estaciones
de trabajo sun
Solaris3 : disponible para la familia sparc de Sun ası́ como para la familia x86.
OSF14 : disponible para Alpha.
Ultrix: disponible para vax de Digital
SYSVR45 : disponible para la familia x86, vax.
IRIX: disponible para mips.
AIX6 : disponible para RS6000 de IBM y PowerPC.
1.2. Ingresando al sistema.

En esta sección comentaremos las operaciones de comienzo y fin de una sesión en unix
ası́ como la modificación de la contraseña (que a menudo no es la deseada por el usuario, y
que por lo tanto puede olvidar con facilidad).
1.2.1. Terminales.
Para iniciar una sesión es necesario poder acceder a un terminal. Pueden destacarse dos
tipos de terminales:
Terminal de texto: consta de una pantalla y de un teclado. Como indica su nombre, en
la pantalla sólo es posible imprimir caracteres de texto.
Terminal gráfico: Consta de pantalla gráfica, teclado y mouse. Dicha pantalla suele ser
de alta resolución. En este modo se pueden emplear ventanas que emulan el comporta-
miento de un terminal de texto (xterm o gnome-terminal).
1
Incluyendo el caso en que la máquina es un PC normal corriendo Linux u otra versión de unix.
2
SunOS 4.1.x también se conoce como Solaris 1.
3
También conocido como SunOS 5.x, solaris 2 o Slowaris :-).
4
También conocido como Dec Unix.
5
También conocido como Unixware y Novell-Unix.
6
También conocido como Aches.
1.2. INGRESANDO AL SISTEMA. 5
1.2.2. Login.
El primer paso es encontrar un terminal libre donde aparezca el login prompt del sistema:
Debian GNU/Linux 4.0 hostname tty2
hostname login:
También pueden ocurrir un par de cosas:
La pantalla no muestra nada.
• Comprobar que la pantalla esté encendida.

• Pulsar alguna tecla o mover el mouse para desactivar el protector de pantalla.
Otra persona ha dejado una sesión abierta. En este caso existe la posibilidad de intentar
en otra máquina o bien finalizar la sesión de dicha persona (si ésta no se halla en las
proximidades).
Una vez que se haya superado el paso anterior de encontrar el login prompt se procede
con la introducción del Username al prompt de login y después la contraseña (password)
adecuada.
1.2.3. Passwords.
El password puede ser cualquier secuencia de caracteres a elección. Deben seguirse las
siguientes pautas:
Debe ser fácil de recordar por uno mismo. Si se olvida, deberá pasarse un mal rato
diciéndole al administrador de sistema que uno lo ha olvidado.
Para evitar que alguna persona no deseada obtenga el password y tenga libre acceso a
los archivos de tu cuenta:
• Las mayúsculas y minúsculas no son equivalentes, sin embargo se recomienda que

se cambie de una a otra.
• Los caracteres numéricos y no alfabéticos también ayudan. Debe tenerse sin em-
bargo la precaución de usar caracteres alfanuméricos que se puedan encontrar en
todos los terminales desde los que se pretenda acceder.
• Las palabras de diccionario deben ser evitadas.
Debe cambiarlo si cree que su password es conocido por otras personas, o descubre que
algún intruso7 está usando su cuenta.
El password debe ser cambiado con regularidad.

7
Intruso es cualquier persona que no sea el usuario.
La instrucción para cambiar el password en unix es passwd. A menudo, cuando existen

varias máquinas que comparten recursos (disco duro, impresora, correo electrónico, . . . ), para
facilitar la administración de dicho sistema se unifican los recursos de red (entre los que se
hayan los usuarios de dicho sistema) en una base de datos común. Dicho sistema se conoce
como NIS (Network Information Service)8 . Si el sistema empleado dispone de este servicio, la
modificación de la contraseña en una máquina supone la modificación en todas las máquinas
que constituyan el dominio NIS.
1.2.4. Cerrando la sesión.
Es importante que nunca se deje abierta una sesión, pues algún “intruso” podrı́a tener
libre acceso a archivos de propiedad del usuario y manipularlos de forma indeseable. Para
evitar todo esto basta teclear logout o exit y habrás acabado la sesión de unix en dicha
máquina9 .
1.3. El Proyecto Debian.

El proyecto Debian es una asociación de personas que han creado un sistema operativo
gratis y de código abierto (free). Este sistema operativo se denomina Debian GNU/Linux o
simplemente Debian.
Actualmente Debian ocupa el kernel Linux desarrollado por Linus Torvalds apoyado por
miles de programadores de todo el mundo. También están implementados otros kernels como
Hurd, desarrollado por GNU, NetBSD y FreeBSD.
La mayorı́a de las herramientas del sistema operativo Debian provienen del proyecto
GNU y por ende son free. Cabe destacar que actualmente Debian tiene un total de más de
18733 paquetes (por paquetes entendemos software precompilado, para la versión estable,
en un formato que permite su fácil instalación en nuestra máquina). Entre estos paquetes
encontramos desde las herramientas básicas para procesar texto, hojas de cálculo, edición de
imágenes, audio, video, hasta aplicaciones de gran utilidad cientı́fica. Es importante recordar
que todo este software es free y por lo tanto está al alcance de todos sin la necesidad de
comprar licencias ni pagar por actualizaciones. También existe la posibilidad de modificar el
software ya que tenemos acceso al código fuente de los programas. Debian siempre mantiene
activas al menos tres versiones que tienen las siguientes clasificaciones:
stable (estable): Es la última versión oficial de Debian que ha sido probada para asegurar
su estabilidad. Actualmente corresponde a la versión 4.0r0 cuyo nombre código es etch.
testing (en prueba): Esta es la versión que se está probando para asegurar su estabilidad
y para luego pasar a ser versión estable. Nombre código lenny.
unstable (inestable): Aquı́ es donde los programadores verdaderamente desarrollan De-
bian y por esto no es muy estable y no se recomienda para el uso diario. Esta versión
se denomina siempre sid.
Para información sobre Debian y cómo bajarlo visite la página oficial http://www.debian.org.
8
Antiguamente se conocı́a como YP (Yellow Pages), pero debido a un problema de marca registrada de
United Kingdom of British Telecomunications se adoptaron las siglas nis.
9
En caso que se estuviera trabajando bajo X-Windows debes cerrar la sesión con Log Out Usuario de
Gnome.
1.4. ARCHIVOS Y DIRECTORIOS. 7
1.4. Archivos y directorios.

Aunque las diferentes distribuciones ubiquen sus programas en diferentes partes, la es-
tructura básica de directorios en una máquina Linux es más o menos la misma:
/-|--> bin
|--> boot
|--> cdrom
|--> dev
|--> emul
|--> etc
|--> home
|--> initrd
|--> lib
|--> lib32
|--> lib64
|--> media
|--> mnt
|--> opt
|--> proc
|--> root
|--> sbin
|--> selinux
|--> sys
|--> tmp
|--> usr--|--> bin
|--> games
|--> include
|--> lib
|--> lib32
|--> lib64
|--> local -|--> bin
|--> include
|--> lib
|...
|--> sbin
|--> share
|--> src --> linux
|--> X11R6
|...
|--> var--|--> lock
|--> log
|--> mail
|--> www
|...
|...
El árbol que observamos muestra el tı́pico árbol de directorios en Linux. Pueden haber
pequeñas variaciones en algunos de los nombres de estos directorios dependiendo de la distri-
bución o versión de Linux que se esté usando. Entre los directorios más destacados tenemos:
/home - Espacio reservado para las cuentas de los usuarios.
/bin, /usr/bin - Binarios (ejecutables) básicos de unix.
/etc, aquı́ se encuentran los archivos de configuración de todo los diferentes softwares
de la máquina.
/proc, es un sistema de archivos virtuales. Contiene archivos que residen en memoria

y no en el disco duro. Hace referencia a los programas que están corriendo en este
momento en el sistema.
/dev (device) (dispositivo). Aquı́ se guardan los archivos asociados a los dispositivos.
Se usan para acceder los dispositivos fı́sicos del sistema y recursos tales como discos
duros, modems, memoria, mouse, etc. Algunos dispositivos:
• hd: hda1 será el disco duro IDE, primario (a), y la primera partición (1).
• fd: los archivos que empiecen con las letras fd se referirán a los controladores de
las disketteras: fd0 serı́a la primera diskettera, fd1 serı́a la segunda y ası́ sucesi-
vamente.
• ttyS: se usan para acceder a los puertos seriales como por ejemplo ttyS0, que es
el puerto conocido como com1.
• sd: son los dispositivos SCSI y/o SATA. Su uso es muy similar al del hd. También
se usa para denominar a los dispositivos de almacenamiento conectados vı́a USB
(pendrives).
• lp: son los puertos paralelos. lp0 es el puerto conocido como LPT1.
• null: éste es usado como un agujero negro, ya que todo lo que se dirige allı́ desa-
parece.
• tty: hacen referencia a cada una de las consolas virtuales. Como es de suponer,
tty1 será la primera consola virtual, tty2 la segunda, etc.
/usr/local - Zona con las aplicaciones no comunes a todos los sistemas unix, pero no
por ello menos utilizadas.
/usr/share/doc aquı́ se puede encontrar información relacionada con aplicaciones (en

forma de páginas de manual, texto, html o bien archivos dvi, Postscript o pdf). También
encontramos archivos de ejemplo, tutoriales, HOWTO, etc.
1.5. ÓRDENES BÁSICAS. 9
1.5. Órdenes básicas.

Para ejecutar un comando, basta con teclear su nombre (también debes tener permiso para
hacerlo). Las opciones o modificadores empiezan normalmente con el caracter - (p. ej. ls -l).
Para especificar más de una opción, se pueden agrupar en una sola cadena de caracteres
(ls -l -h es equivalente a ls -lh). Algunos comandos aceptan también opciones dadas por
palabras completas, en cuyo caso usualmente comienzan con -- (ls --color=auto).
1.5.1. Órdenes relacionadas con archivos.

En un sistema computacional la información se encuentra en archivos que la contienen
(tabla de datos, texto ASCII, fuente en lenguaje Python, Fortran o C++, ejecutable, imagen,
mp3, figura, resultados de simulación, . . . ). Para organizar toda la información se dispone de
una entidad denominada directorio, que permite el almacenamiento en su interior tanto de
archivos como de otros directorios10 .
Se dice que la estructura de directorios en unix es jerárquica o arborescente, debido a
que todos los directorios nacen en un mismo punto (denominado directorio raı́z). De hecho,
la zona donde uno trabaja es un nodo de esa estructura de directorios, pudiendo uno a su vez
generar una estructura por debajo de ese punto. Un archivo se encuentra situado siempre en
un directorio y su acceso se realiza empleando el camino que conduce a él en el Árbol de
Directorios del Sistema. Este camino es conocido como el path. El acceso a un archivo se
puede realizar empleando:
Path Absoluto, aquél que empieza con /
Por ejemplo : /etc/printcap
Path Relativo, aquél que no empieza con /
Por ejemplo : ../examples/rc.dir.01
Los nombres de archivos y directorios pueden usar un máximo de 255 caracteres, cual-
quier combinación de letras y sı́mbolos (el caracter / no se permite).
Los caracteres comodı́n (wildcard ) pueden ser empleados para acceder a un conjunto
de archivos con caracterı́sticas comunes. El signo * puede sustituir cualquier conjunto de
caracteres11 y el signo ? a cualquier caracter individual. Por ejemplo:12
10
Normalmente se acude a la imagen de una carpeta que puede contener informes, documentos o bien otras
carpetas, y ası́ sucesivamente.
11
Incluido el punto ‘.’, unix no es dos.
12
bash$ es el prompt en todos los ejemplos.
bash$ ls
f2c.1 flexdoc.1 rcmd.1 rptp.1 zforce.1
face.update.1 ftptool.1 rlab.1 rxvt.1 zip.1
faces.1 funzip.1 robot.1 zcat.1 zipinfo.1
flea.1 fvwm.1 rplay.1 zcmp.1 zmore.1
flex.1 rasttoppm.1 rplayd.1 zdiff.1 znew.1
bash$ ls rp*
rplay.1 rplayd.1 rptp.1
bash$ ls *e??
face.update.1 zforce.1 zmore.1
Los archivos cuyo nombre comiencen por . se denominan ocultos, ası́ por ejemplo en el
directorio de partida de un usuario.
bash$ ls -a user
. .alias .fvwmrc .login .xinitrc
.. .cshrc .joverc .profile
.Xdefaults .enviroment .kshrc .tcshrc
Algunos caracteres especiales para el acceso a archivos son:
. Directorio actual
.. Directorio superior en el árbol
~ Directorio $HOME
~user Directorio $HOME del usuario user
1.5.2. Órdenes relacionadas con directorios.

ls (LiSt)
Este comando permite listar los archivos de un determinado directorio. Si no se le suministra
argumento, lista los archivos y directorios en el directorio actual. Si se añade el nombre de
un directorio el listado es del directorio suministrado. Existen varias opciones que modifican
su funcionamiento entre las que destacan:
-l (Long listing) proporciona un listado extenso, que consta de los permisos13 de cada
archivo, el usuario, el tamaño del archivo, . . . , etc. Adicionalmente la opción -h imprime
los tamaños en un formato fácil de leer (Human readable).
-a (list All) lista también los archivos ocultos.
-R (Recursive) lista recursivamente el contenido de todos los directorios que encuentre.
-t ordena los archivos por tiempo de modificación.
-S ordena los archivos por tamaño.
-r invierte el sentido de un ordenamiento.
-p agrega un caracter al final de cada nombre de archivo, indicando el tipo de archivo

(por ejemplo, los directorios son identificados con un / al final).
13
Se comentará posteriormente este concepto.
pwd (Print Working Directory)

Este comando proporciona el nombre del directorio actual.
cd (Change Directory)
Permite moverse a través de la estructura de directorios. Si no se le proporciona argumento se
provoca un salto al directorio $HOME. El argumento puede ser un nombre absoluto o relativo
de un directorio. cd - vuelve al último directorio visitado.
mkdir (MaKe DIRectory)
Crea un directorio con el nombre (absoluto o relativo) proporcionado.
rmdir (ReMove DIRectory)
Elimina un directorio con el nombre (absoluto o relativo) suministrado. Dicho directorio debe
de estar vacı́o.
1.5.3. Visitando archivos.

Este conjunto de órdenes permite visualizar el contenido de un archivo sin modificar su
contenido.
cat
Muestra por pantalla el contenido de un archivo que se suministra como argumento.
more
Este comando es análogo al anterior, pero permite la paginación.
less
Es una versión mejorada del anterior. Permite moverse en ambas direcciones. Otra ventaja
es que no lee el archivo entero antes de arrancar.
1.5.4. Copiando, moviendo y borrando archivos.

cp (CoPy)
Copia un archivo(s) con otro nombre y/o a otro directorio, por ejemplo, el comando para
copiar el archivo1.txt con el nombre archivo2.txt es:
cp archivo1.txt archivo2.txt
Veamos algunas opciones:
-a copia en forma recursiva, no sigue los link simbólicos y preserva los atributos de lo
copiado.
-i (interactive), impide que la copia provoque una pérdida del archivo destino si éste
existe14 .
-R (recursive), copia un directorio y toda la estructura que cuelga de él.
mv (MoVe)
Mueve un archivo(s) a otro nombre y/o a otro directorio, por ejemplo, el comando para mover
el archivo1.txt al nombre archivo2.txt es:
14
Muchos sistemas tienen esta opción habilitada a través de un alias, para evitar equivocaciones.
mv archivo1.txt archivo2.txt
Este comando dispone de opciones análogas al anterior.

rm (ReMove)
Borra un archivo(s). En caso de que el argumento sea un directorio y se haya suministrado la
opción -r, es posible borrar el directorio y todo su contenido. La opción -i pregunta antes
de borrar.
1.5.5. Espacio de disco.

El recurso de almacenamiento en el disco es siempre limitado. A continuación se comentan
un par de comandos relacionados con la ocupación de este recurso:
du (Disk Usage)
Permite ver el espacio de disco ocupado (en bloques de disco15 ) por el archivo o directorio
suministrado como argumento. La opción -s impide que cuando se aplique recursividad en
un directorio se muestren los subtotales. La opción -h imprime los tamaños en un formato
fácil de leer (Human readable).
df (Disk Free)
Muestra los sistemas de archivos que están montados en el sistema, con las cantidades totales,
usadas y disponibles para cada uno. df -h muestra los tamaños en formato fácil de leer.
1.5.6. Links.
ln (LiNk)
Permite realizar un enlace (link) entre dos archivos o directorios. Un enlace puede ser:
hard link : se puede realizar sólo entre archivos del mismo sistema de archivos. El archivo
enlazado apunta a la zona de disco donde se ubica el archivo original. Por tanto, si se
elimina el archivo original, el enlace sigue teniendo acceso a dicha información. Es el
enlace por omisión.
symbolic link : permite enlazar archivos/directorios16 de diferentes sistemas de archivos.

El archivo enlazado apunta al nombre del original. Ası́ si se elimina el archivo original
el enlace apunta hacia un nombre sin información asociada. Para realizar este tipo de
enlace debe emplearse la opción -s.
Un enlace permite el uso de un archivo en otro directorio distinto del original sin necesidad
de copiarlo, con el consiguiente ahorro de espacio. Veamos un ejemplo. Creemos un enlace
clásico en Linux, al directorio existente linux-2.6.12.5 nombrémoslo sencillamente linux.
mitarro:/usr/src# ln -s linux-2.6.12.5 linux

15
1 bloque normalmente es 1 Kbyte.
16
Debe hacerse notar que los directorios sólo pueden ser enlazados simbólicamente.
1.5.7. Protección de archivos.

Dado que el sistema de archivos unix es compartido por un conjunto de usuarios, surge el
problema de la necesidad de privacidad. Sin embargo, dado que existen conjuntos de personas
que trabajan en común, es necesaria la posibilidad de que un conjunto de usuarios puedan
tener acceso a una serie de archivos (que puede estar limitado para el resto de los usuarios).
Cada archivo y directorio del sistema dispone de un propietario, un grupo al que pertenece
y unos permisos. Existen tres tipos fundamentales de permisos:
lectura (r-Read ): en el caso de un archivo, significa poder examinar el contenido del

mismo; en el caso de un directorio significa poder entrar en dicho directorio.
escritura (w-Write): en el caso de un archivo significa poder modificar su contenido;

en el caso de un directorio es crear un archivo o directorio en su interior.
ejecución (x-eXecute): en el caso de un archivo significa que ese archivo se pueda

ejecutar (binario o archivo de procedimientos); en el caso de un directorio es poder
ejecutar alguna orden dentro de él.
Se distinguen tres grupos de personas sobre las que se deben especificar permisos:
user: el usuario propietario del archivo.
group: el grupo propietario del archivo (excepto el usuario). Como ya se ha comentado,

cada usuario puede pertenecer a uno o varios grupos y el archivo generado pertenece a
uno de los mismos.
other: el resto de los usuarios (excepto el usuario y los usuarios que pertenezcan al
grupo)
También se puede emplear all que es la unión de todos los anteriores. Para visualizar las
protecciones de un archivo o directorio se emplea la orden ls -l, cuya salida es de la forma:
-rw-r--r-- ...otra información... nombre
Los 10 primeros caracteres muestran las protecciones de dicho archivo:
El primer caracter indica el tipo de archivo de que se trata:
• - archivo
• d directorio
• l enlace (link )
• c dispositivo de caracteres (p.e. puerta serial)
• b dispositivo de bloques (p.e. disco duro)
• s socket (conexión de red)
Los caracteres 2, 3, 4 son los permisos de usuario
Los caracteres 5, 6, 7 son los permisos del grupo

Los caracteres 8, 9, 10 son los permisos del resto de usuarios

Ası́ en el ejemplo anterior -rw-r--r-- se trata de un archivo donde el usuario puede
leer y escribir, mientras que el grupo y el resto de usuarios sólo pueden leer. Estos suelen
ser los permisos por omisión para un archivo creado por un usuario. Para un directorio
los permisos por omisión suelen ser: drwxr-xr-x, donde se permite al usuario “entrar”
en el directorio y ejecutar órdenes desde él.
chmod (CHange MODe)
Esta orden permite modificar los permisos de un archivo. Con opción -R es recursiva.
chmod permisos files
Existen dos modos de especificar los permisos:
Modo absoluto o modo numérico. Se realiza empleando un número que resulta de la OR

binario de los siguientes modos:
400 lectura por el propietario.
200 escritura por el propietario.
100 ejecución (búsqueda) por el propietario.
040 lectura por el grupo.
020 escritura por el grupo.
010 ejecución (búsqueda) por el grupo.
004 lectura por el resto.
002 escritura por el resto.
001 ejecución (búsqueda) por el resto.
4000 Set User ID, cuando se ejecuta el proceso corre
con los permisos del dueño del archivo.
Por ejemplo:
chmod 640 *.txt
Permite la lectura y escritura por el usuario, lectura para el grupo y ningún permiso
para el resto, de un conjunto de archivos que acaban en .txt
Modo simbólico o literal. Se realiza empleando una cadena (o cadenas separadas por
comas) para especificar los permisos. Esta cadena se compone de los siguientes tres
elementos: who operation permission
• who : es una combinación de:

◦ u : user
◦ g : group
◦ o : others
◦ a : all (equivalente a ugo)
Si se omite este campo se supone a, con la restricción de no ir en contra de la
máscara de creación (umask).
• operation: es una de las siguientes operaciones:
◦ + : añadir permiso.
◦ - : eliminar permiso.
◦ = : asignar permiso, el resto de permisos de la misma categorı́a se anulan.
• permission: es una combinación de los caracteres:
◦ r : read.
◦ w : write.
◦ x : execute.
◦ s : en ejecución fija el usuario o el grupo.
Por ejemplo:
chmod u+x tarea
Permite la ejecución por parte del usuario17 del archivo tarea.
chmod u=rx, go=r *.txt
Permite la lectura y ejecución del usuario, y sólo la lectura por parte del grupo y el
resto de usuarios.
umask
Esta es una orden intrı́nseca del Shell que permite asignar los permisos que se desea tengan
los archivos y directorios por omisión. El argumento que acompaña a la orden es un número
octal que aplicará una xor sobre los permisos por omisión (rw-rw-rw-) para archivos y
(rwxrwxrwx) para directorios. El valor por omisión de la máscara es 022 que habilita al
usuario para lectura-escritura, al grupo y al resto para lectura. Sin argumentos muestra el
valor de la máscara.
chgrp (CHange GRouP)
Cambia el grupo propietario de una serie de archivos/directorios
chgrp grupo files
El usuario que efectúa esta orden debe pertenecer al grupo mencionado.
chown (CHange OWNer)
Cambia el propietario y el grupo de una serie de archivos/directorios
chown user:group files
La opción -r hace que la orden se efectúe recursivamente.
id
Muestra la identificación del usuario18 , ası́ como el conjunto de grupos a los que el usuario
pertenece.
user@hostname:~$ id
uid=1000(user) gid=1000(group) groups=1000(group),25(floppy),29(audio)
user@hostname:~$
17
Un error muy frecuente es la creación de un archivo de órdenes (script file) y olvidar permitir la ejecución
del mismo.
18
A pesar de que el usuario se identifica por una cadena denominada username, también existe un número
denominado uid que es un identificativo numérico de dicho usuario.
1.5.8. Filtros.
Existe un conjunto de órdenes en unix que permiten el procesamiento de archivos de texto.
Se denominan filtros (Unix Filters), porque normalmente se trabaja empleando redirección
recibiendo datos por su stdin19 y retornándolos modificados por su stdout20 .
Para facilitar la comprensión de los ejemplos siguientes supondremos que existen tres
archivos llamados mylist.txt, yourlist.txt y tercero.txt que tienen en su interior:
mylist.txt yourlist.txt tercero.txt
1 190 1 190 11 b
2 280 2 281 33 c
3 370 3 370 222 a
echo
Éste no es propiamente un filtro, pero nos será muy útil más adelante. Despliega sobre la
pantalla un mensaje, sin argumento despliega una lı́nea en blanco. La opción -n elimina el
cambio de lı́nea al final del mensaje.
user@hostname:~$ echo Hola Mundo

Hola Mundo
user@hostname:~$ echo ; echo chao; echo
chao
user@hostname:~$
Varias instrucciones pueden ser separadas por ;

cat
Es el filtro más básico, copia la entrada a la salida.
user@hostname:~$ cat mylist.txt

1 190
2 280
3 370
También lo podemos usar para crear un archivo
user@hostname:~$ cat > myfile.txt

Este es mi archivo
con muchas lineas
^d
user@hostname:~$
El caracter final ^d corresponde a fin de archivo y termina el ingreso.
19
Entrada estándar.
20
Salida estándar.
seq
Genera una secuencia de números naturales consecutivos.
user@hostname:~$ seq 4 8
4
5
6
7
8
cut
Para un archivo compuesto por columnas de datos, permite escribir sobre la salida cierto
intervalo de columnas. La opción -b N-M permite indicar el intervalo en bytes que se escribirán
en la salida.
user@hostname:~$ cut -b 3-4 mylist.txt
19
28
37
user@hostname:~$
paste
Mezcla lı́neas de distintos archivos. Escribe lı́neas en el stdout pegando secuencialmente las
lı́neas correspondientes de cada uno de los archivo separadas por tab. Ejemplo, supongamos
que tenemos nuestros archivos mylist.txt y yourlist.txt y damos el comando
user@hostname:~$ paste mylist.txt yourlist.txt
1 190 1 190
2 280 2 281
3 370 3 370
user@hostname:~$
sed
Es un editor de flujo. Veamos algunos ejemplos
user@hostname:~$ sed = mylist.txt
1
1 190
2
2 280
3
3 370
user@hostname:~$
Numera las lı́neas.
user@hostname:~$ sed -n -e ’3p’ mylist.txt

3 370
user@hostname:~$
Sólo muestra la lı́nea 3. El modificador -n suprime la impresión de todas las lı́neas excep-
to aquellas especificadas por p. El modificador -e corre un script, secuencia de comandos.
Separando por coma damos un rango en el número de lı́neas.
user@hostname:~$ sed -e ’2q’ mylist.txt

1 190
2 280
user@hostname:~$
Muestra hasta la lı́nea 2 y luego se sale de sed.
user@hostname:~$ sed -e ’s/0/a/g’ mylist.txt

1 19a
2 28a
3 37a
user@hostname:~$
Reemplaza todos los 0 del archivo por la letra a. Éste es uno de los usos más comunes.
user@hostname:~$ sed -e ’/2 2/s/0/a/g’ mylist.txt

1 190
2 28a
3 370
user@hostname:~$
Busca las lı́neas con la secuencia 2 2 y en ellas reemplaza todos los 0 por la letra a.
user@hostname:~$ sed -e ’s/1/XX/2’ mylist.txt

1 XX90
2 280
3 370
user@hostname:~$
Reemplaza la segunda aparición de un 1 en una lı́nea por los caracteres XX.

A continuación mostramos otras posibilidades del comando sed
Para remover una lı́nea especifica (X) de un archivo (file.txt)
user@hostname:~$ sed -e ’Xd’ file.txt
Para remover un intervalo de lı́neas de un archivo
user@hostname:~$ sed -e ’X,Yd’ file.txt
Para mostrar sólo las lı́neas X e Y de un archivo

user@hostname:~$ sed -n -e ’Xp;Yp’ file.txt
Para mostrar un archivo salvo las lı́neas que contengan key
user@hostname:~$ sed -e ’/key/d’ file.txt
Para mostrar de un archivo sólo las lı́neas que contengan key
user@hostname:~$ sed -n -e ’/key/p’ file.txt
Para mostrar un archivo salvo las lı́neas que comienzan con #
user@hostname:~$ sed -e ’/^#/d’ file.txt
Expresiones regulares:
^ Matches al comienzo de la lı́nea
$ Matches al final de la lı́nea, se pone después del caracter a buscar.
. Matches cualquier caracter.
[] Matches con todos los caracteres dentro de los paréntesis
diff
Permite comparar el contenido de dos archivos o directorios
user@hostname:~$ diff mylist.txt yourlist.txt

2c2
< 2 280
---
> 2 281
user@hostname:~$
Hay una diferencia entre los archivos en la segunda fila.

sort
Permite ordenar alfabéticamente
user@hostname:~$ sort tercero.txt

11 b
222 a
33 c
user@hostname:~$
user@hostname:~$ sort -r tercero.txt

33 c
222 a
11 b
user@hostname:~$
user@hostname:~$ sort -n tercero.txt

11 b
33 c
222 a
user@hostname:~$
user@hostname:~$ sort -k 2 tercero.txt

222 a
11 b
33 c
user@hostname:~$
La opción -n considera los valores numéricos y la opción -r invierte el orden. La opción -k

permite especificar la columna a usar para hacer el sort.
find
Permite la búsqueda de un archivo en la estructura de directorios
find . -name file.dat -print
Comenzando en el directorio actual(.) recorre la estructura de directorios buscando el archivo
file.dat, cuando lo encuentre imprime el path al mismo, actualmente es innecesaria la
opción print.
find . -name ’*~’ -exec rm ’{}’ \;
Esta es otra aplicación de find que busca en la estructura de directorios un archivo que
termine en ~ y lo borra.
El comando xargs ordena repetir orden para cada argumento que se lea desde stdin. Este
lo podemos combinar con find.
find . -name ’*.dat’ -print | xargs mv ../data \;
Logrando un comando que busca en la estructura de directorios todos los archivos que ter-
mines en .dat, y los mueve a un directorio ../data.
grep
Permite la búsqueda de una cadena de caracteres en uno o varios archivos, imprimiendo el
nombre del archivo y la lı́nea en que se encuentra la cadena.
user@hostname:~$ grep 1 *list.txt

mylist.txt:1 190
yourlist.txt:1 190
yourlist.txt:2 281
user@hostname:~$
Algunas opciones útiles
-c Elimina la salida normal y sólo cuenta el número de apariciones de la cadena en

cada archivo.
-i Ignora para la comparación entre la cadena dada y el archivo, si la cadena está en

mayúsculas o minúsculas.
-n Incluye el número de lı́neas en que aparece la cadena en la salida normal.

-r Hace la búsqueda recursiva.
-v Invierte la búsqueda mostrando todas las lı́neas donde no aparece la cadena pedida.
head
Muestra las primeras diez lı́neas de un archivo.
head -30 file Muestra las 30 primeras lı́neas de file.
user@hostname:~$ head -1 mylist.txt

1 190
user@hostname:~$
tail
Muestra las diez últimas lı́neas de un archivo.
tail -30 file Muestra las 30 últimas lı́neas de file.
tail +30 file Muestra desde la lı́nea 30 en adelante de file.
user@hostname:~$ tail -1 mylist.txt

3 370
user@hostname:~$
La opción -f permite que se actualice la salida cuando el archivo crece.

awk
Es un procesador de archivos de texto que permite la manipulación de las lı́neas de forma tal
que tome decisiones en función del contenido de la misma. Ejemplo, supongamos que tenemos
nuestro archivo mylist.txt con sus dos columnas
user@hostname:~$ awk ’{print }’ mylist.txt

1 190
2 280
3 370
user@hostname:~$
Funciona como el comando cat
user@hostname:~$ awk ’{print $2, $1 }’ mylist.txt

190 1
280 2
370 3
user@hostname:~$
Imprime esas dos columnas en orden inverso.
user@hostname:~$ awk ’{print ‘‘a’’, 8*$1, $2-1 }’ mylist.txt

a 8 189
a 16 279
a 24 369
user@hostname:~$
Permite operar sobre las columnas.
user@hostname:~$ awk ’{ if (NR>1 && NR < 3) print}’ mylist.txt

2 280
user@hostname:~$
Sólo imprime la lı́nea 2.
user@hostname:~$ awk ’{print $NF}’ archivo.txt
Imprime en pantalla la última columna de cada fila del archivo archivo.txt.
user@hostname:~$ awk ’{print NF}’ archivo.txt
Imprime en pantalla el número respectivo a la última columna de cada fila, que equivalente-
mente es la cantidad de columnas por fila en el archivo archivo.txt.
Supongamos que tenemos el archivo notas.txt que contiene lo siguiente:
hugo 4.0 5.0 5.0

paco 3.0 6.0 4.0
luis 2.0 5.0 7.0
El comando
user@hostname:~$ awk ’{print "Las notas del alumno",$0}’ notas.txt
Imprime en pantalla
Las notas del alumno hugo 4.0 5.0 5.0

Las notas del alumno paco 3.0 6.0 4.0
Las notas del alumno luis 2.0 5.0 7.0
El comando
user@hostname:~$ awk ’{printf "%s %1.1f\n", $1,($2+$3+$4)/3}’ notas.txt
Imprime en pantalla con formato
hugo 4.7
paco 4.3
luis 4.7
El comando
$awk ’{ print >$N }’ archivo.txt
Crea archivos cuyos nombres correspondan a las palabras de la columna N en cada fila.
Además, cada archivo contiene la fila correspondiente. Por ejemplo si aplicamos este filtro a
nuestro archivo notas.txt por la primera columna, es decir,
$awk ’{ print >$1 }’ archivo.txt

Crea tres archivos: hugo, paco y luis. El archivo hugo contiene

hugo 4.0 5.0 5.0
el archivo paco
paco 3.0 6.0 4.0
y el archivo luis
luis 2.0 5.0 7.0
tar
Este comando permite la creación/extracción de archivos contenidos en un único archivo
denominado tarfile (o tarball). Este tarfile suele ser luego comprimido con gzip, la
versión de compresión gnu,21 o bien con bzip2.
La acción a realizar viene controlada por el primer argumento:
c (Create) creación
x (eXtract) extracción
t (lisT) mostrar contenido
r añadir al final
u (Update) añadir aquellos archivos que no se hallen en el tarfile o que hayan sido
modificados con posterioridad a la versión que aparece.
A continuación se muestran algunas de las opciones:
v Verbose (indica qué archivos son agregados a medida que son procesados)
z Comprimir o descomprimir el contenido con gzip.
j Comprimir o descomprimir el contenido con bzip2.
f File: permite especificar el archivo para el tarfile.

Veamos algunos ejemplos:
tar cvf simul.tar *.dat
Genera un archivo simul.tar que contiene todos los archivos que terminen en .dat del
directorio actual. A medida que se va realizando indica el tamaño en bloques de cada archivo
añadido modo verbose.
tar czvf simul.tgz *.dat
Igual que en el caso anterior, pero el archivo generado simul.tgz ha sido comprimido emplean-
do gzip.
21
gnu es un acrónimo recursivo, significa: gnu’s Not unix! gnu es el nombre del producto de la Free
Software Foundation, una organización dedicada a la creación de programas compatibles con unix algunos
mejorado respecto a los estándars, y de libre distribución. La distribución de Linux gnu es debian.
tar tvf simul.tar

Muestra los archivos contenidos en el tarfile simul.tar.
tar xvf simul.tar
Extrae todos los archivos contenidos en el tarfile simul.tar.
wc (Word Count) Contabiliza el número de lı́neas, palabras y caracteres de un archivo.
user@hostname:~$ wc mylist.txt
3 6 18 mylist.txt
user@hostname:~$
El archivo tiene 3 lı́neas, 6 palabras, considerando cada número como una palabra i.e. 1 es la
primera palabra y 190 la segunda, y finalmente 18 caracteres. ¿Cuáles son los 18 caracteres?
1.5.9. Otros usuarios y máquinas

users who w
Para ver quién está conectado en la máquina.
ping
Verifica si una máquina está conectada a la red y si el camino de Internet hasta la misma
funciona correctamente.
finger
finger user, muestra información22 sobre el usuario user en la máquina local.
finger user@hostname, muestra información sobre un usuario llamado user en una máquina
hostname.
finger @hostname, muestra los usuarios conectados en la máquina hostname.
Este comando suele estar desabilitado en las máquinas actuales.
1.5.10. Utilitarios, fecha y calculadora

cal
Muestra el calendario del mes actual. Con la opción -y y el año presenta el calendario del
año completo.
date
Muestra el dı́a y la hora actual.
Dar el comando
user@hostname:~$ echo 3.76*17.8|bc}

66.92
user@hostname:~$ echo "scale=3;s(3.14/2.0)"|bc -l
22
La información proporcionada es el nombre completo del usuario, las últimas sesiones en dicha máquina,
si ha leı́do o no su correo y el contenido de los archivos .project y .plan del usuario.
1.6. SHELLS. 25
1.000
user@hostname:~$
Permite calcular expresiones directamente desde la lı́nea de comando mediante la calculadora

de precisión arbitraria bc. En el segundo caso se fijan los decimales de salida a 3 y se evalua
la función sen(π/2), la opción -l permite el uso de funciones especiales.
1.5.11. Diferencias entre sistemas.

Cuando se transfieren archivos de texto entre windows y unix sin las precauciones
adecuadas pueden aparecer los siguientes problemas:
En unix no existe obligatoriedad respecto a que los archivos llevan extensión. Incluso
pueden tener más de una extensión algo.v01.tar.gz, esto puede complicar a otros
sistemas que usan sólo una extensión de tres caracteres.
El cambio de lı́nea en un archivo de texto windows se compone de Carriage Return

y Line Feed. Sin embargo, en unix sólo existe el Carriage Return. Ası́ un archivo de
unix visto desde windows parece una única lı́nea. El caso inverso es la aparición del
caracter ^M al final de cada lı́nea. Además, el fin de archivo en windows es ^Z y en
unix es ^D.
Usando el comando tr se puede transformar un archivo con cambios de lı́neas para DOS
en uno para unix. Sabiendo que ^M es ascii 13 decimal, pero 15 en octal:
tr -d ’\015’ < datafile > TEMPFILE

mv -f TEMPFILE datafile
En Debian, instalando el paquete sysutils, queda instalado el comando dos2unix que tam-
bién lo hace.
1.6. Shells.
El sistema operativo unix soporta varios intérpretes de comandos o shells, que ayudan a
que la interacción con el sistema sea lo más cómoda y amigable posible. La elección de cuál
es la shell más cómoda es algo personal; en este punto sólo indicaremos algunos de los más
populares:
sh : Bourne SHell, el shell básico, no pensado para uso interactivo.
csh : C-SHell, shell con sintaxis como el lenguaje “C”. El archivo de configuración es
.cshrc (en el directorio $HOME).
ksh : Korn-SHell, shell diseñada por David Korn en los Laboratorios AT&T Bell. Es
un intento para una shell interactiva y para uso en script. Su lenguaje de comandos es
un superconjunto de el lenguaje de shell sh.
tcsh : alTernative C-Shell (Tenex-CSHell), con editor de lı́nea de comando. El archivo

de configuración es .tcshrc, o en caso de no existir, .cshrc (en el directorio $HOME).
bash : Bourne-Again Shell, con lo mejor de sh, ksh y tcsh. El archivo de configuración
es .bash_profile cuando se entra a la cuenta por primera vez, y después el archivo de
configuración es .bashrc siempre en el directorio $HOME. La lı́nea de comando puede
ser editada usando comandos (secuencias de teclas) del editor emacs. Es el shell por
defecto de Linux.
Si queremos cambiar de shell en un momento dado, sólo será necesario que tecleemos el
nombre del mismo y estaremos usando dicho shell. Si queremos usar de forma permanente otro
shell del que tenemos asignado por omisión23 podemos emplear la orden chsh que permite
realizar esta acción.
En los archivos de configuración se encuentran las definiciones de las variables de entorno
(enviroment variables) como camino de búsqueda PATH, los aliases y otras configuraciones
personales. Veamos unos caracteres con especial significado para el Shell:
‘ 24 permite que el output de un comando reemplace al nombre del comando. Por

ejemplo: echo ‘pwd‘ imprime por pantalla el nombre del directorio actual.
user@hostname:~$ echo ‘pwd‘

/home/user
user@hostname:~$
’ 25 preserva el significado literal de cada uno de los caracteres de la cadena que

delimita.
user@hostname:~$ echo ’Estoy en ‘pwd‘’

Estoy en ‘pwd‘
user@hostname:~$
” 26 preserva el significado literal de todos los caracteres de la cadena que delimita,

salvo $, ‘, \.
user@hostname:~$ echo "Estoy en ‘pwd‘"

Estoy en /home/user
user@hostname:~$
; permite la ejecución de más de una orden en una sola lı́nea de comando.
user@hostname:~$ mkdir textos; cd textos; cp ../*.txt . ; cd ..

user@hostname:~$
23
Por omisión se asigna bash.
24
Acento agudo o inclinado hacia atrás, backquote.
25
Acento usual o inclinado hacia adelante, single quote.
26
double quote.
1.6. SHELLS. 27
1.6.1. Variables de entorno.

Las variables de entorno permiten la configuración, por defecto, de muchos programas
cuando ellos buscan datos o preferencias. Se encuentran definidas en los archivos de configu-
ración anteriormente mencionados. Para referenciar a las variables se debe poner el sı́mbolo
$ delante, por ejemplo, para mostrar el camino al directorio por defecto del usuario user:
user@hostname:~$ echo $HOME
/home/user
user@hostname:~$
Las variables de entorno más importantes son:
HOME - El directorio por defecto del usuario.
PATH - El camino de búsqueda, una lista de directorios separados con ‘:’ para buscar
programas.
EDITOR - El editor por defecto del usuario.
DISPLAY - Bajo el sistema de X windows, el nombre de máquina y pantalla que está usan-
do. Si esta variable toma el valor :0 el despliegue es local.
TERM - El tipo de terminal. En la mayorı́a de los casos bajo el sistema X windows se

trata de xterm y en la consola en Linux es linux. En otros sistemas puede ser vt100.
SHELL - La shell por defecto.
MANPATH - Camino para buscar páginas de manuales.
PAGER - Programa de paginación de texto (less o more).
TMPDIR - Directorio para archivos temporales.
1.6.2. Redirección.
Cuando un programa espera que se teclee algo, aquello que el usuario teclea se conoce
como el Standard Input: stdin. Los caracteres que el programa retorna por pantalla es lo que
se conoce como Standard Output: stdout (o Standard Error : stderr27 ). El signo < permite
que un programa reciba el stdin desde un archivo en vez de la interacción con el usuario. Por
ejemplo: mail root < file, invoca el comando mail con argumento (destinatario del men-
saje) root, siendo el contenido del mensaje el contenido del archivo file en vez del texto que
usualmente teclea el usuario. Más a menudo aparece la necesidad de almacenar en un archivo
la salida de un comando. Para ello se emplea el signo >. Por ejemplo, man bash > file,
invoca el comando man con argumento (información deseada) bash pero indicando que la
información debe ser almacenada en el archivo file en vez de ser mostrada por pantalla.
En otras ocasiones uno desea que la salida de un programa sea la entrada de otro. Esto
se logra empleando los denominados pipes, para ello se usa el signo |. Este signo permite que
27
Si estos mensajes son de error.
el stdout de un programa sea el stdin del siguiente. Por ejemplo:

zcat manual.gz | more
Invoca la orden de descompresión de zcat y conduce el flujo de caracteres hacia el paginador
more, de forma que podamos ver página a página el archivo descomprimido. A parte de los
sı́mbolos mencionados existen otros que permiten acciones tales como:
>> Añadir el stdout al final del archivo indicado (append ).28
>& o &> (sólo csh, tcsh y bash) Redireccionar el stdout y stderr. Con 2> redirec-
cionó sólo el stderr.
>>& Igual que >& pero en modo append.
1.6.3. Ejecución de comandos.

Si el comando introducido es propio del shell (built-in), se ejecuta directamente.
En caso contrario:
• Si el comando contiene /, el shell lo considera un PATH e intenta resolverlo (entrar

en cada directorio especificado para encontrar el comando).
• En caso contrario el shell busca en una tabla hash table que contiene los nombres de
los comandos que se han encontrado en los directorios especificados en la variable
PATH, cuando ha arrancado el shell.
1.6.4. Aliases.
Para facilitar la entrada de algunas órdenes o realizar operaciones complejas, los shells
interactivos permiten el uso de aliases. La orden alias permite ver qué aliases hay definidos
y también definir nuevos. Es corriente definir el alias rm =‘rm -i’, de esta forma la orden
siempre pide confirmación para borrar un archivo. Si alguna vez quieres usar rm sin alias, sólo
hace falta poner delante el sı́mbolo \, denominado backslash . Por ejemplo \rm elimina los alias
aplicados a rm. Otro ejemplo, bastante frecuente podrı́a ser (debido a la complejidad de la
orden): alias ffind =’find . -name \!*’. Para emplearlo: ffind tema.txt, el resultado
es la búsqueda recursiva a partir del directorio actual de un archivo que se llame tema.txt,
mostrando el camino hasta el mismo.
1.6.5. La shell bash.

Sólo bash puede considerarse un shell interactivo, permitiendo la edición de la lı́nea de
comandos, y el acceso a la historia de órdenes (readline). En uso normal (historia y editor
de lı́nea de comandos) bash es compatible con otras shells como tcsh y ksh, ver apéndice.
En bash el modo de completado (file completion) es automático (usando TAB sólo) si el shell
está en modo interactivo.
28
En bash, si el archivo no existe, es creado.
1.6. SHELLS. 29
Comandos del shell.
help
Ayuda interna sobre los comandos del shell.
set
Muestra el valor de todas las variables.
VARIABLE=VALUE
Permite asignar el valor de una variable de entorno. Para que dicha variable sea “heredada”
es necesario emplear: export VARIABLE o bien combinarlas: export VARIABLE=VALUE.
for var in wordlist do comandos done
A la variable var, que puede llamarse de cualquier modo, se le asignan sucesivamente los
valores de la cadena wordlist, y se ejecuta el conjunto de comandos. El contenido de dicha
variable puede ser empleado en los comandos: $var. Ejemplo:
$ for i in 1 2 tres 4; do echo $i; done

1
2
tres
4
alias
En bash, alias sólo sirve para substitución simple de una cadena por otra. Por ejemplo:
alias ls=’ls -F’. Para crear alias con argumentos se usan funciones, ver la documentación.
unalias name
Elimina un alias asignado.
history
Muestra las últimas órdenes introducidas en el shell. Algunos comandos relacionados con el
Command history son:
!!
Repite la última orden.
!n
Repite la orden n-ésima.
!string
Repite la orden más reciente que empiece por la cadena string.
!?string
Repite la orden más reciente que contenga la cadena string.
∧
str1∧ str2 o !!:s/str1/str2/
(substitute) Repite la última orden reemplanzando la primera ocurrencia de la cadena

str1 por la cadena str2.
!!:gs/str1/str2/
(global substitute) Repite la última orden reemplazando todas las ocurrencias de la
cadena str1 por la cadena str2.
!$
Es el último argumento de la orden anterior que se haya tecleado.
source file
Ejecuta las órdenes del fichero file en el shell actual.
umask value
Asigna la máscara para los permisos por omisión.
29
Los comandos umask , source , history , unalias y hash , funcionan igual en la
shell tcsh.
1.6.6. Archivos de script.

Un archivo de script es una sucesión de comandos de la shell que se ejecutan secuencial-
mente. Veamos un ejemplo simple:
#!/bin/bash
variable="/home/yo"
cp $1 /tmp/$2
rm $1
cd $variable
# Hecho por mi
La primera lı́nea declara la shell especı́fica que se quiere usar. En la segunda lı́nea hay una
declaración de una variable interna. La tercera contiene los dos primeros argumentos con que
fue llamado el script. Por ejemplo, si el anterior script está en un archivo llamado ejemplo,
el comando ejemplo file1 file2 asocia $1 a file1 y $2 a file2. La lı́nea 5 hace uso de la
variable interna dentro de un comando. La última lı́nea, que comienza con un # corresponde
a un comentario. Notemos que la primera también es un comentario, pero la combinación #!
en la primera lı́nea fuerza a que se ejecute esa shell.
Esto sólo es una mı́nima pincelada de una herramienta muy poderosa y útil. Los comandos
disponibles en la shell conforman un verdadero lenguaje de programación en sı́, y los scripts
pueden diseñarse para realizar tareas monótonas y complejas. Éste es un tema que le será útil
profundizar.
29
En bash y sh la hash table se va generando dinámicamente a medida que el usuario va empleando las
órdenes. Ası́ el arranque del shell es más rápido, y el uso de orden equivalente hash -r casi nunca hace falta.
1.7. AYUDA Y DOCUMENTACIÓN. 31
1.7. Ayuda y documentación.

Para obtener ayuda sobre comandos de unix, se puede emplear la ayuda on-line, en la
forma de páginas de manual. Ası́ man comando proporciona la ayuda sobre el comando desea-
do. Por ejemplo, para leer el manual de los shells, puedes entrar: man sh csh tcsh bash,
la orden formatea las páginas y te permite leer los manuales en el orden pedido. En el caso
de bash se puede usar el comando help, por ejemplo, help alias. Además, para muchos
comandos y programas se puede obtener información tipeando info comando. Finalmen-
te, algunos comandos tienen una opción de ayuda (--help), para recordar rápidamente las
opciones más comunes disponibles (ls --help).
1.8. Procesos.
En una máquina existen una multitud de procesos que pueden estar ejecutándose si-
multáneamente. La mayorı́a de ellos no corresponden a ninguna acción realizada por el usua-
rio y no merecen que se les preste mayor atención. Estos procesos corresponden a programas
ejecutados en el arranque del sistema y tienen que ver con el funcionamiento global del
servidor. En general, los programas suelen tener uno de estos dos modos de ejecución:
foreground: Son aquellos procesos que requieren de la interacción y/o atención del
usuario mientras se están ejecutando, o bien en una de sus fases de ejecución (i.e.
introducción de datos). Ası́ por ejemplo, la consulta de una página de manual es un
proceso que debe ejecutarse claramente en foreground.
background: Son aquellos procesos que no requieren de la interacción con el usuario

para su ejecución. Si bien el usuario desearı́a estar informado cuando este proceso
termine. Un ejemplo de este caso serı́a la impresión de un archivo.
Sin embargo, esta división que a primera vista pueda parecer tan clara y concisa, a menudo
en la práctica aparece la necesidad de conmutar de un modo al otro, detención de tareas
indeseadas, etc. Ası́ por ejemplo, puede darse el caso de que estemos leyendo una página de
manual y de repente necesitemos ejecutar otra tarea. Un proceso viene caracterizado por:
process number
job number
Veamos algunas de las órdenes más frecuentes para la manipulación de procesos:
30
comando & Ejecución de un comando en el background.
Ctrl-Z Detiene el proceso que estuviera ejecutándose en el foreground y lo coloca

detenido en el background.
Ctrl-C Termina un proceso que estaba ejecutándose en foreground.

30
Por omisión un comando se ejecuta siempre en el foreground.
Ctrl-\ Termina de forma definitiva un proceso que estaba ejecutándose en foreground.
ps x Lista todos los procesos que pertenezcan al usuario, incluyendo los que no están
asociados a un terminal.
jobs Lista los procesos que se hayan ejecutado desde el shell actual, mostrando el job
number.
fg (job number) Pasa a ejecución en foreground un proceso que se hallase en back-

ground.
bg (job number) Pasa a ejecución en background un proceso que se hallase detenido

con Ctrl-Z.
kill (process number) Envı́a una señal31 a un proceso unix. En particular, para
enviar la señal de término a un programa, damos el comando kill -KILL, pero no
hace falta al ser la señal por defecto.
Cuando se intenta abandonar una sesión con algún proceso aún detenido en el background
del shell, se informa de ello con un mensaje del tipo: There are stopped jobs si no importa,
el usuario puede intentar abandonar de nuevo el shell y éste matará los jobs, o puedes utilizar
fg para traerlos al foreground y ahı́ terminar el mismo.
1.9. Editores.
Un editor es un programa que permite crear y/o modificar un archivo. Existen una mul-
titud de editores diferentes, y al igual que ocurre con los shells, cada usuario tiene alguno de
su predilección. Mencionaremos algunos de los más conocidos:
vi - El editor standard de unix.
emacs (xemacs) - Editor muy configurable escrito en lenguaje Lisp. Existen muchos
modos para este editor (lector de mail, news, www,. . . ) que lo convierten en un ver-
dadero shell para multitud de usuarios. Las últimas versiones del mismo permiten la
ejecución desde X-windows o terminal indistintamente con el mismo binario. Posee un
tutorial en lı́nea, comando C-H t dentro del editor. El archivo de configuración perso-
nalizada es: $HOME/.emacs.
jove - Basado en Emacs, (Jonathan’s Own Version of Emacs). Posee tutorial en una uti-
lidad asociada: teachjove. El archivo de configuración personalizada es: $HOME/.joverc.
jed - Editor configurable escrito en S-Lang. Permite la emulación de editores como

emacs y Wordstar. Posee una ayuda en lı́nea C-H C-H. El archivo de configuración
personalizada es: $HOME/.jedrc.
gedit - Un pequeño y liviano editor de texto para Gnome

31
Para ver las señales disponibles entra la orden kill -l (l por list).
1.9. EDITORES. 33
xjed - Versión de jed para el X-windows system. Presenta como ventaja que es capaz
de funcionar en muchos modos: lenguaje C, Fortran, TeX, etc., reconociendo palabras
clave y signos de puntuación, empleando un colorido distinto para ellos. El archivo de
configuración personalizada es el mismo que el de jed.
Dado que los editores del tipo de gedit disponen de menús auto explicativos, daremos a
continuación unas ligeras nociones sólo de vi y emacs.
1.9.1. El editor vi.

El vi es un editor de texto muy poderoso pero un poco difı́cil de usar. Lo importante
de este editor es que se puede encontrar en cualquier sistema unix y sólo hay unas pocas
diferencias entre un sistema y otro. Explicaremos lo básico solamente. Comencemos con el
comando para invocarlo:
localhost:/# vi
~
~
~
/tmp/vi.9Xdrxi: new file: line 1
La sintaxis para editar un archivo es:

localhost:/# vi nombre.de.archivo
~
~
~
nombre.de.archivo: new file: line 1
Insertar y borrar texto en vi.

Cuando se inicia el vi, editando un archivo, o no, se entra en un modo de órdenes, es decir,
que no se puede empezar a escribir directamente. Si se quiere entrar en modo de inserción
de texto se debe presionar la tecla i. Entrando en el modo de inserción, se puede empezar a
escribir. Para salir del modo de inserción de texto y volver al modo de órdenes se apreta ESC.
Aqui ya estamos escribiendo porque apretamos

la tecla ’i’ al estar en modo ordenes.
~
~
La tecla a en el modo de órdenes también entra en modo de inserción de texto, pero en

vez de comenzar a escribir en la posición del cursor, empieza un espacio después.
La tecla o en el modo de órdenes inserta texto pero desde la lı́nea que sigue a la lı́nea
donde se está ubicado.
Para borrar texto, hay que salir al modo órdenes, y presionar la tecla x que borrará el
texto que se encuentre sobre el cursor. Si se quiere borrar las lı́neas enteras, entonces se debe
presionar dos veces la tecla d sobre la lı́nea que deseo eliminar. Si se presionan las teclas dw
se borra la palabra sobre la que se está ubicado.
La letra R sobre una palabra se puede escribir encima de ella. Esto es una especie de modo
de inserción de texto pero sólo se podrá modificar la palabra sobre la que se está situado. La
tecla ~ cambia de mayúscula a minúscula la letra sobre la que se está situado.
Moverse dentro de vi.
Estando en modo órdenes podemos movernos por el archivo que se está editando usando
las flechas hacia la izquierda, derecha, abajo o arriba. Con la tecla 0 nos movemos al comienzo
de la lı́nea y con la tecla $ nos movemos al final de la misma.
Con las teclas w y b nos movemos al comienzo de la siguiente palabra o al de la palabra
anterior respectivamente. Para moverme hacia la pantalla siguiente la combinación de teclas
CTRL F y para volver a la pantalla anterior CTRL B. Para ir hasta el principio del archivo se
presiona la tecla G.
Opciones de comandos.
Para entrar al menú de comandos se debe presionar la tecla : en el modo de órdenes.

Aparecerán los dos puntos (:). Aquı́ se pueden ingresar ordenes para guardar, salir, cambiar
de archivo entre otras cosas. Veamos algunos ejemplos:
:w Guardar los cambios.
:w otherfile.txt Guardar con el nuevo nombre otherfile.txt
:wq Guardar los cambios y salir.
:q! Salir del archivo sin guardar los cambios.
:e file1.txt Si deseo editar otro archivo al que se le pondrá por nombre file1.txt.
:r file.txt Si se quiere insertar un archivo ya existente, por ejemplo file.txt.
:r! comando Si se quiere ejecutar algún comando del shell y que su salida aparezca en
el archivo que se está editando.
1.10. EL SISTEMA X WINDOWS. 35
1.9.2. Editores modo emacs.

El editor GNU Emacs, escrito por Richard Stallman de la Free Software Foundation, es
uno de los que tienen mayor aceptación entre los usuarios de unix, estando disponible bajo
licencia GNU GPL32 para una gran cantidad de arquitecturas. También existe otra versión
de emacs llamada XEmacs totalmente compatible con la anterior pero presentando mejoras
significativas respecto al GNU Emacs. Dentro de los “inconvenientes” que presenta es que no
viene por defecto incluido en la mayorı́a de los sistemas unix. Las actuales distribuciones
de Linux y en particular Debian GNU/Linux contienen ambas versiones de emacs, tanto
GNU Emacs como XEmacs, como también versiones de jove, jed, xjed y muchos otros editores.
Para mayor información ver Apéndice.
1.10. El sistema X Windows.

El X Windows system es el sistema estándar de ventanas en las estaciones de trabajo. Lo
usual actualmente es que el sistema de ventanas sea arrancado automáticamente cuando la
máquina parte. En el sistema X Windows deben distinguirse dos conceptos:
server : Es un programa que se encarga de escribir en el dispositivo de video y de

capturar las entradas (por teclado, ratón, etc.). Asimismo se encarga de mantener
los recursos y preferencias de las aplicaciones. Sólo puede existir un server para cada
pantalla.
client : Es cualquier aplicación que se ejecute en el sistema X Windows. No hay lı́mite
(en principio) en el número de clientes que pueden estarse ejecutando simultáneamente.
Los clientes pueden ser locales o remotos.
Window Manager (WM) Es un cliente con “privilegios especiales”: controla el compor-

tamiento (forma, tamaño,. . . ) del resto de clientes. Existen varios, destacando:
icewm : Ice Window Manager, uno de los window managers gnome compatible.
sawfish : Window managers gnome compatible, altamente configurable y muy integra-
do al gnome desktop.
Metacity : Window managers gnome 2 compatible.
El look and feel (o GUI) de X Windows es extremadamente configurable, y puede parecer
que dos máquinas son muy distintas, pero esto se debe al WM que se esté usando y no a que
las aplicaciones sean distintas.
Para configurar tu sesión es necesario saber qué programas estás usando y ver las páginas
de manual. Los archivos principales son:
.xinitrc o .xsession archivo leı́do al arrancar X Windows. Aquı́ se pueden definir

los programas que aparecen al inicio de tu sesión.
32
La licencia de GNU, da el permiso de libre uso de los programas con sus fuentes, pero los autores
mantienen el Copyright y no es permitido distribuir los binarios sin acceso a sus fuentes. Los programas
derivados de dichos fuentes heredan la licencia GNU.
.fvwmrc archivo de configuración del fvwm. Ver las páginas del manual de fvwm.
.olwmrc archivo de configuración del olwm. Ver las páginas del manual de olwm.
.Xdefaults Configuración general de las aplicaciones de X Windows. Aquı́ puedes

definir los resources que encontrarás en los manuales de las aplicaciones de X.
En caso de que tengas que correr una aplicación de X que no esté disponible en la máquina
que estás usando, eso no representa ningún problema. Las órdenes necesarias son (por ejemplo,
para arrancar un gnome-terminal remoto):
user@hostname1:~$ ssh -XC userB@hostname2

userB@hostname2’s password:
userB@hostname2:~$ gnome-terminal &
Las opciones XC en el comando ssh corresponden a que exporte el DISPLAY y que com-
prima, respectivamente. La forma antigua
userA@hostname1:~$ xhost +hostname2

hostname2 being added to access control list
user@hostname1:~$ ssh userB@hostname2
userB@hostname2’s password:
userB@hostname2:~$ export DISPLAY=hostname1:0
userB@hostname2:~$ gnome-terminal &
Si todo está previamente configurado, es posible que no haga falta dar el password.
Cuando quieres salir, normalmente puedes encontrar un ı́cono con la opción Log out, en
un menú o panel de la pantalla.
1.11. Uso del ratón.

El ratón es un dispositivo esencial en el uso de programas X, sin embargo, la función que
realiza en cada uno de ellos no está normalizada.
Comentaremos la pauta seguida por la mayorı́a de las aplicaciones, pero debe tenerse
presente que es muy frecuente encontrar aplicaciones que no las respetan.33
Botón izquierdo (LB): Seleccionar. Comienza el bloque de selección.
Botón central (MB): Pegar. Copia la selección en la posición del cursor.
Botón derecho (RB): Habitualmente ofrece un menú para partir aplicaciones.
Existen dos modos para determinar cuál es la ventana activa, aquélla que recibe las
entradas de teclado:
33
Las aplicaciones que son conscientes de un uso anormal y están realizadas por programadores inteligentes,
muestran en pantalla la función de cada botón cuando son posibles varias alternativas.
1.12. INTERNET. 37
Focus Follows Mouse: La ventana que contenga al ratón es la que es activa. No usado
por defecto actualmente.
Click To Focus: La ventana seleccionada es la activa. El modo que esté activo depende
de la configuración del Window Manager.
1.12. Internet.
En esta sección denominaremos unix1 a la máquina local (desde donde ejecutamos la
orden) y unix2 a la máquina remota (con la que interaccionamos). Ambos son los hostnames
de las respectivas máquinas. Existen algunos conceptos que previamente debemos comentar:
IP-number: es un conjunto de 4 números separados por puntos (p.e. 200.89.74.6) que

se asocia a cada máquina. No puede haber dos máquinas conectadas en la misma red
con el mismo número.
hostname: es el nombre que tiene asociada la máquina (p.e. macul). A este nombre se le
suelen añadir una serie de sufijos separados por puntos que constituyen el denominado
dominio (p.e. macul.ciencias.uchile.cl). Una máquina por tanto puede tener más
de un nombre reconocido (se habla en este caso de alias). Se denomina resolución
a la identificación entre un hostname y el IP-number correspondiente. La consulta
se realiza inicialmente en el archivo /etc/hosts, donde normalmente se guardan las
identificaciones de las máquinas más comúnmente empleadas. En caso de que no se
logre se accede al servicio DNS (Domain Name Service), que permite la identificación
(resolución) entre un hostname y un IP-number.
mail-address: es el nombre que se emplea para enviar correo electrónico. Este nombre
puede coincidir con el nombre de una máquina, pero se suele definir como un alias, con
objeto de que la dirección no deba de cambiarse si la máquina se estropea o se cambia
por otra.
1.12.1. Acceso a la red.

Existen muchos programas para la conexión de la red, los más usados son:
telnet unix2, hace un login en la máquina unix2, debe ingresarse el usuario y su

respectiva passwd. Además, permite especificar el puerto en conexión en la máquina
remota.
ssh nombre@unix2, muy similar a telnet pero se puede especificar el usuario, si no

se especifica se usa el nombre de la cuenta local. Además, el passwd pasa encriptado
a través de la red. ssh nombre@unix2 comando, muy similar a rsh, el passwd pasa
encriptado y ejecuta el comando en la máquina remota, mostrando el resultado en la
máquina local.
scp file1 usuario2@unix2:path/file, copia el archivo file1, del usuario1, que se

encuentra en el directorio local en la máquina unix1, en la cuenta del usuario2 en la
máquina unix2 en $HOME/path/file. Si no se especifica el nombre del usuario se usa el
nombre de la cuenta local. Si se quiere copiar el archivo file2 del usuario3 en unix2
en la cuenta actual de unix1 el comando serı́a: scp usuario3@unix2:file2 .. Antes
de realizar cualquiera de las copias el sistema preguntará por el passwd del usuario en
cuestión en la máquina unix2. Nuevamente, el passwd pasa encriptado a través de la
red.
talk usuario1@unix2, intenta hacer una conexión para hablar con el usuario1 en la
máquina unix2. Existen varias versiones de talk en los diferentes sistemas operativos,
de forma que no siempre es posible establecer una comunicación entre máquinas con
sistemas operativos diferentes.
ftp unix2, (file transfer protocol) aplicación para copiar archivos entre máquinas de
una red. ftp exige un nombre de cuenta y password para la máquina remota. Algunas
de las opciones más empleadas (una vez establecida la conexión) son:
• bin: Establece el modo de comunicación binario. Es decir, transfiere una imagen

exacta del archivo.
• asc: Establece el modo de comunicación ascii. Realiza las conversiones necesarias
entre las dos máquinas en comunicación. Es el modo por defecto.
• cd: Cambia directorio en la máquina remota.
• lcd: Cambia directorio en la máquina local.
• ls: Lista el directorio remoto.
• !ls: Lista el directorio local.
• prompt : No pide confirmación para transferencia múltiple de archivos.
• get rfile [lfile]: transfiere el archivo rfile de la máquina remota a la máqui-
na local denominándolo lfile. En caso de no suministrarse el segundo argumento
supone igual nombre en ambas máquinas.
• put lfile [rfile] : transfiere el archivo lfile de la máquina local a la máquina
remota denominándolo rfile. En caso de no suministrarse el segundo argumento
supone igual nombre en ambas máquinas. También puede usarse send.
• mget rfile : igual que get, pero con más de un archivo (rfile puede contener
caracteres comodines).
• mput lfile : igual que put, pero con más de un archivo (lfile puede contener
caracteres comodines).
Existen versiones mejoradas de ftp con muchas más posibilidades, por ejemplo, ncftp.
También existen versiones gráficas de clientes ftp donde la elección de archivo, el sentido
de la transferencia y el modo de ésta, se elige con el mouse (p.e. wxftp).
1.12. INTERNET. 39
rlogin -l nombre unix2, (remote login), hace un login a la máquina unix2 como el
usuario nombre por defecto, sin los argumentos -l nombre rlogin usa el nombre de la
cuenta local. Normalmente rlogin pide el password de la cuenta remota, pero con el
uso del archivo .rhosts o /etc/hosts.equiv esto no es siempre necesario.
rsh -l nombre unix2 orden, (remote shell ), ejecuta la orden en la máquina unix2
como usuario nombre. Es necesario que pueda entrar en la máquina remota sin password
para ejecutar una orden remota. Sin especificar orden actúa como rlogin.
1.12.2. El correo electrónico.

El correo electrónico (e-mail) es un servicio para el envı́o de mensajes entre usuarios,
tanto de la misma máquina como de diferentes máquinas.
Direcciones de correo electrónico.

Para mandar un e-mail es necesario conocer la dirección del destinatario. Esta dirección
consta de dos campos que se combinan intercalando entre ellos el @ (at): user@domain
user : es la identificación del usuario (i.e. login) en la máquina remota.
domain : es la máquina donde recibe correo el destinatario. A menudo, es frecuente

que si una persona tiene acceso a un conjunto de máquinas, su dirección de correo no
corresponda con una máquina sino que corresponda a un alias que se resolverá en un
nombre especı́fico de máquina en forma oculta para el que envı́a.
Si el usuario es local, no es necesario colocar el campo domain (ni tampoco el @).
Nomenclatura.
Veamos algunos conceptos relacionados con el correo electrónico:
Subject : Es una parte de un mensaje que piden los programas al comienzo y sirve
como tı́tulo para el mensaje.
Cc (Carbon Copy) : Permite el envı́o de copias del mensaje que está siendo editado a
terceras personas.
Reply : Cuando se envı́a un mensaje en respuesta a otro se suele añadir el comienzo

del subject: Re:, con objeto de orientar al destinatario sobre el tema que se responde.
Es frecuente que se incluya el mensaje al que se responde para facilitar al destinatario
la comprensión de la respuesta.
Forward : Permite reenviar un mensaje completo (con modificaciones o sin ellas) a una
tercera persona. Notando que Forward envı́a también los archivos adjuntos, mientras
que la opción Reply no lo hace.
Forwarding Mail : Permite a un usuario que disponga de cuentas en varias máquinas

no relacionadas, de concentrar su correo en una cuenta única34 . Para ello basta con
tener un archivo $HOME/.forward que contenga la dirección donde desea centralizar su
correo.
Mail group : Un grupo de correo es un conjunto de usuarios que reciben el correo

dirigido a su grupo. Existen órdenes para responder a un determinado correo recibido
por esa vı́a de forma que el resto del grupo sepa lo que ha respondido un miembro del
mismo.
In-Box : Es el archivo donde se almacena el correo que todavı́a no ha sido leı́do por el
usuario. Suele estar localizado en /var/spool/mail/user.
Mailer-Daemon : Cuando existe un problema en la transmisión de un mensaje se

recibe un mensaje proveniente del Mailer-Daemon que indica el problema que se ha
presentado.
Aplicación mail.
Es posiblemente la aplicación más simple. Para la lectura de mail teclear simplemente:
mail y a continuación aparece un ı́ndice con los diferentes mensajes recibidos. Cada mensaje
tiene una lı́nea de identificación con número. Para leer un mensaje basta teclear su número y a
continuación return. Para enviar un mensaje: mail (address) se pregunta por el Subject:
y a continuación se introduce el mensaje. Para acabar se teclea sólo un punto en una lı́nea o
bien Ctr-D. Por último, se pregunta por Cc:. Es posible personalizar el funcionamiento me-
diante el archivo $HOME/.mailrc. Para enviar un archivo de texto a través del correo se suele
emplear la redirección de entrada: mail (address) < file. Si queremos enviar un archivo
binario en forma de attach en el mail, el comando es mpack archivo-binario address.
1.12.3. Ftp anonymous.

Existen servidores que permiten el acceso por ftp a usuarios que no disponen de cuenta
en dichas máquinas. Para ello se emplea como login de entrada el usuario anonymous y como
passwd la dirección de e-mail personal. Existen servidores que no aceptan conexiones desde
máquinas que no están declaradas correctamente en el servicio de nombre (dns), ası́ como
algunas que no permiten la entrada a usuarios que no se identifican correctamente. Dada la
sobrecarga que existe, muchos de los servidores tienen limitado el número de usuarios que
pueden acceder simultáneamente.
1.12.4. WWW.
WWW son las siglas de World-Wide Web. Este servicio permite el acceso a información
entrelazada (dispone de un texto donde un término puede conducir a otro texto): hyperlinks.
Los archivos están realizados en un lenguaje denominado html. Para acceder a este servicio
34
Este comando debe usarse con conocimiento pues en caso contrario podrı́a provocar un loop indefinido y
no recibir nunca correo.
1.13. IMPRESIÓN. 41
es necesario disponer de un lector de dicho lenguaje conocido como browser o navegador.

Destacan actualmente: Iceweasel, Iceape, Opera, Camino (para MAC) y el simple pero muy
rápido Lynx.
1.13. Impresión.
Cuando se quiere obtener una copia impresa de un archivo se emplea el comando lpr.
lpr file - Envı́a el archivo file a la cola de impresión por defecto. Si la cola está activa-
da, la impresora lista y ningún trabajo por encima del enviado, nuestro trabajo será procesado
de forma automática.
A menudo existen varias posibles impresoras a las que poder enviar los trabajos. Para
seleccionar una impresora en concreto (en vez de la por defecto) se emplea el modificador:
lpr -Pimpresora, siendo impresora el nombre lógico asignado a esta otra impresora. Para
recibir una lista de las posibles impresoras de un sistema, ası́ como su estado, se puede em-
plear el comando /usr/sbin/lpc status. La lista de impresoras y su configuración también
está disponible en el archivo /etc/printcap.
Otras órdenes para la manipulación de la cola de impresión son:
lpq [-Pimpresora], permite examinar el estado de una determinada cola (para ver la
cantidad de trabajos sin procesar de ésta, por ejemplo).
lprm [-Pimpresora] jobnumber, permite eliminar un trabajo de la cola de impresión.
Uno de los lenguajes de impresión gráfica más extendidos en la actualidad es PostScript.
La extensión de los archivos PostScript empleada es .ps. Un archivo PostScript puede ser
visualizado e impreso mediante los programas: gv, gnome-gv o ghostview. Por ello muchas
de las impresoras actuales sólo admiten la impresión en dicho formato.
En caso de desear imprimir un archivo ascii deberá previamente realizarse la conversión
a PostScript empleando la orden a2ps: a2ps file.txt Esta orden envı́a a la impresora
el archivo ascii file.txt formateado a 2 páginas por hoja. Otro programa que permite
convertir un archivo ascii en postscript es enscript.
Otro tipo de archivos ampliamente difundido y que habitualmente se necesita imprimir
es el conocido como Portable Document Format. Este tipo de archivo poseen una extensión
.pdf y pueden ser visualizados e impresos usando aplicaciones tales como: xpdf, acroread
o gv.
1.14. Compresión.
A menudo necesitamos comprimir un archivo para disminuir su tamaño, o bien crear un
respaldo (backup) de una determinada estructura de directorios. Se comentan a continuación
una serie de comandos que permiten ejecutar dichas acciones.
El compresor compress está relativamente fuera de uso35 pero aún podemos encontrarnos
con archivos comprimidos por él.
35
Este comando no se incluye en la instalación básica. Debemos cargar el paquete ncompress para tenerlo
compress file : comprime el archivo, creando el archivo file.Z. Destruye el archivo

original.
uncompress file.Z : descomprime el archivo, creando el archivo file. Destruye el

archivo original.
zcat file.Z : muestra por el stdout el contenido descomprimido del archivo (sin
destruir el original).
Otra alternativa de compresor mucho más usada es gzip, el compresor de GNU que posee
una mayor razón de compresión que compress. Veamos los comandos:
gzip file : comprime el archivo, creando el archivo file.gz. Destruye el archivo

original.
gunzip file.gz : descomprime el archivo, creando el archivo file. Destruye el archivo

original.
zless file.gz : muestra por el stdout el contenido descomprimido del archivo pagi-
nado por less.
La extensión empleada en los archivos comprimidos con gzip suele ser .gz, pero a veces
se usa .gzip. Adicionalmente el programa gunzip también puede descomprimir archivos
creados con compress.
La opción con mayor tasa de compresión que gzip es bzip2 y su descompresor bunzip2.
bzip2 file : comprime el archivo, creando el archivo file.bz2. Destruye el archivo

original.
bunzip2 file.bz2 : descomprime el archivo, creando el archivo file. Destruye el

archivo original.
bzcat file.bz2 : muestra por el stdout el contenido descomprimido del archivo. De-
bemos usar un paginador, adicionalmente, para verlo por páginas.
La extensión usada en este caso es .bz2. El kernel de Linux se distribuye en forma-

to bzip2. También existe una versión paralelizada llamada pbzip2. Uno de los mejores
algoritmos de compresión está disponible para Linux en el programa p7zip. Veamos un
ejemplo: un archivo linux-2.6.18.tar que contiene el kernel 2.6.18 de Linux que tiene un
tamaño de 230 Mb. Los resultados al comprimirlo con compress, gzip, bzip2 y 7za son:
linux-2.6.18.tar.Z 91 Mb, linux-2.6.18.tar.gz 51 Mb, linux-2.6.18.tar.bz2 40 Mb
y linux-2.6.18.tar.7z 33 Mb.36
Existen también versiones de los compresores compatibles con otros sistemas operativos:
zip, unzip, unarj, lha, rar y zoo.
36
Los comandos gzip y bzip2 fueron dados con la opción --best para lograr la mayor compresión. El
comando usado para la compresión con 7z fue: 7za a -t7z -m0=lzma -mx=9 -mfb=64 -md=32m -ms=on
file.tar.7z file.tar, note la nueva extensión 7z. Para descomprimir con 7z basta 7z e file.tar.7z
1.14. COMPRESIÓN. 43
Compresor Tamaño
Sin comprimir 230 Mb
compress 91 Mb
gzip 51 Mb
bzip2 40 Mb
7z 33 Mb
Cuadro 1.1: Tabla de compresión del archivo linux-2.6.18.tar que contiene el kernel 2.6.18
de Linux.
En caso que se desee crear un archivo comprimido con una estructura de directorios debe
ejecutarse la orden:
tar cvzf nombre.tgz directorio o bien tar cvjf nombre.tbz directorio
En el primer caso comprime con gzip y en el segundo con bzip2. Para descomprimir y
restablecer la estructura de directorio almacenada se usan los comandos:
tar xvzf nombre.tgz directorio
si se realizó la compresión con gzip o bien
tar xvjf nombre.tbz directorio
si se realizó la compresión con bzip2.
Capı́tulo 2
Introducción a programación.
versión 1.0, 30 de Agosto del 2007
En este capı́tulo se intentará dar los elementos básicos de lo que es un lenguaje de pro-
gramación y lo que es programar.
2.1. ¿Qué es programar?

A continuación, presentamos algunas alternativas de respuesta a esta pregunta:
Hacer un programa.
Escribir una secuencia de instrucciones para que un computador haga algo que uno le
pide.
Darle, de alguna forma, una secuencia de pasos lógicos para que un computador los
ejecute con la intención de alcanzar algún objetivo.
Escribir una precisa secuencia de comandos o instrucciones, en algún lenguaje que el

computador entienda (a este tipo de lenguaje lo llamaremos lenguaje de programación)
para que luego el computador las realice exactamente, paso a paso.
Un programa es un archivo que puede ser tan corto como una sola lı́nea de código, o tan
largo como varios millones de lı́neas de código.
2.2. Lenguajes de programación.

Existen diferentes tipos de lenguajes de programación, algunos más cercanos a la máquina
y menos al programador; otros más cercanos al programador y distantes de la máquina.
Realmente existe toda una jerarquı́a entre los lenguajes de programación. Veamos algunos
ejemplos:
2.2.1. Código de Máquina binario.

Es el lenguaje de la CPU, y el lenguaje de más bajo nivel. Compuesto de 0 y 1 binario,
lo que está muy cerca de la máquina pero muy lejos del programador. Una de sus grandes
desventajas es que no es fácil de escribir o de leer para el programador.
45
46 CAPÍTULO 2. INTRODUCCIÓN A PROGRAMACIÓN.
Un programa simple, como Hola mundo, se verı́a en código binario algo ası́ como:
10001010101010011110010
10001011010101000111010
11000101000101010000111
00101010101010010110000
11110010101010101000011
10001010010101010101001
00101010101101010101001
2.2.2. Lenguaje de Ensamblador (Assembler).

El paso siguiente es reemplazar los 1 y 0 por una secuencia de abreviaturas de lenguaje
de máquina, este tipo de lenguaje se conoce como lenguaje de Ensamblador o Assembler.
Está cerca de la máquina pero no tanto como el anterior y esta un poco más cerca del
programador. Veamos el programa Hola mundo en lenguaje de Ensamblador para la familia
de procesadores X86.
title Programa Hola Mundo (hola.asm)

; Este programa muestra "Hola, Mundo!" dosseg
.model small
.stack 100h .data
hello_message db ’Hola, Mundo!’, 0dh, 0ah, ’$’ .code
main proc
mov ax, @ .data
mov ds,ax mov ah,9
mov dx, offset hello_message
int 21h mov ax,4C00h
int 21h
main endp
end main
2.2.3. Lenguaje de alto nivel.

Utilizan declaraciones y sentencias con palabras y expresiones algebraicas. Estos lenguajes
fueron inicialmente desarrollados en las décadas del 50 y 60. Son lenguajes que están más
cerca del programador que de la máquina, por lo tanto, necesitan una etapa de tradución
para que los entienda la máquina. Este proceso se puede hacer de dos maneras: traduciendo
el programa fuente todo de una vez, lo que llamaremos lenguaje compilando; o traduciendo
el programa fuente lı́nea por lı́nea, lo que llamaremos lenguaje interpretando.
Lenguajes Compilados.
En este caso, otro programa (el compilador) lee el programa fuente, un archivo en ASCII
donde se encuentran el listado de instruciones y lo reescribe en un archivo binario, en lenguaje
de máquina para que la CPU pueda entenderlo. Esto se hace de una sola vez y el programa
2.2. LENGUAJES DE PROGRAMACIÓN. 47
final se guarda en esta nueva forma (un ejecutable). El ejecutable de un programa que es
compilado se estima que será considerablemente más largo que el original, programa fuente.
Algunos de los lenguajes compilados más notables son Fortran, C y C++. Un ejemplo del
programa Hola mundo escrito en C++ es dado a continuación:
//
// Programa Hola Mundo
//
#include <iostream>
using namespace std;
int main()
{
cout << "Hola mundo" << endl;
return 0;
}
2.2.4. Lenguajes interpretados.

En este caso otro programa (el intérprete) traduce las declaraciones del programa original
a lenguaje de máquina, lı́nea por lı́nea, a medida que va ejecutando el programa original. Un
programa interpretado suele ser más pequeño que uno compilado pero tardará más tiempo en
ser ejecutado. Existe gran cantidad de este tipo de lenguajes, Python, Perl, Bash, por nombrar
algunos. Un ejemplo del programa Hola mundo escrito en Python es dado a continuación:
# Programa Hola mundo

print "Hola Mundo"
2.2.5. Lenguajes especializados.

Desde el punto de vista de la funcionalidad de los lenguajes podemos separarlos en len-
guajes de carácter general y lenguajes especializados. Los lenguajes de carácter general son
aquellos que sirven para programar una gran número de problemas, por ejemplo C o C++,
Python. Los lenguajes especializados han sido diseñados para realizar tareas especı́ficas. Ejem-
plos de ello son PHP y JavaScript, especializados en crear páginas web, o SQL, creado para
manipular información en bases de datos.
Una lista de lenguajes.

A continuación, damos una lista, probablemente muy incompleta, de los lenguajes de
programación más comunes en la actualidad:
ABC, Ada, ASP, Awk, BASIC, C, C++, C#, Caml, Cobol, código de máquina, Corba,
Delphi, Eiffel, Erlang, Fortran, Haskell, Java, JavaScript, Lisp, Logo, Modula, Modula 2,
Mozart, Mumps, Oberon, Objetive C, Oz, Pascal, Perl, PHP, Python, Realbasic, Rebol,
Rexx, RPG, Ruby, Scheme, Smaltalk, SQL, Squeak, TCL, Visual Basic.
2.3. Lenguajes naturales y formales.

2.3.1. Lenguajes naturales.
Son lenguajes hablados por la gente (por ejemplo: Español, Inglés, Alemán o Japonés).
Una de sus caracteristicas es que son ambiguos, por ejemplo: “Dame esa cosa” o “¡Oh, seguro,
Grande!”. En ambos ejemplos no es claro a que se están refiriendo y se necesita un contexto
para entenderlos. Muchas veces estos lenguajes son redundantes y están llenos de expresiones
idiomáticas las cuales no deben ser tomadas literalmente, por ejemplo: “Me podrı́a comer
una vaca”, “Me mataste”, o “Ándate a la punta del cerro”.
2.3.2. Lenguajes formales.

Hecho por el hombre, como las matemáticas, la notación en quı́mica o los lenguajes
de programación de computadores. Se caracterizan por ser inambiguos. Por ejemplo, una
expresión matemática: 1 + 4 = 5; o una expresión en quı́mica: CH4 +2O2 → 2H2 O+CO2 ; o,
finalmente, una expresión en lenguaje de programación print "Hola mundo". Los lenguajes
formales son además concisos y estrictamente literales.
Sintaxis.
Los lenguajes, tanto naturales como formales, tienen reglas de sintaxis. Por una parte,
están los tokens, que corresponden a los elementos básicos (i.e. letras, palabras, sı́mbolos) del
lenguaje:
Tokens correctos: 1+3=4; gato, H2 O.
Tokens incorrectos: @+#=!;+2 4;Hh O.
Por otro lado, tenemos las estructuras, esto es la manera en que los tokens son organizados:
Estructuras correctas: 1 + 3 = 4, gato, H2 O.
Estructuras incorrectas: 13+ = 4, gtoa, 2 HO.
2.4. Desarrollando programas.

Para desarrollar sus primeros programas parta escribiendo en sus propias palabras lo que
el programa deberı́a hacer. Convierta esta descripción en una serie de pasos en sus propias
palabras. Para cada uno de los pasos propuestos traduzca sus palabras en un código (Python
o C++). Dentro del código incluya instrucciones que impriman los valor de las variables para
probar que el programa está haciendo lo que usted esperaba.
2.5. LA INTERFAZ CON EL USUARIO. 49
2.5. La interfaz con el usuario.

Siempre que escriba un programa debe tener presente que alguien, que puede no ser usted
mismo, lo puede usar alguna vez. Lo anterior significa, en particular, que el programa debe
tener documentación, ya que un programa sin documentación es muy difı́cil de usar. Pero
además es importante cuidar la parte del programa con la que el usuario interactúa, es decir
la interfaz con el usuario. Esta interfaz podrı́an ser tanto mensajes simples de texto como so-
fisticadas ventanas gráficas. Lo importante es que ayuden al usuario a ejecutar correctamente
el programa.
Revisemos una mala interfaz con el usuario. Tenemos un programa que no sabemos lo
que hace, pero al ejecutarse resulta lo siguiente:
Entre un numero 5
Entre otro numero 7
La respuesta es 12
Hay una evidente falta de instrucciones de parte del programador para el usuario, que primero
no sabe para qué se le pide cada número, y luego no sabe qué hizo con ellos, sólo la respuesta,
12, sin mayor explicación de lo que significa.
Como contraparte, una buena interfaz con el usuario tiene documentación anexa, o bien,
alguna ayuda en el mismo programa. Esta documentación debiera explicar que hace el pro-
grama, los datos que necesitará y el o los resultados que entregará cuando finalice.
Cada vez que se le pide algo al usuario deberı́an estar claras las siguientes preguntas:
¿qué es exactamente lo que se supone que yo tipee?; ¿los números que ingreso deben tener
decimales?; ¿o deben ser sin decimales?; ¿los números que ingreso son positivos o negativos?;
¿los números que se piden son grandes o son números pequeños?; ¿en qué unidades de medidas
debo ingresarlos? Si se trata de palabras, ¿debo ingresarlas en minúsculas o mayúsculas?
Algunos lineamientos básicos que deberı́a observar para construir interfaces con el usuario
que sea claras son los siguientes:
Parta con un tı́tulo e indicaciones dentro del programa.
Cuando pregunte por un dato que quiere que el usuario ingrese, dele la ayuda necesaria,
por ejemplo
Entre el largo en metros (0-100):
Que las preguntas tengan sentido.

Use espacios y caracteres especiales para mantener la pantalla despejada.
Indı́quele al usuario que el programa terminó.
Una versión mejorada del programa anterior podrı́a ser la siguiente:
Calculo de la suma de dos numeros
Ingrese un numero entero: 5
Ingrese otro numero entero: 7
La suma es 12
2.6. Sacar los errores de un programa.

Los errores en un programa son llamados bugs. Al proceso de rastrear los errores y corre-
girlos se le conoce como debugging. Un programa especializado en hacer debugging es llamado
debugger. El debugging es una de las más importantes habilidades en programa-
ción. Los tres principales tipos de errores o bugs y sus consecuencias para la ejecución del
programa son:
1. Errores de sintaxis
Usar un token incorrecto o usar token correctos pero estructurarlos en forma in-
correcta.
Caso compilado, no genera el ejecutable.
Caso interpretado, el programa termina abruptamente con un mensaje de error.
2. Errores de ejecución (run-time error )
Errores que ocurren durante la ejecución.

El programa deja de correr abruptamente.
3. Errores lógicos
Errores en cómo el programa está lógicamente construido.

El programa corre, pero hace las cosas mal.
Capı́tulo 3
Una breve introducción a Python.

versión 2.2, 18 de Enero del 2008
En este capı́tulo se intentará dar los elementos más básicos del lenguaje de programación
Python. No se pretende más que satisfacer las mı́nimas necesidades del curso, sirviendo como
un ayuda de memoria de los tópicos abordados, para futura referencia. Se debe consignar que
no se consideran todas las posibilidades del lenguaje y las explicaciones están reducidas al
mı́nimo.
3.1. Python.
El Lenguaje Python fue inventado alrededor de 1990 por el cientı́fico en computación
holandés Guido van Rossem y su nombre es un tributo a la grupo cómico Monty Python del
cual Guido es admirador. El sitio oficial del lenguage en la web es http://www.python.org.
3.1.1. Interactivo versus scripting.

El programa Python (como programa, no como lenguaje) posee un ambiente interactivo
que nos permite ejecutar instrucciones del lenguaje Python directamente. Para ello, basta
dar el comando:
username@host:~$ python
Python 2.4.4 (#2, Apr 5 2007, 20:11:18)
[GCC 4.1.2 20061115 (prerelease) (Debian 4.1.1-21)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>>
El programa ofrece un prompt (>>>), esperando instrucciones del usuario. Las instruccio-
nes son interpretadas y ejecutadas de inmediato. Esta forma de usar Python tiene la ventaja
de la retroalimentación inmediata; de inmediato el programador sabe si la instrucción está co-
rrecta o incorrecta. Sin embargo, tiene la desventaja de que el código no es guardado, y no
puede por tanto ser reutilizado.
Por otra parte, cuando escribimos un archivo de instrucciones en Python (script), tenemos
la ventaja de que el código sı́ es almacenado, pudiendo ser reutilizado. En este caso las
desventajas son que la retroalimentación no es inmediata y que habitualmente requiere más
debugging para que el código funcione correctamente.
51
52 CAPÍTULO 3. UNA BREVE INTRODUCCIÓN A PYTHON.
3.1.2. Creando un script.

Para crear un script de Python requerimos de un editor (vi, jed, xemacs, gedit. . . elija
su favorito). Para ser ordenado, grábelo con extensión (supongamos que lo grabamos como
archivo.py), para poder identificarlo rápidamente más adelante. Recuerde darle los permi-
sos de ejecución adecuados (chmod u+x archivo.py). Para ejecutarlo basta ubicarse en el
directorio donde está el archivo y dar el comando
jrogan@manque:~/InProgress/python$ ./archivo.py
3.2. Lenguaje Python.

3.2.1. Algunos tipos básicos.
Cadenas de caracteres (strings): Usualmente un conjunto de caracteres, i.e. un texto.
Están delimitados por "comillas" simples o dobles.
Números enteros: Los números, que pertenecen al conjunto Z, es decir, sin decimales.
No pueden ser mayores que un tamaño fijo, en torno a dos billones (2 × 1012 ) en un
sistema de 32 bits usando signo ±. Cuando se dividen entre ellos sólo dan valores
enteros. Por ejemplo: 4/3=1.
Números con punto flotante: Los números, que pertenecen al conjunto R, es decir,
con decimales (un número finito de ellos).
Enteros largos: Números enteros mayores que 2 × 1012 . Los distinguimos por una L
al final del número, por ejemplo: 23434235234L.
Varios de los otros tipos serán explicados más adelante en el capı́tulo
Tipo Descripción Ejemplo

bool booleano True o False
int entero 117
long int entero largos 23434235234L
float número con punto flotante 1.78
complex número complejo 0.5 +2.0j
str string ’abc’
tuple tuplas (1, ’hum’, 2.0)
list listas [1, ’hum’, 2.0]
dict diccionario ’a’:7.0, 23: True
file archivo file(’stuff.dat’, ’w’)
Cuadro 3.1: Los tipos del lenguaje Python.

3.2. LENGUAJE PYTHON. 53
Trabajando con números.

Use el tipo de número en el cual quiere obtener su resultado. Es decir, si usted desea un
valor con decimales, use al menos un número con decimales en el cálculo. Por ejemplo: 15/2.0
producirá 7.5 y 15/2 producirá 7, porque son ambos enteros. Si desea enteros largos, use al
menos un entero largo en su expresión, por ejemplo: 23434235234L/2.
Número complejos.
Los números complejos son también soportados en Python. Los números imaginarios puros
son escritos con un sufijo j o J. Los números complejos con parte real no nula son escritos
como real +imagj, o pueden ser creados con la función complex(real,imag). Ejemplos
>>> 1j*1J
(-1+0j)
>>> 1j*complex(0,1)
(-1+0j)
>>> 3+1j*3
(3+3j)
>>> (1+2j)/(1+1j)
(1.5+0.5j)
>>> a=1.5+0.5j
>>> a.real
1.5
>>> a.imag
0.5
Cadenas de caracteres (strings).

Una cadena de caracteres debe estar entre apóstrofes o comillas simples o dobles. Por
ejemplo:
nombre = "Este es tu nombre"
nombre2= ‘Este es tambien su nombre’
Si una cadena de caracteres necesita un apóstrofe dentro de ella, anteponga un \ al

apóstrofe extra. Ejemplos:
titulo = "Ella dijo: \"Te amo\""
titulo2 = ‘I\’m a boy’
Algunas cadenas de caracteres con significado especial empiezan con el caracter \ (String
Backslash Characters).
\\ = Incluya \.
\’ = Apóstrofe simple.
\" = Apóstrofe doble.
\n = Lı́nea nueva.
3.2.2. Imprimiendo en la misma lı́nea.

Agregando una coma (,) al final de una instrucción print hará que el próximo comando
print aparezca en la misma lı́nea. Ejemplo
print num1,"+", num2, "=",

print respuesta
3.2.3. Imprimiendo un texto de varias lı́neas.

Si queremos imprimir un texto que tenga varias lı́neas podemos usar dos formas distintas
de la función print usando el caracter \n o bien usando un texto entre triple comilla
>>> print "primera linea\nsegunda linea"

primera linea
segunda linea
>>> print """primera linea
... segunda linea"""
primera linea
segunda linea
3.2.4. Variables.
Las variable son un nombre, usado dentro del programa, para referirse a un objeto o
valor. Las limitaciones y consideraciones que hay que tener en cuenta para darle nombre a
una variable son:
No puede ser una palabra reservada del lenguaje (i.e. print, and, or, not).
No puede comenzar por un número.
Las mayúsculas y las minúsculas son diferentes.
No puede incluir caracteres ilegales (i.e. $,%,+,=).
Cree variables cuyos nombres signifiquen algo:
MAL : diy=365
BIEN: days_in_year=365
3.2. LENGUAJE PYTHON. 55
3.2.5. Asignación de variables.

Para asignarle un valor a una variable, digamos num, basta poner el nombre de la variable
a la izquierda un signo igual y al lado derecho el valor o expresión que queremos asignarle
num=8.0
num=pi*3.0**2
Un mismo valor puede ser asignado a varias variables simultaneamente
>>> x=y=z=0 # Todas las variables valen cero

>>> print x,y,z
0 0 0
O bien podemos hacer asignasiones diferentes valores a diferentes variables en una misma
asignación
>>> a,b=0,1
>>> print a,b
0 1
>>> a,b=b,a+b
>>> print a,b
1 1
>>> a,b,c=0,1,2
>>> print a,b,c
0 1 2
3.2.6. Reciclando variables.

Una vez que una variable es creada su valor puede ser reasignado. Veamos un ejemplo
donde la variable card_value es reutilizada
card_value=card1+card2
print card_value
card_value=card1+card2+card3
print card_value
3.2.7. Operaciones matemáticas.

Con Python podemos realizar las operaciones básicas: suma (+), resta (−), multiplicación
(∗) y división (/). Operaciones menos básicas también están disponibles: el exponente (∗∗),
el módulo ( %).
Entre las operaciones hay un orden de precedencia, unas se realizarán primero que otras.
A continuación damos el orden de precedencia, partiendo por lo que se hace primero:
Paréntesis, exponentes, división y multiplicación.
Suma y resta.
De izquierda a derecha.
Como ejemplo de la importancia de saber el orden de precedencia veamos los siguiente
ejemplos:
2 ∗ (3 − 1) = 4 y 2∗3−1=5
3.2.8. Operaciones con strings.

Dos de las operaciones más comunes con strings:
Concatenación: se pueden concatenar dos strings al sumarlos, veamos un ejemplo:
>>> x = "Hola"
>>> y = "Mundo"
>>> print x+y
>>> HolaMundo
Repetición:
>>> z = "Ja"
>>> print z*3
>>> JaJaJa
3.2.9. Composición.
Se pueden combinar sentencias simples en una compuesta, a través del operador ”,”:
>>> x = "Elizabeth"
>>> print "Tu nombre es : ", x
>>> Tu nombre es : Elizabeth
En el ejemplo, x fue asignado explı́citamente a una variable, pero naturalmente cualquier
tipo de asignación es posible, por ejemplo:
>>> promedio=(nota+extra_creditos)/posibles
>>> print "Tu promedio es : ", promedio
3.2.10. Comentarios.
Los comentarios son anotaciones que usted escribe para ayudar a explicar lo que está ha-
ciendo en el programa. Los comentarios comienzan con #. Lo escrito después de #, hasta el
final de la lı́nea, es ignorado por el intérprete. Por ejemplo:
dias = 60 #disponibles para el proyecto
Naturalmente, los comentarios no son muy útiles cuando se trabaja interactivamente
con Python, pero sı́ lo son cuando se escribe un script. De este modo se pueden insertar
explicaciones en el código que ayuden a recordar qué hace el programa en cada una de sus
secciones, o explicarlo a terceros. Es buena costumbre de programación que las primeras
lı́neas de un código sean comentarios que incluyan el nombre del programador y una breve
descripción del programa.
3.3. CONDICIONALES. 57
3.2.11. Entrada (input).

Para leer strings del stdin use la instrucción raw_input(), por ejemplo
nombre = raw_input("Cual es tu nombre?")
Si necesita leer números del stdin use la instrucción input():

numero=input("Cuantos?")
En ambos casos, el mensaje entre comillas dentro de los paréntesis es opcional, sin embar-
go, aclara al usuario lo que el programa le está solicitando. En el siguiente par de ejemplos, el
programa solicita información al usuario, salvo que en el primero, el programa queda esperan-
do una respuesta del usuario, quien, a menos que sepa de antemano qué quiere el programa,
no tiene modo de saber por qué el programa no continúa ejecutándose.
Ejemplo sin mensaje (queda esperando para siempre una respuesta):
>>> nombre = raw_input()
Ejemplo con mensaje:

>>> nombre = raw_input("Cual es tu nombre?")
Cual es tu nombre? Pedro
>>>
3.3. Condicionales.
Los condicionales son expresiones que puede ser ciertas o falsas. Por ejemplo, ¿el usuario
tipeó la palabra correcta? o ¿El número es mayor que 10? El resultado de la condición decide
que sucederá, por ejemplo, a todos los números mayores que 100 réstele 20, cuando la palabra
ingresada sea la correcta, imprima “¡Bien!”
3.3.1. Posibles condicionales.

x == y
x es igual a y.
x != y
x no es igual a y.
x >y
x es mayor que y.
x <y
x es menor que y.
x >= y
x es mayor igual a y.
x <= y
x es menor igual a y.
A continuación, algunos ejemplos de los anteriores condicionales:
x == 125
passwd == "nix"
num >= 0
letter >"L"
num/2 == (num1-num)
num %5 != 0
3.3.2. El if.
A continuación, estudiemos la instrucción if, partamos de la forma general de la instruc-
ción:
if condition:
statements
Primero la palabra clave if, luego la condición condition, que puede ser algo como x<y
o x==y, etc. La lı́nea termina con : requerido por la sintaxis del if. En las lı́neas siguientes
statements, viene las instrucciones a seguir si la condición es cierta. Estas instrucciones
deben ir con sangrı́a (indent).
Un ejemplo de una construcción if simple.
num = input("Entre su edad")

if num >= 30:
old-person(num)
print
print "Gracias"
3.3.3. El if. . . else.

La forma general de la construcción if...else a continuación:
if condition:
statements_1
else:
statements_2
El else debe de estar después de una prueba condicional. Sólo se ejecutará cuando la
condición evaluada en el if sea falsa. Use esta construcción cuando tenga dos conjuntos
diferentes de instrucciones a realizar dependiendo de la condición. Un ejemplo
3.3. CONDICIONALES. 59
if x%2 == 0:
print "el numero es par"
else:
print "el numero es impar"
3.3.4. El if...elif...else.
La forma general de la construcción if...elif...else, a continuación:
if condition_1:
statements_1
elif condition_2:
statements_2
else:
statements_3
Para más de dos opciones use la construcción con elif. elif es la forma acortada de las
palabras else if. Las instrucciones asociadas a la opción else se ejecutarán si todas las otras
fallan. Un ejemplo concreto
if x<0 :
print x," es negativo"
elif x==0 :
print x," es cero"
elif x>0 :
print x," es positivo"
else:
print x," Error, no es un numero"
3.3.5. La palabra clave pass.

El comando pass no realiza acción alguna, es decir, no hace nada. Un ejemplo
if x<0:
HagaAlgo()
else:
pass
3.3.6. Operadores lógicos.

Los condicionales pueden ser unidos usando las palabras reservadas and, or o not. Si
ocupamos un and para unir dos condiciones lógicas tenemos que ambas condiciones deben
satisfacerse para que el condicional sea cierto. En el caso de ocupar or para unir dos condi-
ciones lógicas una de ellas debe ser satisfecha para que el condicional sea cierto. Finalmente
el not se antepone a una condición y la niega, es decir, será cierto si la condición no es
satisfecha. En todos los caso se aplica que falso == 0 y cierto == 1 (en realidad cierto ! = 0).
A continuación, algunos ejemplos de operadores lógicos:
if x>0 and x<10:
if y>0 and x>0:
if pwd=="code" or pwd=="monster":
if y>0 or x<0:
if not(x<y):
if x>y or not(x<0):
3.3.7. Forma alternativa.

Cuando pruebe valores para < o >, estas pruebas pueden ser escritas como un sólo condi-
cional sin usar el and. Veamos ejemplos
if 0<x<100:
if 1000>=x >=0:
3.4. Funciones Pre-hechas.

Una función define un conjunto de instrucciones. Es un conjunto de código que puede ser
usado una y otra vez. Puede ser creado por usted o importado desde algún módulo. Ejemplos
de funciones:
De cálculo matemático
log, sen, cos, tan, exp, hypot.
Funciones que generan números al azar, funciones de ingreso, funciones que hacen
cambios sobre un string.
Código hecho por el usuario que puede ser reciclado.
Hay un grupo de funciones que vienen hechas, es decir, listas para usar. Para encon-
trar qué funciones están disponibles tenemos la documentación del Python y un sitio web
http://www.python.org/doc/current/modindex.html
Estas funciones pre-hechas vienen en grupos llamados módulos. Para importar en nuestro
código el módulo apropiado, que contiene la función que nos interesa, usamos el comando
import modulo name
Una vez importado el módulo, cuando queremos llamar a la función para usarla, debemos
dar el comando
modulo name.function(arguments)
3.4. FUNCIONES PRE-HECHAS. 61
Veamos un ejemplo com la función hypot del módulo matemático
import math
math.hypot(8,9)
Si analizamos las lı́neas anteriores de código debemos decir que el módulo que contiene las
funciones matemáticas se llama math y éste incluye la función hypot que devuelve el largo
de la hipotenusa. El sı́mbolo . separa el nombre del módulo del de la función. Por supuesto
hypot es el nombre de la función y () es el lugar para los argumentos. Una función podrı́a
no tener argumentos, pero aún ası́ deben ir los paréntesis, son obligatorios. Los números 8,9
son enviados a la función para que los procese. En el ejemplo, estos números corresponden a
los dos catetos de un triángulo rectángulo.
En las secciones anteriores vimos funciones especializadas en el ingreso de strings y de
números. Nos referimos a input() para números y a raw input() para strings. En este caso,
input e raw input corresponden al nombre de las funciones, y entre los paréntesis se acepta
un string como argumento, el cual es desplegado como prompt cuando se da el comando.
Como vimos, este argumento es opcional en ambas funciones, sin embargo, lo incluyan o no,
siempre se deben poner los paréntesis.
Funciones como input() y raw input() están incorporadas al lenguaje y no necesitamos
importar ningún módulo para usarlas.
3.4.1. Algunas funciones incorporadas.

float(obj) Convierte un string u otro número a un número de punto flotante. Con
decimales.
int(obj) Convierte un string u otro número a un número entero. Sin decimales.
long(obj) Convierte un string u otro número a un número entero largo. Sin decimales.
str(num) Convierte un número a un string.
divmod(x,y) Devuelve los resultados de x/y y x %y.
len(s) Retorna el largo de un string u otro tipo de dato (una lista o diccionario).
pow(x,y) Retorna x a la potencia y.
range(start,stop,step) Retorna un conjunto de números desde start hasta stop,

con un paso igual a step.
round(x,n) Retorna el valor del punto flotante x redondeado a n digitos después del
punto decimal. Si n es omitido el valor por defecto es cero.
3.4.2. Algunas funciones del módulo math.

acos(x), asin(x), atan(x) El arcocoseno, el arcoseno y la arcotangente de un núme-
ro.
cos(x), sin(x), tan(x) El coseno, el seno y la tangente de un número.
log(x), log10(x) El logaritmo natural y el logaritmo en base 10 de un número.
pow(x,y) Retorna x a la potencia y.
hypot(x,y) Retorna el largo de la hipotenusa de un triángulo rectángulo de catetos x

e y.
3.4.3. Algunas funciones del módulo string.

capitalize(string) Pone en mayúscula la primera letra de la primera palabra.
capwords(string) Pone en mayúscula la primera letra de todas las palabras.
lower(string) Todas las letras en minúsculas.
upper(string) Todas las letras en mayúsculas.
replace(string,old,new) reemplaza todas las palabras old en string por las pala-
bras new.
center(string, width) Centra el string en un campo de un ancho dado por width.
rjust(string, width) Justifica a la derecha el string en un campo de un ancho dado

por width.
ljust(string, width) Justifica a la izquierda el string en un campo de un ancho

dado por width.
3.4.4. Algunas funciones del módulo random.

randrange(start, stop, step) Da un número al azar entre el número start y el
número stop. El número step es opcional.
choice(sequence) Elige al azar un objeto que pertenece a la sequencia sequence (una

lista). Por ejemplo sequence=["a", "b", "c", "d", "e"].
3.4.5. Algunos otros módulos y funciones.

Una función del módulo time:
sleep(x) El computador queda en pausa por x segundos.
Un par de funciones del módulo calendar:

3.5. FUNCIONES HECHAS EN CASA. 63
prcal(year) Imprime un calendario para el año year.
prmoth(year, month) Imprime un calendario para el mes month del año year.
3.5. Funciones hechas en casa.

Una función define un conjunto de instrucciones. A menudo son almacenadas en conjuntos
llamados módulos. Pueden o no necesitar argumentos. Pueden o no retornar un valor al
programa.
3.5.1. Receta para una función.

Para crear una función primero hay que definir la función, darle un nombre y escribir el
conjunto de instrucciones que la constituyen. La función realizará las instrucciones cuando
es llamada. Después, en el programa, llame la función que ya definió. A continuación veamos
la definición formal de una función hecha por nosotros
def nombre(argumentos):
comandos
Comenzamos con la palabra def, la cual es un palabra requerida. Debe ir en minúsculas.

Luego nombre es el nombre que uno le da a la función. Después vienes los argumentos
(argumentos) que corresponden a las variables que se le pasan a la función para que las
utilice. Finalmente, :, requeridos al final de la lı́nea que define una función. El bloque de
commandos asociados a la función deben tener sangrı́a para identificarlos como parte de la
misma. A continuación, un ejemplo concreto:
# Definiendo la funcion
def mi_function():
print "Nos gusta mucho la Fisica"
# Usando la funcion
mi_function()
La definición de una función puede ser en cualquier parte del programa con la salvedad
que debe ser antes de que la función misma sea llamada. Una vez definidas las funciónes ellas
se ejecutarán cuando sean llamadas. Cuando enviamos valores a nuestras funciones se crean
las variables nombradas en la definición. Por ejemplo:
def mi_function(nombre1, nombre2):

print nombre1+nombre2
Los nombres de las variables de una función sólo serán válidos dentro de la misma función,
esto es lo que se conoce como variables locales). Todas las funciones usan por defecto variables
locales.
3.5.2. Variables globales.

Si desea asignar una variable definida fuera de la función en la función, tiene que utilizar
la sentencia global. Esta se emplea para declarar que la variable es global es decir que no es
local.
Puede utilizar los valores de las variables definidas fuera de la función (y no hay variables
con el mismo nombre dentro de la misma). Sin embargo, esto es inapropiado y debe ser evitado
puesto que llega a ser confuso al lector del programa, en cuanto a donde se ha realizado dicha
definición de variables. Usando la sentencia global queda claro que la variable se define en
un bloque externo.
#!/usr/bin/python
def func():
global x
print ’x es’, x
x = 2
print ’x cambiada a’, x
#main
x = 50
func()
print ’El valor de x es’, x
La salida del programa
x es 50
Cambiada a 2
El valor de x es 2
3.5.3. Pasando valores a la función.

Para enviar los valores a nuestra función ponga los valores en la llamada de la función. El
tipo de los valores debe estar de acuerdo con lo que la función espera. Las funciones pueden
tomar variables u otras funciones como argumentos. Veamos un ejemplo:
def mi_function(nombre1, nombre2):
print nombre1,nombre2
mi_function("azul","rojo")
3.5.4. Valores por defecto de una función.

En algunas funciones, se puede hacer que el uso de algunos parámetros sean opcionales
y usar valores predeterminados si el usuario no desea proporcionarlos (los valores de dichos
parámetros). Esto se hace con la ayuda de valores pre-definidos. Puedes especificar los valores
por defecto después del nombre del parámetro en la definición de la función con el operador
de asignación (=) seguido por el argumento a definir.
#!/usr/bin/python
def say(s, times = 1):

print s * times
say(’Hola’)
say(’Mundo’, 5)
Salida del programa
Hola
MundoMundoMundoMundoMundo
Solamente los parámetros que están en el extremo de la lista de parámetros pueden tener
valores por defecto; es decir, no puedes tener un parámetro con un valor por defecto antes
de uno sin un valor, en el orden de los parámetros declarados, en la lista del parámetro de la
función. Esto se debe a que los valores son asignados a los parámetros por la posición. Por
ejemplo def func(a, b=5) es válido, pero def func(a=5, b) no lo es.
3.5.5. Argumentos claves.

Si se tiene funciones con muchos parámetros y se quiere especificar solamente algunos de
ellos, entonces se puede asignar los valores para tales parámetros con solo nombrarlos, a esto
se denomina argumentos claves. Utilizamos el nombre en vez de la posición que se ha estado
utilizando. Esto tiene dos ventajas: la primera, es que usar la función es más fácil puesto que
no se necesita preocuparnos del orden de los argumentos. La segunda, es que podemos dar
valores solamente a los parámetros que deseamos, a condición de que los otros tengan valores
por defecto. Usando Argumentos Claves
#!/usr/bin/python
def func(a, b=5, c=10):

print ’a es’, a, ’y b es’, b, ’y c es’, c
func(3, 7)
func(25, c=24)
func(c=50, a=100)
La salida es:
a es 3 y b es 7 y c es 10
3.5.6. Documentación de una función, docstrings.

Python tiene una caracterı́stica interesante llamada cadenas de documentación que ge-
neralmente son llamadas por su nombre corto: docstrings. Docstrings es una herramienta
importante de la que se puede hacer uso puesto que ayuda a documentar mejor el programa.
Podemos incluso ubicar docstring en una función a tiempo de ejecución, es decir cuando el
programa está funcionando. Usando Docstrings
#!/usr/bin/python
def printMax(x, y):

’’’Imprime el maximo de 2 numeros.
Los dos valores deben ser enteros. Si hubieran

decimales, son convertidos a enteros.’’’
x = int(x) # Convierte a enteros, si es posible

y = int(y)
if x > y:
print x, ’es maximo’
else:
print y, ’es maximo’
printMax(3, 5)
print printMax.__doc__
La salida
5 es maximo
Imprime el maximo de 2 numeros.
Los dos valores deben ser enteros. Si hubieran

decimales, son convertidos a enteros.
3.5.7. La palabra clave return.

El comando return termina la ejecución de una función. Un ejemplo
import math
def raiz(num):
if num<0:
print "Ingrese un numero positivo"
return
print math.sqrt(num)
Los condicionales como el if son especialmente útil para atrapar y manejar errores. Use
el else para atrapar el error cuando la condición no es satisfecha.
Los if pueden ser anidados. Sea cuidadoso, ya que la anidación puede producir confusión
y deberı́a ser usada con moderación y mesura.
3.5.8. Funciones que tienen un valor de retorno.

Podemos crear funciones que retornen un valor al programa que las llamó. Por ejemplo
def sumalos(x,y):
new = x+y
return new
# Llamada a la funcion
sum = sumalos(5,6)
3.5.9. Recursión.
Se llama recursión cuando una función se llama a si misma. La recursión permite repetir
el uso de una función incluso dentro de la misma función. Un ejemplo es
def count(x):
x=x+1
print x
count(x)
En este caso la función nunca para, este tipo de recursión es llamada recursión infinita.
Para prevenir este situación creamos un caso base. El caso base es la condición que causará que
la función pare de llamarse a si misma. Un ejemplo
def count(x):
if x<100:
x=x+1
print x
count(x)
else:
return
time.sleep(1)
En un ejemplo, más adelante, veremos un programa que calcula el factorial de un número

en forma recursiva.
3.6. Iteraciones con while.

La palabra reservada while puede ser usada para crear una iteración. La instrucción
while necesita una condición que es cierta y luego deja de serlo, por ejemplo un contador
que se incrementa y supera un valor lı́mite. Ejemplo
while x < 10:

print x
x = x+1
Para hacer una sección de código reusable, en vez de usar valores constantes use variables.
Primero un ejemplo no generalizado
while x < 12:

print 2*x
x = x+1
Ahora el mismo ejemplo generalizado
while x < max_num:

print num*x
x = x+1
Utilicemos la instrucción while para hacer una salida ordenada para un programa. El
código de escape del tabulador (\t) en un string permite hacer tabulaciones. Los tabuladores
mantienen los items alineados dando una salida ordenada. Ejemplo, en este caso combinando
la instrucción while y el código de escape del tabulador haremos una tabla:
while x < 10:

print item1, "\t", item2
x = x+1
3.7. Los strings.

Los strings son hechos de pequeñas unidades, cada caracter individual. Cada uno de los
caracteres tiene una dirección numérica dentro del string, donde el primer caracter tiene la
dirección cero (0). Cada caracter individual, o conjunto de caracteres, en un string puede ser
acccesado usando sus direcciones numéricas. Use [ ] para accesar caracteres dentro de un
string. Veamos un ejemplo
palabra = "computador"
letra = palabra[0]
Para acceder un conjunto de caracteres dentro de un string lo podemos hacer como sigue:
Use [#:#] para obtener un conjunto de letras.

parte = palabra[1:3]
3.7. LOS STRINGS. 69
Para tomar desde el comienzo a un punto dado en el string.

parte = palabra[:4]
Para tomar desde un punto dado al final del string.

parte = palabra[3:]
3.7.1. Índice negativos.

Veamos que pasa cuando usamos ı́ndices negativos
>>> a="hola"
>>> a[0]
’h’
>>> a[-1]
’a’
>>> a[-2]
’l’
>>> a[-3]
’o’
>>> a[-4]
’h’
>>> a[-5]
Traceback (most recent call last):
File "<stdin>", line 1, in ?
IndexError: string index out of range
3.7.2. ¿Cuán largo es un string ?

Para encontrar cuántos caracteres tiene un string usamos la función len(string). La
función len requiere un string como argumento. Un ejemplo:
largo = len(palabra)
3.7.3. Recorriendo un string.

Uno puede desear hacer una prueba sobre cada una de las letras que componen el string
todas de una vez. Hay dos maneras de hacer esto usando una instrucción while o una
instrucción for para realizar el ciclo o loop. Primero veamos el ciclo con while:
indice = 0
while indice < len(palabra):
letra = palabra[indice]
print letra
indice=indice +1
3.7.4. Comparando strings.

Los strings pueden ser usados en comparaciones. Ejemplo
if palabra < "cebu":

print palabra
De acuerdo a Python, todas las letras minúsculas. son mayores que las letras mayúsculas
Ası́ .a”>”Z”.
Una buena idea es convertir todos los strings a mayúscula o minúscula, según sea el caso,
antes de hacer comparaciones. Recordemos que el módulo string contiene varias funciones
útiles incluyendo: lower(string), upper(string) y replace(string,string,string). Re-
vise la documentación.
3.8. El ciclo for.

Una manera más compacta de escribir el ciclo while donde se recorrio un strings es
usando un ciclo for, veamos cómo queda el código
for letra in palabra:
print letra
Notemos que hemos creado la variable letra cuando iniciamos el ciclo for. A continuación,
un ejemplo más completo del ciclo for:
#!/usr/bin/env python
# -*- coding: iso-8859-1 -*-
# Programa que cuenta vocales
import string
palabra = raw_input("Entre una palabra : ")

palabra_min = string.lower(palabra)
vocales="aeiouáéı́óú"
contador = 0
for letra in palabra_min:
if letra in vocales:
contador=contador +1
else:
pass
print "El número de vocales en la palabra que ingresó fueron : ", contador
Notemos la segunda lı́nea de este programa que nos permite ingresar e imprimir strings
con caracteres acentuados y caracteres especiales.
3.9. LISTAS. 71
3.8.1. El comando break.

El comando break es capaz de salirse de un ciclo for o while. Un ejemplo que recorre
los números calculando su cuadrado mientras sea menor que 50:
for n in range(1,10):
c=d*d
if c > 50:
print n, "al cuadrado es ",c," > 50"
print "PARO"
break
else:
print n,"su cuadrado es ",c
3.8.2. El comando else.

Un ciclo puede tener una sección else, esta es ejecutada cuando el ciclo termina por
haber agotado la lista, en un ciclo for o cuando la comparación llega a ser falsa en un ciclo
while, pero no cuando el ciclo es ternimado con break. A continuación, un programa que
muestra este hecho y sirve para encontrar números primos
for n in range(2,10):
for x in range(2,n):
if n % x ==0:
print n, "igual a", x,"*", n/x
break
else:
print n,"es un numero primo"
3.9. Listas.
Una lista es un conjunto ordenado de elementos. Las listas están encerradas entre parénte-
sis [ ]. Cada item en una lista está separado por una coma. Veamos ejemplos de listas
mascotas = ["perros", "gatos", "canarios", "elefantes"]

numeros = [1,2,3,4,5,6]
cosas = [ 1, 15, "gorila", 23.9, "alfabeto"]
Un elemento de una lista puede ser otra lista. Una lista dentro de otra lista es llamada
lista anidada. A continuación un ejemplo de listas anidadas
para_hacer = ["limpiar", ["comida perro", "comida gato","comida pez"], "cena"]
3.9.1. Rebanando listas.

Una lista puede ser accesada al igual que un string usando el operador [ ]. Ejemplo
>>> lista=["Pedro", "Andres", "Jaime", "Juan"]

>>> print lista[0]
Pedro
>>> print lista[1:]
[’Andres’, ’Jaime’, ’Juan’]
Para accesar un item en una lista anidada hay que proveer dos ı́ndices. Ejemplo
>>> lista_palabras = ["perro", ["fluffy", "mancha", "toto"], "gato"]

>>> print lista_palabras[1][2]
toto
3.9.2. Mutabilidad.
A diferencia de los strings las listas son mutables, lo que significa que se pueden cambiar.
Ejemplo
>>> string = "perro"

>>> string [2] = "d" # Esta NO es un instruccion VALIDA
Traceback (most recent call last):
File "<stdin>", line 1, in ?
TypeError: object does not support item assignment
En cambio en una lista
>>> lista = ["p", "e", "r", "r", "o"]

>>> lista [2] = "d"
>>> print lista
[’p’, ’e’, ’d’, ’r’, ’o’]
3.9.3. Modificando listas.

Como se muestra en la comparación anterior una lista puede ser cambiada usando el
operador [ ]. Ejemplo

>>> lista[0]="Matias"
>>> print lista
[’Matias’, ’Andres’, ’Jaime’, ’Juan’]
>>> lista[1:2]=["perro","gato"]
>>> print lista
[’Matias’, ’perro’, ’gato’, ’Jaime’, ’Juan’]
3.9.4. Agregando a una lista.

Para agregar items al final de una lista use list.append(item). Ejemplo
3.9. LISTAS. 73

>>> lista.append("Matias")
>>> print lista
[’Pedro’, ’Andres’, ’Jaime’, ’Juan’, ’Matias’]
Notemos que las operaciones que modifican la lista la modificarán de manera tal que si
multiples variables apuntan a la misma lista todas las variables cambiarán al mismo tiempo.
>>> L=[]
>>> M=L
>>> # modifica ambas listas
>>> L.append(obj)
Para crear una lista separada se puede usar el “rebanado” o la función list para crear una
copia.
>>> L=[]
>>> M=L[:] # creando una copia
>>> N=list(L) # crea otra copia
>>> # modifica solo a L
>>> L.append(obj)
3.9.5. Borrando items de una lista.

Use el comando del para remover items basado en el ı́ndice de posición. Ejemplo en forma
interactivo

>>> del lista[1]
>>> print lista
[’Pedro’, ’Jaime’, ’Juan’]
Para remover items desde una lista sin usar el ı́ndice de posición, use el siguiente coman-
do nombre_lista.remove("item") que borra la primera aparición del item en la lista. Un
ejemplo interactivo
>>> jovenes = ["Pancho", "Sole", "Jimmy", "Pancho"]

>>> jovenes.remove("Pancho")
>>> print jovenes
[’Sole’, ’Jimmy’, ’Pancho’]
3.9.6. Operaciones con listas.

Las listas se pueden sumar resultando una sola lista que incluya ambas listas iniciales.
Además, podemos multiplicar una lista por un entero n obteniendo una nueva lista con n
réplicas de la lista inicial. Veamos ejemplos de ambas operaciones en forma interactiva
>>> lista1=["Pedro", "Andres", "Jaime", "Juan"]

>>> lista2=["gato", 2]
>>> print lista1+lista2
[’Pedro’, ’Andres’, ’Jaime’, ’Juan’, ’gato’, 2]
>>> print lista2*2
[’gato’, 2, ’gato’, 2]
>>> print 2*lista2
[’gato’, 2, ’gato’, 2]
3.9.7. ¿Qué contiene una lista?

Con la palabra reservada in podemos preguntar si un item está en la lista, veamos un
ejemplo
lista = ["rojo", "naranjo", "verde", "azul"]

if "rojo" in lista:
haga_algo()
La palabra clave not puede ser combinada con in para hacer la pregunta contraria, es decir,
si un item no está en un lista. Veamos un ejemplo
lista = ["rojo", "naranjo", "verde", "azul"]

if "purpura" not in lista:
haga_algo()
3.9.8. Un ciclo for y las listas.

Los ciclos for pueden ser usados con listas de la misma manera que lo eran con strings,
un ejemplo para mostrarlo
email = ["[email protected]", "[email protected]"]

for item in email:
envie_mail(item)
3.9.9. Otros trucos con listas.

len(list_name) Da el largo de la lista, su número de elementos.
list_name.sort() Pone la lista en orden alfabético y numérico.
random.choice(list_name) Escoge un elemento al azar de la lista.
string.split(list_name) Convierte un string, como una frase, en una lista de pala-

bras.
string.join(list_name) Convierte una lista de palabras en una frase dentro de un

string.
3.10. TUPLAS. 75
3.9.10. Generando listas de números.

La función range(num_init, num_fin, num_paso) toma tres argumentos enteros, el
número de partida, el numero final y el paso, para generar una lista de enteros que co-
mienza en el número de partida, termina con un número menor que el final saltandose el
paso señalado, si se omite el paso el salto será de uno en uno. Veamos ejemplos
range(10) = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
range(2,10) = [2, 3, 4, 5, 6, 7, 8, 9]
range(0,11,2) = [0, 2, 4, 6, 8, 10]
3.10. Tuplas.
Una tupla es una lista inmutable. Una tupla no puede modificarse de ningún modo después
de su creación.
>>> t = ("a", "b", 8)
>>> t[0]
’a’
Una tupla se define del mismo modo que una lista, salvo que el conjunto se encierra entre
paréntesis ( ), en lugar de entre corchetes [ ]. Los elementos de la tupla tienen un orden
definido, como los de la lista. Las tuplas tienen primer ı́ndice 0, como las listas, de modo que
el primer elemento de una tupla t, no vacı́a es siempre t[0]. Los ı́ndices negativos cuentan
desde el final de la tupla, como en las listas. Las porciones funcionan como en las listas.
Advierta que al extraer una porción de una lista, se obtiene una nueva lista; al extraerla
de una tupla, se obtiene una nueva tupla. No hay métodos asociados a tuplas ( tal como
append() en una lista).
No pueden añadirse elementos a una tupla, no pueden eliminarse elementos de una tupla,
no pueden buscarse elementos en una tupla, se puede usar in para ver si un elemento existe
en la tupla.
Las tuplas son más rápidas que las listas. Si está definiendo un conjunto constante de
valores y todo lo que va ha hacer con él es recorrerlo, utilice una tupla en lugar de una
lista. Una tupla puede utilizarse como clave en un diccionario, pero las listas no. Las tuplas
pueden convertirse en listas y vice versa. La función incorporada tuple(lista) toma una
lista y devuelve una tupla con los mismos elementos. La función list(tupla) toma una
tupla y devuelve una lista.
3.11. Parámetros desde la lı́nea de comando.

Python puede recibir parámetros directamente de la lı́nea de comando. La lista sys.argv
los contiene. Supongamos que el programa se llama main.py y es como sigue:
#!/usr/bin/python
import sys
for i in sys.argv:
print i
print sys.argv[0]
Si ejecutamos el programa con la lı́nea de comando
jrogan@huelen:~$ ./main.py h -l --mas xvzf
La salida será
./main.py
h
-l
--mas
xvzf
./main.py
Otro ejemplo, un programa que suma dos números desde la lı́nea de comando,
#!/usr/bin/python
import sys
if (len(sys.argv)>2):
n1=float(sys.argv[1])
n2=float(sys.argv[2])
print n1+n2
else:
pass
Si ejecutamos el programa con la lı́nea de comando
jrogan@huelen:~$ ./suma.py 1.2 3.5
La salida será
4.7
Si se llama el programa con menos argumentos, el programa no hará nada.
3.12. Ejemplos de funciones: raı́z cuadrada y factorial.

3.12.1. Raı́z cuadrada.
Con lo visto hasta ahora, ya podemos escribir un programa que calcule la raı́z cuadrada de
una función. Para escribir una función, debemos tener claro qué se espera de ella: cuántos son
los argumentos que recibirá, si tendrá valor de retorno, y, por cierto, un nombre adecuado.
Para la raı́z cuadrada, es claro que el argumento es un número. Pero ese número podrı́a ser un
entero o un real, evidentemente esperamos que el valor de retorno de la función sea también
un número. Llamando a la función raiz, tenemos la declaración:
3.12. EJEMPLOS DE FUNCIONES: RAÍZ CUADRADA Y FACTORIAL. 77
def raiz(x):
Debido a la naturaleza de la función raı́z cuadrada, raiz() no tendrı́a sentido, y por tanto
no corresponde declararla con un valor default.
Ahora debemos pensar en cómo calcular la raı́z cuadrada. Usando una variante del método
de Newton-Raphson, se obtiene que la secuencia

1 a
xn+1 = xn +
2 xn
√
converge a a cuando n → ∞. Por tanto, podemos calcular la raı́z cuadrada con aproxima-
ciones sucesivas. El cálculo terminará en el paso N , cuando la diferencia entre el cuadrado
de la aproximación actual, xN , y el valor de a, sea menor que un cierto número pequeño:
| x2N − a | < ǫ ≪ 1. El valor de ǫ determinará la precisión de nuestro cálculo. Un ejemplo de
código lo encontramos a continuación:
#!/usr/bin/python
#
# Programa que calcula la raiz cuadrada
import math
def raiz(a):
x =a/2.0 # para comenzar
dx, epsilon = 1e3, 1e-8;
while (math.fabs(dx)>epsilon):
x = (x + a/x)/2;
dx = x*x - a;
print "x = ", x, ", precision = ", dx
return x
# main
r=input("Ingrese un numero: ")

print raiz(r)
Primero está la función raiz, y luego el main. En el main se pide al usuario que ingrese
un número, el cual se aloja en la variable r, y se muestra en pantalla el valor de su raı́z
cuadrada.
En la implementación de la función hay varios aspectos que observar. Se ha llamado x a la
variable que contendrá las sucesivas aproximaciones a la raı́z. Al final del ciclo, x contendrá el
valor (aproximado) de la raı́z cuadrada. dx contiene la diferencia entre el cuadrado de x y el
valor de a, epsilon es el número (pequeño) que determina si la aproximación es satisfactoria
o no.
El ciclo está dado por una instrucción while, y se ejecuta mientras dx>epsilon, es decir,
termina cuando dx es suficientemente pequeño. El valor absoluto del real dx se obtiene con la
función matemática fabs, disponible en el módulo math incluido al comienzo del programa.
Observar que inicialmente dx=1e3, esto es un valor muy grande; esto permite que la condición
del while sea siempre verdadera, y el ciclo se ejecuta al menos una vez.
Dentro del ciclo, se calcula la nueva aproximación, y se envı́a a pantalla un mensaje con
la aproximación actual y la precisión alcanzada (dada por dx). Eventualmente, cuando la
aproximación es suficientemente buena, se sale del ciclo y la función devuelve al main el valor
de x actual, que es la última aproximación calculada.
3.12.2. Factorial.
Otro ejemplo útil es el cálculo del factorial, definido para números naturales:
n! = n · (n − 1) · · · 2 · 1 , 0! ≡ 1 .
Una estrategia es utilizar un ciclo for, determinado por una variable entera i, que va
desde 1 a n, guardando los resultados en una variable auxiliar que contiene el producto de
todos los números naturales desde 1 hasta i:
#!/usr/bin/python
#
# Programa que calcula el factorial
def factorial(i):
f = 1
for j in range(2,i+1):
f = f*j
return f
# main
n=input("Ingrese un numero: ")

print "El factorial de ", n, " es: ", factorial(n)
Observar que la variable auxiliar f, que contiene el producto de los primeros i números
naturales, debe ser inicializada a 1. Si se inicializara a 0, factorial(n) serı́a 0 para todo n.
Esta funcion responde correctamente en el caso n = 0, pero retorna el valor 1 para todos
los enteros negativos.
Otra estrategia para calcular el factorial es hacer uso de su propiedad recursiva
n! = n × (n − 1)! 1! = 0! ≡ 1
Un programa que calcula el factorial en forma recursiva

def fact(n):
if n<2:
return 1
3.13. TRABAJANDO CON ARCHIVOS. 79
else:
return n*fact(n-1)
#main
i=input("Ingrese un natural :")
print "El factorial de",i," es ",fact(i)
3.13. Trabajando con archivos.

El lenguaje Python puede ser usado para crear programas que manipulan archivos sobre
un sistema de archivos en un computador. El módulo os contiene las funciones necesarias
para buscar, listar, renombrar y borrar archivos. El módulo os.path contiene unas pocas
funciones especializadas para manipular archivos. Las funciones necesarias para abrir, leer y
escribir archivos son funciones intrı́nsecas de Python.
3.13.1. Funciones del módulo os.

Funciones que sólo dan una mirada.
getcwd() Retorna el nombre el directorio actual.
listdir(path) Retorna una lista de todos los archivos en un directorio.
chdir(path) Cambia de directorio. Mueve el foco a un directorio diferente.
Función que ejecuta un comando del sistema operativo.
system(’comando’) Ejecuta el comando
Funciones que agregan.
mkdir(path) Hace un nuevo directorio con el nombre dado.
makedirs(path) Hace un subdirectorio y todos los directorios del path requeridos.
Funciones que borran o remueven.
remove(path) Borra un archivo.
rmdir(path) Borra un directorio vacı́o.
removedirs(path) Borra un directorio y todo dentro de él.
Funciones que cambian.
rename(viejo,nuevo) Cambia el nombre de un archivo de viejo a nuevo
renames(viejo,nuevo) Cambia el nombre de un archivo de viejo a nuevo cambiando

los nombres de los directorios cuando es necesario.
3.13.2. Funciones del módulo os.path.

Funciones que verifican.
exists(file) Retorna un booleano si el archivo file existe.
isdir(path) Retorna un booleano si el path es un directorio.
isfile(file) Retorna un booleano si el file es un archivo.
3.13.3. Ejemplo de un código.

Un programa que borra todo un directorio
import os, os.path

path = raw_input("Directorio a limpiar : ")
os.chdir(path)
files= os.listdir(path)
print files
for file in files:
if os.path.isfile(file):
os.remove(file)
print "borrando", file
elif os.path.isdir(file):
os.removedirs(file)
print "removiendo", file
else:
pass
3.13.4. Abriendo un archivo.

Para abrir un archivos debemos dar la instrucción open(filename,mode) donde filename
es el nombre del archivo y el mode corresponde a una de tres letras "r" para lectura solamente
del archivo, "w" para escritura y "a" para agregar al final del archivo. para poder manejar
un archivo abierto hay que crear una variable con él. Ejemplo
salida= open("datos.txt","w")
salidaAppend= open("programa.log","a")
entrada= open("archivo.txt","r")
3.13.5. Leyendo un archivo.

entrada.read() Lee el archivo completo como un string.
entrada.readline() Lee una lı́nea en un string.
entrada.readlines() Lee el archivo completo, cada lı́nea llega a ser un item tipo
string en una lista.
3.13. TRABAJANDO CON ARCHIVOS. 81
3.13.6. Escribiendo a un archivo.

salida.write(string) Escribe el string al archivo. Cómo se escribira este depende
de en qué modo el archivo fue abierto.
salida.writelines(list) Escribe todos los items tipo string en la lista list. Cada
elemento en la lista estará en la misma lı́nea a menos que un elemento contenga una
caracter de newline
Si queremos usar la instruccion print para escribir sobre un archivo abierto, digamos
salida, podemos usar la instrucción
salida = open("resultados.txt", "w")
print >> salida, datos # Imprime datos en el archivo resultados.txt
print >> salida # Imprime una linea en blanco en el archivo resultados.txt
salida.close()
3.13.7. Cerrando un archivo.

file.close() Cierra un archivo previamente abierto.
3.13.8. Archivos temporales.

Las funciones en el módulo tempfile puede ser usadas para crear y manejar archivos
temporales. La instrucción tempfile.mkstemp() devuelve una lista en el que el segundo
item es un nombre al azar que no ha sido usado. Los archivos temporales estarán localizados
en el directorio temporal por defecto.
3.13.9. Ejemplo de lectura escritura.

# Programa que reemplaza una palabra vieja por otra nueva
import string, tempfile, os
# Preguntarle al usuario por Informacion

filename = raw_input("Nombre del archivo: ")
find = raw_input("Busque por: ")
replace = raw_input("Reemplacelo por: ")
# Abra el archivo del usuario, lealo y cierrelo
file = open(filename, "r")
text = file.readlines()
file.close()
# Edite la informacion del archivo del usuario
nueva = []
for item in text:

line = string.replace(item, find, replace)

nueva.append(line)
# Cree un nuevo archivo temporal

newname=tempfile.mkstemp()
temp_filename=newname[1]
newfile = open(temp_filename, "w")
newfile.writelines(nueva)
newfile.close()
# Cambie los nombres de los archivos y borra los temporales

oldfile=filename+"~"
os.rename(filename, oldfile)
os.system(" cp "+temp_filename+" "+filename)
os.remove(temp_filename)
3.14. Excepciones.
Las palabras reservadas try y except pueden ser usadas para atrapar errores de ejecución
en el código. Primero en el bloque try se ejecutan un grupo de instrucciones o alguna función.
Si estas fallan o devuelven un error, el bloque de comandos encabezados por except se
ejecutará. Lo anterior, puede ser usado para manejar programas que pueden fallar bajo
alguna circunstancia de una forma muy elegante.
# Sample Try / Except

def open_file():
filename = raw_input("Entre el nombre del archivo: ")
try:
file = open(filename)
except:
print "Archivo no encontrado."
open_file()
return file
3.15. Diccionarios.
Las listas son colecciones de items (strings, números o incluso otras listas). Cada item en
la lista tiene un ı́ndice asignado.
>>> lista = ["primero", "segundo", "tercero"]

>>> print lista[0]
primero
>>> print lista[1]
segundo
3.15. DICCIONARIOS. 83
>>> print lista[2]

tercero
Para acceder a un valor de la lista uno debe saber su ı́ndice de posición. Si uno remueve
un item desde la lista, el ı́ndice puede cambiar por el de otro item en la lista.
Un diccionario es una colección de items que tiene una llave y un valor. Ellos son parecidos
a las listas, excepto que en vez de tener asignado un ı́ndice uno crea los ı́ndices.
lista = ["primero", "segundo", "tercero"]
diccionario = {0:"primero", 1:"segundo", 2:"tercero"}
Para crear un diccionario debemos encerrar los item entre paréntesis de llave {}. Debemos
proveer una llave y un valor, un signo : se ubica entre la llave y el valor (llave:valor).
cada llave debe ser única. Cada par llave:valor está separado por una coma. Veamos un
par de ejemplos con diccionarios
ingles = {’one’:’uno’, ’two’:’dos’}
Uno en japonés
nihon_go = {}
nihon_go["ichi"] = "uno"
nihon_go["ni"] = "dos"
nihon_go["san"] = "tres"
print nihon_go
{ ’ichi’:’uno’, ’ni’:’dos’, ’san’:’tres’}
Para acceder el valor de un item de un diccionario uno debe entrar la llave. Los diccionarios
sólo trabajan en una dirección. Uno debe dar la llave y le devolverán el valor. Uno no puede
dar el valor y que le devuelvan la llave. Ejemplo
nihon_go = { ’ichi’:’uno’, ’ni’:’dos’, ’san’:’tres’}
print nihon_go[’ichi’]
uno
Notemos que este diccionario traduce del japonés al español pero no del español al japonés.
3.15.1. Editando un diccionario.

Para cambiar un valor de un par, simplemente reası́gnelo
nihon_go["ichi"]=1
Para agregar un par valor:llave, éntrelo

nihon_go["shi"]=cuatro
Para remover un par use del

del nihon_go["ichi"]
Para ver si una llave ya existe, use la función has_key()

nihon_go.has_key("ichi")
Para copiar el diccionario entero use la función o método copy().

japones= nihon_go.copy()
Los diccionarios son mutables. Uno no tiene que reasignar el diccionario para hacer cam-
bios en él.
Los diccionarios son útiles cada vez que usted tiene items que desea ligar juntos. También
son útiles haciendo sustituciones (reemplace todos los x por y). Almacenando resultados
para una inspección rápida. Haciendo menús para programas. Creando mini bases de datos
de información.
3.15.2. Un ejemplo de código, un menú.

import string
def add(num1,num2):
print num1+num2
def mult(num1,num2):
print num1*num2
# Programa
num1 = input("Entre el primer numero: ")
num2 = input("Entre el segundo numero: ")
menu = {’S’:add, ’M’:mult}
print "[S] para sumar, [M] para multiplicar: "
choice = string.upper(raw_input())
menu[choice] (num1,num2)
3.15.3. Tuplas y diccionarios como argumentos.

Si un parámetro formal de la forma **name está presente, la función recibe un diccionario.
Si un parámetro formal de la forma *name está presente, la función recibe una tupla. Los
parámetros formales *name deben ir antes que los **name. Ejemplo
def funcion(*mi_tupla, **nihon_go):

..
3.16. Modules y Shelve.

Algunos problemas que se presentan a medida que los códigos crecen son: con cientos
de lı́neas es muy fácil perderse; trabaja en equipo se hace difı́cil con códigos muy grandes.
Entonces, serı́a bueno poder separar el código en pequeños archivos independientes. Por otra
parte, se nos presenta otra dificultad, no podemos salvar estructuras de datos, es decir, si
creamos un diccionario, sabemos como salvarlo como un archivo de texto, pero no podemos
leerlo como un diccionario. Serı́a bueno poder salvar las listas como listas, los diccionarios
como diccionarios y ası́ luego poder leerlos e incorporarlos a nuestro código en forma fácil.
3.16. MODULES Y SHELVE. 85
3.16.1. Partiendo el código.

El código puede ser dividido en archivos separados llamados modules. Ya hemos usado
varios de estos módulos trabajando en Python (string, math, random, etc.). Para crear un
módulo sólo tipee su código Python y sálvelo de la manera usual. Su módulo salvado puede
ser importado y usado tal como cualquier otro módulo de Python.
3.16.2. Creando un módulo.

Lo principal para almacenar nuestro código en un módulo es escribir código reusable. El
código debe ser principalmente funciones y clases. Evite tener variables o comandos fuera de
la definición de funciones. Las funciones pueden requerir valores desde el programa quien las
llama. Salve el código como un archivo regular .py. Luego en el programa principal, importe
el módulo y úselo.
3.16.3. Agregando un nuevo directorio al path.

Cuando Python busca módulos sólo lo hace en ciertos directorios. La mayorı́a de los
módulos que vienen con Python son salvados en /usr/lib/python. Cuando salve sus pro-
pios módulos seguramente lo hará en un lugar diferente, luego es necesario agregar el nuevo
directorio a sys.path. Hay que consignar que el directorio desde el cual se invoca Python,
si está en el path. Para editar el sys.path, en el modo interactivo tipee
>>> import sys

>>> sys.path #imprime los actuales directorios en el path
>>> sys.path.append(’/home/usuario/mis_modulos’)
Dentro de un script usamos para importar mi módulos mis_funciones que está salvado en
mi directorio de módulos
import sys
sys.path.append(’/home/usuario/mis_modulos’)
import mis_funciones
3.16.4. Haciendo los módulos fáciles de usar.

Como ya vimos los comentarios con triple comilla son usados para agregar documentación
al código, ejemplo
def mi_funcion(x,y):
"""mi_funcion( primer nombre, ultimo nombre) """
Use al principio y al final triple comilla. El texto en triple comilla deberı́a explicar lo que
la función, clase o módulo hace. Estas lı́neas de documentación las podré ver, en el modo
interactivo, si da el comando help(module.mi_funcion).
3.16.5. Usando un módulo.

En el programa principal incluya el comando import y el nombre del módulo. Cuando
llame a una función del módulo debe incluir el nombre del módulo . el nombre de la función,
esta no es la única manera de importarlos, veamos unos ejemplo, primero la forma habitual:
# Sean f(x,y) una funcion y C una clase con un metodo m(x) del modulo stuff
import stuff
print stuff.f(1,2)
print stuff.C(1).m(2)
una segunda forma
from stuff import f, C
print f(1,2)
print C(1).m(2)
una tercera forma
from stuff import *
print f(1,2)
print C(1).m(2)
una última manera
import stuff as st
print st.f(1,2)
print st.C(1).m(2)
3.16.6. Trucos con módulos.

Un módulo puede ser corrido como programa independiente si incluı́mos las siguientes
lı́neas en el final
if __name__ == ’__main__’:
funcion_a_correr()
Sustituya funcion_a_correr() por el nombre de la función principal en el módulo.

3.16. MODULES Y SHELVE. 87
3.16.7. Preservando la estructura de la información.

Existen dos métodos de preservar la data:
El módulo pickle almacena una estructura de datos de Python en un archivo binario.

Está limitado a sólo una estructura de datos por archivo.
El módulo shelve almacena estructuras de datos de Python pero permite más de una
estructura de datos y puede ser indexado por una llave.
3.16.8. ¿Cómo almacenar?

Importe el módulo shelve, abra un archivo shelve, asigne un item, por llave, al archivo
shelve. Para traer la data de vuelta al programa, abra el archivo shelve y accese el item
por llave. Los shelve trabajan como un diccionario, podemos agregar, accesar y borrar items
usando sus llaves.
3.16.9. Ejemplo de shelve.

import shelve
colores = ["verde", "rojo", "azul"]
equipos = ["audax", "union", "lachile"]
shelf = shelve.open(’mi_archivo’)
# Almacenendo items
shelf[’colores’] = colores
shelf[’equipos’] = equipos
# trayendolos de vuelta
newlist = shelf[’colores’]
# Cerrando
shelf.close()
3.16.10. Otras funciones de shelve.

Para tomar una lista de todas las llaves disponibles en un archivo shelve, use la función
keys():
lista = shelf.keys()
Para borrar un item, use la función del:

del shelf(’ST’)
Para ver si una llave existe, use la función has_key():

if shelf.has_key(’ST’): print "si"
3.17. Clases y métodos.

Las clases son colecciones de data y funciones que pueden ser usadas una y otra vez. Para
crear una clase parta con la palabra reservada class, luego necesita un nombre para la clase.
Los nombres de las clases, por convención, tiene la primera letra en mayúscula. Después del
nombre termine la lı́nea con un : y entonces cree el cuerpo de la clase, las instrucciones que
forman el cuerpo deben ir con sangrı́a. En el cuerpo cree las definiciones de las funciones,
cada función debe tomar self como parámetro.
class MiClase:
def hola(self):
print "Bienvenido. "
def math(self,v1,v2):
print v1+v2
Declarando y luego usando la clase
class MiClase:
def hola(self):
print "Bienvenido. "
def math(self,v1,v2):
print v1+v2
fred = MiClase()
fred.hola()
fred.math(2,4)
Creamos una instancia de una clase al asignarla a una variable, fred = MiClase(). Para
aplicar una función o método a una nueva instancia debemos especificar en forma completa
la instancia y el método fred.hola(). Si el método toma argumentos debemos estar seguro
de incluir todos los valores necesitados, por ejemplo fred.math(2,4).
3.17.1. Clase de muestra LibretaNotas.

class LibretaNotas:
def __init__(self, name, value):
self.nombre = name
self.puntaje = value
self.evaluaciones = 1
def sumanota(self, puntos):
self.evaluaciones += 1
self.puntaje += puntos
self.promedio = self.puntaje/float(self.evaluaciones)
def promedio(self)
print self.nombre, ": promedio =", self.promedio
3.17. CLASES Y MÉTODOS. 89
Las variables dentro de una clase deben ser accesadas poniendo el prefijo a su nombre la
palabra self.
La función __init__ es la que correrá si una nueva instancia de la clase es creada. Esta
función es especial y se conoce como el constructor de la clase.
Usando la clase LibretaNotas
eli = LibretaNota(’Elizabeth’, 6.5)

mario = LibretaNota(’Mario’, 6.0)
carmen = LibretaNota(’Carmen’, 6.1)
eli.sumanota(6.2)
mario.sumanota(6.1)
carmen.sumanota(6.3)
eli.sumanota(6.8)
mario.sumanota(6.7)
carmen.sumanota(6.6)
eli.promedio()
mario.promedio()
carmen.promedio()
Cada nueva instancia de la clase LibretaNotas debe tener un nombre y una primera nota
porque ası́ lo requiere la función constructor __init__. Notemos que cada instancia tiene su
propio promedio.
3.17.2. Valores por defecto.

Una función puede tener valores por defecto, estos valores son usados sólo cuando la
función es llamada sin especificar un valor. Ejemplo
def potencia(voltaje, corriente=0):

return voltaje*corriente
# Podemos llamarla
potencia(220)
potencia(voltaje=110, corriente=5)
Veamos un ejemplo de valores por defecto en una clase
class Dinero:
def __init__(self, amount = 0) :
self.amount=amount
def print(self):
print "Tienes", self.amount, "de dinero"
# Llamadas posibles
mi_dinero = Dinero(100)
tu_dinero = Dinero()
mi_dinero.print()
tu_dinero.print()
3.18. Sobrecarga de Operadores.

Las clases pueden redefinir comandos regulares de Python. Cambiar como los comandos
regulares trabajan en una clase se llama sobrecarga de operadores. Para definir la sobrecarga,
debemos usar nombres especiales cuando definimos los métodos. Las definiciones sobrecarga-
das deben retornar un valor. Veamos un ejemplo de sobrecarga
class Loca:
def __init__(self, num1=2):
self.num1=num1
def __del__(self):
print "%d Destruido!" % self.num1
def __repr__(self):
return "Su numero es %d" % self.num1
def __add__(self, newnum):
return newnum*self.num1
Notemos que tenemos un método nuevo, el destructor que es la función que se invoca
cuando un objeto se destruye. A continuación, una lista de nombre especiales para sobrecargar
los operadores
__add__ La suma +.
__sub__ La resta −.
__mul__ La multiplicación ∗.
__div__ La división /.
__pow__ La exponenciación ∗∗.
__repr__ El comando print.
__len__ El comando len(x).
__call__ El comando de llamada x().
__init__ El método constructor.
__del__ El método destructor.
3.18.1. Función driver.

Una función driver es puesta al final de la clase para probarla. La función toma la forma
if __name__ == ’__main__’:
funcion_a_correr()
Cuando una clase o módulo es llamado como programa principal, correrá este código.
3.18. SOBRECARGA DE OPERADORES. 91
3.18.2. Atributos de las clases.

La información que necesita acceder una clase en cada una de sus instancias u objetos
puede ser almacenada en atributos de la clase. Los valores serán creados fuera de las defi-
niciones de las funciones de la clase. La data será accesada dentro de las definición de las
funciones o métodos de la clase usando la notación NombredelaClase.NombredelaVariable.
Un ejemplo
class Cuentas:
alumnos=[]
def __init__(self,nombre):
self.nombre=nombre
Cuentas.alumnos.append(self.nombre)
def __del__(self)
Cuentas.alumnos.remove(self.nombre)
Notese que la lista de alumnos es siempre llamada por su nombre completo Cuentas.alumnos.
Para acceder a la lista fuera de la clase, use su nombre completo Cuentas.alumnos.
3.18.3. Ejemplo de clase vectores.

Escribamos un módulo vec2d.py con una clase de vectores bidimensionales sobrecargando
la suma, la resta, el producto, la impresión, entre otros métodos
from math import sqrt
class Vec2d:
def __init__(self, x=0, y=0):
self.x = x
self.y = y
def module(self):
return sqrt(self.x**2+self.y**2)
def __repr__(self):
return "(%11.5f,%11.5f)" % (self.x,self.y)
def __add__(self,newvec):
return Vec2d(self.x+newvec.x,self.y+newvec.y)
def __sub__(self,newvec):
return Vec2d(self.x-newvec.x,self.y-newvec.y)
def __mul__(self,newvec):
return self.x*newvec.x+self.y*newvec.y
Ahora un programa que ocupa el módulo
from vec2d import *

a=Vec2d(1.3278,2.67)
b=Vec2d(3.1,4.2)
print a, b
print a+b
print a-b
print a*b
print a.module(),b.module()
3.19. Algunos módulos interesantes.

Hay muchos módulos que le pueden ser útiles, aquı́ le sugerimos unos pocos particular-
mente importantes.
3.19.1. El módulo Numeric.

Extensión numérica de Python que agrega poderosos arreglos multidimensionales.
>>> import Numeric as num

>>> a = num.zeros((3,2), num.Float)
>>> a
array([[ 0., 0.],
[ 0., 0.],
[ 0., 0.]])
>>> a[1]=1
>>> a
array([[ 0., 0.],
[ 1., 1.],
[ 0., 0.]])
>>> a[0][1]=3
>>> a
array([[ 0., 3.],
[ 1., 1.],
[ 0., 0.]])
>>> a.shape
(3, 2)
3.20. El módulo Tkinter

Este paquete es el encargado de ayudarnos a desarrollar la interfaz gráfica con el usuario
de nuestro programa. Para comenzar a utilizarlo veamos el siguiente ejemplo:
3.20. EL MÓDULO TKINTER 93
Ejemplo Al ejecutar el programa
from Tkinter import *

vent=Tk()
etiqueta=Label(vent, text="Hola Mundo!!")
etiqueta.grid(row=1, column=1)
vent.mainloop()
En la primera linea importamos el módulo Tkinter, en la segunda creamos la ventana, la

que es proporcionada por el window manager, en la tercera linea generamos una etiqueta, y
que en particular para este ejemplo ocupamos la opción de texto “text”, en la cuarta linea
ubicamos la etiqueta en la fila 1 y la columna 1 de la ventana (como no hay mas elementos
en el ejemplo, la ventana se distribuye como una matriz de 1 × 1) y en la última linea se dice
al computador que ejecute la orden (e.d. la ventana no aparecerá antes de leer esta linea),
por lo que toda acción escrita después de esta linea no aparecerá en la ventana.
3.20.1. Elementos importantes en una ventana.

La forma de configurar un elemento en la ventana es de la forma:
Funcion(master, opcion1=valor1, opcion2=valor2, ...)
Donde cada elemento esta determinado por una Funcion, la variable master es la que
determina a la ventana particular (como en el ejemplo anterior lo era vent), y todas las
opciones siguientes tienen un valor por defecto que podemos cambiar solo enunciándolas y
dandole el nuevo valor. Algunos de los elementos que podemos agregar son:
1. Etiquetas
Se enuncian llamando a la función Label(...), cuyas opciones son:
text : El texto que llevará escrito la etiqueta. (p.e. text=‘‘Hola!’’)

image : Si quiero agregar una imagen. (p.e. image=imagen1 )
fg : El color del texto, si es que la etiqueta esta conformada por texto (p.e. fg=‘‘red’’)
bg : El color del fondo de la etiqueta (p.e. bg=‘‘black’’)
width : Nos dice el largo de la etiqueta en la ventana (p.e. width=100)
2. Botones
Se enuncian llamando a la función Button(...), tiene las mismas opciones que la
etiqueta y además se le agragan las siguientes:
command : Aqui ponemos el nombre de la función que se ejecuta cuando se clickea el

boton.
1
Donde la variable imagen está determinada por la función imagen=PhotoImage(file=‘‘archivo.gif’’)
relief : Es el relieve que tendra el boton, esta variable puede tomar los valores FLAT,
RAISED, SUNKEN, GROOVE y RIDGE, el valor por defecto es RAISED, estéti-
camente se ven:
cursor : Es el nombre del cursor que aparece cuando pasamos el mouse sobre el boton,
algunos de los valores que puede tomar esta opción son: arrow, mouse, pencil,
question arrow, circle, dot, star, fleur, hand1, heart, xterm, etc.
bitmap : Los bitmaps son imágenes prehechas que vienen incorporadas en Tkinter,
algunos de los valores que puede tomar ésta variable son: error, hourglass,
info, questhead, question, warning, etc, estéticamente se ven:
3. Input
Es equivalente a la opción raw input, y se enuncia llamando a la función Entry(...),
tiene disponibles las opciones witdh, bg, fg, cursor, entre otros. Se ve de la forma:
4. Boton de Checkeo
Se llama con la función Checkbutton(...) y tiene las mismas opciones que Button(),
se ve ası́:
5. Menú
Para crear un menú debemos generar una variable similar al master que determinaba
la ventana, pero esta vez para determinar al menú, la forma de hacer esto es con la
función Menu(...), cuyo argumento debe ser la variable que representa a la ventana.
Luego, con esta variable puedo crear un menú, veamos el siguiente ejemplo:
vent=Tk()
.
.
.
men=Menu(vent)
archivo=Menu(men, tearoff=0)
men.add_cascade(label="Archivo", men=archivo)
archivo.add_command(label="Abrir", command=A)
archivo.add_command(label="Nuevo", command=B)
archivo.add_command(label="Salir", command=C)
editar=Menu(men, tearoff=0)
men.add_cascade(label="Editar", men=editar)
editar.add_command(label="Copiar", command=D)
editar.add_command(label="Cortar", command=E)
vent.config(menu=men)
.
.
.
vent.mainloop()
El código anterior generará un menú llamado Archivo, que contiene las opciones Abrir
(cuya funcion es A()), Nuevo (cuya función es B()) y Salir (con función C()), y otro
menú llamado Editar, de similares caracterı́sticas.
3.20.2. Ubicación de un elemento en la ventana.

Para ubicar en la ventana los distintos elementos existe la función grid(... ) cuyos
argumentos son desde que fila (row) hasta que fila (rowspan) y desde que columna (column)
hasta que columna (columnspan) se encuentra el lugar que determinaré para el elemento
particular, es importante saber que las filas se enumeran de arriba hacia abajo y las columnas
de izquierda a derecha. Para ejecutar grid() correctamente debemos escribirla seguida de
un punto despues de la variable que tiene asignada el elemento, por ejemplo:
vent=Tk()
.
.
.
A=Label(vent, text="hola")
B=Button(vent, text="aceptar", command=F)
A.grid(row=1, rowspan=2, column=1, columnspan=3)
B.grid(row=3, column=1)
.
.
.
vent.mainloop()
El código anterior pondrá el texto “hola” desde la primera fila hasta la segunda y desde
la primera columna hasta la tercera, y debajo, en la fila 3 y la columna 1 pondrá un botón
que dice “aceptar” y ejecuta la función F.
3.20.3. Atributos del master.

El master como ya lo hemos visto, es la variable que está determinada por la función
Tk(), y la forma de darle distintos atributos es:
master.atributo(valor) ó master.atributo(opcion1=valor1,...)
Algunos de los atributos que le puedes asignar a una ventana son.
Tı́tulo : La forma de ponerle el tı́tulo a la ventana es dando la orden:

master.title("texto en el titulo de mi ventana")
Geometrı́a : Se refiere a las dimensiones de la ventana (la unidad que se ocupa es 0,023
cm), se debe dar la orden:
master.geometry("nxm"), donde n=ancho y m=alto.
Configuración : Aquı́ ponemos algunas de las caracterı́sticas generales de la ventana, como

por ejemplo, el color de fondo, el cursor que aparece cuando el mouse pasa sobre ella,
etc. Se debe dar la orden:
master.configure(cursor="nombre cursor", background= "color")
3.20.4. Un ejemplo más elaborado.

Veamos un ejemplo usando los elementos explicados.
#IMPORTO EL PAQUETE
from Tkinter import *
#DEFINO UNA FUNCION

def salir():
vent.destroy()
#DEFINO EL MASTER
vent=Tk()
#ATRIBUTOS DEL MASTER

vent.title("Ejemplo")
vent.geometry("350x120")
vent.configure(cursor="spider")
#GUARDO UNA IMAGEN EN LA VARIABLE dibujo1

dibujo1 = PhotoImage(file="tux.gif")
#DEFINO LOS ELEMENTOS DE LA VENTANA

Dibujo1 = Label(vent, image=dibujo1, bg="white")
Nombre = Label(vent, text="Nombre", fg="white", bg="red")
nombre = Entry(vent, width=20, bg="white")
Apellido = Label(vent, text="Apellido", fg="white", bg="red")
apellido = Entry(vent, width=20, bg="white")
boton = Button(vent,width=30, text="Salir", cursor="hand1", \
fg="white", bg="black", command=salir)
#UBICO LOS ELEMENTO EN LA VENTANA

Dibujo1 .grid(row=1, rowspan=3, column=1)
Nombre .grid(row=1, column=2)
nombre .grid(row=1, column=3)
Apellido.grid(row=2, column=2)
apellido.grid(row=2, column=3)
boton .grid(row=3, column=2, columnspan=3)
#EJECUTO EL CODIGO
vent.mainloop()
Al ejecutar el programa el resultado es:
3.20.5. El módulo Visual.

Un módulo que permite crear y manipular objetos 3D en un espacio 3D.
Capı́tulo 4
Una breve introducción a C++.

versión 7.60, 13 de Noviembre del 2007
En este capı́tulo se intentará dar los elementos básicos del lenguaje de programación
C++. No se pretende más que satisfacer las mı́nimas necesidades del curso, sirviendo como
un ayuda de memoria de los tópicos abordados, para futura referencia. Se debe consignar que
no se consideran todas las posibilidades del lenguaje y las explicaciones están reducidas al
mı́nimo.
4.1. Estructura básica de un programa en C++.

4.1.1. El programa más simple.
El primer ejemplo de todo manual es el que permite escribir “Hola” en la pantalla.
//
// Los comentarios comienzan con //
//
#include <iostream>
int main()
{
cout << "Hola." << endl;
return 0 ;
}
Las tres primeras lı́neas corresponden a comentarios, todo lo que está a la derecha de
los caracteres // son comentarios y no serán considerados en la compilación. En la lı́nea
siguiente se incluye un archivo de cabecera, o header, con la instrucción de preprocesador
#include. El nombre del archivo se puede escribir como <nombre> o bien "nombre.h". En
el primer caso el archivo nombre será buscado en el path por defecto para los include,
tı́picamente /usr/include o /usr/include/c++/3.x/ en el caso de headers propios de C++;
en el segundo caso la búsqueda se hace en el directorio local. También podrı́amos incluir
un path completo cuando se ocupan las comillas. En nuestro ejemplo se incluye el archivo
iostream, en el cual se hacen las definiciones adecuadas para el manejo de la entrada y salida
en C++. Este archivo es necesario para enviar luego un mensaje a pantalla.
99
100 CAPÍTULO 4. UNA BREVE INTRODUCCIÓN A C++.
La función int main es donde comienza a ejecutarse el programa; siempre debe haber una
función main en nuestro programa. Debido a imposiciones del sistema operativo la función
main devuelve un entero y por tanto debe ser declarada int. Los paréntesis vacı́os () indican
que el main no tiene argumentos de entrada (más adelante se verá que puede tenerlos). Lo
que está encerrado entre llaves {} corresponde al cuerpo de la función main. Cada una de
las lı́neas termina con el carácter ;. El identificador predefinido cout representa la salida a
pantalla. El operador << permite que lo que está a su derecha se le dé salida por el dispositivo
que está a su izquierda, en este caso cout. Si se quiere enviar más de un objeto al dispositivo
que está al inicio de la lı́nea agregamos otro operador <<, y en este caso lo que está a la
derecha del operador se agregará a lo que está a la izquierda y todo junto será enviado al
dispositivo. En nuestro caso se ha enviado endl, un objeto predefinido en el archivo iostream
que corresponde a un cambio de lı́nea, el cual será agregado al final del mensaje. La lı́nea
final contiene la instrucción de retorno del entero cero, return 0.
Si escribimos nuestro primer programa en el editor xemacs con el nombre de primero.cc
las instrucciones para editarlo, compilarlo y correrlo serán:
jrogan@pucon:~/tmp$ xemacs primero.cc

jrogan@pucon:~/tmp$ g++ -Wall -o primero primero.cc
jrogan@pucon:~/tmp$ ./primero
Hola.
jrogan@pucon:~/tmp$
Luego de la compilación, un archivo ejecutable llamado primero es creado en el directo-

rio actual. Si el directorio actual no está en el PATH, nuestro programa debe ser ejecutado
anteponiendo ./. Si está en el PATH, para ejecutarlo basta escribir primero. (Para agre-
gar el directorio local al PATH basta editar el archivo ~/.bashrc agregarle una lı́nea como
PATH="${PATH}:." y ejecutar en la lı́nea de comando source ~/.bashrc para que los cam-
bios tengan efecto.)
4.1.2. Definición de funciones.

Las funciones en C++ son muy importantes, pues permiten aislar parte del código en
una entidad separada. Esto es un primer paso a la modularización de nuestro programa,
es decir, a la posibilidad de escribirlo en partes que puedan ser editadas de modo lo más
independiente posible. Ello facilita enormemente la creación de código complicado, pues sim-
plifica su modificación y la localización de errores. Nos encontraremos frecuentemente con
este concepto.
Aprovecharemos de introducir las funciones modificando el primer programa de manera
que se delegue la impresión del mensaje anterior a una función independiente:
//
// Segunda version incluye funcion adicional
//
#include <iostream>
4.1. ESTRUCTURA BÁSICA DE UN PROGRAMA EN C++. 101
void PrintHola()
{
}
int main()
{
PrintHola();
return 0;
}
La función debe estar definida antes de que sea ocupada, por eso va primero en el código
fuente. Como ya se dijo antes, la ejecución del programa comienza en la función main a
pesar de que no está primera en el código fuente. Los paréntesis vacı́os indican que la función
PrintHola no tiene argumentos y la palabra delante del nombre de la función indica el tipo
de dato que devuelve. En nuestro caso la palabra void indica que no devuelve nada a la
función main.
Una alternativa al código anterior es la siguiente:
#include <iostream>
void PrintHola();
int main()
{
PrintHola();
return 0 ;
}
void PrintHola()
{
}
En esta versión se ha separado la declaración de la función de su implementación. En

la declaración se establece el nombre de la función, los argumentos que recibe, y el tipo de
variable que entrega como resultado. En la implementación se da explı́citamente el código
que corresponde a la función. Habı́amos dicho que una función debe estar definida antes que
sea ocupada. En verdad, basta con que la función esté declarada. La implementación puede
ir después (como en el ejemplo anterior), o incluso en un archivo distinto, como veremos más
adelante. La separación de declaración e implementación es otro paso hacia la modularización
de nuestro programa.
4.1.3. Nombres de variables.

Nuestros datos en los programas serán almacenados en objetos llamados variables. Para
referirnos a ellas usamos un nombre que debe estar de acuerdo a las siguientes reglas:
– Deben comenzar con una letra (mayúsculas y minúsculas son distintas).
– Pueden contener números, pero no comenzar por uno.
– Pueden contener el sı́mbolo _ (underscore).
– Longitud arbitraria.
– No pueden corresponder a una de las palabras reservadas de C++1 :

asm delete if return try
auto do inline short typedef
break double int signed union
case else long sizeof unsigned
catch enum new static virtual
char extern operator struct void
class float private switch volatile
const for protected template while
continue friend public this
default goto register throw
4.1.4. Tipos de variables.

Todas las variables a usar deben ser declaradas de acuerdo a su tipo. Por ejemplo, si
usamos una variable i que sea un número entero, debemos, antes de usarla, declararla, y sólo
entonces podemos asignarle un valor:
int i;
i=10;
Esta necesidad de declarar cada variable a usar se relaciona con la caracterı́stica de C++ de
ser fuertemente “tipeado”2 . Algunos de los errores más habituales en programación se deben
al intento de asignar a variables valores que no corresponden a sus tipos originales. Si bien
esto puede no ser muy grave en ciertos contextos, a medida que los programas se vuelven
más complejos puede convertirse en un verdadero problema. El compilador de C++ es capaz
de detectar los usos indebidos de las variables pues conoce sus tipos, y de este modo nuestro
código se vuelve más seguro.
Es posible reunir las acciones de declaración e inicialización en una misma lı́nea:
int i=10;
1
A esta tabla hay que agregar algunas palabras adicionales, presentes en versiones más recientes de C++,
como namespace y using
2
Una traducción libre del término inglés strongly typed.
o declarar más de una variable del mismo tipo simultáneamente, e inicializar algunas en la
misma lı́nea:
int r1, r2, r3 = 10;
A veces se requiere que una variable no varı́e una vez que se le asigna un valor. Por ejemplo,
podrı́amos necesitar definir el valor de π = 3.14159..., y naturalmente no nos gustarı́a que,
por un descuido, a esa variable se le asignara otro valor en alguna parte del programa. Para
asegurarnos de que ello no ocurra, basta agregar el modificador const a la variable:
const float pi = 3.14159;
Para números reales se puede usar la notación exponencial. Por ejemplo, 1.5e-3 repre-
senta el número 1.5 × 10−3 .
Una variable puede ser declarada sólo una vez, pero naturalmente se le pueden asignar
valores en un número arbitrario de ocasiones.
Los 15 tipos de datos aritméticos fundamentales disponibles son3 :
Booleanos y caracteres
bool Booleanas true o false.
char Caracteres de 0 a 255 o -128 a 127, usa 8 bits,
signed char Caracteres −128 a 127,
unsigned char Caracteres de 0 a 255.
Enteros
short Enteros entre −215 = −32768 y 215 − 1 = 32767
unsigned short Enteros entre 0 y 65535
int Enteros entre −231 = −2147483648 y 231 − 1 = 2147483647
unsigned int Enteros entre 0 y 232 = 4294967295
long (32 bits) Entero entre −2147483648 y 2147483647,
long (64 bits) Entero entre −9223372036854775808 y 9223372036854775807,
unsigned long (32 bits) Enteros entre 0 y 4294967295,
unsigned long (64 bits) Enteros entre 0 y 18446744073709551615,
long long Enteros entre −9223372036854775808 y 9223372036854775807
unsigned long long Enteros entre 0 y 18446744073709551615
Float
float Reales x tal que 1.17549435 × 10−38 ≤ |x| ≤ 3.40282347 × 1038 ,
(Precisión de 7 dı́gitos decimales.)
double Reales x tal que
2.2250738585072014 × 10−308 ≤ |x| ≤ 1.7976931348623157 × 10308 ,
long double Reales x tal que
3.36210314311209350626 × 10−4932 ≤ |x| ≤ 1.18973149535723176502 × 104932 ,
3
Los valores de los rangos indicados son simplemente representativos y dependen de la máquina utilizada
(32 bits o 64 bits). Además, estos valores no corresponden exactamente a las versiones más recientes de C++.
Las variables tipo char alojan caracteres, debiendo inicializarse en la forma:

char c = ’a’;
Además de las letras mayúsculas y minúsculas, y sı́mbolos como &, (, :, etc., hay una
serie de caracteres especiales (escape codes) que es posible asignar a una variable char. Ellos
son:
newline \n
horizontal tab \t
vertical tab \v
backspace \b
carriage return \r
form feed \f
alert (bell) \a
backslash \\
single quote \’
double quote \"
Por ejemplo, la lı́nea:
cout << "Primera columna\t Segunda columna\n
Segunda linea" << endl;
corresponde al output
Primera columna Segunda columna
Segunda linea
4.1.5. Ingreso de datos desde el teclado.

El header iostream define un objeto especial llamado cin que está asociado al teclado o
stdin. Con el operador >> asignamos la entrada en el dispositivo de la izquierda a la variable
de la derecha; una segunda entrada requiere de otro operador >> y de otra variable. En el
siguiente ejemplo veremos una declaración simultánea de dos variables del mismo tipo i y
j, un mensaje a pantalla con las instrucciones a seguir, el ingreso de dos variables desde el
teclado y luego su escritura en la pantalla.
#include <iostream>
int main()
{
int i, j ;
cout << "Ingrese dos numeros enteros: " ;
cin >> i >> j ;
cout << "Los dos numeros ingresados fueron: " << i <<" "<< j << endl ;
return 0;
}
4.1.6. Operadores aritméticos.

Existen operadores binarios (i.e., que actúan sobre dos variables, una a cada lado del
operador) para la suma, la resta, la multiplicación y la división:
+ - * /
4.1.7. Operadores relacionales.

Los sı́mbolos para los operadores relacionales de igualdad, desigualdad, menor, menor o
igual, mayor y mayor o igual son:
== != < <= > >=
Para las relaciones lógicas AND, OR y NOT:
&& || !
4.1.8. Asignaciones.
a) Asignación simple. Podemos asignar a una variable un valor explı́cito, o el valor de otra
variable:
i = 1;
j = k;
Una práctica habitual en programación es iterar porciones del código. La iteración

puede estar determinada por una variable cuyo valor aumenta (disminuye) cada vez,
hasta alcanzar cierto valor máximo (mı́nimo), momento en el cual la iteración se detiene.
Para que una variable x aumente su valor en 2, por ejemplo, basta escribir:
x = x + 2;
Si x fuera una variable matemática normal, esta expresión no tendrı́a sentido. Esta
expresión es posible porque el compilador interpreta a x de modo distinto a cada lado
del signo igual: a la derecha del signo igual se usa el valor contenido en la variable x
(por ejemplo, 10); a la izquierda del signo igual se usa la dirección de memoria en la
cual está alojada la variable x. De este modo, la asignación anterior tiene el efecto de
colocar en la dirección de memoria que contiene a x, el valor que tiene x más 2. En
general, todas las variables tienen un rvalue y un lvalue: el primero es el valor usado a
la derecha (right) del signo igual en una asignación, y el segundo es el valor usado a la
izquierda (left), es decir, su dirección de memoria.
b) Asignación compuesta.
La expresión x = x + 2 se puede reemplazar por x += 2.
Existen los operadores += -= *= /=
c) Operadores de incremento y decremento.

La expresión x = x + 1 se puede reescribir x += 1 o bien x++.
Análogamente, existe el operador --. Ambos operadores unarios, ++ y -- pueden ocu-
parse como prefijos o sufijos sobre una variable y su acción difiere en ambos casos.
Como prefijo la operación de incremento o decremento se aplica antes de que el valor
de la variable sea usado en la evaluación de la expresión. Como sufijo el valor de la va-
riable es usado en la evaluación de la expresión antes que la operación de incremento o
decremento. Por ejemplo, supongamos que inicialmente x = 3. Entonces la instrucción
y=x++ hace que y = 3, x = 4; por su parte, y=++x hace que y = 4, x = 4.
Con estas consideraciones, deberı́amos poder convencernos de que la salida del siguiente
programa es 3 2 2-1 1 1 :
// Ejemplo de operadores unarios ++ y --.

#include <iostream>
int main()
{
int y ; int x = (y = 1) ;
int w = ++x + y++;
cout << w <<" " << x << " " << y << "-" ;
w = x-- - --y;
cout << w << " " << x << " " << y << endl ;
return 0;
}
Los operadores para asignación compuesta, y los de incremento y decremento, no son sólo
abreviaciones. En realidad hay que preferirlas porque implican optimizaciones en el ejecutable
resultante.
4.1.9. Conversión de tipos.

Una consecuencia de que C++ sea fuertemente “tipeado” es que no se pueden hacer
operaciones binarias con objetos de tipos distintos. En la siguiente expresión,
int i = 3;
float x = 43.8;
cout << "Suma = " << x + i << endl;
el computador debe sumar dos variables de tipos distintos, y en principio la operación es

imposible. La estrategia para resolver este problema es convertir ambas variables a un tipo
común antes de efectuar la suma (en inglés, decimos que hacemos un cast de un tipo a otro).
Existen dos modos de proceder:
a) Conversión explı́cita.
Si i es un int, por ejemplo, entonces float(i) la convierte en float. Ası́, el programa
anterior se puede reescribir:
int i = 3;
float x = 43.8;
cout << "Suma = " << x + float(i) << endl;
Ahora la suma es claramente entre dos variables float, y se puede realizar. Sin em-
bargo, esto es bastante tedioso, por cuanto el programador debe realizar el trabajo de
conversión personalmente cada vez que en su código se desee sumar un real con un
número entero.
b) Conversión implı́cita.
En este caso, el compilador realiza las conversiones de modo automático, prefiriendo
siempre la conversión desde un tipo de variable de menor precisión a uno de mayor
precisión (de int a double, de short a int, etc.). Ası́, a pesar de lo que dijimos, el
código anterior habrı́a funcionado en su forma original. Evidentemente esto es muy
cómodo, porque no necesitamos hacer una conversión explı́cita cada vez que sumamos
un entero con un real. Sin embargo, debemos estar conscientes de que esta comodidad
sólo es posible porque ocurren varias cosas: primero, el compilador detecta el intento de
operar sobre dos variables que no son del mismo tipo; segundo, el compilador detecta,
en sus reglas internas, la posibilidad de cambiar uno de los tipos (int en este caso) al
otro (float); tercero, el compilador realiza la conversión, y finalmente la operación se
puede llevar a cabo. Entender este proceso nos permitirá aprovechar las posibilidades
de la conversión implı́cita de tipos cuando nuestro código involucre tipos de variables
más complicados, y entender varios mensajes de error del compilador.
Es interesante notar cómo las conversiones implı́citas de tipos pueden tener consecuen-
cias insospechadas. Consideremos las tres expresiones:
i) x = (1/2) * (x + a/x) ;
ii) x = (0.5) * (x + a/x) ;
iii) x = (x + a/x)/2 ;
Si inicialmente x=0.5 y a=0.5, por ejemplo, i) entrega el valor x=0, mientras ii) y iii)
entregan el valor x=1.5. Lo que ocurre es que 1 y 2 son enteros, de modo que 1/2 = 0.
De acuerdo a lo que dijimos, uno esperarı́a que en i), como conviven números reales
con enteros, los números enteros fueran convertidos a reales y, por tanto, la expresión
tuviera el resultado esperado, 1.5. El problema es la prioridad de las operaciones. No
todas las operaciones tienen igual prioridad (las multiplicaciones y divisiones se realizan
antes que las sumas y restas, por ejemplo), y esto permite al compilador decidir cuál
operación efectuar primero. Cuando se encuentra con operaciones de igual prioridad
(dos multiplicaciones, por ejemplo), se procede a efectuarlas de izquierda a derecha.
Pues bien, en i), la primera operación es 1/2, una división entre enteros, i.e. cero. En
ii) no hay problema, porque todas son operaciones entre reales. Y en iii) la primera
operación es el paréntesis, que es una operación entre reales. Al dividir por 2 éste es
convertido a real antes de calcular el resultado.
i) aún podrı́a utilizarse, cambiando el prefactor del paréntesis a 1.0/2.0, una práctica
que serı́a conveniente adoptar como standard cuando queremos utilizar enteros den-
tro de expresiones reales, para evitar errores que pueden llegar a ser muy difı́ciles de
detectar.
4.2. Control de flujo.

4.2.1. if, if... else, if... else if.
Las construcciones siguientes permiten controlar el flujo del programa en base a si una
expresión lógica es verdadera o falsa.
a) En el caso de la sentencia if se evaluará la expresión (a==b), si ella es cierta ejecutará la

o las lı́neas entre los paréntesis de llave y si la expresión es falsa el programa se salta
esa parte del código.
if (a==b) {
cout << "a es igual a b" << endl;
}
En este y en muchos de los ejemplos que siguen, los paréntesis cursivos son opcionales.
Ellos indican simplemente un grupo de instrucciones que debe ser tratado como una sola
instrucción. En el ejemplo anterior, los paréntesis cursivos después del if (o después de
un while, for, etc. más adelante) indican el conjunto de instrucciones que deben o no
ejecutarse dependiendo de si cierta proposición es verdadera o falsa. Si ese conjunto de
instrucciones es una sola, se pueden omitir los paréntesis:
if (a==b) cout << "a es igual a b" << endl;
b) En el caso if... else hay dos acciones mutuamente excluyentes. La sentencia

if (c!=b) evaluará la expresión (c!=b). Si ella es cierta ejecutará la o las lı́neas entre
los paréntesis de llave que le siguen, saltándose la o las lı́neas entre los paréntesis de
llave que siguen a la palabra clave else. Si la expresión es falsa el programa se salta la
primera parte del código y sólo ejecuta la o las lı́neas entre los paréntesis de llave que
siguen a else.
if (c!=d) {
cout << "c es distinto de d" << endl;
}
else {
cout << "c es igual a d" << endl;
}
4.2. CONTROL DE FLUJO. 109
c) En el último caso se evaluará la expresión que acompaña al if y si ella es cierta se

ejecutará la o las lı́neas entre los paréntesis de llave que le siguen, saltándose todo el
resto de las lı́neas entre los paréntesis de llave que siguen a las palabras claves else if
y else. Si la primera expresión es falsa el programa se salta la primera parte del código
y evalúa la expresión que acompaña al primer else if y si ella es cierta ejecutará la
o las lı́neas entre los paréntesis de llave que le siguen, saltándose todo el resto de las
lı́neas entre los paréntesis que siguen a otros eventuales else if o al else. Si ninguna
de las expresiones lógicas resulta cierta se ejecutará la o las lı́neas entre los paréntesis
que siguen al else.
if (e > f) {
cout << "e es mayor que f" << endl;
}
else if (e == f) {
cout << "e es igual a f" << endl;
}
else {
cout << "e es menor que f" << endl;
}
Para C++, una expresión verdadera es igual a 1, y una falsa es igual a 0. Esto es, cuando
escribimos if(e>f), y e>f es falsa, en realidad estamos diciendo if(0). A la inversa, 0
es considerada una expresión falsa, y cualquier valor no nulo es considerado una expresión
verdadera. Ası́, podrı́amos hacer que una porción del código siempre se ejecute (o nunca)
poniendo directamente if(1) o if(0), respectivamente.
Naturalmente, lo anterior no tiene mucho sentido, pero un error habitual (y particular-
mente difı́cil de detectar) es escribir a = b en vez de a == b en una expresión lógica. Esto
normalmente trae consecuencias indeseadas, pues la asignación a = b es una función que se
evalúa siempre al nuevo valor de a. En efecto, una expresión como a=3 siempre equivale a
verdadero, y a=0 siempre equivale a falso. Por ejemplo, en el siguiente programa:
#include <iostream>
int main(){
int k=3;
if (k==3){
cout << "k es igual a 3" << endl;
}
k=4;
if (k=3){
cout << "k es igual a 3" << endl;
}
return 0;
}
la salida siempre es:
k es igual a 3
k es igual a 3
aunque entre los dos if el valor de k cambia.
4.2.2. Expresión condicional.

Una construcción if else simple, que sólo asigna un valor distinto a una misma variable
según si una proposición es verdadera o falsa, es muy común en programación. Por ejemplo:
if (a==b) {
c = 1;
} else {
c = 0;
}
Existen dos maneras de compactar este código. Éste se puede reemplazar por
if (a==b) c = 1;
else c = 0;
Sin embargo, esto no es recomendable por razones de claridad al leer el código. Una expresión
más compacta y clara, se consigue usando el operador ternario ? :
c = (a==b) ? 1 : 0;
Como en el caso de los operadores de incremento y decremento, el uso del operador ? es

preferible para optimizar el ejecutable resultante.
4.2.3. switch.
La instrucción switch permite elegir múltiples opciones a partir del valor de una variable
entera. En el ejemplo siguiente tenemos que si i==1 la ejecución continuará a partir del caso
case 1:, si i==2 la ejecución continuará a partir del caso case 2: y ası́ sucesivamente. Si
i toma un valor que no está enumerado en ningún case y existe la etiqueta default, la
ejecución continuará a partir de ahı́. Si no existe default, la ejecución continúa luego del
último paréntesis cursivo.
switch (i)
{
case 1:
{
cout << "Caso 1." << endl;
}
break;
case 2:
{
cout << "Caso 2." << endl;
}
break;
default:
{
cout << "Otro caso." << endl;
}
break;
}
La instrucción break permite que la ejecución del programa salte a la lı́nea siguiente después
de la serie de instrucciones asociadas a switch. De esta manera sólo se ejecutarán las lı́neas
correspondientes al case elegido y no el resto. Por ejemplo, si i==1 verı́amos en pantalla
sólo la lı́nea Caso 1. En el otro caso, si no existieran los break, y también i==1, entonces
verı́amos en pantalla las lı́neas Caso 1., Caso 2. y Otro caso. La instrucción default es
opcional.
4.2.4. for.
Una instrucción que permite repetir un bloque de instrucciones un número definido de
veces es el for. Su sintaxis comienza con una o varias inicializaciones, luego una condición
lógica de continuación mientras sea verdadera, y finalmente una o más expresiones que se
evalúan vuelta por vuelta no incluyendo la primera vez. Siguiendo al for(...) viene una
instrucción o un bloque de ellas encerradas entre paréntesis de llave. En el ejemplo siguiente
la variable entera i es inicializada al valor 1, luego se verifica que la condición lógica sea
cierta y se ejecuta el bloque de instrucciones. A la vuelta siguiente se evalúa la expresión a
la extrema derecha (suele ser uno o más incrementadores), se verifica que la condición lógica
se mantenga cierta y se ejecuta nuevamente el bloque de instrucciones. Cuando la condición
lógica es falsa se termina el loop, saltando la ejecución a la lı́nea siguiente al paréntesis que
indica el fin del bloque de instrucciones del for. En este ejemplo, cuando i=4 la condición
de continuación será falsa y terminará la ejecución del for.
for (int i = 1; i < 4; i++) {

cout << "Valor del indice: " << i << endl;
}
El output correspondiente es:
Valor del indice: 1

Valor del indice: 2
Valor del indice: 3
Cualquier variable declarada en el primer argumento del for es local al loop. En este caso,
la variable i es local, y no interfiere con otras posibles variables i que existan en nuestro
código.
for es una instrucción particularmente flexible. En el primer y tercer argumento del for
se puede colocar más de una instrucción, separadas por comas. Esto permite, por ejemplo,
involucrar más de una variable en el ciclo. El código:
for (int i=0, k=20; (i<10) && (k<50); i++, k+=6) {

cout << "i + k = " << i + k << endl;
}
resulta en el output:
i + k = 20
i + k = 27
i + k = 34
i + k = 41
i + k = 48
Además, la condición de continuación (segundo argumento del for), no tiene por qué de-
pender de las variables inicializadas en el primer argumento. Y el tercer argumento no tiene
por qué ser un incremento o decremento de las variables del loop; puede ser cualquier expre-
sión que queramos ejecutar cada vez que un ciclo termina. En el siguiente ejemplo, además
de incrementar los contadores en cada ciclo, se envı́a un mensaje a pantalla:
for (int i=1, k=2;k<5 && i<20;k++, i+=2, cout << "Fin iteracion" << endl){
cout << " i = " << i <<’’,’’;
cout << " k = " << k << endl;
}
El resultado de las iteraciones:
i = 1, k = 2
Fin iteracion
i = 3, k = 3
Fin iteracion
i = 5, k = 4
Fin iteracion
Todos los argumentos del for son opcionales (no los ;), por lo cual se puede tener un for
que carezca de inicialización y/o de condición de continuación y/o de una expresión que se
evalúe en cada iteración.
Un caso tı́pico en que se aprovecha la opcionalidad de los argumentos del for es para
tener un loop infinito, que puede servir para dejar el programa en pausa indefinida. Para salir
del loop (y en general, para detener cualquier programa en C++), hay que presionar ^C:
for (; ; ) cout << "Este es un loop infinito, ^C para detenerlo"<< endl;
Se puede además, salir abruptamente del loop con break. El código:

for(int indice=0; indice<10; indice++) {

int cuadrado = indice*indice ;
cout << indice << " " ;
if(cuadrado > 10 ) break ;
}
cout << endl;
da la salida a pantalla:
0 1 2 3 4
aun cuando la condición de continuación permite que indice llegue hasta 9.

Finalmente, las variables involucradas en el for pueden ser modificadas dentro del ciclo.
Por ejemplo, modifiquemos uno de los ejemplos anteriores, cambiando la variable k en medio
del ciclo:
for (int i=1, k=2;k<5 && i<8;k++, i+=2, cout << "Fin iteracion" << endl){
cout << " i = " << i << ", k = " << k << endl;
k = k+5;
}
El resultado es:
i = 1, k = 2
Fin iteracion
En vez de pasar por el ciclo tres veces, como ocurrı́a originalmente, el programa sale del loop,
al cabo del primer ciclo, k = 2 + 5 = 7 > 5.
En general no es una buena práctica modificar las variables internas del ciclo en medio
de él, porque no es muy ordenado, y el desorden normalmente conduce a los errores en
programación, pero ocasionalmente puede ser útil hacer uso de esta libertad que proporciona
el lenguaje. Los ciclos for pueden anidarse, tal que uno contenga a otro completamente.
4.2.5. while.
La instrucción while permite repetir un bloque de instrucciones encerradas entre parénte-
sis de llave mientras la condición lógica que acompaña al while se mantenga cierta. La con-
dición es evaluada antes de que comience la primera iteración; si es falsa en ésta o en una
posterior evaluación no se ejecuta el bloque de instrucciones que le siguen y se continúa la
ejecución en la lı́nea siguiente al paréntesis que indica el fin del bloque asociado al while.
Hay que notar que la instrucción while podrı́a no ejecutarse ni una sola vez si la condición
no se cumple inicialmente. Un ejemplo simple:
int i=1;
while (i < 3) {
cout << i++ << " ";
}
que da por resultado: 1 2.

En el siguiente loop, la salida será: 5 4 3 2 1 (¿Por qué?)
int k=5 ;
while(k) {
cout << k-- <<" ";
}
4.2.6. do... while.

La instrucción do... while es análoga a while, salvo que la condición lógica es evaluada
después de la primera iteración. Por tanto, el bloque se ejecuta al menos una vez, siempre.
Un ejemplo simple:
do {
cout << i++ << endl;
} while (i<=20);
Podemos construir de otra manera un loop infinito usando do while
do {
cout << "Este es un segundo loop infinito, ^C para detenerlo"<< endl;
} while (1);
4.2.7. goto.
Existe también en C++ una instrucción goto que permite saltar de un punto a otro del
programa (goto salto; permite saltar a la lı́nea que contiene la instrucción salto:). Sin
embargo, se considera una mala técnica de programación usar goto, y siempre se puede di-
señar un programa evitándolo. Es altamente no recomendable, pero si su utilización simplifica
el código se puede usar.
4.3. Funciones.
Las funciones nos permiten programar partes del procedimiento por separado. Un ejemplo
simple de ellas lo vimos en la subsección 4.1.2.
4.3.1. Funciones tipo void.

Un caso especial de funciones es aquel en que el programa que llama la función no espera
que ésta le entregue ningún valor al terminar. Por ejemplo, en la subsección 4.1.2, la función
PrintHola simplemente imprime un mensaje en pantalla. El resto del programa no necesita
de ningún resultado parcial proveniente de la ejecución de dicha función. La definición de
estas funciones debe ir precedida de la palabra void, como en el ejemplo citado.
4.3. FUNCIONES. 115
4.3.2. return.
Si deseamos definir una función que calcule una raı́z cuadrada, evidentemente esperamos
que la función nos entregue un resultado: el valor de la raı́z cuadrada. En este caso hay que
traspasar el valor de una variable desde la función al programa que la llamó. Esto se consigue
con return. Veamos un ejemplo muy simple:
int numero(){
int i = 3;
return i;
}
int main(){
cout << "Llamamos a la funcion" << endl;
cout << "El numero es: " << numero() << endl;
int i = 5;
i = i + numero();
cout << "El numero mas 5 es: " << i << endl;
return 0;
}
En este caso, la función simplemente entrega el valor de la variable interna i, es decir 3, el

cual puede ser usado para salida en pantalla o dentro de operaciones matemáticas corrientes.
Separando declaración e implementación de la función, el ejemplo anterior se escribe:
int numero();
int main(){ ... }
int numero(){
int i = 3;
return i;
}
Dos observaciones útiles:
a) La declaración de la función lleva antepuesto el tipo de variable que la función entrega.
En el ejemplo, la variable entregada es un entero, i, y la declaración debe ser, por tanto,
int numero(). Podemos tener funciones tipo double, char, long, etc., de acuerdo al
tipo de variable que corresponde a return.
b) La variable i que se usa dentro de main() y la que se usa dentro de numero() son
distintas. A pesar de que tienen el mismo nombre, se pueden usar independientemente
como si se llamaran distinto. Se dice que i es una variable local.
Después de return debe haber una expresión que se evalúe a una variable del tipo co-
rrespondiente, ya sea explı́citamente o a través de un cast implı́cito. Las siguientes funciones
devuelven un double al programa:
double f1(){
double l = 3.0;
return l;
}
double f2(){
double l = 3.0, m = 8e10;
return l*m;
}
double f3(){
int l = 3;
return l;
}
Sin embargo, la siguiente función hará que el compilador emita una advertencia, pues se
está tratando de devolver un double donde deberı́a ser un int, y la conversión implica una
pérdida de precisión:
int f4(){
double l=3.0;
return l;
}
Naturalmente, podemos modificar la función anterior haciendo una conversión explı́cita antes
de devolver el valor: return int(l).
4.3.3. Funciones con parámetros.

Volviendo al ejemplo de la raı́z cuadrada, nos gustarı́a llamar a esta función con un
parámetro (el número al cual se le va a calcular la raı́z cuadrada). Consideremos por ejemplo
una función que necesita un solo parámetro, de tipo int, y cuyo resultado es otro int:
int funcion(int i){

i+=4;
return i;
}
int main(){
int i = 3;
cout << "El valor de la funcion es " << funcion(i)
<< endl;
cout << "El valor del parametro es " << i << endl;
return 0 ;
}
El resultado en pantalla es:

4.3. FUNCIONES. 117
El valor de la funcion es 7
El valor del parametro es 3
La función funcion entrega el valor del parámetro más 4. Usamos el mismo nombre (i)
para las variables en main y funcion, pero son variables locales, ası́ que no interfieren. Lo
importante es notar que cuando se llama a la función, la reasignación del valor de i (i+=4)
ocurre sólo para la variable local en funcion; el parámetro externo mantiene su valor.
Separando declaración e implementación el ejemplo anterior se escribe:
int funcion(int);
int main(){...}
int funcion(int i){

i+=4;
return i;
}
Si nuestra función necesita más parámetros, basta separarlos con comas, indicando para
cada uno su tipo:
int funcion2(int,double);
void funcion3(double,int,float);
double funcion4(float);
El compilador verifica cuidadosamente que cada función sea llamada con el número de
parámetros adecuados, y que cada parámetro corresponda al tipo especificado. En los ejem-
plos anteriores, funcion2 debe ser llamada siempre con dos argumentos, el primero de los
cuales es int y el segundo double. Como siempre, puede ser necesario un cast implı́cito (si se
llama funcion2 con el segundo argumento int, por ejemplo), pero si no existe una regla de
conversión automática (llamando a funcion2 con el primer argumento double, por ejemplo),
el compilador enviará una advertencia. Además, el compilador verifica que el valor de retorno
de la función sea usado como corresponde. Por ejemplo, en las dos lı́neas:
double m = funcion2(2,1e-3);
int k = funcion4(0.4);
la primera compilará exitosamente (pero hay un cast implı́cito), y la segunda dará una
advertencia.
Existen dos modos de transferir parámetros a una función:
a) Por valor. Se le pasan los parámetros para que la función que es llamada copie sus
valores en sus propias variables locales, las cuales desaparecerán cuando la función
termine y no tienen nada que ver con las variables originales.
Hasta ahora, en todos los ejemplos de esta subsección el traspaso de parámetros ha sido
por valor. En la función int funcion(int), en el código de la página 116, lo que ha
ocurrido es que la función copia el valor de la variable externa i en una nueva variable
(que también se llama i, pero está en otra dirección de memoria). El valor con el que
trabaja la función es la copia, manteniendo inalterada la variable original.
b) Por referencia. Se le pasa la dirección de memoria de los parámetros. La función llamada

puede modificar el valor de tales variables.
La misma función de la página 116 puede ser modificada para que el paso de parámetros
sea por referencia, modificando la declaración:
#include <iostream>
int funcion(int &);
int main()
{
int i = 3;
cout << "El valor de la funcion es " << funcion(i)
<< endl;
cout << "El valor del parametro es " << i << endl;
return 0;
}
int funcion(int & i)
{
i+=4;
return i;
}
En vez de traspasarle a funcion el valor del parámetro, se le entrega la dirección

de memoria de dicha variable. Debido a ello, funcion puede modificar el valor de la
variable. El resultado en pantalla del último programa será:
El valor de la funcion es 7
El valor del parametro es 7
Debido a que las variables dejan de ser locales, el paso de parámetros por referencia
debe ser usado con sabidurı́a. De hecho el ejemplo presentado es poco recomendable.
Peor aún, el problema es no sólo que las variables dejan de ser locales, sino que es
imposible saber que no lo son desde el main. En efecto, el main en ambas versiones de
funcion es el mismo. Lo único que cambió es la declaración de la función. Puesto que un
usuario normal usualmente no conoce la declaración e implementación de cada función
que desea usar (pues pueden haber sido hechas por otros programadores), dejamos al
usuario en la indefensión.
Por otro lado, hay al menos dos situaciones en que el paso de referencia es la única
opción viable para entregar los parámetros. Un caso es cuando hay que cuidar el uso
de la memoria. Supongamos que una función necesita un parámetros que es una matriz
de 10 millones de filas por 10 millones de columnas. Seguramente estaremos llevando al
4.3. FUNCIONES. 119
lı́mite los recursos de nuestra máquina, y serı́a una torpeza pasarle la matriz por valor:
ello involucrarı́a, primero, duplicar la memoria utilizada, con el consiguiente riesgo de
que nuestro programa se interrumpa; y segundo, harı́a el programa más lento, porque
la función necesitarı́a llenar su versión local de la matriz elemento por elemento. Es
decir, nada de eficiente. En esta situación, el paso por referencia es lo adecuado.
Un segundo caso en que el paso por referencia es recomendable es cuando efectivamente
nuestra intención es cambiar el valor de las variables. El ejemplo tı́pico es el intercambio
de dos variables entre sı́, digamos a1=1 y a2=3. Luego de ejecutar la función queremos
que a1=3 y a1=1. El siguiente código muestra la definición y el uso de una función para
esta tarea, y por cierto requiere el paso de parámetros por referencia:
#include <iostream>
void swap(int &,int &);
int main(){
int i = 3, k=10;
swap(i,k);
cout << "Primer argumento: " << i << endl;
cout << "Segundo argumento: " << k << endl;
return 0 ;
}
void swap(int & j,int & p){

int temp = j;
j = p;
p = temp;
}
El output es:
Primer argumento: 10
Segundo argumento: 3
En el ejemplo de la matriz anterior, serı́a interesante poder pasar el parámetro por refe-
rencia, para ahorrar memoria y tiempo de ejecución, pero sin correr el riesgo de que nuestra
matriz gigantesca sea modificada por accidente. Afortunadamente existe el modo de hacerlo,
usando una palabra que ya hemos visto antes: const. En el siguiente código:
int f5(const int &);
int main(){...}
int f5(const int & i){...};
f5 recibirá su único argumento por referencia, pero, debido a la presencia del modificador
const, el compilador avisará si se intenta modificar el argumento en medio del código de la
función.
4.3.4. Parámetros por defecto.

C++ permite que omitamos algunos parámetros de la función llamada, la cual reem-
plaza los valores omitidos por otros predeterminados. Tomemos por ejemplo la función
int funcion(int); de la subsección 4.3.3, y modifiquémosla de modo que si no le entrega-
mos parámetros, asuma que el número entregado fue 5:
#include <iostream>
int funcion(int i = 5){

i+=4;
return i;
}
int main(){
cout << "El resultado default es " << funcion() << endl;
int i = 3;
cout << "Cuando el parametro vale " << i <<
" el resultado es " << funcion(i) << endl;
return 0;
}
El output correspondiente es:
El resultado default es 9
Cuando el parametro vale 3 el resultado es 7
Separando declaración e implementación:

int funcion(int = 5);
main(){...}
int funcion(int i){
i+=4;
return i;
}
Si una función tiene n argumentos, puede tener m ≤ n argumentos opcionales. La única
restricción es que, en la declaración e implementación de la función, los parámetros opcionales
ocupen los últimos m lugares:
void f1(int,int = 4);
int f2(double,int = 4, double = 8.2);
double f3(int = 3,double = 0.0, int = 0);
En este caso, f1(2), f1(2,8), f2(2.3,5), f3(3), f3(), y muchas otras, son todas llamadas
válidas de estas funciones. Cada vez, los parámetros no especificados son reemplazados por
sus valores predeterminados.
4.3. FUNCIONES. 121
4.3.5. Ejemplos de funciones: raı́z cuadrada y factorial.

Raı́z cuadrada.
Con lo visto hasta ahora, ya podemos escribir un programa que calcule la raı́z cuadrada
de una función. Para escribir una función, debemos tener claro qué se espera de ella: cuántos
y de qué tipo son los argumentos que recibirá, qué tipo de valor de retorno deberá tener,
y, por cierto, un nombre adecuado. Para la raı́z cuadrada, es claro que el argumento es un
número. Pero ese número podrı́a ser un entero o un real, y eso al compilador no le da lo
mismo. En este punto nos aprovechamos del cast implı́cito: en realidad, basta definir la raı́z
cuadrada con argumento double; de este modo, si se llama la función con un argumento int,
el compilador convertirá automáticamente el int en double y nada fallará. En cambio, si la
definiéramos para int y la llamamos con argumento double, el compilador se quejarı́a de que
no sabe efectuar la conversión. Si el argumento es double, evidentemente esperamos que el
valor de retorno de la función sea también un double. Llamando a la función raiz, tenemos
la declaración:
double raiz(double);
Debido a la naturaleza de la función raı́z cuadrada, raiz() no tendrı́a sentido, y por tanto
no corresponde declararla con un valor default.
Ahora debemos pensar en cómo calcular la raı́z cuadrada. Usando una variante del método
de Newton-Raphson, se obtiene que la secuencia

1 a
xn+1 = xn +
2 xn
√
converge a a cuando n → ∞. Por tanto, podemos calcular la raı́z cuadrada con aproxima-
ciones sucesivas. El cálculo terminará en el paso N , cuando la diferencia entre el cuadrado
de la aproximación actual, xN , y el valor de a, sea menor que un cierto número pequeño:
| x2N − a | < ǫ ≪ 1. El valor de ǫ determinará la precisión de nuestro cálculo. Un ejemplo de
código lo encontramos a continuación:
#include <iostream>
#include <cmath>
double raiz(double);
int main(){
double r;
cout.precision(20);
cout << "Ingrese un numero: " << endl;
cin >> r;
cout << raiz(r) << endl;
return 0 ;
double raiz(double a){

double x =a/2.0 ; // para comenzar
double dx = 1e3, epsilon = 1e-8;
while (fabs(dx)>epsilon){
x = (x + a/x)/2;
dx = x*x - a;
cout << "x = " << x << ", precision = " << dx << endl;
}
return x;
}
Luego de la declaración de la función raiz, está main, y al final la implementación de

raiz. En main se pide al usuario que ingrese un número, el cual se aloja en la variable r,
y se muestra en pantalla el valor de su raı́z cuadrada. La instrucción cout.precision(20)
permite que la salida a pantalla muestre el resultado con 20 cifras significativas.
En la implementación de la función hay varios aspectos que observar. Se ha llamado x a la
variable que contendrá las sucesivas aproximaciones a la raı́z. Al final del ciclo, x contendrá el
valor (aproximado) de la raı́z cuadrada. dx contiene la diferencia entre el cuadrado de x y el
valor de a, epsilon es el número (pequeño) que determina si la aproximación es satisfactoria
o no.
El ciclo está dado por una instrucción while, y se ejecuta mientras dx>epsilon, es decir,
termina cuando dx es suficientemente pequeño. El valor absoluto del real dx se obtiene con la
función matemática fabs, disponible en el header cmath incluido al comienzo del programa.
Observar que inicialmente dx=1e3, esto es un valor muy grande; esto permite que la condición
del while sea siempre verdadera, y el ciclo se ejecuta al menos una vez.
Dentro del ciclo, se calcula la nueva aproximación, y se envı́a a pantalla un mensaje con
la aproximación actual y la precisión alcanzada (dada por dx). Eventualmente, cuando la
aproximación es suficientemente buena, se sale del ciclo y la función entrega a main el valor
de x actual, que es la última aproximación calculada.
Factorial.
Otro ejemplo útil es el cálculo del factorial, definido para números naturales:
n! = n · (n − 1) · · · 2 · 1 , 0! ≡ 1 .
La estrategia natural es utilizar un ciclo for, determinado por una variable entera i, que
va desde 1 a n, guardando los resultados en una variable auxiliar que contiene el producto
de todos los números naturales desde 1 hasta i:
#include <iostream>
4.3. FUNCIONES. 123
int factorial(int);
int main(){
int n=5 ;
cout << "El factorial de " << n << " es: " << factorial(n) << endl;
return 0 ;
}
int factorial(int i)
{
int f =1;
for (int j=1;j<=i;j++){
f = f*j;
}
return f;
}
Observar que la variable auxiliar f, que contiene el producto de los primeros i números
naturales, debe ser inicializada a 1. Si se inicializara a 0, factorial(n) serı́a 0 para todo n.
Esta función no considera el caso n=0, pero al menos para el resto de los naturales fun-
cionará bien.
4.3.6. Alcance, visibilidad, tiempo de vida.

Con el concepto de función hemos apreciado que es posible que coexistan variables con el
mismo nombre en puntos distintos del programa, y que signifiquen cosas distintas. Conviene
entonces tener en claro tres conceptos que están ligados a esta propiedad:
Alcance (scope) La sección del código durante la cual el nombre de una variable puede ser
usado. Comprende desde la declaración de la variable hasta el final del cuerpo de la
función donde es declarada.
Si la variable es declarada dentro de una función es local . Si es definida fuera de todas
las funciones (incluso fuera de main), la variable es global.
Visibilidad Indica cuáles de las variables, actualmente al alcance, pueden ser accesadas. En
nuestros ejemplos (subsección 4.3.3), la variable i en main aún está al alcance dentro
de la función funcion, pero no es visible, y por eso es posible reutilizar el nombre.
Tiempo de vida Indica cuándo las variables son creadas y cuándo destruidas. En general
este concepto coincide con el alcance (las variables son creadas cuando son declaradas y
destruidas cuando la función dentro de la cual fueron declaradas termina), salvo porque
es posible definir: (a) variables dinámicas, que no tienen alcance, sino sólo tiempo de
vida; (b) variables estáticas, que conservan su valor entre llamadas sucesivas de una
función (estas variables tienen tiempo de vida mayor que su alcance). Para declarar
estas últimas se usa un modificador static.
El efecto del modificador static se aprecia en el siguiente ejemplo:
#include <iostream>
int f();
int main(){
cout << f() << endl;

return 0;
}
int f(){
int x=0;
x++;
return x;
}
La función f simplemente toma el valor inicial de x y le suma 1. Como cada vez que la
función es llamada la variable local x es creada e inicializada, el resultado de este programa
es siempre un 1 en pantalla:
1
1
Ahora modifiquemos la función, haciendo que x sea una variable estática:
#include <iostream>
int f();
int main(){

return 0 ;
}
int f(){
static int x=0;
x++;
return x;
}
4.3. FUNCIONES. 125
Ahora, al llamar a f por primera vez, la variable x es creada e inicializada, pero no

destruida cuando la función termina, de modo que conserva su valor cuando es llamada por
segunda vez:
1
2
Veamos un ejemplo de una variable estática en el cálculo del factorial:
#include <iostream>
int factorial2(int i=1){

static int fac = 1;
fac*=i;
return fac ;
}
int main (){

int n=5;
int m=n;
while(n>0) factorial2(n--);
cout << "El factorial de "<< m << " es = " << factorial2() << endl;
return 0 ;
}
La idea, si se desea calcular el factorial de 5, por ejemplo, es llamar a la función factorial2

una vez, con argumento n = 5, y después disminuir n en 1. Dentro de la función, una variable
estática (fac) aloja el valor 1 ∗ 5 = 5. Luego se llama nuevamente con n = 4, con lo cual
fac=1*5*4, y ası́ sucesivamente, hasta llegar a n = 1, momento en el cual fac=1*5*4*3*2*1.
Al disminuir n en 1 una vez más, la condición del while es falsa y se sale del ciclo. Al llamar
una vez más a factorial2, esta vez sin argumentos, el programa asume que el argumento
tiene el valor predeterminado 1, y ası́ el resultado es 1*5*4*3*2*1*1, es decir 5!.
Observemos el uso del operador de decremento en este programa: factorial2(n--) llama
a la función con argumento n y después disminuye n en 1. Ésto es porque el operador de
decremento está actuando como sufijo, y es equivalente a las dos instrucciones:
factorial2(n);
n--;
Si fuera un prefijo [factorial2(n--)], primero disminuirı́a n en 1, y llamarı́a luego a factorial2

con el nuevo valor de n
Este ejemplo de cálculo del factorial ilustra el uso de una variable estática, que aloja los
productos parciales de los números enteros, pero no es un buen ejemplo de una función que
calcule el factorial, porque de hecho esta función no lo calcula: es main quien, a través de
sucesivas llamadas a factorial2, calcula el factorial, pero la función en sı́ no.
4.3.7. Recursión.
C++ soporta un tipo especial de técnica de programación, la recursión, que permite que
una función se llame a sı́ misma (esto es no trivial, por cuanto si definimos, digamos, una
función f, dentro del cuerpo de la implementación no hay ninguna declaración a una función
f, y por tanto en principio no se podrı́a usar f porque dicho nombre no estarı́a en scope;
C++ permite soslayar este hecho). La recursión permite definir de modo muy compacto una
función que calcule el factorial de un número entero n.
#include <iostream>
int factorial3(int n){

return (n<2) ? 1: n * factorial3(n-1);
}
int main(){
int n=5;
cout << "El factorial de "<< n << " es = " << factorial3(n) << endl;
return 0;
}
En este tercer ejemplo, el factorial de n es definido en función del factorial de n − 1.

Se ha usado la expresión condicional (operador ?) para compactar aún más el código. Por
ejemplo, al pedir el factorial de 5 la función se pregunta si 5 < 2. Esto es falso, luego, la
función devuelve a main el valor 5*factorial3(4). A su vez, factorial3(4) se pregunta si
4 < 2; siendo falso, devuelve a la función que la llamó (es decir, a factorial3(5)), el valor
4*factorial3(3). El proceso sigue hasta que factorial(2) llama a factorial3(1). En
ese momento, 1 < 2, y la función factorial3(1), en vez de llamar nuevamente al factorial,
devuelve a la función que la llamó el valor 1. No hay más llamadas a factorial3, y el
proceso de recursión se detiene. El resultado final es que main recibe el valor factorial3(5)
= 5*factorial3(4) = · · · = 5*4*3*2*factorial3(1) = 5*4*3*2*1= 120.
Este tercer código para el cálculo del factorial sı́ considera el caso n = 0, y además es más
eficiente, al ser más compacto.
La recursión debe ser empleada con cuidado. Es importante asegurarse de que existe
una condición para la cual la recursión se detenga, de otro modo, caerı́amos en una recursión
infinita que harı́a inútil nuestro programa. En el caso del factorial, pudimos verificar que dicha
condición existe, por tanto el programa es finito. En situaciones más complicadas puede no
ser tan evidente, y es responsabilidad del programador —como siempre— revisar que todo
esté bajo control.
4.3.8. Funciones internas.

Existen muchas funciones previamente implementadas en C++ almacenadas en distintas
bibliotecas. Una de las bibliotecas importante es la matemática. Para usarla uno debe incluir
4.4. PUNTEROS. 127
el archivo de header <cmath> y luego al compilar agregar al final del comando de compilación
-lm:
g++ -Wall -o <salida> <fuente>.cc -lm
si se desea crear un ejecutable <salida> a partir del código en <fuente>.cc.
Veamos algunas de estas funciones:
pow(x,y) Eleva a potencia, xy
fabs(x) Valor absoluto
sqrt(x) Raı́z cuadrada
sin(x) cos(x) Seno y coseno
tan(x) Tangente
atan(x) Arcotangente de x en [−π, π]
atan2(y, x) Arcotangente de y/x en [−π, π]
exp(x) Exponencial
log(x) log10(x) Logaritmo natural y logaritmo en base 10
floor(x) Entero más cercano hacia abajo (e.g. floor(3.2)=3)
ceil(x) Entero más cercano hacia arriba (e.g. ceil(3.2)=4)
fmod(x,y) El resto de x/y (e.g. fmod(7.3, 2)=1.3)
Para elevar a potencias enteras, es más conveniente usar la forma explı́cita en vez de la
función pow, i.e. calcular x^3 como x*x*x es más eficiente computacionalmente que pow(x,3),
debido a los algoritmos que usa pow para calcular potencias. Éstos son más convenientes
cuando las potencias no son enteras, en cuyo caso no existe una forma explı́cita en términos
de productos.
4.4. Punteros.
Una de las ventajas de C++ es permitir el acceso directo del programador a zonas de
memoria, ya sea para crearlas, asignarles un valor o destruirlas. Para ello, además de los tipos
de variables ya conocidos (int, double, etc.), C++ proporciona un nuevo tipo: el puntero.
El puntero no contiene el valor de una variable, sino la dirección de memoria en la cual dicha
variable se encuentra.
Un pequeño ejemplo nos permite ver la diferencia entre un puntero y la variable a la cual
ese puntero “apunta”:
#include <iostream>
int main(){
int i = 42;
int * p = &i;
cout << "El valor del puntero es: " << p << endl;
cout << "Y apunta a la variable: " << *p << endl;
return 0;
}
En este programa definimos una variable i entera. Al crear esta variable, el programa
reservó un espacio adecuado en algún sector de la memoria. Luego pusimos, en esa dirección
de memoria, el valor 42. En la siguiente lı́nea creamos un puntero a i, que en este caso
denominamos p. Los punteros no son punteros a cualquier cosa, sino punteros a un tipo
particular de variable. Ello es manifiesto en la forma de la declaración: int * p. En la
misma lı́nea asignamos a este puntero un valor. Ese valor debe ser también una dirección de
memoria, y para eso usamos &i, que es la dirección de memoria donde está i. Ya hemos visto
antes el uso de & para entregar una dirección de memoria, al estudiar paso de parámetros a
funciones por referencia (4.3.3).
Al ejecutar este programa vemos en pantalla los mensajes:
El valor del puntero es: 0xbffff9d8

Y apunta a la variable: 42
Primero obtenemos un número hexadecimal imposible de determinar a priori, y que corres-

ponde a la dirección de memoria donde quedó ubicada la variable i. La segunda lı́nea nos
da el valor de la variable que está en esa dirección de memoria: 42. Puesto que * aplicado
a un puntero entrega el contenido de esa dirección de memoria, se le denomina operador de
desreferenciación.
En este ejemplo, hemos creado un puntero que contiene la dirección de memoria de una
variable preexistente: declaramos una variable, esa variable queda en alguna dirección de
memoria, y después asignamos esa dirección de memoria a un puntero. En este caso, podemos
referirnos a la variable tanto por su nombre (i) como por su puntero asociado (p_i).
También es posible crear directamente una dirección de memoria, sin necesidad de crear
una variable antes. En este caso, la única forma de manipular este objeto es a través de su
puntero, porque no existe ninguna variable y por tanto ningún nombre asociado a él. Esto se
hace con el operador new. El mismo ejemplo anterior puede ser reescrito usando sólo punteros:
#include <iostream>
int main(){
int * p = new int;
*p = 42;
cout << "El valor del puntero es: " << p << endl;
cout << "Y apunta a la variable: " << *p << endl;
delete p;
return 0;
}
La primera lı́nea crea un nuevo puntero a int llamado p. new verifica que haya suficiente
memoria para alojar un nuevo int, y si es ası́ reserva ese espacio de memoria. En p queda la
dirección de la memoria reservada. Esto es equivalente a la declaración int i; del programa
anterior, salvo que ahora la única manera de accesar esa dirección de memoria es a través
del puntero p. A continuación se coloca dentro de esa dirección (observar la presencia del
4.5. MATRICES O ARREGLOS. 129
operador de desreferenciación *) el número 42. El programa manda a pantalla la misma

información que la versión anterior, salvo que seguramente el valor de p será distinto.
Finalmente, ya que el puntero no volverá a ser usado, la dirección de memoria debe ser
liberada para que nuestro u otros programas puedan utilizarla. Ello se realiza con el operador
delete. Todo puntero creado con new debe ser, cuando ya no se utilice, borrado con delete.
Ello evitará desagradables problemas en nuestro programa debido a fuga de memoria (memory
leak ).
Los punteros tienen gran importancia cuando de manejar datos dinámicos se trata, es
decir, objetos que son creados durante la ejecución del programa, en número imposible de
predecir al momento de compilar. Por ejemplo, una aplicación X-windows normal que crea
una, dos, tres, etc. ventanas a medida que uno abre archivos. En este caso, cada ventana es
un objeto dinámico, creado durante la ejecución, y la única forma de manejarlo es a través
de un puntero a ese objeto, creado con new cuando la ventana es creada, y destruido con
delete cuando la ventana es cerrada.
4.5. Matrices o arreglos.

4.5.1. Declaración e inicialización.
Podemos declarar (e inicializar inmediatamente) matrices de enteros, reales de doble pre-
cisión, caracteres, etc., según nuestras necesidades.
int a[5];
double r[3] = {3.5, 4.1, -10.8};
char palabra[5];
Una vez declarada la matriz (digamos a[5]), los valores individuales se accesan con a[i],
con i desde 0 a 4. Por ejemplo, podemos inicializar los elementos de la matriz ası́:
a[0] = 3;
a[3] = 5; ...
o si queremos ingresarlos desde el teclado:
for (i = 0; i < 5; i++){

cin >> a[i];
}
Y si deseamos escribirlos en pantalla:
for (i = 0; i < 5; i++){

cout << a[i] ;
}
4.5.2. Matrices como parámetros de funciones.

Si deseamos, por ejemplo, diseñar una función que mande los elementos de una matriz
a pantalla, necesitamos entregarle como parámetro la matriz que va a utilizar. Para ello se
agrega [] luego del nombre de la variable, para indicar que se trata de una matriz:
#include <iostream>
void PrintMatriz(int, double []);
int main(){
double matriz[5] = {3.5, 5.2, 2.4, -0.9, -10.8};
PrintMatriz(5, matriz);
return 0;
}
void PrintMatriz(int i, double a[]){

for (int j = 0; j < i; j++){
cout << "Elemento " << j << " = " << a[j] << endl;
}
}
Observemos que la función debe recibir dos parámetros, uno de los cuales es la dimensión
de la matriz. Esto se debe a que cuando las matrices son usadas como parámetros la infor-
mación de su dimensión no es traspasada, y debe ser comunicada independientemente. Una
ligera optimización al programa anterior es modificar main a:
#include <iostream>
int main()
{
int dim = 5;
double matriz[dim] = {3.5, 5.2, 2.4, -0.9, -10.8};
PrintMatriz(dim, matriz);
return 0;
}
De este modo, si eventualmente cambiamos de opinión y deseamos trabajar con matrices
de longitud distinta, sólo hay que modificar una lı́nea de código (la primera) en todo el
programa, el cual puede llegar a ser bastante largo por cierto. (En el ejemplo, también habrı́a
que cambiar la lı́nea de inicialización de la matriz, porque asume que la matriz requiere sólo 5
elementos, pero de todos modos deberı́a ser clara la enorme conveniencia.) Podemos reescribir
este programa con un comando de preprocesador para hacer la definición de la dimensión:
#include <iostream>
#define DIM 5
int main(){
double matriz[DIM] = {3.5, 5.2, 2.4, -0.9, -10.8};
PrintMatriz(DIM, matriz);
return 0;
}
4.5.3. Asignación dinámica.

La reserva de memoria para la matriz podemos hacerla en forma dinámica ocupando el
operador new que pedirá al sistema la memoria necesaria, si está disponible el sistema se
la asignará. Como con cualquier puntero, una vez desocupado el arreglo debemos liberar la
memoria con el comando delete.
#include <iostream>
int main()
{
cout<<"Ingrese la dimension deseada :" ;
int dim ;
cin >> dim ;
double * matriz = new double[dim] ; // Reserva la memoria
for(int i=0; i < dim; i++) {
cout << "Ingrese elemento "<< i <<" : ";
cin >> matriz[i] ;
}
for (int i=0;i<dim;i++){

cout << matriz[i] << ", ";
}
cout << endl;
delete [] matriz; // Libera la memoria reservada

return 0;
}
Este ejemplo permite apreciar una gran ventaja del uso de punteros, al permitirnos liberarnos
de definir la dimensión de una matriz como una constante. Aquı́, dim es simplemente un int.
La asignación dinámica permite definir matrices cuya dimensión se determina recién durante
la ejecución.
Observemos finalmente que la liberación de memoria, en el caso de arreglos, se hace con
el operador delete [], no delete como en los punteros usuales.
4.5.4. Matrices multidimensionales.

Es fácil declarar e inicializar matrices de más de una dimensión:
double array[10][8];
int array[2][3] = {{1, 2, 3},
{4, 5, 6}};
Una operación usual es definir primero las dimensiones de la matriz, y luego llenar sus
elementos uno por uno (o desplegarlos en pantalla), recorriendo la matriz ya sea por filas o
por columnas. Hay que tener cuidado del orden en el cual uno realiza las operaciones. En
el siguiente código, definimos una matriz de 10 filas y 3 columnas, la llenamos con ceros
elemento por elemento, y luego inicializamos tres de sus elementos a números distintos de
cero. Finalmente desplegamos la matriz resultante en pantalla:
#include <iostream>
#define dimx 3
#define dimy 10
void imprime(int,int,double[][dimx]);
int main()
{
double a[dimy][dimx];
for (int i=0;i<dimy;i++)
{
for (int j=0;j<dimx;j++)
{
a[i][j]=0;
}
}
a[0][0]=1;
a[3][2]=2;
a[9][2]=3;
imprime(dimx,dimy,a);
return 0;
}
void imprime(int dx, int dy, double a[][dimx])

{
for (int i=0;i<dy;i++)
{
for (int j=0;j<dx;j++)

{
cout << a[i][j] << ", ";
}
cout << endl;
}
}
Inicializar los elementos a cero inicialmente es particularmente relevante. Si no, la matriz

se llenarı́a con elementos aleatorios. Veamos un ejemplo a continuación que ilustra el paso de
arreglos multidimensionales como un parámetro a una función y la necesidad de inicializar a
cero los elementos de un arreglo
#include <iostream>
#define NROWS 3
#define NCOLUMNS 2

void f(int, int, int [][NCOLUMNS]);
int main()
{
int array[NROWS][NCOLUMNS];
f(NROWS, NCOLUMNS, array);
for(int i=0;i<NROWS;i++) {
for(int j=0;j<NCOLUMNS;j++) array[i][j]=0;
}
f(NROWS, NCOLUMNS, array);
return 0;
}
void f(int n, int m, int a[][NCOLUMNS]) {

for(int i=0;i<n;i++) {
for(int j=0;j<m;j++) cout <<a[i][j]<<" ";
cout << endl;
}
}
4.5.5. Matrices de caracteres: cadenas (strings).

Una palabra, frase o texto más largo es representado internamente por C++ como una
matriz de chars. A esto se le llama “cadena” (string). Sin embargo, esto ocasiona un problema,
pues las matrices deben ser definidas con dimensión constante (a menos que sean definidas
dinámicamente), y las palabras pueden tener longitud arbitraria. La convención de C++ para
resolver el problema es aceptar que una cadena tiene longitud arbitraria, pero debe indicar
dónde termina. Esto se hace con el char nulo: ’\0’. Ası́, para asignar a la variable palabra
el valor “Hola”, debe definirse como una matriz de dimensión 5 (una más que el número de
letras):
char palabra[5] = {’H’, ’o’, ’l’, ’a’, ’\0’};
Para escribir “Hola” en pantalla basta recorrer los elementos de palabra uno a uno:
for (i = 0; i < 5; i++)

{
cout << palabra[i];
}
Si tuviéramos que hacer esto cada vez que queremos escribir algo a pantalla no serı́a muy
cómodo. Por ello, también podemos escribir “Hola” en pantalla simplemente con cout << "Hola",
y de hecho ése fue el primer ejemplo de este capı́tulo. De hecho, la declaración de palabra
podrı́a haberse escrito:
char palabra[5] = "Hola";
Esto ya es bastante más cómodo, aunque persiste la inconsistencia de definir palabra con
dimensión 5, cuando en realidad al lado derecho de la asignación hay un objeto con sólo 4
elementos (visibles).
Éste y otros problemas asociados con el manejo convencional de cadenas en C++ se
resuelven incluyendo el header string.
Usando string.
El código anterior se puede reescribir:
#include <iostream>
#include <string>
int main(){
string palabra = "Hola";
cout << palabra << endl;
return 0;
}
Observar que la lı́nea a incluir es #include <string>, sin la extensión “.h”. Al incluir
string, las cadenas pueden ser declaradas como objetos tipo string en vez de arreglos
de char. El hecho de que ya no tengamos que definir a priori la dimensión de la cadena
es una gran ventaja. De hecho, permite ingresar palabras desde el teclado trivialmente, sin
preocuparse de que el input del usuario sea demasiado grande (tal que supere la dimensión del
arreglo que podamos haber declarado inicialmente) o demasiado corto (tal que se traduzca
en un despilfarro de memoria por reservar más memoria para el arreglo de la que realmente
se necesita):
#include <iostream>
#include <string>
int main(){
string palabra;
cin >> palabra;
return 0;
}
Además, este nuevo tipo string permite acceder a un sin número de funciones adicionales
que facilitan enormemente el manejo de cadenas. Por ejemplo, las cadenas se pueden sumar,
donde la suma de cadenas a y b está definida (siguiendo la intuición) como la cadena que
resulta de poner b a continuación de a:
#include <iostream>
#include <string>
int main(){
string texto1 = "Primera palabra";
string texto2 = "Segunda palabra";
cout << texto1 << endl << texto2 << endl;
cout << texto1 + ", " + texto2 << endl;
// La ultima linea es equivalente a:
// string texto3 = texto1 + ", " + texto2;
// cout << texto3 << endl;
return 0 ;
}
El output de este programa será:
Primera palabra
Segunda palabra
Primera palabra, Segunda palabra
Ingreso con espacios.

Dijimos que es muy fácil ingresar una cadena desde el teclado, pues no es necesario
definir la dimensión desde el comienzo. Sin embargo, el código anterior, usando cin, no
es muy general, porque el input termina cuando el usuario ingresa el primer cambio de
lı́nea o el primer espacio. Esto es muy cómodo cuando queremos ingresar una serie de va-
lores (por ejemplo, para llenar un arreglo), pues podemos ingresarlos ya sea en la forma:
1<Enter> 2<Enter> 3<Enter>, etc., o 1 2 3, etc, pero no es óptimo cuando deseamos in-
gresar texto, que podrı́a constar de más de una palabra y, por tanto, necesariamente incluirı́a
espacios (por ejemplo, al ingresar el nombre y apellido de una persona). Sin explicar dema-
siado por qué, digamos que la solución a este problema es utilizar una función asociada a cin
llamada get, y leer desde el teclado hasta que el usuario dé el primer cambio de lı́nea. Un
ejemplo simple lo encontramos en el siguiente código:
#include <iostream>
#include <string>
int main(){
string texto1 = "El resultado es: " ;
string texto2 ="";
char ch;
cout << "Entre un string:" << endl;

while( ( ch = cin.get() ) != ’\n’ ) texto2 = texto2 + ch;
cout << texto1 + texto2 << endl;

return 0;
}
Observamos que cin.get() no necesita argumento y devuelve un char el cual es primero

comparado con el caracter de fin de lı́nea y luego acumulado en texto2.
4.6. Manejo de archivos.

Una operación usual en todo tipo de programas es la interacción con archivos. Ya sea que
el programa necesite conocer ciertos parámetros de configuración, hacer análisis estadı́stico
sobre un gran número de datos generados por otro programa, entregar las coordenadas de
los puntos de una trayectoria para graficarlos posteriormente, etc., lo que se requiere es un
modo de ingresar datos desde, o poner datos en, archivos. En C++ ello se efectúa incluyendo
el header fstream.
4.6.1. Archivos de salida.

Observemos el siguiente programa:
#include <iostream>
#include <fstream>
int main(){
ofstream nombre_logico("nombre_fisico.dat");
int i = 3, j;
cout << i << endl;
nombre_logico << i << endl;
cout << "Ingrese un numero entero: ";
4.6. MANEJO DE ARCHIVOS. 137
cin >> j;
cout << j << endl;
nombre_logico << j << endl;
nombre_logico.close();
return 0;
}
La primera lı́nea de main define un objeto de tipo ofstream (output file stream). Es-
to corresponde a un archivo de salida. Dentro de main este archivo será identificado por
una variable llamada nombre_logico, y corresponderá a un archivo en el disco duro llama-
do nombre_fisico.dat. Naturalmente, el identificador nombre_logico puede ser cualquier
nombre de variable válido para C++, y nombre_fisico.dat puede ser cualquier nombre de
archivo válido para el sistema operativo. En particular, se pueden también dar nombres que
incluyan paths absolutos o relativos:
ofstream nombre_logico_1("/home/vmunoz/temp/nombre_fisico.dat");
ofstream nombre_logico_2("../nombre_fisico.dat");
Cuando creamos un objeto del tipo archivo, sin importar si es de salida o de entrada,
podemos inicializarlo con un nombre de archivo fı́sico. Este nombre lo podemos almacenar
previamente en una variable de string, llamemosla mi_nombre_archivo. En este caso, cuan-
do creamos el objeto ofstream debemos usar un método del objeto string que devuelve un
puntero a char, para poder inicializar el objeto ofstream. Veamos la sintaxis explı́citamente
string mi_nombre_archivo=’’archivo.txt’’;
ofstream nombre_logico_1( mi_nombre_archivo.c_str());
Las lı́neas cuarta y octava de main envı́an a nombre_logico (es decir, escribe en
nombre_fisico.dat), las variables i y j. Observar la analogı́a que existe entre estas opera-
ciones y las que envı́an la misma información a pantalla.4 Si ejecutamos el programa y en
el teclado ingresamos el número 8, al finalizar la ejecución el archivo nombre_fisico.dat
tendrá los dos números escritos:
3
8
Finalmente, el archivo creado debe ser cerrado (nombre_logico.close()). Si esta última
operación se omite en el código, no habrá errores de compilación, y el programa se encar-
gará de cerrar por sı́ solo los archivos abiertos durante su ejecución, pero un buen programador
debiera tener cuidado de cerrarlos explı́citamente. Por ejemplo, un mismo programa podrı́a
desear utilizar un mismo archivo más de una vez, o varios programas podrı́an querer acceder
al mismo archivo, y si no se ha insertado un close en el punto adecuado esto podrı́a provocar
problemas.
El archivo indicado al declarar la variable de tipo ofstream tiene modo de escritura, para
permitir la salida de datos hacia él. Si no existe un archivo llamado nombre_fisico.dat es
4
Esta analogı́a no es casual y se entiende con el concepto de clases (Sec. 4.8). fstream e iostream definen
clases que heredan sus propiedades de un objeto abstracto base, común a ambas, y que en el caso de iostream
se concreta en la salida estándar —pantalla—, y en el de fstream en un archivo.
creado; si existe, los contenidos antiguos se pierden y son reemplazados por los nuevos. No
siempre deseamos este comportamiento. A veces deseamos agregar la salida de un programa
a un archivo de texto ya existente. En ese caso la declaración del archivo es diferente, para
crear el archivo en modo “append”:
#include <iostream>
#include <fstream>
int main(){
ofstream nombre_logico("nombre_fisico.dat",ios::app);
int i = 3;

return 0;
}
Si ejecutamos este programa y el archivo nombre_fisico.dat no existe, será creado. El

resultado será un archivo con el número 3 en él. Al ejecutarlo por segunda vez, los datos se
ponen a continuación de los ya existentes, resultando el archivo con el contenido:
3
3
La lı́nea del tipo ofstream a("b") es equivalente a una del tipo int i=3, declarando
una variable (a/i) de un cierto tipo (ofstream/int) y asignándole un valor simultáneamente
"b"/3. Como para los tipos de variables predefinidos de C++, es posible separar declaración
y asignación para una variable de tipo ofstream:
ofstream a;
a.open("b");
es equivalente a ofstream a("b"). Esto tiene la ventaja de que podrı́amos usar el mismo
nombre lógico para identificar dos archivos fı́sicos distintos, usados en distintos momentos
del programa:
ofstream a;
a.open("archivo1.txt");
// Codigo en que "archivo1.txt" es utilizado
a.close();
a.open("archivo2.txt");
// Ahora "archivo2.txt" es utilizado
a.close();
4.6. MANEJO DE ARCHIVOS. 139
Observar la necesidad del primer close, que permitirá liberar la asociación de a a un nombre
fı́sico dado, y reutilizar la variable lógica en otro momento.
En los ejemplos hemos escrito solamente variables de tipo int en los archivos. Esto por
cierto no es restrictivo. Cualquiera de los tipos de variables de C++ —float, double, char,
etc.— se puede enviar a un archivo del mismo modo. Dicho esto, en el resto de esta sección
seguiremos usando como ejemplo el uso de int.
4.6.2. Archivos de entrada.

Ya sabemos que enviar datos a un archivo es tan fácil como enviarlos a pantalla. ¿Cómo
hacemos ahora la operación inversa, de leer datos desde un archivo? Como es de esperar, es tan
fácil como leerlos desde el teclado. Para crear un archivo en modo de lectura, basta declararlo
de tipo ifstream (input file stream). Por ejemplo, si en nombre_logico.dat tenemos los
siguientes datos:
3
6
9
12
el siguiente programa,
#include <iostream>
#include <fstream>
int main(){
ifstream nombre_logico("nombre_fisico.dat");
int i, j,k,l;
nombre_logico >> i >> j >> k >> l;
cout << i << "," << j << "," << k << "," << l << endl;
return 0;
}
será equivalente a asignar i=3, j=6, k=9, l=12, y luego enviar los datos a pantalla. Observar
que la sintaxis para ingresar datos desde un archivo, nombre_logico >> i, es idéntica a
cin >> i, para hacerlo desde el teclado. Al igual que cin, espacios en blanco son equivalentes
a cambios de lı́nea, de modo que el archivo podrı́a haber sido también:
3 6 9 12
Por cierto, el ingreso de datos desde un archivo se puede hacer con cualquier técnica, por
ejemplo, usando un for:
ifstream nombre_logico("nombre_fisico.dat");
int i;
for (int j=0;j<10;j++){
nombre_logico >> i;
cout << i << ",";
}
}
Como con ofstream, es posible separar declaración e implementación:
ifstream a;
a.open("b");
a.close();
4.6.3. Archivos de entrada y salida.

Ocasionalmente nos encontraremos con la necesidad de usar un mismo archivo, en el
mismo programa, a veces para escribir datos, y otras veces para leer datos. Por ejemplo,
podrı́amos tener una secuencia de datos en un archivo, leerlos, y de acuerdo al análisis de
esos datos agregar más datos a continuación del mismo archivo, o reemplazar los datos ya
existentes con otros. Necesitamos entonces un tipo de variable flexible, que pueda ser usado
como entrada y salida. Ese tipo es fstream. Todo lo que hemos dicho para ofstream y
ifstream por separado es cierto simultáneamente para fstream.5 Para especificar si el archivo
debe ser abierto en modo de escritura o lectura, open contiene el argumento ios::out o
ios::in, respectivamente. Por ejemplo, el siguiente código escribe el número 4 en un archivo,
y luego lo lee desde el mismo archivo:
#include <iostream>
#include <fstream>
int main(){
fstream nombre_logico;
nombre_logico.open("nombre_fisico.dat",ios::out);
int i = 4,j;

nombre_logico.open("nombre_fisico.dat",ios::in);
nombre_logico >> j;
5
Nuevamente, este hecho se debe al concepto de clases que subyace a las definiciones de estos tres tipos
de variables; fstream es una clase derivada a la vez de ofstream y de ifstream, heredando las propiedades
de ambas.
4.7. MAIN COMO FUNCIÓN. 141
cout << j << endl;

return 0;
}
Las dos primeras lı́neas de main separan declaración y asignación, y son equivalentes a
fstream nombre_logico("nombre_fisico.dat",ios::out);, pero lo hemos escrito ası́ pa-
ra hacer evidente la simetrı́a entre el uso del archivo como salida primero y como entrada
después.
De lo anterior, se deduce que:
fstream archivo_salida("salida.dat",ios::out);
fstream archivo_entrada("entrada.dat",ios::in);
es equivalente a
ofstream archivo_salida("salida.dat");
ifstream archivo_entrada("entrada.dat");
4.7. main como función.

Para ejecutar un programa compilado en C++, escribimos su nombre en el prompt:
user@host:~/$ programa
Si el mismo usuario desea ejecutar alguno de los comandos del sistema operativo, debe hacer
lo mismo:
user@host:~/$ ls
Sin embargo, ls es en realidad el nombre de un archivo ejecutable en el directorio /bin,
de modo que en realidad no hay diferencias entre nuestro programa y un comando del siste-
ma operativo en ese sentido. Sin embargo, éstos pueden recibir argumentos y opciones. Por
ejemplo, para ver todos los archivos que comienzan con l en el directorio local basta con
darle a ls el argumento l*: ls l*. Si queremos ordenar los archivos en orden inverso de
modificación, basta dar otro argumento, en forma de opción: ls -tr l*. Se ve entonces que
los argumentos de un archivo ejecutable permiten modificar el comportamiento del programa
de modos especı́ficos.
¿Es posible hacer lo mismo con archivos ejecutables hechos por el usuario? La respuesta
es sı́, y para eso se usan los argumentos del main. Recordemos que main es una función,
pero hasta el momento no hemos aprovechado esa caracterı́stica. Simplemente sabemos que
el programa empieza a ejecutarse en la lı́nea donde está la función main. Además, siempre
hemos escrito esa lı́nea como main(). Sin embargo, main, como cualquier función, es capaz de
aceptar argumentos. Especı́ficamente, acepta dos argumentos, el primero es un entero (que
cuenta el número de argumentos que main recibió), y el segundo es un puntero a un arreglo
de caracteres (que contiene los distintos argumentos, en forma de cadenas de caracteres, que
se le entregaron).
Por ejemplo:
#include <iostream>
int main( int argc, char * argv[])

{
for(int i = 0; i < argc; i++) {
cout << argv[i] << endl ;
}
return 0;
}
Si llamamos a este programa argumentos, obtenemos distintas salidas al llamarlo con distin-
tos argumentos:
user@host:~/$ argumentos
argumentos
user@host:~/$ argumentos ap k 5
argumentos
ap
k
5
user@host:~/$ argumentos -t -s 4 arg1
argumentos
-t
-s
4
arg1
Observar que el primer argumento del programa es siempre el nombre del propio programa.
Naturalmente, éste es un ejemplo muy simple. Es tarea del programador decidir cómo manejar
cada una de las opciones o argumentos que se le entregan al programa desde la lı́nea de
comandos, escribiendo el código correspondiente.
4.7.1. Tipo de retorno de la función main.

Un segundo aspecto con el cual no hemos sido sistemáticos es que main, como toda función,
tiene un tipo de retorno. En el caso de main, ese tipo debe ser int. Este int es entregado al
sistema operativo, y puede servir para determinar si el programa se ejecutó con normalidad o
si ocurrió algo anormal. Podrı́amos hacer ese valor de retorno igual a 0 o 1, respectivamente.
Ası́, la siguiente estructura es correcta:
int main(){
// Codigo
return 0;
}
4.8. CLASES. 143
En este caso, el programa entrega siempre el valor 0 al sistema operativo.

Los códigos del tipo:
main(){
// Codigo
}
o
void main(){
// Codigo
}
también compilan, pero el compilador emite una advertencia si es llamado con la opción
-Wall (Warning all ). En el primer caso, la advertencia es:
warning: ANSI C++ forbids declaration ‘main’ with no type
En el segundo:
return type for ‘main’ changed to ‘int’
En general, siempre es conveniente compilar con la opción -Wall, para lograr que nuestro
código esté realmente correcto (g++ -Wall <archivo>.cc -o <archivo>).
4.8. Clases.
C++ dispone de una serie de tipos de variables con las cuales nos está permitido operar:
int, double, char, etc. Creamos variables de estos tipos y luego podemos operar con ellas:
int x, y;
x = 3;
y = 6;
int z = x + y;
No hay, sin embargo, en C++, una estructura predefinida que corresponda a números
complejos, vectores de dimensión n o matrices, por ejemplo. Y sin embargo, nos agradarı́a
disponer de números complejos que pudiéramos definir como
z = (3,5);
w = (6,8);
y que tuvieran sentido las expresiones
a = z + w;
b = z * w;
c = z / w;
d = z + 3;
e = modulo(z);
f = sqrt(z);
Todas estas expresiones son completamente naturales desde el punto de vista matemático,
y serı́a bueno que el lenguaje las entendiera. Esto es imposible en el estado actual, pues, por
ejemplo, el signo + es un operador que espera a ambos lados suyos un número. Sumar cualquier
cosa con cualquier cosa no significa nada necesariamente, ası́ que sólo está permitido operar
con números. Pero los humanos sabemos que los complejos son números. ¿Cómo decı́rselo
al computador? ¿Cómo convencerlo de que sumar vectores o matrices es también posible
matemáticamente, y que el mismo signo + deberı́a servir para todas estas operaciones?
La respuesta es: a través del concepto de clases. Lo que debemos hacer es definir una clase
de números complejos. Llamémosla Complejo. Una vez definida correctamente, Complejo
será un tipo más de variable que el compilador reconocerá, igual que int, double, char, etc.
Y será tan fácil operar con los Complejos como con todos los tipos de variables preexistentes.
Esta facilidad es la base de la extensibilidad de que es capaz C++, y por tanto de todas las
propiedades que lo convierten en un lenguaje muy poderoso.
Las clases responden a la necesidad del programador de construir objetos o tipos de datos
que respondan a sus necesidades. Si necesitamos trabajar con vectores de 5 coordenadas,
será natural definir una clase que corresponda a vectores con 5 coordenadas; si se trata de
un programa de administración de personal, la clase puede corresponder a un empleado, con
sus datos personales como elementos.
Si bien es cierto uno puede trabajar con clases en el contexto de orientación al procedi-
miento, las clases muestran con mayor propiedad su potencial con la orientación al objeto,
donde cada objeto corresponde a una clase. Por ejemplo, para efectuar una aplicación para
X-windows, la ventana principal, las ventanas de los archivos abiertos, la barra de menú, las
cajas de diálogo, los botones, etc., cada uno de estos objetos estará asociado a una clase.
4.8.1. Definición.
Digamos que queremos una clase para representar a los empleados de una empresa.
Llamémosla Persona. La convención aceptada es que los nombres de las clases comiencen
con mayúscula. Esto es porque las clases, recordemos, corresponderán a tipos de variables
tan válidos como los internos de C++ (int, char, etc.). Al usar nombres con mayúscula
distinguimos visualmente los nombres de un tipo de variable interno y uno definido por el
usuario.
La estructura mı́nima de la definición de la clase Persona es:
class Persona
{
};
Todas las caracterı́sticas de la clase se definen entre los paréntesis cursivos.
4.8. CLASES. 145
4.8.2. Miembros.
Se denomina miembros de una clase a todas las variables y funciones declaradas dentro de
una clase. Por ejemplo, para personas, es natural caracterizarlas por su nombre y su edad. Y
si se trata de empleados de una empresa, es natural también tener una función que entregue
su sueldo:
class Persona
{
string nombre;
fecha nacimiento;
int rut;
double edad();
};
Los miembros de una clase pueden tener cualquier nombre, excepto el nombre de la propia
clase dentro de la cual se definen; ese nombre está reservado.
4.8.3. Miembros públicos y privados.

Una clase distingue información (datos o funciones) privada (accesible sólo a otros miem-
bros de la misma clase) y pública (accesible a funciones externas a la clase). La parte privada
corresponde a la estructura interna de la clase, y la parte pública a la implementación (tı́pi-
camente funciones), que permite la interacción de la clase con el exterior.
Consideremos ahora nuestro deseo de tener una clase que represente números complejos.
Un número complejo tiene dos números reales (parte real e imaginaria), y ésos son elementos
privados, es decir, parte de su estructura interna. Sin embargo, nos gustarı́a poder modificar
y conocer esas cantidades. Eso sólo puede hacerse a través de funciones públicas.
class Complejo
{
private:
double real, imaginaria;
public:
void setreal(double);
void setimag(double);
double getreal();
double getimag();
};
En este ejemplo, los miembros privados son sólo variables, y los miembros públicos son sólo
funciones. Éste es el caso tı́pico, pero puede haber variables y funciones de ambos tipos.
4.8.4. Operador de selección (.).

Hemos definido una clase de números complejos y funciones que nos permiten conocer
y modificar las partes real e imaginaria. ¿Cómo se usan estos elementos? Consideremos el
siguiente programa de ejemplo:
class Complejo
{
private:
public:
double getreal();
double getimag();
};
int main()
{
Complejo z, w;
z.setreal(3);
z.setimag(2.8);
w.setreal(1.5);
w.setimag(5);
cout << "El primer numero complejo es: " << z.getreal()
<< " + i*" << z.getimag() << endl;
cout << "El segundo es: " << w.getreal() << " + i*"
<< z.getimag() << endl;
return 0;
}
Vemos en la primera lı́nea de main cómo la clase Complejo se usa del mismo modo que
usarı́amos int o double. Ahora Complejo es un tipo de variable tan válido como los tipos
predefinidos por C++. Una vez definida la variable, el operador de selección (.) permite
acceder a las funciones públicas correspondientes a la clase Complejo, aplicadas a la variable
particular que nos interesa: z.setreal(3) pone en la parte real del Complejo z el número
3, y w.setreal(1.5) hace lo propio con w.
4.8.5. Implementación de funciones miembros.

Ya sabemos cómo declarar funciones miembros en el interior de la clase y cómo usarlas.
Ahora veamos cómo se implementan.
void Complejo::setreal(double x)
{
real = x;
}
void Complejo::setimag(double x)
{
4.8. CLASES. 147
imaginaria = x;
}
double Complejo::getreal()
{
return real;
}
double Complejo::getimag()
{
return imaginaria;
}
Como toda función, primero va el tipo de la función (void o double en los ejemplos), luego
el nombre de la función y los argumentos. Finalmente la implementación. Lo diferente es que
el nombre va precedido del nombre de la clase y el operador “::” .
4.8.6. Constructor.
Al declarar una variable, el programa crea el espacio de memoria suficiente para alojarla.
Cuando se trata de variables de tipos predefinidos en C++ esto no es problema, pero cuando
son tipos definidos por el usuario, C++ debe saber cómo construir ese espacio. La función
que realiza esa tarea se denomina constructor.
El constructor es una función pública de la clase, que tiene el mismo nombre que ella.
Agreguemos un constructor a la clase Complejo:
class Complejo
{
private:
double real,imaginaria;
public:
Complejo(double,double);
double getreal();
double getimag();
};
Complejo::Complejo (double x, double y)

: real(x), imaginaria(y)
{}
Definir el constructor de esta manera nos permite crear en nuestro programa variables de
tipo Complejo y asignarles valores sin usar setreal() o setimag():
Complejo z (2, 3.8);
Complejo w = Complejo(6.8, -3);
En el constructor se inicializan las variables internas que nos interesa inicializar al mo-
mento de crear un objeto de esta clase.
Si una de las variables internas a inicializar es una cadena de caracteres, hay que inicia-
lizarla de modo un poco distinto. Por ejemplo, si estamos haciendo una clase OtraPersona
que sólo tenga el nombre de una persona, entonces podemos definir la clase y su constructor
en la forma:
class OtraPersona
{
private:
char nombre[20];
public:
Persona(char []);
};
Persona::Persona(char a[])
{
strcpy(nombre,a);
}
Si uno no especifica el constructor de una clase C++ crea uno default, pero en general
será insuficiente para cualquier aplicación realmente práctica. Es una mala costumbre ser
descuidado y dejar estas decisiones al computador.
4.8.7. Destructor.
Ası́ como es necesario crear espacio de memoria al definir una variable, hay que deshacerse
de ese espacio cuando la variable deja de ser necesaria. En otras palabras, la clase necesita
también un destructor . Si la clase es Complejo, el destructor es una función pública de ella,
llamada ~Complejo.
class Complejo
{
private:
public:
Complejo(double,double);
~Complejo();
double getreal();
double getimag();
};
Complejo::Complejo (double x, double y): real(x), imaginaria(y)

{
}
4.9. SOBRECARGA. 149
Complejo::~Complejo()
{
}
Como con los constructores, al omitir un destructor C++ genera un default, pero es una
mala costumbre. . . , etc.
4.8.8. Arreglos de clases.

Una clase es un tipo de variable como cualquier otra de las predefinidas en C++. Es
posible construir matrices con ellas, del mismo modo que uno tiene matrices de enteros o
caracteres. La única diferencia con las matrices usuales es que no se pueden sólo declarar,
sino que hay que inicializarlas simultáneamente. Por ejemplo, si queremos crear una matriz
que contenga 2 números complejos, la lı́nea
Complejo z[2];
es incorrecta, pero sı́ es aceptable la lı́nea
Complejo z[2] = {Complejo(3.5,-0.8), Complejo(-2,4)};
4.9. Sobrecarga.
Para que la definición de nuevos objetos sea realmente útil, hay que ser capaz de hacer
con ellos muchas acciones que nos serı́an naturales. Como ya comentamos al introducir el
concepto de clase, nos gustarı́a sumar números complejos, y que esa suma utilizara el mismo
signo + de la suma usual. O extraerles la raı́z cuadrada, y que la operación sea tan fácil
como escribir sqrt(z). Lo que estamos pidiendo es que el operador + o la función sqrt()
sean polimórficos, es decir, que actúen de distinto modo según el tipo de argumento que
se entregue. Si z es un real, sqrt(z) calculará la raı́z de un número real; si es complejo,
calculará la raı́z de un número complejo.
La técnica de programación mediante la cual podemos definir funciones polimórficas se
llama sobrecarga.
4.9.1. Sobrecarga de funciones.

Digamos que la raı́z cuadrada de un número complejo a + ib es (a/2) + i(b/2). (Es más
complicado en realidad, pero no queremos escribir las fórmulas ahora.)
Para sobrecargar la función sqrt() de modo que acepte números complejos basta definirla
ası́:
Complejo sqrt(Complejo z)
{
return Complejo (z.getreal()/2, z.getimag()/2);
}
Observemos que definimos una función sqrt que acepta argumentos de tipo Complejo, y que
entrega un número del mismo tipo. Cuando pidamos la raı́z de un número, el computador
se preguntará si el número en cuestión es un int, double, float o Complejo, y según eso
escogerá la versión de sqrt que corresponda.
Con la definición anterior podemos obtener la raı́z cuadrada de un número complejo
simplemente con las instrucciones:
Complejo z(1,3);
Complejo raiz = sqrt(z);
4.9.2. Sobrecarga de operadores.

¿Cómo le decimos al computador que el signo + también puede aceptar números comple-
jos? La respuesta es fácil, porque para C++ un operador no es sino una función, y la acción
de sobrecargar que ya vimos sirve en este caso también. La sintaxis es:
Complejo operator + (Complejo z, Complejo w)
{
return Complejo (z.getreal() + w.getreal(),
z.getimag() + w.getimag());
}
4.9.3. Coerción.
Sabemos definir a + b, con a y b complejos. Pero ¿qué pasa si a o b son enteros? ¿O reales?
Pareciera que tendrı́amos que definir no sólo
Complejo operator + (Complejo a, Complejo b);
sino también todas las combinaciones restantes:
Complejo operator + (Complejo a, int b);
Complejo operator + (Complejo a, float b);
Complejo operator + (int a, Complejo b);
etcétera.
En realidad esto no es necesario. Por cierto, un número real es un número complejo con
parte imaginaria nula, y es posible hacerle saber esto a C++, usando la posibilidad de definir
funciones con parámetros default. Basta declarar (en el interior de la clase) el constructor de
los números complejos como
Complejo (double, double = 0);
Esto permite definir un número complejo con la instrucción:
Complejo c = Complejo(3.5);
resultando el número complejo 3.5 + i · 0. Y si tenemos una lı́nea del tipo:
Complejo c = Complejo(3,2.8) + 5;
el computador convertirá implı́citamente el entero 5 a Complejo (sabe cómo hacerlo porque
el constructor de números complejos acepta también un solo argumento en vez de dos), y
luego realizará la suma entre dos complejos, que es entonces la única que es necesario definir.
4.10. HERENCIA. 151
4.10. Herencia.
Herencia es el mecanismo mediante el cual es posible definir clases a partir de otras,
preservando parte de las propiedades de la primera y agregando o modificando otras.
Por ejemplo, si definimos la clase Persona, toda Persona tendrá una variable miembro
que sea su nombre. Si definimos una clase Hombre, también será Persona, y por tanto deberı́a
tener nombre. Pero además puede tener esposa. Y ciertamente no toda Persona tiene esposa.
Sólo un Hombre.
C++ provee mecanismos para implementar estas relaciones lógicas y poder definir una
clase Hombre a partir de Persona. Lo vemos en el siguiente ejemplo:
class Persona
{
private:
string nombre;
public:
Persona(string = "");
~Persona();
string getname();
}
class Hombre : public Persona

{
private:
string esposa;
public:
Hombre(string a) : Persona(a)
{ };
string getwife();
void setwife(string);
};
Primero definimos una clase Persona que tiene nombre. Luego definimos una clase Hombre
a partir de Persona (con la lı́nea class Hombre : public Persona). Esto permite de modo
automático que Hombre tenga también una variable nombre. Y finalmente, dentro de la clase
Hombre, se definen todas aquellas caracterı́sticas adicionales que una Persona no tiene pero
un Hombre sı́: esposa, y funciones miembros para modificar y obtener el nombre de ella.
Un ejemplo de uso de estas dos clases:
Persona cocinera("Maria");
Hombre panadero("Claudio");
panadero.setwife("Estela");
cout << cocinera.getname() << endl;

cout << panadero.getname() << endl;
cout << panadero.getwife() << endl;
Observemos que panadero también tiene una función getname(), a pesar de que la clase
Hombre no la define explı́citamente. Esta función se ha heredado de la clase de la cual Hombre
se ha derivado, Persona.
4.11. Ejemplo: la clase de los complejos.

A continuación, una clase de complejos más completa. Primero el archivo de headers
complejos.h, con las definiciones:
#ifndef _complejos_
#define _complejos_
#include <iostream>
#include <cmath>
class Complejo {
private:
public:
Complejo();
Complejo(double,double=0);
~Complejo();
double getreal();
double getimag();
double getmodule();
double getmodule2();
double getphase();
};
Complejo operator + (Complejo,Complejo);

Complejo operator - (Complejo,Complejo);
Complejo operator * (Complejo,Complejo);
Complejo operator / (Complejo,Complejo);
Complejo conjugate(Complejo);
Complejo inverse(Complejo);
Complejo sqrt(Complejo);
Complejo log(Complejo);
bool operator == (Complejo,Complejo);
bool operator != (Complejo,Complejo);
std::ostream & operator << (std::ostream &, Complejo);
#endif
4.11. EJEMPLO: LA CLASE DE LOS COMPLEJOS. 153
y la implementación de lo anterior
#include "complejos.h"
Complejo::Complejo(double x, double y)
:real(x), imaginaria(y)
{}
Complejo::Complejo()
:real(0), imaginaria(0)
{}
Complejo::~Complejo()
{}
void Complejo::setreal(double x)
{
real = x;
}
void Complejo::setimag(double x)
{
imaginaria = x;
}
double Complejo::getreal()
{
return real;
}
double Complejo::getimag()
{
return imaginaria;
}
double Complejo::getmodule()
{
return sqrt(real*real+imaginaria*imaginaria);
}
double Complejo::getmodule2()
{
return real*real+imaginaria*imaginaria;
}
double Complejo::getphase()
{
return atan2(real,imaginaria);
}
Complejo operator + (Complejo z,Complejo w)

{
return Complejo(z.getreal()+w.getreal(), z.getimag()+w.getimag());
}
Complejo operator - (Complejo z,Complejo w)

{
return Complejo(z.getreal()-w.getreal(), z.getimag()-w.getimag());
}
Complejo operator * (Complejo z,Complejo w)

{
return Complejo(z.getreal()*w.getreal()- z.getimag()*w.getimag(),
z.getreal()*w.getimag()+ z.getimag()*w.getreal());
}
Complejo operator / (Complejo z,Complejo w)

{
return z*inverse(w);
}
Complejo conjugate(Complejo z)
{
return Complejo(z.getreal(), -z.getimag());
}
Complejo inverse(Complejo z)
{
return Complejo(z.getreal()/z.getmodule2(), -z.getimag()/z.getmodule2());
}
Complejo sqrt(Complejo z)
{
return Complejo(sqrt(z.getmodule())*cos(z.getphase()/2.0),
sqrt(z.getmodule())*sin(z.getphase()/2.0)) ;
}
Complejo log(Complejo z)
{
return Complejo(log(z.getmodule()), z.getphase());
}
4.12. COMPILACIÓN Y DEBUGGING. 155
bool operator == (Complejo z,Complejo w)

{
return bool(z.getreal()==w.getreal() && z.getimag()==w.getimag());
}
bool operator != (Complejo z,Complejo w)

{
return bool(z.getreal()!=w.getreal() || z.getimag()!=w.getimag());
}
std::ostream & operator << (std::ostream & os , Complejo z)

{
os << z.getreal();
if(z.getimag() !=0) os << " + i*"<< z.getimag();
return os;
}
4.12. Compilación y debugging.

4.12.1. Compiladores.
El comando para usar el compilador de lenguaje C es gcc, para usar el compilador de
C++ es g++ y para usar el compilador de fortran 77 es g77. Centrémosnos en el compilador
de C++, los demás funcionan en forma muy similar. Su uso más elemental es:
g++ filename.cc
Esto compila el archivo filename.cc y crea un archivo ejecutable que se denomina a.out
por omisión. Existen diversas opciones para el compilador, sólo comentaremos una pocas.
-c realiza sólo la compilación pero no el link:

g++ -c filename.cc
genera el archivo filename.o que es código objeto.
-o exename define el nombre del ejecutable creado, en lugar del por defecto a.out.
g++ -o outputfile filename.cc
-lxxx incluye la biblioteca /usr/lib/libxxx.a en la compilación.

g++ filename.cc -lm
En este caso se compila con la biblioteca matemática libm.a.
-g permite el uso de un debugger posteriormente.
-On optimización de grado n que puede tomar valores de 1 (por defecto) a 3. El objetivo
inicial del compilador es reducir el tiempo de la compilación. Con -On, el compilador
trata de reducir el tamaño del ejecutable y el tiempo de ejecución, con n se aumenta el
grado de optimización.
-Wall notifica todos los posibles warnings en el código que está siendo compilado.
-L/path1 -I/path2/include incluye en el camino de búsqueda /path1/ para las bi-

bliotecas y /path2/include para los archivos de cabecera (headers).
El compilador gcc (the GNU C compiler) es compatible ANSI.

Capı́tulo 5
Gráfica.
versión 4.12, 24 de Octubre del 2003
En este capı́tulo quisiéramos mostrar algunas de las posibilidades gráficas presentes en Li-
nux. Nuestra intensión es cubrir temas como la visualización, conversión, captura y creación
de archivos gráficos. Sólo mencionaremos las aplicaciones principales en cada caso centrándo-
nos en sus posibilidades más que en su utilización especı́fica, ya que la mayorı́a posee una
interfase sencilla de manejar y una amplia documentación.
5.1. Visualización de archivos gráficos.

Si disponemos de un archivo gráfico conteniendo algún tipo de imagen lo primero que es
importante determinar es en qué tipo de formato gráfico está codificada. Existe un número
realmente grande de diferentes tipos de codificaciones de imágenes, cada una de ellas se
considera un formato gráfico. Por razones de reconocimiento inmediato del tipo de formato
gráfico se suelen incluir en el nombre del archivo, que contiene la imagen, un trı́o de letras
finales, conocidas como la extensión, que representan el formato. Por ejemplo: bmp, tiff, jpg,
ps, eps, fig, gif entre muchas otras, si uno quiere asegurarse puede dar el comando:
jrogan@huelen:~$file mono.jpg
mono.jpg: JPEG image data, JFIF standard 1.01, resolution (DPCM), 72 x 72
¿De qué herramientas disponemos en Linux para visualizar estas imágenes? La respuesta
es que en Linux disponemos de variadas herramientas para este efecto.
Si se trata de archivos de tipo PostScript o Encapsulated PostScript, identificados por la
extensión ps o eps, existen las aplicaciones gv, gnome-gv o kghostview, todos programas que
nos permitirán visualizar e imprimir este tipo de archivos. Si los archivos son tipo Portable
Document Format, con extensión pdf, tenemos las aplicaciones gv, acroread o xpdf, Con
todas ellas podemos ver e imprimir dicho formato. Una mención especial requieren los archivos
DeVice Independent con extensión dvi ya que son el resultado de la compilación de un
documento TEX o LATEX, para este tipo de archivo existen las aplicaciones xdvi, advi, gxdvi
y kdvi por nombrar las principales. La aplicación xdvi sólo permite visualizar estos archivos
y no imprimirlos, la mayorı́a de las otras permiten imprimirlo directamente. Si usa xdvi y
desea imprimir el documento debe transformar a ps vı́a dvips y luego se imprime como
cualquier otro Postscript.
Para la gran mayorı́a de formatos gráficos más conocidos y usualmente usados para al-
macenar fotos existen otra serie se programas especializados en visualización que son capaces
157
158 CAPÍTULO 5. GRÁFICA.
de entender la mayorı́a de los formatos más usados. Entre estos programas podemos mencio-
nar: Eye of Gnome (eog), Electric Eyes (eeyes), kview o display. Podemos mencionar que
aplicaciones como display entienden sobre ochenta formatos gráficos distintos entre los que
se encuentran la mayorı́a de los formatos conocidos más otros como ps, eps, pdf, fig, html,
entre muchos otros. Una mención especial merece el utilitario gthumb que nos permite hacer
un preview de un directorio con muchas imagenes de manera muy fácil.
5.2. Modificando imágenes

Si queremos modificaciones como rotaciones, ampliaciones, cortes, cambios de paleta de
colores, filtros o efectos sencillos, display es la herramienta precisa. Pero si se desea intervenir
la imagen en forma profesional, el programa gimp es el indicado. El nombre gimp viene de
GNU Image Manipulation Program. Se puede usar esta aplicación para editar y manipular
imágenes. Pudiendo cargar y salvar en una variedad de formatos, lo que permite usarlo para
convertir entre ellos. La aplicación gimp puede también ser usado como programa de pintar,
de hecho posee una gran variedad de herramientas en este sentido, tales como brocha de
aire, lápiz clonador, tijeras inteligentes, curvas bezier, etc. Además, permite incluir plugins
que realizan gran variedad de manipulaciones de imagen. Como hecho anecdótico podemos
mencionar que la imagen oficial de Tux, el pingüino mascota de Linux, fue creada en gimp. Sin
embargo, si gimp le parece muy profesional o usted sólo necesita un programa para dibujar
en el cual se entretenga su hermano menor tuxpaint es la alternativa.
5.3. Conversión entre formatos gráficos.

El problema de transformar de un formato a otro es una situación usual en el trabajo con
archivos gráficos. Muchos softwares tienen salidas muy restringidas en formato o bien usan
formatos arcaicos (gif) por ejemplo. De ahı́ que se presenta la necesidad de convertir estos
archivos de salida en otros formatos que nos sean más manejables o prácticos. Como ya se
mencionó, gimp puede ser usado para convertir entre formatos gráficos. También display
permite este hecho. Sin embargo, en ambos casos la conversión es vı́a menús, lo cual lo
hace engorroso para un gran número de conversiones e imposible para conversiones de tipo
automático. Existe un programa llamado convert que realiza conversiones desde la lı́nea de
comando. Este programa junto con display, import y varios otros forman la suite gráfica
ImageMagick, una de las más importantes en unix, en general, y en especial en Linux y que
ya ha sido migrada a otras plataformas. Además, de la clara ventaja de automatización que
proporciona convert, posee otro aspecto interesante, puede convertir un grupo de imágenes
asociadas en una secuencia de animación o pelı́cula. Veamos la sintaxis para este programa:
user@host:~/imagenes$convert cockatoo.tiff cockatoo.jpg
user@host:~/secuencias$convert -delay 20 dna*.png dna.mng
En el primer caso convierte el archivo cockatoo de formato tiff a formato jpg. En el

segundo, a partir de un conjunto de archivos con formato png llamados dna más un número
5.4. CAPTURA DE PANTALLA. 159
correlativo, crea una secuencia animada con imágenes que persisten por 20 centésimas de
segundos en un formato conocido como mng.
5.4. Captura de pantalla.

A menudo se necesita guardar imágenes que sólo se pueden generar a tiempo de ejecución,
es decir, mientras corre nuestro programa genera la imagen pero no tiene un mecanismo propio
para exportarla o salvarla como imagen. En este caso necesitamos capturar la pantalla y
poderla almacenar en un archivo para el cual podamos elegir el formato. Para estos efectos
existe un programa, miembro también de la suite ImageMagick, llamado import que nos
permite hacer el trabajo. La sintaxis del comando es
import figure.eps
import -window root root.jpg

En el primer caso uno da el comando en un terminal y queda esperando hasta que uno toque
alguna de las ventanas, la cual es guardada en este caso en un archivo figure.eps en formato
PostScript. La extensión le indica al programa qué formato usar para almacenar la imagen.
En el segundo caso uno captura la pantalla completa en un archivo root.jpeg. Este comando
puede ser dado desde la consola de texto para capturar la imagen completa en la pantalla
gráfica.
5.5. Creando imágenes.

Para imágenes artı́sticas sin duda la alternativa es gimp, todo le que se dijo respecto a
sus posibilidades para modificar imágenes se aplica también en el caso de crearlas. En el caso
de necesitar imágenes más bien técnicas como esquemas o diagramas o una ilustración para
aclarar un problema las alternativas pueden ser xfig, sodipodi o sketch todas herramientas
vectoriales muy poderosa. Este tipo de programas son manejados por medio de menús y
permiten dibujar y manipular objetos interactivamente. Las imágenes pueden ser salvadas,
en formato propios y posteriormente editadas. La gran ventaja de estos programas es que
trabaja con objetos y no con bitmaps. Además, puede exportar las imágenes a otros formatos:
PostScript o Encapsulated PostScript o bien gif o jpeg.
Habitualmente los dibujos necesarios para ilustrar problemas en Fı́sica en tareas, pruebas
y apuntes son realizados con software de este tipo, principalmente xfig, luego exportados
a PostScript e incluı́dos en los respectivos archivos LATEX. También existe una herramienta
extremadamente útil que permite convertir un archivo PostScript, generado de cualquier
manera, a un archivo fig que puede ser editado y modificado. Esta aplicación que transforma
se llama pstoedit y puede llegar a ser realmente práctica. Otra herramienta interesante es
autotrace que permite pasar una figura en bitmap a forma vectorial.
Una aparente limitación de este tipo de software es que se podrı́a pensar que no podemos
incluir curvas analı́ticas, es decir, si necesitamos ilustrar una función gaussiana no podemos
pretender “dibujarla” con las herramientas de que disponen. Sin embargo, este problema
puede ser resuelto ya que software que grafica funciones analı́ticas, tales como gnuplot,
permite exportar en formato que entienden los programas vectoriales (fig, por ejemplo)
luego podemos leer el archivo y editarlo. Además, xfig permite importar e incluir imágenes
del tipo bitmap, agregando riqueza a los diagramas que puede generar.
Una caracterı́stica importante de este tipo de programas es que trabajen por capas, las
cuales son tratadas independientemente, uno puede poner un objeto sobre otro o por debajo
de otro logrando diferentes efectos. Algunos programas de presentación gráficos basados en
LATEX y pdf están utilizando esta capacidad en xfig para lograr animaciones de imágenes.
Finalmente el programa xfig permite construir una biblioteca de objetos reutilizables
ahorrando mucho trabajo. Por ejemplo, si uno dibuja los elementos de un circuito eléctrico y
los almacena en el lugar de las bibliotecas de imágenes podrá incluir estos objetos en futuros
trabajos. El programa viene con varias bibliotecas de objetos listas para usar.
5.6. Graficando funciones y datos.

Existen varias aplicaciones que permiten graficar datos de un archivo, entre las más popu-
lares están: gnuplot, xmgrace y SciGraphica. La primera está basada en la lı́nea de comando
y permite gráficos en 2 y 3 dimensiones, pudiendo además, graficar funciones directamente
sin pasar por un archivo de datos. Las otras dos son aplicaciones basadas en menús que
permiten un resultado final de mucha calidad y con múltiples variantes. La debilidad en el
caso de xmgrace es que sólo hace gráficos bidimensionales.
El programa gnuplot se invoca de la lı́nea de comando y da un prompt en el mismo
terminal desde el cual se puede trabajar, veamos una sesión de gnuplot:
jrogan@huelen:~$ gnuplot
G N U P L O T
Version 3.7 patchlevel 2
last modified Sat Jan 19 15:23:37 GMT 2002
System: Linux 2.4.19
Copyright(C) 1986 - 1993, 1998 - 2002

Thomas Williams, Colin Kelley and many others
Type ‘help‘ to access the on-line reference manual

The gnuplot FAQ is available from
http://www.gnuplot.info/gnuplot-faq.html
Send comments and requests for help to <[email protected]>

Send bugs, suggestions and mods to <[email protected]>
Terminal type set to ’x11’

gnuplot> plot sqrt(x)
gnuplot> set xrange[0:5]
gnuplot> set xlabel" eje de las x"
5.7. GRAFICANDO DESDE NUESTROS PROGRAMAS. 161
gnuplot> replot
gnuplot> set terminal postscript
Terminal type set to ’postscript’
Options are ’landscape noenhanced monochrome dashed defaultplex "Helvetica" 14’
gnuplot> set output "mygraph.ps"
gnuplot> replot
gnuplot> set terminal X
Terminal type set to ’X11’
Options are ’0’
gnuplot> set xrange[-2:2]
gnuplot> set yrange[-2:2]
gnuplot> splot exp(-x*x-y*y)
gnuplot> plot "myfile.dat" w l
gnuplot> exit
jrogan@huelen:~$
En el caso de xmgrace y SciGraphica mucho más directo manejarlo ya que está ba-
sado en menús. Además, existe abundante documentación de ambos softwares. El software
SciGraphica es una aplicación de visualización y análisis de data cientı́fica que permite el
despliegue de gráficos en 2 y 3 dimensiones, además, exporta los resultados a formato Pos-
tScript. Realmente esta aplicación nació como un intento de clonar el programa comercial
origen no disponible para Linux.
5.7. Graficando desde nuestros programas.

Finalmente para poder graficar desde nuestro propio programa necesitamos alguna biblio-
teca gráfica, en nuestro caso usaremos la biblioteca iglu, hecha completamente en casa. La
página de iglu está en : http://aristoteles.ciencias.uchile.cl/homepage/iglu/iglu.html
El comando de compilación incluido en un script, que llamaremos iglu_compila, y que con-
tiene las siguientes lı́neas:
#!/bin/bash
g++ -Wall -O3 -o $1 $1.cc -I. -I$HOME/iglu/ \
-L/usr/X11R6/lib/ -L$HOME/iglu/ -liglu -lX11 -lm
Veamos algunos ejemplos:
/* Ejemplo: sen(x) */
#include ‘‘iglu.h’’
#include <cmath>
int main()
{
IgluDibujo v(‘‘Funcion Seno’’);
const int N=100;
double x[N], y[N];
v.map_coordinates(0,2*M_PI,-1.2,1.2);
double dx = 2*M_PI/(N-1);
for (int i=0;i<N;i++){
x[i] = i*dx;
y[i] = sin(x[i]);
}
v.plot_line(x,y,N);
v.wait();
return 0;
}
Este programa grafica la función seno con un número de puntos dado.

Otro caso, una primitiva animación
// Ejemplo sen(x-vt)
#include "iglu.h"
#include <cmath>
int main(){
IgluDibujo v(‘‘Pelicula’’);
const int N=100, Nt=100;
double x[N], y[N];
v.map_coordinates(0,2*M_PI,-1.2,1.2);
double dx = 2*M_PI/(N-1), dt = 1, t=0;
for (int j=0;j<Nt;j++){
v.clean();
t += dt;
x[i] = i*dx;
y[i] = sin(x[i]-.1*t);
}
v.plot_line(x,y,N);
v.wait(.03);
v.flush();
}
v.wait();
return 0;
}
Capı́tulo 6
El sistema de preparación de
documentos TEX .
versión 5.0, 30 de Julio del 2003
6.1. Introducción.
TEX es un procesador de texto o, mejor dicho, un avanzado sistema de preparación de
documentos, creado por Donald Knuth, que permite el diseño de documentos de gran cali-
dad, conteniendo textos y fórmulas matemáticas. Años después, LATEX fue desarrollado por
Leslie Lamport, facilitando la preparación de documentos en TEX, gracias a la definición de
“macros” o conjuntos de comandos de fácil uso.
LATEX tuvo diversas versiones hasta la 2.09. Actualmente, LATEX ha recibido importantes
modificaciones, siendo la distribución actualmente en uso y desarrollo LATEX 2ε , una versión
transitoria en espera de que algún dı́a se llegue a la nueva versión definitiva de LATEX, LATEX3.
En estas páginas cuando digamos LATEX nos referiremos a la versión actual, LATEX 2ε . Cuan-
do queramos hacer referencia a la versión anterior, que deberı́a quedar progresivamente en
desuso, diremos explı́citamente LATEX 2.09.
6.2. Archivos.
El proceso de preparación de un documento LATEX consta de tres pasos:
1. Creación de un archivo con extensión tex con algún editor.
2. Compilación del archivo tex, con un comando del tipo latex

<archivo>.tex o latex <archivo>. Esto da por resultado tres archivos adicionales,
con el mismo nombre del archivo original, pero con extensiones distintas:
a) dvi. Es el archivo procesado que podemos ver en pantalla o imprimir. Una vez
compilado, este archivo puede ser enviado a otro computador, para imprimir en
otra impresora, o verlo en otro monitor, independiente de la máquina (de donde
su extensión dvi, device independent).
163
164 CAPÍTULO 6. EL SISTEMA DE PREPARACIÓN DE DOCUMENTOS TEX .
b) log. Aquı́ se encuentran todos los mensajes producto de la compilación, para

consulta si es necesario (errores encontrados, memoria utilizada, mensajes de ad-
vertencia, etc.).
c) aux. Contiene información adicional que, por el momento, no nos interesa.
3. Visión en pantalla e impresión del archivo procesado a través de un programa anexo

(xdvi o dvips, por ejemplo), capaz de leer el dvi.
6.3. Input básico.

6.3.1. Estructura de un archivo.
En un archivo no pueden faltar las siguientes lı́neas:
\documentclass[12pt]{article}
\begin{document}
\end{document}
Haremos algunas precisiones respecto a la primera lı́nea más tarde. Lo importante es que
una lı́nea de esta forma debe ser la primera de nuestro archivo. Todo lo que se encuentra
antes de \begin{document} se denomina preámbulo. El texto que queramos escribir va entre
\begin{document} y \end{document}. Todo lo que se encuentre después de \end{document}
es ignorado.
6.3.2. Caracteres.
Pueden aparecer en nuestro texto todos los caracteres del código ASCII no extendido
(teclado inglés usual): letras, números y los signos de puntuación:
. : ; , ? ! ‘ ’ ( ) [ ] - / * @
Los caracteres especiales:
# $ % & ~ _ ^ \ { }
tienen un significado especı́fico para LATEX. Algunos de ellos se pueden obtener anteponiéndo-
les un backslash:
# \# $ \$ % \% & \& { \{ } \}
Los caracteres
+ = | < >
6.3. INPUT BÁSICO. 165
generalmente aparecen en fórmulas matemáticas, aunque pueden aparecer en texto normal.

Finalmente, las comillas dobles (") casi nunca se usan.
Los espacios en blanco y el fin de lı́nea son también caracteres (invisibles), que LATEX
considera como un mismo carácter, que llamaremos espacio, y que simbolizaremos ocasional-
mente como .
Para escribir en castellano requeriremos además algunos signos y caracteres especiales:
ñ \~n á \’a ı́ \’{\i} ü \"u ¡ !‘ ¿ ?‘
6.3.3. Comandos.
Todos los comandos comienzan con un backslash, y se extienden hasta encontrar el primer
carácter que no sea una letra (es decir, un espacio, un número, un signo de puntuación o
matemático, etc.).
6.3.4. Algunos conceptos de estilo.

LATEX es consciente de muchas convenciones estilı́sticas que quizás no apreciamos cuando
leemos textos bien diseñados, pero las cuales es bueno conocer para aprovecharlas.
a) Observemos la siguiente palabra: fino. Esta palabra fue generada escribiendo simple-
mente fino, pero observemos que las letras ‘f’ e ‘i’ no están separadas, sino que unidas
artı́sticamente. Esto es una ligadura, y es considerada una práctica estéticamente pre-
ferible. LATEX sabe esto e inserta este pequeño efecto tipográfico sin que nos demos
cuenta.
b) Las comillas de apertura y de cierre son distintas. Por ejemplo: ‘insigne’ (comillas
simples) o “insigne” (comillas dobles). Las comillas de apertura se hacen con uno o con
dos acentos graves (‘), para comillas simples o dobles, respectivamente, y las de cierre
con acentos agudos (’): ‘insigne’, ‘‘insigne’’. No es correcto entonces utilizar las
comillas dobles del teclado e intentar escribir "insigne" (el resultado de esto es el poco
estético ”insigne”).
c) Existen tres tipos de guiones:
Corto Saint-Exupéry (entre palabras, corte en

-
sı́labas al final de la lı́nea)
Medio páginas 1–2 -- (rango de números)
Largo un ejemplo —como éste --- (puntuación, paréntesis)
d) LATEX inserta después de un punto seguido un pequeño espacio adicional respecto al

espacio normal entre palabras, para separar sutilmente frases. Pero, ¿cómo saber que
un punto termina una frase? El criterio que utiliza es que todo punto termina una
frase cuando va precedido de una minúscula. Esto es cierto en la mayorı́a de los casos,
ası́ como es cierto que generalmente cuando un punto viene después de una mayúscula
no hay fin de frase:
China y U.R.S.S. estuvieron de acuerdo. Sin embargo. . .
Pero hay excepciones:
En la pág. 11 encontraremos noticias desde la U.R.S.S. Éstas fueron entrega-

das. . .
Cuando estas excepciones se producen, nosotros, humanos, tenemos que ayudarle al

computador, diciéndole que, aunque hay un punto después de la “g”, no hay un fin de
frase, y que el punto después de la última “S” sı́ termina frase. Esto se consigue ası́:
En la p\’ag.\ 11 encontraremos noticias desde la

U.R.S.S\@. \’Estas fueron entregadas...
d) Énfasis de texto:
Éste es un texto enfatizado. \’Este es un texto

{\em enfatizado}.
Otro texto enfatizado. Otro texto \emph{enfatizado}.
Al enfatizar, pasamos temporalmente a un tipo de letra distinto, la itálica. Esta letra es

ligeramente inclinada hacia adelante, lo cual puede afectar el correcto espaciado entre
palabras. Comparemos, por ejemplo:
Quiero hoy mi recompensa. Quiero {\em hoy} mi recompensa.

Quiero hoy mi recompensa. Quiero {\em hoy\/} mi recompensa.
Quiero hoy mi recompensa. Quiero \emph{hoy} mi recompensa.
La segunda y tercera frase tienen un pequeño espacio adicional después de “hoy”,

para compensar el espacio entre palabras perdido por la inclinación de la itálica. Este
pequeño espacio se denomina corrección itálica, y se consigue usando \emph, o, si se
usa \em, agregando \/ antes de cerrar el paréntesis cursivo. La corrección itálica es
innecesaria cuando después del texto enfatizado viene un punto o una coma. LATEX
advierte esto y omite el espacio adicional aunque uno lo haya sugerido.
6.3.5. Notas a pie de página.

Insertemos una nota a pie de p\’agina.\footnote{Como \’esta.}
LATEX colocará una nota a pie de página1 en el lugar apropiado.

1
Como ésta.
6.3.6. Fórmulas matemáticas.

LATEX distingue dos modos de escritura: un modo de texto, en el cual se escriben los
textos usuales como los ya mencionados, y un modo matemático, dentro del cual se escriben
las fórmulas. Cualquier fórmula debe ser escrita dentro de un modo matemático, y si algún
sı́mbolo matemático aparece fuera del modo matemático el compilador acusará un error.
Hay tres formas principales para acceder al modo matemático:
a) $x+y=3$
b) $$xy=8$$
c) \begin{equation}
x/y=5
\end{equation}
Estas tres opciones generan, respectivamente, una ecuación en el texto: x + y = 3, una

ecuación separada del texto, centrada en la página:
xy = 8
y una ecuación separada del texto, numerada:
x/y = 5 (6.1)
Es importante notar que al referirnos a una variable matemática en el texto debemos
escribirla en modo matemático:
Decir que la incógnita es x es Decir que la inc{\’o}gnita es
incorrecto. No: la incógnita es x es incorrecto. No: la
x. inc{\’o}gnita es $x$.
6.3.7. Comentarios.
Uno puede hacer que el compilador ignore parte del archivo usando %. Todo el texto desde
este carácter hasta el fin de la lı́nea correspondiente será ignorado (incluyendo el fin de lı́nea).
Un pequeño comentario. Un peque{\~n}o co% Texto ignorado
mentario.
6.3.8. Estilo del documento.

Las caracterı́sticas generales del documento están definidas en el preámbulo. Lo más
importante es la elección del estilo, que determina una serie de parámetros que al usuario
normal pueden no importarle, pero que son básicas para una correcta presentación del texto:
¿Qué márgenes dejar en la página? ¿Cuánto dejar de sangrı́a? ¿Tipo de letra? ¿Distancia
entre lı́neas? ¿Dónde poner los números de página? Y un largo etcétera.
Todas estas decisiones se encuentran en un archivo de estilo (extensión cls). Los archivos
standard son: article, report, book y letter, cada uno adecuado para escribir artı́culos
cortos (sin capı́tulos) o más largos (con capı́tulos), libros y cartas, respectivamente.
La elección del estilo global se hace en la primera lı́nea del archivo:2

\documentclass{article}
Esta lı́nea será aceptada por el compilador, pero nos entregará un documento con un
tamaño de letra pequeño, técnicamente llamado de 10 puntos ó 10pt (1pt = 1/72 pulgadas).
Existen tres tamaños de letra disponibles: 10, 11 y 12 pt. Si queremos un tamaño de letra
más grande, como el que tenemos en este documento, se lo debemos indicar en la primera
lı́nea del archivo:
Todas las decisiones de estilo contenidas dentro del archivo cls son modificables, exis-
tiendo tres modos de hacerlo:
a) Modificando el archivo cls directamente. Esto es poco recomendable, porque dicha
modificación (por ejemplo, un cambio de los márgenes) se harı́a extensible a todos los
archivos compilados en nuestro computador, y esto puede no ser agradable, ya sea que
nosotros seamos los únicos usuarios o debamos compartirlo. Por supuesto, podemos
deshacer los cambios cuando terminemos de trabajar, pero esto es tedioso.
b) Introduciendo comandos adecuados en el preámbulo. Ésta es la opción más recomen-
dable y la más usada. Nos permite dominar decisiones especı́ficas de estilo válidas sólo
para el archivo que nos interesa.
c) Creando un nuevo archivo cls. Esto es muy recomendable cuando las modificaciones de
estilo son abundantes, profundas y deseen ser reaprovechadas. Se requiere un poco de
experiencia en LATEX para hacerlo, pero a veces puede ser la única solución razonable.
En todo caso, la opción a usar en la gran mayorı́a de los casos es la b) (Sec. 6.9).
6.3.9. Argumentos de comandos.

Hemos visto ya algunos comandos que requieren argumentos. Por ejemplo: \begin{equation},
\documentclass[12pt]{article}, \footnote{Nota}. Existen dos tipos de argumentos:
1. Argumentos obligatorios. Van encerrados en paréntesis cursivos: \footnote{Nota},
por ejemplo. Es obligatorio que después de estos comandos aparezcan los paréntesis. A
veces es posible dejar el interior de los paréntesis vacı́o, pero en otros casos el compilador
reclamará incluso eso (\footnote{} no genera problemas, pero \documentclass{} sı́ es
un gran problema).
Una propiedad muy general de los comandos de LATEX es que las llaves de los argumentos
obligatorios se pueden omitir cuando dichos argumentos tienen sólo un carácter. Por
ejemplo, \~n es equivalente a \~{n}. Esto permite escribir más fácilmente muchas
expresiones, particularmente matemáticas, como veremos más adelante.
2
En LATEX 2.09 esta primera lı́nea debe ser \documentstyle[12pt]article, y el archivo de estilo tiene
extensión sty. Intentar compilar con LATEX 2.09 un archivo que comienza con \documentclass da un error.
Por el contrario, la compilación con LATEX 2ε de un archivo que comienza con \documentstyle no genera un
error, y LATEX entra en un modo de compatibilidad . Sin embargo, interesantes novedades de LATEX 2ε respecto
a LATEX 2.09 se pierden.
2. Argumentos opcionales. Van encerrados en paréntesis cuadrados. Estos argumentos

son omitibles, \documentclass[12pt]... . Ya dijimos que \documentclass{article}
es aceptable, y que genera un tamaño de letra de 10pt. Un argumento en paréntesis
cuadrados es una opción que modifica la decisión default del compilador (en este caso,
lo obliga a usar 12pt en vez de sus instintivos 10pt).
6.3.10. Tı́tulo.
Un tı́tulo se genera con:
\title{Una breve introducci\’on}

\author{V\’{\i}ctor Mu\~noz}
\date{30 de Junio de 1998}
\maketitle
\title, \author y \date pueden ir en cualquier parte (incluyendo el preámbulo) an-

tes de \maketitle. \maketitle debe estar después de \begin{document}. Dependiendo de
nuestras necesidades, tenemos las siguientes alternativas:
a) Sin tı́tulo:
\title{}
b) Sin autor:
\author{}
c) Sin fecha:
\date{}
d) Fecha actual (en inglés): omitir \date.
e) Más de un autor:
\author{Autor_1 \and Autor_2 \and Autor_3}
Para artı́culos cortos, LATEX coloca el tı́tulo en la parte superior de la primera página
del texto. Para artı́culos largos, en una página separada.
6.3.11. Secciones.
Los tı́tulos de las distintas secciones y subsecciones de un documento (numerados ade-
cuadamente, en negrita, como en este texto) se generan con comandos de la forma:
\section{Una secci\’on}
\subsection{Una subsecci\’on}
Los comandos disponibles son (en orden decreciente de importancia):
\part \subsection \paragraph

\chapter \subsubsection \subparagraph
\section
Los más usados son \chapter, \section, \subsection y

\subsubsection. \chapter sólo está disponible en los estilos report y book.
6.3.12. Listas.
Los dos modos usuales de generar listas:
a) Listas numeradas (ambiente enumerate):
\begin{enumerate}
1. Nivel 1, ı́tem 1. \item Nivel 1, \’{\i}tem 1.
\item Nivel 1, \’{\i}tem 2.
2. Nivel 1, ı́tem 2.
\begin{enumerate}
a) Nivel 2, ı́tem 1. \item Nivel 2, \’{\i}tem 1.
\begin{enumerate}
1) Nivel 3, ı́tem 1. \item Nivel 3, \’{\i}tem 1.
3. Nivel 1, ı́tem 3. \end{enumerate}
\end{enumerate}
\item Nivel 1, \’{\i}tem 3.
\end{enumerate}
b) Listas no numeradas (ambiente itemize):
Nivel 1, ı́tem 1. \begin{itemize}

\item Nivel 1, {\’\i}tem 1.
Nivel 1, ı́tem 2. \item Nivel 1, {\’\i}tem 2.
• Nivel 2, ı́tem 1. \begin{itemize}
◦ Nivel 3, ı́tem 1. \begin{itemize}
Nivel 1, ı́tem 3.
\end{itemize}
\end{itemize}
\end{itemize}
Es posible anidar hasta tres niveles de listas. Cada uno usa tipos distintos de rótulos,
según el ambiente usado: números arábes, letras y números romanos para enumerate, y
puntos, guiones y asteriscos para itemize. Los rótulos son generados automáticamente por
cada \item, pero es posible modificarlos agregando un parámetro opcional:
a) Nivel 1, ı́tem 1. \begin{enumerate}

\item[a)] Nivel 1, \’{\i}tem 1.
b) Nivel 1, ı́tem 2. \item[b)] Nivel 1, \’{\i}tem 2.
\end{enumerate}
\item es lo primero que debe aparecer después de un \begin{enumerate} o \begin{itemize}.
6.3.13. Tipos de letras.

Fonts.
Los fonts disponibles por default en LATEX son:
roman italic Small Caps

boldface slanted typewriter
sans serif
Los siguientes modos de cambiar fonts son equivalentes:
texto {\rm texto} \textrm{texto}

texto {\bf texto} \textbf{texto}
texto {\sf texto} \textsf{texto}
texto {\it texto} \textit{texto}
texto {\sl texto} \textsl{texto}
Texto {\sc Texto} \textsc{texto}
texto {\tt texto} \texttt{texto}
\rm es el default para texto normal; \it es el default para texto enfatizado; \bf es el
default para tı́tulos de capı́tulos, secciones, subsecciones, etc.
\textrm, \textbf, etc., sólo permiten cambiar porciones definidas del texto, contenido
entre los paréntesis cursivos. Con \rm, \bf, etc. podemos, omitiendo los paréntesis, cambiar
el font en todo el texto posterior:
Un cambio local de fonts y uno Un cambio {\sf local} de fonts
global, interminable e infini- \sl y uno global, interminable
to. . . e infinito...
También es posible tener combinaciones de estos fonts, por ejemplo, bold italic, pero no
sirven los comandos anteriores, sino versiones modificadas de \rm, \bf, etc.:
\rmfamily
\sffamily
\ttfamily
\mdseries
\bfseries
\upshape
\itshape
\slshape
\scshape
Por ejemplo:
texto {\bfseries\itshape texto}

texto {\bfseries\upshape texto} (= {\bf texto})
Texto {\ttfamily\scshape texto}
texto {\sffamily\bfseries texto}
texto {\sffamily\mdseries texto} (= {\sf texto})
Para entender el uso de estos comandos hay que considerar que un font tiene tres atributos:
family (que distingue entre rm, sf y tt), series (que distingue entre md y bf), y shape (que
distingue entre up, it, sl y sc). Cada uno de los comandos \rmfamily, \bfseries, etc.,
cambia sólo uno de estos atributos. Ello permite tener versiones mixtas de los fonts, como
un slanted sans serif, imposible de obtener usando los comandos \sl y \sf. Los defaults para
el texto usual son: \rmfamily, \mdseries y \upshape.
Tamaño.
Los tamaños de letras disponibles son:
texto \tiny texto \normalsize texto \LARGE
texto \scriptsize texto \large texto \huge
texto \footnotesize texto \Large texto \Huge
texto \small
Se usan igual que los comandos de cambio de font \rm, \sf, etc., de la sección 6.3.13.
\normalsize es el default para texto normal; \scriptsize para sub o supraı́ndices;
\footnotesize para notas a pie de página.
6.3.14. Acentos y sı́mbolos.

LATEX provee diversos tipos de acentos, que se muestran en la Tabla 6.1 (como ejemplo
consideramos la letra “o”, pero cualquiera es posible, por supuesto). (Hemos usado acá el
hecho de que cuando el argumento de un comando consta de un carácter, las llaves son
omitibles.)
Otros sı́mbolos especiales y caracteres no ingleses disponibles se encuentran en la Tabla
6.2.
ó \’o õ \~o ǒ \v o o̧ \c o
ò \‘o ō \=o ő \H o o. \d o
ô \ô ȯ \. o o⁀ o \t{oo} o \b o
¯
ö \"o ŏ \u o o̊ \r o
Cuadro 6.1: Acentos.
† \dag œ \oe l \l
‡ \ddag Œ \OE L \L
§ \S æ \ae ß \ss
¶ \P Æ \AE SS \SS
c \copyright å \aa ¿ ?‘
a \textcircled a Å \AA ¡ !‘
\textvisiblespace ø \o
£ \pounds Ø \O
Cuadro 6.2: Sı́mbolos especiales y caracteres no ingleses.
6.3.15. Escritura de textos en castellano.
LATEX emplea sólo los caracteres ASCII básicos, que no contienen sı́mbolos castellanos
como ¿, ¡, ñ, etc. Ya hemos visto que existen comandos que permiten imprimir estos caracteres,
y por tanto es posible escribir cualquier texto en castellano (y otros idiomas, de hecho).
Sin embargo, esto no resuelve todo el problema, porque en inglés y castellano las palabras
se cortan en “sı́labas” de acuerdo a reglas distintas, y esto es relevante cuando se debe cortar el
texto en lı́neas. LATEX tiene incorporados algoritmos para cortar palabras en inglés y, si se ha
hecho una instalación especial de LATEX en nuestro computador, también en castellano u otros
idiomas (a través del programa babel, que es parte de la distribución standard de LATEX 2ε ).
En un computador con babel instalado y configurado para cortar en castellano basta incluir el
comando \usepackage[spanish]{babel} en el preámbulo para poder escribir en castellano
cortando las palabras en sı́labas correctamente.3
Sin embargo, ocasionalmente LATEX se encuentra con una palabra que no sabe cortar,
en cuyo caso no lo intenta y permite que ella se salga del margen derecho del texto, o bien
toma decisiones no óptimas. La solución es sugerirle a LATEX la silabación de la palabra. Por
ejemplo, si la palabra conflictiva es matem\’aticas (generalmente hay problemas con las
palabras acentuadas), entonces basta con reescribirla en la forma: ma\-te\-m\’a\-ti\-cas.
Con esto, le indicamos a LATEX en qué puntos es posible cortar la palabra. El comando \- no
tiene ningún otro efecto, de modo que si la palabra en cuestión no queda al final de la lı́nea,
LATEX por supuesto ignora nuestra sugerencia y no la corta.
Consideremos el siguiente ejemplo:
3
Esto resuelve también otro problema: los encabezados de capı́tulos o ı́ndices, por ejemplo, son escritos
“Capı́tulo” e “Índice”, en vez de “Chapter” e “Index”, y cuando se usa el comando \date, la fecha aparece
en castellano.
Podemos escribir matemáti- Podemos escribir matem\’aticas.

cas. O matemáticas. O matem\’aticas.
Podemos escribir matemáti- Podemos escribir

cas. O matemáticas. ma\-te\-m\’a\-ti\-cas.
O ma\-te\-m\’a\-ti\-cas.
En el primer caso, LATEX decidió por sı́ mismo dónde cortar “matemáticas”. Como es una
palabra acentuada tuvo problemas y no lo hizo muy bien, pues quedó demasiado espacio
entre palabras en esa lı́nea. En el segundo párrafo le sugerimos la silabación y LATEX pudo
tomar una decisión más satisfactoria. En el mismo párrafo, la segunda palabra “matemáticas”
también tiene sugerencias de corte, pero como no quedó al final de lı́nea no fueron tomadas
en cuenta.
6.4. Fórmulas matemáticas.

Hemos mencionado tres formas de ingresar al modo matemático: $...$ (fórmulas dentro
del texto), $$...$$ (fórmulas separadas del texto, no numeradas) y \begin{equation} ...
\end{equation} (fórmulas separadas del texto, numeradas). Los comandos que revisaremos
en esta sección sólo pueden aparecer dentro del modo matemático.
6.4.1. Sub y supraı́ndices.

xy1
2
x2y x^{2y} xy x^{y^{2}} (ó x^{y^2}) x^y_1 (ó x_1^y)
x2y x_{2y} x y1 x^{y_{1}} (ó x^{y_1})
\textsuperscript permite obtener supraı́ndices fuera del modo matemático:
La 3a es la vencida. La 3\textsuperscript{a}
es la vencida.
6.4.2. Fracciones.
a) Horizontales
n/2 n/2
b) Verticales
1
\frac{1}{2}, \frac 1{2}, \frac{1}2 ó \frac 12
2
y + z/2
x= x = \frac{y + z/2}{y^2+1}
y2 + 1
x+y
y \frac{x+y}{1 + \frac y{z+1}}
1 + z+1
6.4. FÓRMULAS MATEMÁTICAS. 175
La forma a) es más adecuada y la preferida para fracciones dentro del texto, y la se-
gunda para fórmulas separadas. \frac puede aparecer en fórmulas dentro del texto ( 12 con
$\frac 12$), pero esto es inusual y poco recomendable estéticamente, salvo estricta necesi-
dad.
6.4.3. Raı́ces.
√
n \sqrt{n} ó \sqrt n
√
a2 + b 2 \sqrt{a^2 + b^2}
√
n
2 \sqrt[n]{2}
6.4.4. Puntos suspensivos.

a) ... \ldots
Para fórmulas como
a1 a2 . . . an a_1 a_2 \ldots a_n
b) ··· \cdots
Entre sı́mbolos como +, −, = :
x1 + · · · + xn x_1 + \cdots + x_n
..
c) . \vdots
 
x1
 .. 
 . 
xn
..
d) . \ddots
 
1 0 ··· 0
 0 1 0 
In×n = .. . . .. 
 
 . . . 
0 0 ... 1
\ldots puede ser usado también en el texto usual:
Arturo quiso salir. . . pero se Arturo quiso salir\ldots

detuvo. pero se detuvo.
No corresponde usar tres puntos seguidos (...), pues el espaciado entre puntos es incorrecto.
Minúsculas
α \alpha θ \theta o o τ \tau
β \beta ϑ \vartheta π \pi υ \upsilon
γ \gamma ι \iota ̟ \varpi φ \phi
δ \delta κ \kappa ρ \rho ϕ \varphi
ǫ \epsilon λ \lambda ̺ \varrho χ \chi
ε \varepsilon µ \mu σ \sigma ψ \psi
ζ \zeta ν \nu ς \varsigma ω \omega
η \eta ξ \xi
Mayúsculas
Γ \Gamma Λ \Lambda Σ \Sigma Ψ \Psi
∆ \Delta Ξ \Xi Υ \Upsilon Ω \Omega
Θ \Theta Π \Pi Φ \Phi
Cuadro 6.3: Letras griegas.
6.4.5. Letras griegas.

Las letras griegas se obtienen simplemente escribiendo el nombre de dicha letra (en inglés):
\gamma. Para la mayúscula correspondiente se escribe la primera letra con mayúscula: \Gamma.
La lista completa se encuentra en la Tabla 6.3.4
No existen sı́mbolos para α, β, η, etc. mayúsculas, pues corresponden a letras romanas
(A, B, E, etc.).
6.4.6. Letras caligráficas.

Letras caligráficas mayúsculas A, B, . . . , Z se obtienen con \cal. \cal se usa igual que
los otros comandos de cambio de font (\rm, \it, etc.).
Sea F una función con Sea $\cal F$ una funci\’on
F(x) > 0. con ${\cal F}(x) > 0$.
No son necesarios los paréntesis cursivos la primera vez que se usan en este ejemplo,
porque el efecto de \cal está delimitado por los $.
6.4.7. Sı́mbolos matemáticos.

LATEX proporciona una gran variedad de sı́mbolos matemáticos (Tablas 6.4, 6.5, 6.6, 6.7).
La negación de cualquier sı́mbolo matemático se obtiene con \not:
x 6< y x \not < y
a 6∈ M a \not \in {\cal M}
4
Un ejemplo del uso de variantes de letras griegas, en el idioma griego σ se usa dentro de una palabra y ς
se usa al finalizar una palabra. El nombre Felipe en griego, es Felipós, y se escribe de la forma: Φεληπóς. El
nombre José, serı́a algo como Josué en griego: Ioσυ ή o la palabra Fı́sica: Φυσική
± \pm ∩ \cap ⋄ \diamond ⊕ \oplus

∓ \mp ∪ \cup △ \bigtriangleup ⊖ \ominus
× \times ⊎ \uplus ▽ \bigtriangledown ⊗ \otimes
÷ \div ⊓ \sqcap ⊳ \triangleleft ⊘ \oslash
∗ \ast ⊔ \sqcup ⊲ \triangleright ⊙ \odot
⋆ \star ∨ \lor \bigcirc
◦ \circ ∧ \land † \dagger
• \bullet \ \setminus ‡ \ddagger
· \cdot ≀ \wr ∐ \amalg
Cuadro 6.4: Sı́mbolos de operaciones binarias.
≤ \leq ≥ \geq ≡ \equiv |= \models

≺ \prec ≻ \succ ∼ \sim ⊥ \perp
\preceq \succeq ≃ \simeq | \mid
≪ \ll ≫ \gg ≍ \asymp k \parallel
⊂ \subset ⊃ \supset ≈ \approx ⊲⊳ \bowtie
⊆ \subseteq ⊇ \supseteq ∼
= \cong 6= \neq
.
⌣ \smile ⊑ \sqsubseteq ⊒ \sqsupseteq = \doteq
⌢ \frown ∈ \in ∋ \ni ∝ \propto
⊢ \vdash ⊣ \dashv
Cuadro 6.5: Sı́mbolos relacionales.
← \gets ←− \longleftarrow ↑ \uparrow

⇐ \Leftarrow ⇐= \Longleftarrow ⇑ \Uparrow
→ \to −→ \longrightarrow ↓ \downarrow
⇒ \Rightarrow =⇒ \Longrightarrow ⇓ \Downarrow
⇔ \Leftrightarrow ⇐⇒ \Longleftrightarrow m \Updownarrow
7→ \mapsto 7−→ \longmapsto ր \nearrow
←֓ \hookleftarrow ֒→ \hookrightarrow ց \searrow
↼ \leftharpoonup ⇀ \rightharpoonup ւ \swarrow
↽ \leftharpoondown ⇁ \rightharpoondown տ \nwarrow
⇋ \rightleftharpoons
Cuadro 6.6: Flechas

ℵ \aleph ′ \prime ∀ \forall ∞ \infty

~ \hbar ∅ \emptyset ∃ \exists △ \triangle
ı \imath ∇
√ \nabla ¬ \lnot ♣ \clubsuit
 \jmath \surd ♭ \flat ♦ \diamondsuit
ℓ \ell ⊤ \top ♮ \natural ♥ \heartsuit
℘ \wp ⊥ \bot ♯ \sharp ♠ \spadesuit
ℜ \Re k \| \ \backslash
ℑ \Im ∠ \angle ∂ \partial
Cuadro 6.7: Sı́mbolos varios.

P X T \ F G
\sum \bigcap \bigsqcup
Q Y S [ J K
\prod \bigcup \bigodot
` a U ] N O
\coprod \biguplus \bigotimes
Z
R W _ L M
\int \bigvee \bigoplus
I
H V ^
\oint \bigwedge
Cuadro 6.8: Sı́mbolos de tamaño variable.
[Notemos, sı́, en la Tabla 6.5, que existe el sı́mbolo 6= (\neq).]

Algunos sı́mbolos tienen tamaño variable, según aparezcan en el texto o en fórmulas
separadas del texto. Se muestran en la Tabla 6.8.
Estos sı́mbolos pueden tener ı́ndices que se escriben como sub o supraı́ndices. Nuevamente,
la ubicación de estos ı́ndices depende de si la fórmula está dentro del texto o separada de él:
n
X Z 1
xi = f $$\sum_{i=1}^n x_i = \int_0^1 f $$
i=1 0
Pn R1
i=1 xi = 0 f $\sum_{i=1}^n x_i = \int_0^1 f $
6.4.8. Funciones tipo logaritmo.

Observemos la diferencia entre estas dos expresiones:
x = logy $x = log y$
x = log y $x = \log y$
En el primer caso LATEX escribe el producto de cuatro cantidades, l, o, g e y. En el segundo,

representa correctamente nuestro deseo: el logaritmo de y. Todos los comandos de la Tabla
6.9 generan el nombre de la función correspondiente, en letras romanas.
Algunas de estas funciones pueden tener ı́ndices:
lı́m xn = 0 $$\lim_{n\to\infty} x_n = 0 $$
n→∞
\arccos \cos \csc \exp \ker \limsup \min \sinh

\arcsin \cosh \deg \gcd \lg \ln \Pr \sup
\arctan \cot \det \hom \lim \log \sec \tan
\arg \coth \dim \inf \liminf \max \sin \tanh
Cuadro 6.9: Funciones tipo logaritmo
lı́mn→∞ xn = 0 $\lim_{n\to\infty} x_n = 0 $
6.4.9. Matrices.
Ambiente array.
Se construyen con el ambiente array. Consideremos, por ejemplo:
a + b + c uv 27
a+b u+v 134
a 3u + vw 2.978
La primera columna está alineada al centro (c, center); la segunda, a la izquierda (l, left); la
tercera, a la derecha (r, right). array tiene un argumento obligatorio, que consta de tantas
letras como columnas tenga la matriz, letras que pueden ser c, l o r según la alineación
que queramos obtener. Elementos consecutivos de la misma lı́nea se separan con & y lı́neas
consecutivas se separan con \\. Ası́, el ejemplo anterior se obtiene con:
\begin{array}{clr}
a+b+c & uv & 27 \\
a+b & u + v & 134 \\
a & 3u+vw & 2.978
\end{array}
Delimitadores.
Un delimitador es cualquier sı́mbolo que actúe como un paréntesis, encerrando una ex-
presión, apareciendo a la izquierda y a la derecha de ella. La Tabla 6.10 muestra todos los
delimitadores posibles.
Para que los delimitadores tengan el tamaño correcto para encerrar la expresión correspon-
diente hay que anteponerles \left y \right. Podemos obtener ası́ expresiones matriciales:
\left(\begin{array}{cc}
a b a&b\\
c d c&d
\end{array}\right)
 v = \left(\begin{array}{c}
1 1\\
v= 2  2\\
3 3
\end{array}\right)
( ( ) ) ↑ \uparrow
[ [ ] ] ↓ \downarrow
{ \{ } \} l \updownarrow
⌊ \lfloor ⌋ \rfloor ⇑ \Uparrow
⌈ \lceil ⌉ \rceil ⇓ \Downarrow
h \langle i \rangle m \Updownarrow
/ / \ \backslash
| | k \|
Cuadro 6.10: Delimitadores
\Delta = \left|\begin{array}{cc}
a a
∆ = 11 12 a_{11} & a_{12}\\

a21 a22
a_{21} & a_{22}
\end{array}\right|
\left y \right deben ir de a pares, pero los delimitadores no tienen por qué ser los
mismos:
\left(\begin{array}{c}
a a\\
b b
\end{array}\right[
Tampoco es necesario que los delimitadores encierren matrices. Comparemos, por ejemplo:
~ + B)
~ =( dF~
(A )x=a (\vec A + \vec B) =
dx
( \frac{d \vec F}{dx} )_{x=a}
!

~+B
~ =
dF~
A \left(\vec A + \vec B\right) =
dx
x=a \left( \frac{d \vec F}{dx} \right)_{x=a}
El segundo ejemplo es mucho más adecuado estéticamente.

Algunas expresiones requieren sólo un delimitador, a la izquierda o a la derecha. Un punto
(.) representa un delimitador invisible. Los siguientes ejemplos son tı́picos:
b
b
df
Z

dx = f (x) \left. \int_a^b dx \frac{df}{dx} =
a dx a f(x) \right |_a^b
f(x) = \left\{ \begin{array}{cl}

0 x<0 0 & x<0 \\
f (x) =
1 x>0 1 & x>0
\end{array} \right.
â \hat a á \acute a ā \bar a ȧ \dot a

ǎ \check a à \grave a ~a \vec a ä \ddot a
ă \breve a ã \tilde a
Cuadro 6.11: Acentos matemáticos
Fórmulas de más de una lı́nea.

eqnarray ofrece una manera de ingresar a modo matemático (en reemplazo de $, $$ o
equation) equivalente a un array con argumentos {rcl}:
x = a+b+c+ \begin{eqnarray*}
d+e x& = & a + b + c +\\
&& d + e
\end{eqnarray*}
El asterisco impide que aparezcan números en las ecuaciones. Si deseamos que numere
cada lı́nea como una ecuación independiente, basta omitir el asterisco:
x = 5 (6.2) \begin{eqnarray}
a + b = 60 (6.3) x& = & 5 \\
a + b&= & 60
\end{eqnarray}
Si queremos que solamente algunas lı́neas aparezcan numeradas, usamos \nonumber:
x = a+b+c+ \begin{eqnarray}
d+e (6.4) x& = & a + b + c + \nonumber\\
&& d + e
\end{eqnarray}
El comando \eqnarray es suficiente para necesidades sencillas, pero cuando se requiere
escribir matemática de modo intensivo sus limitaciones comienzan a ser evidentes. Al agre-
gar al preámbulo de nuestro documento la lı́nea \usepackage{amsmath} quedan disponibles
muchos comandos mucho más útiles para textos matemáticos más serios, como el ambiente
equation*, \split, \multline o \intertext. En la sección 6.8.2 se encuentra una descrip-
ción de estos y otros comandos.
6.4.10. Acentos.
Dentro de una fórmula pueden aparecer una serie de “acentos”, análogos a los de texto
usual (Tabla 6.11).
Las letras i y j deben perder el punto cuando son acentuadas: ~i es incorrecto. Debe ser ~ı.
\imath y \jmath generan las versiones sin punto de estas letras:
~ı + ̂ \vec \imath + \hat \jmath
6.4.11. Texto en modo matemático.

Para insertar texto dentro de modo matemático empleamos \mbox:
Vcrı́tico V_{\mbox{\scriptsize cr\’{\i}tico}}
Bastante más óptimo es utilizar el comando \text, disponible a través de amsmath (sección
6.8.2).
6.4.12. Espaciado en modo matemático.

TEX ignora los espacios que uno escribe en las fórmulas y los determina de acuerdo a sus propios
criterios. A veces es necesario ayudarlo para hacer ajustes finos. Hay cuatro comandos que agregan
pequeños espacios dentro de modo matemático:
\, espacio pequeño \: espacio medio

\! espacio pequeño (negativo) \; espacio grueso
Algunos ejemplos de su uso:

√ √
2x \sqrt 2 \, x en vez de 2x
Rn/log n n / \!\log n en vez de Rn/ log n
f dx \int f \, dx en vez de f dx
El último caso es quizás el más frecuente, por cuanto la no inserción del pequeño espacio adicional
entre f y dx hace aparecer el integrando como el producto de tres variables, f , d y x, que no es la
idea.
6.4.13. Fonts.
Análogamente a los comandos para texto usual (Sec. 6.3.13), es posible cambiar los fonts dentro
del modo matemático:
(A, x) \mathrm{(A,x)}
(A, x) \mathnormal{(A,x)}
(A, B) \mathcal{(A,B)}
(A, x) \mathbf{(A,x)}
(A, x) \mathsf{(A,x)}
(A, x) \mathtt{(A,x)}
(A, x ) \mathit{(A,x)}
(Recordemos que la letras tipo \cal sólo existen en mayúsculas.)

Las declaraciones anteriores permiten cambiar los fonts de letras, dı́gitos y acentos, pero no de
los otros sı́mbolos matemáticos:
Ã × 1 \mathbf{\tilde A \times 1}
Como en todo ambiente matemático, los espacios entre caracteres son ignorados:
Hola \mathrm{H o l a}
Finalmente, observemos que \mathit corresponde al font itálico, en tanto que \mathnormal al
font matemático usual, que es también itálico. . . o casi:
6.5. TABLAS. 183
dif f erent $different$

dif f erent $\mathnormal{different}$
different $\mathit{different}$
different \textit{different}
6.5. Tablas.
array nos permitió construir matrices en modo matemático. Para tablas de texto existe tabular,
que funciona de la misma manera. Puede ser usado tanto en modo matemático como fuera de él.
\begin{tabular}{lcl}
Nombre : Juan Pérez Nombre&:&Juan P\’erez\\
Edad : 26 Edad&:&26\\
Profesión : Estudiante Profesi\’on&:&Estudiante
\end{tabular}
Si deseamos agregar lı́neas verticales y horizontales para ayudar a la lectura, lo hacemos inser-
tando | en los puntos apropiados del argumento de tabular, y \hline al final de cada lı́nea de la
tabla:
\begin{tabular}{|l|r|}\hline
Item Gastos Item&Gastos\\ \hline
Vasos $ 500 Vasos& \$ 500 \\
Botellas $ 1300 Botellas & \$ 1300 \\
Platos $ 500 Platos & \$ 500 \\ \hline
Total $ 2300 Total& \$ 2300 \\ \hline
\end{tabular}
6.6. Referencias cruzadas.

Ecuaciones, secciones, capı́tulos y páginas son entidades que van numeradas y a las cuales
podemos querer referirnos en el texto. Evidentemente no es óptimo escribir explı́citamente el número
correspondiente, pues la inserción de una nueva ecuación, capı́tulo, etc., su eliminación o cambio de
orden del texto podrı́a alterar la numeración, obligándonos a modificar estos números dispersos en
el texto. Mucho mejor es referirse a ellos de modo simbólico y dejar que TEX inserte por nosotros
los números. Lo hacemos con \label y \ref.
La ecuación de Euler La ecuaci\’on de Euler

\begin{equation}
eiπ + 1 = 0 (6.5) \label{euler}
e^{i\pi} + 1 = 0
reúne los números más impor- \end{equation}
tantes. La ecuación (6.5) es fa- re\’une los n\’umeros
mosa. m\’as importantes.
La ecuaci\’on (\ref{euler})
es famosa.
El argumento de \label (reiterado luego en \ref) es una etiqueta simbólica. Ella puede ser
cualquier secuencia de letras, dı́gitos o signos de puntuación. Letras mayúsculas y minúsculas son
diferentes. Ası́, euler, eq:euler, euler_1, euler1, Euler, etc., son etiquetas válidas y distintas.
Podemos usar \label dentro de equation, eqnarray y enumerate.
También podemos referenciar páginas con \pageref:
Ver página 184 para más de- Ver p\’agina

talles. \pageref{significado}
para m\’as detalles.
[Texto en pág. 184] ...
El significado
El significado de la vida. . . \label{significado}
de la vida...
LATEX puede dar cuenta de las referencias cruzadas gracias al archivo aux (auxiliar) generado
durante la compilación.
Al compilar por primera vez el archivo, en el archivo aux es escrita la información de los \label
encontrados. Al compilar por segunda vez, LATEX lee el archivo aux e incorpora esa información al
dvi. (En realidad, también lo hizo la primera vez que se compiló el archivo, pero el aux no existı́a
entonces o no tenı́a información útil.)
Por tanto, para obtener las referencias correctas hay que compilar dos veces, una para generar
el aux correcto, otra para poner la información en el dvi. Toda modificación en la numeración
tendrá efecto sólo después de compilar dos veces más. Por cierto, no es necesario preocuparse de
estos detalles a cada momento. Seguramente compilaremos muchas veces el archivo antes de tener
la versión final. En todo caso, LATEX avisa, tras cada compilación, si hay referencias inexistentes
u otras que pudieron haber cambiado, y sugiere compilar de nuevo para obtener las referencias
correctas. (Ver Sec. 6.14.2.)
6.7. Texto centrado o alineado a un costado.

Los ambientes center, flushleft y flushright permiten forzar la ubicación del texto respecto
a los márgenes. Lı́neas consecutivas se separan con \\:
Una lı́nea centrada, \begin{center}

otra Una l\’{\i}nea centrada,\\
y otra más. otra\\
y otra m\’as.
Ahora el texto continúa \end{center}
Ahora el texto contin\’ua
alineado a la izquierda \begin{flushleft}
alineado a la izquierda
y finalmente
\end{flushleft}
dos lı́neas y finalmente
alineadas a la derecha. \begin{flushright}
dos l\’{\i}neas\\
alineadas a la derecha.
\end{flushright}
6.8. ALGUNAS HERRAMIENTAS IMPORTANTES 185
6.8. Algunas herramientas importantes

Hasta ahora hemos mencionado escencialmente comandos disponibles en LATEX standard. Sin
embargo, éstos, junto con el resto de los comandos básicos de LATEX, se vuelven insuficientes cuando
se trata de ciertas aplicaciones demasiado especı́ficas, pero no inimaginables: si queremos escribir
un texto de alta matemática, o usar LATEX para escribir partituras, o para escribir un archivo .tex
en un teclado croata. . . . Es posible que con los comandos usuales LATEX responda a las necesidades,
pero seguramente ello será a un costo grande de esfuerzo por parte del autor del texto. Por esta
razón, las distribuciones modernas de LATEX incorporan una serie de extensiones que hacen la vida
un poco más fácil a los eventuales autores. En esta sección mencionaremos algunas extensiones muy
útiles. Muchas otras no están cubiertas, y se sugiere al lector consultar la documentación de su
distribución para saber qué otros paquetes se encuentran disponibles.
En general, las extensiones a LATEX vienen contenidas en paquetes (“packages”, en inglés), en
archivos .sty. Ası́, cuando mencionemos el paquete amsmath, nos referimos a caracterı́sticas dis-
ponibles en el archivo amsmath.sty. Para que los comandos de un paquete <package>.sty estén
disponibles, deben ser cargados durante la compilación, incluyendo en el preámbulo del documento
la lı́nea:
\usepackage{<package>}
Si se requiere cargar más de un paquete adicional, se puede hacer de dos formas:
\usepackage{<package1>,<package2>}
\usepackage{<package1>}
\usepackage{<package2>}
Algunos paquetes aceptan opciones adicionales (del mismo modo que la clase article acepta
la opción 12pt):
\usepackage[option1,option2]{<package1>}
Revisemos ahora algunos paquetes útiles.
6.8.1. babel
Permite el procesamiento de textos en idiomas distintos del inglés. Esto significa, entre otras
cosas, que se incorporan los patrones de silabación correctos para dicho idioma, para cortar adecua-
damente las palabras al final de cada lı́nea. Además, palabras claves como “Chapter”, “Index”, “List
of Figures”, etc., y la fecha dada por \date, son cambiadas a sus equivalentes en el idioma escogido.
La variedad de idiomas disponibles es enorme, pero cada instalación de LATEX tiene sólo algunos de
ellos incorporados. (Ésta es una decisión que toma el administrador del sistema, de acuerdo a las
necesidades de los usuarios. Una configuración usual puede ser habilitar la compilación en inglés,
castellano, alemán y francés.)
Ya sabemos como usar babel para escribir en castellano: basta incluir en el preámbulo la lı́nea
\usepackage[spanish]{babel}
6.8.2. AMS-LATEX
El paquete amsmath permite agregar comandos para escritura de textos matemáticos profe-
sionales, desarrollados originalmente por la American Mathematical Society. Si un texto contiene
abundante matemática, entonces seguramente incluir la lı́nea correspondiente en el preámbulo:
\usepackage{amsmath}
aliviará mucho la tarea. He aquı́ algunas de las caracterı́sticas adicionales disponibles con AMS-
LATEX.
Ambientes para ecuaciones

Con equation* generamos una ecuación separada del texto, no numerada:
x = 2y − 3 \begin{equation*}
x = 2y - 3
\end{equation*}
multline permite dividir una ecuación muy larga en varias lı́neas, de modo que la primera lı́nea
quede alineada con el margen izquierdo, y la última con el margen derecho:
15
X \begin{multline}
= 1 + 2 + 3 + 4 + 5+ \sum_{i=1}^{15} = 1 +2+3+4+5+\\
i=1 6+7+8+9+10+\\
6 + 7 + 8 + 9 + 10+ 11+12+13+14+15
11 + 12 + 13 + 14 + 15 (6.6) \end{multline}
align permite reunir un grupo de ecuaciones consecutivas alineándolas (usando &, igual que la
alineación vertical de tabular y array). gather hace lo mismo, pero centrando cada ecuación en
la página independientemente.
a1 = b1 + c1 (6.7) \begin{align}
a2 = b2 + c2 − d2 + e2 (6.8) a_1 &= b_1 + c_1 \\
a_2 &= b_2 + c_2 - d_2 + e_2
\end{align}
a1 = b1 + c1 (6.9) \begin{gather}
a2 = b2 + c2 − d2 + e2 (6.10) a_1 = b_1 + c_1 \\
a_2 = b_2 + c_2 - d_2 + e_2
\end{gather}
Con multline*, align* y gather* se obtienen los mismos resultados, pero con ecuaciones no
numeradas.
split permite escribir una sola ecuación separada en lı́neas (como multline), pero permite
alinear las lı́neas con & (como align). split debe ser usado dentro de un ambiente como equation,
align o gather (o sus equivalentes con asterisco):
a1 = b1 + c1 \begin{equation}
(6.11)
= b2 + c2 − d2 + e2 \begin{split}
a_1& = b_1 + c_1 \\
& = b_2 + c_2 - d_2 + e_2
\end{split}
\end{equation}
Espacio horizontal
\quad y \qquad insertan espacio horizontal en ecuaciones:
x>y , ∀x ∈ A \begin{gather*}
x≤z , ∀z ∈ B x > y \ , \quad \forall\, x \in A \\
x \leq z \ , \qquad \forall\, z \in B
\end{gather*}
Texto en ecuaciones
Para agregar texto a una ecuación, usamos \text:
\begin{equation*}
x = 2n − 1 , con n entero x = 2^n - 1 \ , \quad \text{con $n$ entero}
\end{equation*}
\text se comporta como un buen objeto matemático, y por tanto se pueden agregar subı́ndices
textuales más fácilmente que con \mbox (ver sección 6.4.11):
Vcrı́tico $V_{\text{cr\’{\i}tico}}$
Referencia a ecuaciones
\eqref es equivalente a \ref, salvo que agrega los paréntesis automáticamente:
La ecuación (6.5) era la de Eu- La ecuaci\’on \eqref{euler} era la de Euler.
ler.
Ecuaciones con casos

Ésta es una construcción usual en matemáticas:
f(x)=
( \begin{cases}
1 si x < 0 1&\text{si $x<0$} \\
f (x) =
0 si x > 0 0&\text{si $x>0$}
\end{cases}
Notar cómo es más simple que el ejemplo con los comandos convencionales en la sección 6.4.9.
Texto insertado entre ecuaciones alineadas

Otra situación usual es insertar texto entre ecuaciones alineadas, preservando la alineación:
x1 = a + b + c , \begin{align*}
x2 = d + e , x_1 &= a + b + c \ , \\
x_2 &= d + e \ , \\
y por otra parte \intertext{y por otra parte}
x_3 &= f + g + h \ .
x3 = f + g + h . \end{align*}
Matrices y coeficientes binomiales

La complicada construcción de matrices usando array (sección 6.4.9), se puede reemplazar con
ambientes como pmatrix y vmatrix, y comandos como \binom.
\begin{pmatrix}
a b a&b\\
c d c&d
\end{pmatrix}
\Delta = \begin{vmatrix}
a11 a12
∆ = a_{11} & a_{12}\\
a21 a22 a_{21} & a_{22}
\end{vmatrix}

k
v= v = \binom{k}{2}
2
Podemos observar que el espaciado entre los paréntesis y el resto de la fórmula es más adecuado
que el de los ejemplos en la sección 6.4.9.
Flechas extensibles
Las flechas en la tabla 6.6 vienen en ciertos tamaños predefinidos. amsmath proporciona fle-
chas extensibles \xleftarrow y \xrightarrow, para ajustar sub o superı́ndices demasiado anchos.
Además, tienen un argumento opcional y uno obligatorio, para colocar material sobre o bajo ellas:
n+µ−1 n±i−1
A ←−−−− B −−−−→ C −
→D
T U
A \xleftarrow{n+\mu-1} B \xrightarrow[T]{n\pm i-1} C \xrightarrow[U]{} D
Uso del paquete amssymb

Este paquete contiene sı́mbolos matemáticos muy estéticos a la hora de referirse a los conjuntos
de números:
C \mathbb{C} para los números complejos I \mathbb{I} para los números imaginarios
R \mathbb{R} para los números reales Q \mathbb{Q} para los números racionales
Z \mathbb{Z} para los números enteros N \mathbb{N} para los números naturales
Otro sı́mbolo interesante es: ∴ (\therefore) para “por lo tanto”.
6.8.3. fontenc
Ocasionalmente, LATEX tiene problemas al separar una palabra en sı́labas. Tı́picamente, eso
ocurre con palabras acentuadas, pues, debido a la estructura interna del programa, un carácter
como la “á” en “matemáticas” no es tratado igual que los otros. Para solucionar el problema, y
poder cortar en sı́labas palabras que contengan letras acentuadas (además de acceder a algunos
caracteres adicionales), basta incluir el paquete fontenc:
\usepackage[T1]{fontenc}
Técnicamente, lo que ocurre es que la codificación antigua para fonts es la OT1, que no contiene
fonts acentuados, y que por lo tanto es útil sólo para textos en inglés. La codificación T1 aumenta los
fonts disponibles, permitiendo que los caracteres acentuados sean tratados en igual pie que cualquier
otro.
6.8.4. enumerate
enumerate.sty define una muy conveniente extensión al ambiente enumerate de LATEX. El
comando se usa igual que siempre (ver sección 6.3.12), con un argumento opcional que determina
el tipo de etiqueta que se usará para la lista. Por ejemplo, si queremos que en vez de números se
usen letras mayúsculas, basta usar \begin{enumerate}[A]:
A Primer ı́tem.
B Segundo ı́tem.
Si queremos etiquetas de la forma “1.-”, \begin{enumerate}[1.-]:
1.- Primer ı́tem.
2.- Segundo ı́tem.
Si deseamos insertar un texto que no cambie de una etiqueta a otra, hay que encerrarlo entre
paréntesis cursivos (\begin{enumerate}[{Caso} A:]):
Caso A: Primer ı́tem.
Caso B: Segundo ı́tem.
6.8.5. Color.
A través de PostScript es posible introducir color en documentos LATEX. Para ello, incluimos en
el preámbulo el paquete color.sty:
\usepackage{color}
De este modo, está disponible el comando \color, que permite especificar un color, ya sea por
nombre (en el caso de algunos colores predefinidos), por su código rgb (red-green-blue) o código
cmyk (cian-magenta-yellow-black). Por ejemplo:
Un texto en azul Un texto en {\color{blue} azul}

Un texto en un segundo color
Un texto en un tercer color Un texto en un
{\color[rgb]{1,0,1} segundo color}
Un texto en un
{\color[cmyk]{.3,.5,.75,0} tercer color}
Los colores más frecuentes (azul, amarillo, rojo, etc.) se pueden dar por nombre, como en este
ejemplo. Si se da el código rgb, se deben especificar tres números entre 0 y 1, que indican la cantidad
de rojo, verde y azul que constituyen el color deseado. En el ejemplo, le dimos máxima cantidad de
rojo y azul, y nada de verde, con lo cual conseguimos un color violeta. Si se trata del código cmyk los
números a especificar son cuatro, indicando la cantidad de cian, magenta, amarillo y negro. En el
ejemplo anterior pusimos una cantidad arbitraria de cada color, y resultó un color café. Es evidente
que el uso de los códigos rgb y cmyk permite explorar infinidad de colores.
Observar que \color funciona de modo análogo a los comandos de cambio de font de la sección
6.3.13, de modo que si se desea restringir el efecto a una porción del texto, hay que encerrar dicho
texto entre paréntesis cursivos. Análogamente al caso de los fonts, existe el comando \textcolor,
que permite dar el texto a colorear como argumento:
Un texto en azul Un texto en \textcolor{blue}{azul}

Un texto en un segundo color
Un texto en un tercer color Un texto en un
\textcolor[rgb]{1,0,1}{segundo color}
Un texto en un
\textcolor[cmyk]{.3,.5,.75,0}{tercer color}
6.9. Modificando el estilo de la página.

TEX toma una serie de decisiones por nosotros. Ocasionalmente nos puede interesar alterar el
comportamiento normal. Disponemos de una serie de comandos para ello, los cuales revisaremos a
continuación. Todos deben aparecer en el preámbulo, salvo en los casos que se indique.
6.9.1. Estilos de página.

a) Números de página.
Si se desea que los números de página sean arábicos (1, 2, 3. . . ):
\pagenumbering{arabic}
Para números romanos (i, ii, iii,. . . ):
\pagenumbering{roman}
6.9. MODIFICANDO EL ESTILO DE LA PÁGINA. 191
arabic es el default.
b) Estilo de página.
El comando \pagestyle determina dónde queremos que vayan los números de página:
\pagestyle{plain} Números de página en el extremo inferior,

al centro de la página. (Default para esti-
los article, report.)
\pagestyle{headings} Números de página y otra información

(tı́tulo de sección, etc.) en la parte su-
perior de la página. (Default para estilo
book.)
\pagestyle{empty} Sin números de página.
6.9.2. Corte de páginas y lı́neas.

TEX tiene modos internos de decidir cuándo cortar una página o una lı́nea. Al preparar la versión
final de nuestro documento, podemos desear coartar sus decisiones. En todo caso, no hay que hacer
esto antes de preparar la versión verdaderamente final, porque agregar, modificar o quitar texto
puede alterar los puntos de corte de lı́neas y páginas, y los cortes inconvenientes pueden resolverse
solos.
Los comandos de esta sección no van en el preámbulo, sino en el interior del texto.
Corte de lı́neas.
En la página 173 ya vimos un ejemplo de inducción de un corte de lı́nea en un punto deseado
del texto, al dividir una palabra en sı́labas.
Cuando el problema no tiene relación con sı́labas disponemos de dos comandos:
\newline Corta la lı́nea y pasa a la siguiente en el punto

indicado.
\linebreak Lo mismo, pero justificando la lı́nea para ade-

cuarla a los márgenes.
Un corte de lı́nea Un corte de l\’{\i}nea\newline

no justificado a los márgenes no justificado a los m\’argenes
en curso. en curso.
Un corte de lı́nea Un corte de l\’{\i}nea\linebreak

justificado a los márgenes justificado a los m\’argenes
en curso. en curso.
Observemos cómo en el segundo caso, en que se usa \linebreak, la separación entre palabras
es alterada para permitir que el texto respete los márgenes establecidos.
Corte de páginas.
Como para cortar lı́neas, existe un modo violento y uno sutil:
\newpage Cambia de página en el punto indicado. Análogo

a \newline.
\clearpage Lo mismo, pero ajustando los espacios verticales

en el texto para llenar del mejor modo posible
la página.
\clearpage, sin embargo, no siempre tiene efectos visibles. Dependiendo de la cantidad y tipo
de texto que quede en la página, los espacios verticales pueden o no ser ajustados, y si no lo son,
el resultado termina siendo equivalente a un \newpage. TEX decide en última instancia qué es lo
óptimo.
Adicionalmente, tenemos el comando:
\enlargethispage{<longitud>} Cambia el tamaño de la página ac-

tual en la cantidad <longitud>.
(Las unidades de longitud que maneja TEX se revisan a continuación.)
Unidades de longitud y espacios.
a) Unidades.
TEX reconoce las siguientes unidades de longitud:
cm centı́metro
mm milı́metro
in pulgada
pt punto (1/72 pulgadas)
em ancho de una “M” en el font actual
ex altura de una “x” en el font actual
Las cuatro primeras unidades son absolutas; las últimas dos, relativas, dependiendo del ta-
maño del font actualmente en uso.
Las longitudes pueden ser números enteros o decimales, positivos o negativos:
1cm 1.6in .58pt -3ex
b) Cambio de longitudes.
TEX almacena los valores de las longitudes relevantes al texto en comandos especiales:
6.9. MODIFICANDO EL ESTILO DE LA PÁGINA. 193
\parindent Sangrı́a.
\textwidth Ancho del texto.
\textheight Altura del texto.
\oddsidemargin Margen izquierdo menos 1 pulgada.
\topmargin Margen superior menos 1 pulgada.
\baselineskip Distancia entre la base de dos lı́neas de texto

consecutivas.
\parskip Distancia entre párrafos.
Todas estas variables son modificables con los comandos \setlength, que le da a una variable
un valor dado, y \addtolength, que le suma a una variable la longitud especificada. Por
ejemplo:
\setlength{\parindent}{0.3em} (\parindent = 0.3 em.)
\addtolength{\parskip}{1.5cm} (\parskip = \parskip + 1.5 cm.)
Por default, el ancho y altura del texto, y los márgenes izquierdo y superior, están definidos
de modo que quede un espacio de una pulgada (≃ 2.56 cm) entre el borde del texto y el borde
de la página.
Un problema tı́pico es querer que el texto llene un mayor porcentaje de la página. Por ejem-
plo, para que el margen del texto en los cuatro costados sea la mitad del default, debemos
introducir los comandos:
\addtolength{\textwidth}{1in}
\addtolength{\textheight}{1in}
\addtolength{\oddsidemargin}{-.5in}
\addtolength{\topmargin}{-.5in}
Las dos primeras lı́neas aumentan el tamaño horizontal y vertical del texto en 1 pulgada.
Si luego restamos media pulgada del margen izquierdo y el margen superior, es claro que la
distancia entre el texto y los bordes de la página sera de media pulgada, como deseábamos.
c) Espacios verticales y horizontales.
Se insertan con \vspace y \hspace:
\vspace{3cm} Espacio vertical de 3 cm.

\hspace{3cm} Espacio horizontal de 3 cm.
Algunos ejemplos:
Un primer párrafo de un pe- Un primer p\’arrafo de un
queño texto. peque\~no texto.
\vspace{1cm}
Y un segundo párrafo separa- Y un segundo p\’arrafo
do del otro. separado del otro.
Tres palabras separadas Tres\hspace{.5cm}palabras

del resto. \hspace{.5cm}separadas
del resto.
Si por casualidad el espacio vertical impuesto por \vspace debiese ser colocado al comienzo
de una página, TEX lo ignora. Serı́a molesto visualmente que en algunas páginas el texto
comenzara algunos centı́metros más abajo que en el resto. Lo mismo puede ocurrir si el
espacio horizontal de un \hspace queda al comienzo de una lı́nea.
Los comandos \vspace*{<longitud>} y \hspace*{<longitud>} permiten que el espacio en
blanco de la <longitud> especificada no sea ignorado. Ello es útil cuando invariablemente
queremos ese espacio vertical u horizontal, aunque sea al comienzo de una página o una lı́nea
—por ejemplo, para insertar una figura.
6.10. Figuras.
Lo primero que hay que decir en esta sección es que LATEX es un excelente procesador de texto,
tanto convencional como matemático. Las figuras, sin embargo, son un problema aparte.
LATEX provee un ambiente picture que permite realizar dibujos simples. Dentro de la estruc-
tura \begin{picture} y \end{picture} se pueden colocar una serie de comandos para dibujar
lı́neas, cı́rculos, óvalos y flechas, ası́ como para posicionar texto. Infortunadamente, el proceso de
ejecutar dibujos sobre un cierto umbral de complejidad puede ser muy tedioso para generarlo di-
rectamente. Existe software (por ejemplo, xfig) que permite superar este problema, pudiéndose
dibujar con el mouse, exportando el resultado al formato picture de LATEX. Sin embargo, picture
tiene limitaciones (no se pueden hacer lı́neas de pendiente arbitraria), y por tanto no es una solución
óptima.
Para obtener figuras de buena calidad es imprescindible recurrir a lenguajes gráficos externos, y
LATEX da la posibilidad de incluir esos formatos gráficos en un documento. De este modo, tanto el
texto como las figuras serán de la más alta calidad. Las dos mejores soluciones son utilizar Metafont
o PostScript. Metafont es un programa con un lenguaje de programación gráfico propio. De hecho,
los propios fonts de LATEX fueron creados usando Metafont, y sus capacidades permiten hacer dibujos
de complejidad arbitraria. Sin embargo, los dibujos resultantes no son trivialmente reescalables, y
exige aprender un lenguaje de programación especı́fico.
Una solución mucho más versátil, y adoptada como el estándar en la comunidad de usuarios
de LATEX, es el uso de PostScript. Como se mencionó brevemente en la sección 1.13, al imprimir,
una máquina unix convierte el archivo a formato PostScript, y luego lo envı́a a la impresora. Pero
PostScript sirve más que para imprimir, siendo un lenguaje de programación gráfico completo, con
el cual podemos generar imágenes de gran calidad, y reescalables sin pérdida de resolución. Además,
muchos programas gráficos permiten exportar sus resultados en formato PostScript. Por lo tanto,
podemos generar nuestras figuras en alguno de estos programas (xfig es un excelente software, que
satisface la mayor parte de nuestras necesidades de dibujos simples; octave o gnuplot pueden ser
usados para generar figuras provenientes de cálculos cientı́ficos, etc.), lo cual creará un archivo con
extensión .ps (PostScript) o .eps (PostScript encapsulado).5 Luego introducimos la figura en el
documento LATEX, a través del paquete graphicx.
5
eps es el formato preferido, pues contiene información sobre las dimensiones de la figura, información
que es utilizada por LATEX para insertar ésta adecuadamente en el texto.
6.10. FIGURAS. 195
6.10.1. graphicx.sty
Si nuestra figura está en un archivo figura.eps, la instrucción a utilizar es:
\usepackage{graphicx}
\begin{document}
... Texto ...
\includegraphics[width=w, height=h]{figura.eps}
...
\end{document}
Los parámetros width y height son opcionales y puede omitirse uno para que el sistema escale
de acuerdo al parámetro dado. Es posible variar la escala completa de la figura o rotarla usando
comandos disponibles en graphicx.
Una figura aquı́: Una figura aqu\’{\i}:
\begin{center}
\includegraphics[height=3cm]{figura.eps}
\end{center}
puede hacer m\’as agradable

el texto.
puede hacer más agradable el

texto.
En este ejemplo, indicamos sólo la altura de la figura (3cm). El ancho fue determinado de modo
que las proporciones de la figura no fueran alteradas. Si no se especifica ni la altura ni el ancho, la
figura es insertada con su tamaño natural.
Observemos también que pusimos la figura en un ambiente center. Esto no es necesario, pero
normalmente uno desea que las figuras estén centradas en el texto.
6.10.2. Ambiente figure.

Insertar una figura es una cosa. Integrarla dentro del texto es otra. Para ello está el ambiente
figure, que permite: (a) posicionar la figura automáticamente en un lugar predeterminado o espe-
cificado por el usuario; (b) numerar las figuras; y (c) agregar un breve texto explicativo junto a la
figura.
Coloquemos la misma figura de la sección anterior dentro de un ambiente figure. El input:
\begin{figure}[h]
\begin{center}
\includegraphics[height=3cm]{figura.eps}
\end{center}
\caption{Un sujeto caminando.}
\label{caminando}
\end{figure}
Figura 6.1: Un sujeto caminando.
da como resultado:
figure delimita lo que en TEX se denomina un objeto flotante, es decir, un objeto cuya posición
no está determinada a priori, y se ajusta para obtener los mejores resultados posibles. TEX considera
(de acuerdo con la tradición), que la mejor posición para colocar una figura es al principio o al final
de la página. Además, lo ideal es que cada página tenga un cierto número máximo de figuras,
que ninguna figura aparezca en el texto antes de que sea mencionada por primera vez, y que, por
supuesto, las figuras aparezcan en el orden en que son mencionadas. Éstas y otras condiciones
determinan la posición que un objeto flotante tenga al final de la compilación. Uno puede forzar la
decisión de LATEX con el argumento opcional de figure:
t (top) extremo superior de la página

b (bottom) extremo inferior de la página
h (here) aquı́, en el punto donde está el comando
p (page of floats) en una página separada al final del texto
El argumento adicional ! suprime, para ese objeto flotante especı́fico, cualquier restricción que
exista sobre el número máximo de objetos flotantes en una página y el porcentaje de texto mı́nimo
que debe haber en una página.
Varios de estos argumentos se pueden colocar simultánemente, su orden dictando la prioridad.
Por ejemplo,
\begin{figure}[htbp]
...
\end{figure}
indica que la figura se debe colocar como primera prioridad aquı́ mismo; si ello no es posible, al
comienzo de página (ésta o la siguiente, dependiendo de los detalles de la compilación), y ası́ suce-
sivamente.
Además, figure numera automáticamente la figura, colocando el texto “Figura N :”, y \caption
permite colocar una leyenda, centrada en el texto, a la figura. Puesto que la numeración es automáti-
ca, las figuras pueden ser referidas simbólicamente con \label y \ref (sección 6.6). Para que la
referencia sea correcta, \label debe estar dentro del argumento de \caption, o después, como
aparece en el ejemplo de la Figura 6.1 (\ref{caminando}!).
Finalmente, notemos que la figura debió ser centrada explı́citamente con center. figure no
hace nada más que tratar la figura como un objeto flotante, proporcionar numeración y leyenda. El
resto es responsabilidad del autor.
6.11. CARTAS. 197
6.11. Cartas.
Para escribir cartas debemos emplear el estilo letter en vez del que hemos utilizado hasta
ahora, article. Comandos especiales permiten escribir una carta, poniendo en lugares adecuados
la dirección del remitente, la fecha, la firma, etc.
A modo de ejemplo, consideremos el siguiente input:
\documentclass[12pt]{letter}
\usepackage[spanish]{babel}
\begin{document}
\address{Las Palmeras 3425\\

\~Nu\~noa, Santiago}
\date{9 de Julio de 1998}
\signature{Pedro P\’erez \\ Secretario}
\begin{letter}{Dr.\ Juan P\’erez \\ Las Palmeras 3425 \\

\~Nu\~noa, Santiago}
\opening{Estimado Juan}
A\’un no tenemos novedades.
Parece incre\’{\i}ble, pero los recientes acontecimientos nos han superado,

a pesar de nuestros esfuerzos. Esperamos que mejores tiempos nos
aguarden.
\closing{Saludos,}
\cc{Arturo Prat \\ Luis Barrios}
\end{letter}
\end{document}
El resultado se encuentra en la próxima página.

Las Palmeras 3425

Ñuñoa, Santiago
9 de Julio de 1998
Dr. Juan Pérez

Las Palmeras 3425
Ñuñoa, Santiago
Estimado Juan
Aún no tenemos novedades.
Parece increı́ble, pero los recientes acontecimientos nos han superado, a pesar
de nuestros esfuerzos. Esperamos que mejores tiempos nos aguarden.
Saludos,
Pedro Pérez
Secretario
Copia a: Arturo Prat
Luis Barrios
6.12. LATEX Y EL FORMATO PDF. 199
Observemos que el texto de la carta está dentro de un ambiente letter, el cual tiene un argu-
mento obligatorio, donde aparece el destinatario de la carta (con su dirección opcionalmente).
Los comandos disponibles son:
\address{<direccion>} <direccion> del remitente.
\signature{<firma>} <firma> del remitente.
\opening{<apertura>} Fórmula de <apertura>.
\closing{<despedida>} Fórmula de <despedida>.
\cc{<copias>} Receptores de <copias> (si los hubiera).

Uno puede hacer más de una carta con distintos ambientes letter en un mismo archivo. Ca-
da una tomará el mismo remitente y firma dados por \address y \signature. Si deseamos que
\address o \signature valgan sólo para una carta particular, basta poner dichos comandos entre
el \begin{letter} y el \opening correspondiente.
Por ejemplo, la siguiente estructura:
\documentclass[12pt]{letter}
\begin{document}
\address{<direccion remitente>}
\date{<fecha>}
\signature{<firma>}
\begin{letter}{<destinatario 1>}
\opening<apertura 1>
...
\end{letter}
\address{<direccion remitente 2>}
\signature{<firma 2>}
...
\end{letter}
...
\end{letter}
\end{document}
dará origen a tres cartas con la misma dirección de remitente y firma, salvo la segunda.
En todos estos comandos, lı́neas sucesivas son indicadas con \\.
6.12. LATEX y el formato pdf.

Junto con PostScript, otro formato ampliamente difundido para la transmisión de archivos,
especialmente a través de Internet, es el formato pdf (Portable Document Format). Para generar un
archivo pdf con LATEX es necesario compilarlo con pdflatex. Ası́, pdflatex <archivo> generará un
archivo <archivo>.pdf en vez del <archivo>.dvi generado por el compilador usual.
Si nuestro documento tiene figuras, sólo es posible incluirlas en el documento si están también
en formato pdf. Por tanto, si tenemos un documento con figuras en PostScript, debemos introducir
dos modificaciones antes de compilar con pdflatex:
a) Cambiar el argumento de \includegraphics (sección 6.10) de <archivo_figura>.eps

a <archivo_figura>.pdf.
b) Convertir las figuras PostScript a pdf (con epstopdf, por ejemplo). Si tenemos una figura en el
archivo <archivo_figura>.eps, entonces epstopdf <archivo_figura>.eps genera el archivo
correspondiente <archivo_figura>.pdf.
Observar que el mismo paquete graphicx descrito en la sección 6.10 para incluir figuras
PostScript permite, sin modificaciones, incluir figuras en pdf.
6.13. Modificando LATEX.

Esta sección se puede considerar “avanzada”. Normalmente uno se puede sentir satisfecho con
el desempeño de LATEX, y no es necesaria mayor intervención. A veces, dependiendo de la apli-
cación y del autor, nos gustarı́a modificar el comportamiento default. Una alternativa es definir
nuevos comandos que sean útiles para nosotros. Si esos nuevos comandos son abundantes, o quere-
mos reutilizarlos frecuentemente en otros documentos, lo conveniente es considerar crear un nuevo
paquete o incluso una nueva clase. Examinaremos a continuación los elementos básicos de estas
modificaciones.
6.13.1. Definición de nuevos comandos.

El comando \newcommand
Un nuevo comando se crea con:
\newcommand{<comando>}{<accion>}
El caso más sencillo es cuando una estructura se repite frecuentemente en nuestro documento.
Por ejemplo, digamos que un sujeto llamado Cristóbal no quiere escribir su nombre cada vez que
aparece en su documento:
Mi nombre es Cristóbal. \newcommand{\nombre}{Crist\’obal}

Sı́, como oyes, Cristóbal. ...
Cristóbal Loyola. \begin{document}
...
Mi nombre es \nombre. S\’{\i}, como oyes,
\nombre. \nombre\ Loyola.
Un \newcommand puede aparecer en cualquier parte del documento, pero lo mejor es que esté en
el preámbulo, de modo que sea evidente qué nuevos comandos están disponibles en el presente
documento. Observemos además que la definición de un comando puede contener otros comandos
(en este caso, \’). Finalmente, notamos que ha sido necesario agregar un espacio explı́cito con \ ,
al escribir “Cristóbal Loyola”: recordemos que un comando comienza con un backslash y termina
6.13. MODIFICANDO LATEX. 201
con el primer carácter que no es letra. Por tanto, \nombre Loyola ignora el espacio al final de
\nombre, y el output serı́a “CristóbalLoyola”.
También es posible definir comandos que funcionen en modo matemático:
Sea ẋ la velocidad, de modo \newcommand{\vel}{\dot x}

que ẋ(t) > 0 si t < 0.
Sea $\vel$ la velocidad, de modo que
$ \vel(t)> 0$ si $t<0$.
Como \vel contiene un comando matemático (\dot), \vel sólo puede aparecer en modo ma-
temático.
Podemos también incluir la apertura de modo matemático en la definición de \vel:
\newcommand{\vel}{$\dot x$}. De este modo, \vel (no $\vel$) da como output directamen-
te ẋ. Sin embargo, esta solución no es óptima, porque la siguiente ocurrencia de \vel da un error.
En efecto, si \vel = $\dot x$, entonces $ \vel(t)>0$ = $ $\dot x$> 0$. En tal caso, LATEX
ve que un modo matemático se ha abierto y cerrado inmediatamente, conteniendo sólo un espacio
entremedio, y luego, en modo texto, viene el comando \dot, que es matemático: LATEX acusa un
error y la compilación se detiene.
La solución a este problema es utilizar el comando \ensuremath, que asegura que haya modo
matemático, pero si ya hay uno abierto, no intenta volverlo a abrir:
Sea ẋ la velocidad, de modo \newcommand{\vel}{\ensuremath{\dot x}}

que ẋ(t) > 0 si t < 0.
Sea \vel\ la velocidad, de modo que
$ \vel(t)> 0$ si $t<0$.
Un caso especial de comando matemático es el de operadores tipo logaritmo (ver Tabla 6.9). Si
queremos definir una traducción al castellano de \sin, debemos usar el comando \DeclareMathOperator
disponible via amsmath:
Ahora podemos escribir en \usepackage{amsmath}

castellano, sen x. \DeclareMathOperator{\sen}{sen}
...
Ahora podemos escribir en castellano, $\sen x$.
A diferencia de \newcommand, \DeclareMathOperator sólo puede aparecer en el preámbulo del

documento.
Un nuevo comando puede también ser usado para ahorrar tiempo de escritura, reemplazando
comandos largos de LATEX:
\newcommand{\be}{\begin{enumerate}}
1. El primer caso. \newcommand{\ee}{\end{enumerate}}
2. Ahora el segundo.
\be
3. Y el tercero. \item El primer caso.
\item Ahora el segundo.
\item Y el tercero.
\ee
Nuevos comandos con argumentos
Podemos también definir comandos que acepten argumentos. Si el sujeto anterior, Cristóbal,
desea escribir cualquier nombre precedido de “Nombre:” en itálica, entonces puede crear el siguiente
comando:
Nombre: Cristóbal \newcommand{\nombre}[1]{\textit{Nombre:} #1}

Nombre: Violeta
\nombre{Crist\’obal}
\nombre{Violeta}
Observemos que \newcommand tiene un argumento opcional, que indica el número de argumentos
que el nuevo comando va a aceptar. Esos argumentos se indican, dentro de la definición del comando,
con #1, #2, etc. Por ejemplo, consideremos un comando que acepta dos argumentos:
\newcommand{\fn}[2]{f(#1,#2)}
f (x, y) + f (x3 , y∗) = 0 . $$ \fn{x}{y} + \fn{x_3}{y*} = 0 \ . $$

En los casos anteriores, todos los argumentos son obligatorios. LATEX permite definir comandos
con un (sólo un) argumento opcional. Si el comando acepta n argumentos, el argumento opcional es
el #1, y se debe indicar, en un segundo paréntesis cuadrado, su valor default. Ası́, podemos modificar
el comando \fn del ejemplo anterior para que el primer argumento sea opcional, con valor default
x:
\newcommand{\fn}[2][x]{f(#1,#2)}
f (x, y) + f (x3 , y∗) = 0 . $$ \fn{y} + \fn[x_3]{y*} = 0 \ . $$
Redefinición de comandos
Ocasionalmente no nos interesa definir un nuevo comando, sino redefinir la acción de un comando
preexistente. Esto se hace con \renewcommand:
La antigua versión de ldots: La antigua versi\’on de {\tt ldots}: \ldots

...
La nueva versión de ldots: \renewcommand{\ldots}{\textbullet \textbullet
••• \textbullet}
La nueva versi\’on de {\tt ldots}: \ldots
Párrafos y cambios de lı́nea dentro de comandos
En el segundo argumento de \newcommand o \renewcommand puede aparecer cualquier comando

de LAT
EX, pero ocasionalmente la aparición de lı́neas en blanco (para forzar un cambio de párrafo)
puede provocar problemas. Si ello ocurre, podemos usar \par, que hace exactamente lo mismo.
Además, la definición del comando queda más compacta:
\newcommand{\comandolargo}{\par Un nuevo comando que incluye un cambio de

p\’arrafo, porque deseamos incluir bastante texto.\par \’Este es el
nuevo p\’arrafo.\par}
Observemos en acci\’on el comando: \comandolargo Listo.

da como resultado:
Observemos en acción el comando:
Un nuevo comando que incluye un cambio de párrafo, por-
que deseamos incluir bastante texto.
Éste es el nuevo párrafo.
Listo.
Un ejemplo más útil ocurre cuando queremos asegurar un cambio de párrafo, por ejemplo, para
colocar un tı́tulo de sección:
Observemos en acción el co- \newcommand{\seccion}[1]{\par\vspace{.5cm}

mando: {\bf Secci\’on: #1}\par\vspace{.5cm}}
Sección: Ejemplo Observemos en acci\’on el comando:

\seccion{Ejemplo} Listo.
Listo.
Además de las lı́neas en blanco, los cambios de lı́nea pueden causar problemas dentro de la
definición de un nuevo comando. El ejemplo anterior, con el comando \seccion, es un buen ejemplo:
notemos que cuando se definió, pusimos un cambio de lı́nea después de \vspace{.5cm}. Ese cambio
de lı́nea es interpretado (como todos los cambios de lı́nea) como un espacio en blanco, y es posible
que, bajo ciertas circunstancias, ese espacio en blanco produzca un output no deseado. Para ello
basta utilizar sabiamente el carácter %, que permite ignorar todo el resto de la lı́nea, incluyendo el
cambio de lı́nea. Ilustremos lo anterior con los siguientes tres comandos, que subrayan (comando
\underline) una palabra, y difieren sólo en el uso de % para borrar cambios de lı́nea:
Notar la diferencia en- \newcommand{\texto}{

tre: Un texto de prueba
Un texto de prueba , }
Un texto de prueba , y \newcommand{\textodos}{%
Un texto de prueba. Un texto de prueba
}
\newcommand{\textotres}{%
Un texto de prueba%
}
Notar la diferencia entre:
\underline{\texto},
\underline{\textodos},
y
\underline{\textotres}.
\texto conserva espacios en blanco antes y después del texto, \textodos sólo el espacio en
blanco después del texto, y \textotres no tiene espacios en blanco alrededor del texto.
Nuevos ambientes
Nuevos ambientes en LATEX se definen con \newenvironment:
\newenvironment{<ambiente>}{<comienzo ambiente>}{<final ambiente>}
define un ambiente <ambiente>, tal que \begin{ambiente} ejecuta los comandos

<comienzo ambiente>, y \end{ambiente} ejecuta los comandos <final ambiente>.
Definamos un ambiente que, al comenzar, cambia el font a itálica, pone una lı́nea horizontal
(\hrule) y deja un espacio vertical de .3cm, y que al terminar cambia de párrafo, coloca XXX en
sans serif, deja un nuevo espacio vertical de .3cm, y vuelve al font roman:
\newenvironment{na}{\it \hrule \vspace{.3cm}}{\par\sf XXX \vspace{.3cm}\rm}
Entonces, con
\begin{na}
Hola a todos. Es un placer saludarlos en este d\’{\i}a tan especial.
Nunca esper\’e una recepci\’on tan calurosa.

\end{na}
obtenemos:
Hola a todos. Es un placer saludarlos en este dı́a tan especial.

Nunca esperé una recepción tan calurosa.
XXX
Los nuevos ambientes también pueden ser definidos de modo que acepten argumentos. Como con
\newcommand, basta agregar como argumento opcional a \newenvironment un número que indique
cuántos argumentos se van a aceptar:
\newenvironment{<ambiente>}[n]{<comienzo ambiente>}{<final ambiente>}
Dentro de <comienzo ambiente>, se alude a cada argumento como #1, #2, etc. Los argumentos
no pueden ser usados en los comandos de cierre del ambiente (<final ambiente>). Por ejemplo,
modifiquemos el ambiente na anterior, de modo que en vez de colocar una lı́nea horizontal al
comienzo, coloque lo que le indiquemos en el argumento:
\newenvironment{na}[1]{\it #1 \vspace{.3cm}}{\par\sf XXX\hrule\vspace{.3cm}\rm}
Ahora usémoslo dos veces, cada una con un argumento distinto:

El mismo ejemplo anterior, El mismo ejemplo anterior, ahora es

ahora es
Hola a todos. . . \begin{na}{\hrule}
XXX Hola a todos...
\end{na}
Pero podemos ahora cambiar
el comienzo:
Pero podemos ahora cambiar el comienzo:
XXX Hola a todos. . .
XXX \begin{na}{\it XXX}

Hola a todos...
\end{na}
6.13.2. Creación de nuevos paquetes y clases

Si la cantidad de nuevos comandos y/o ambientes que necesitamos en nuestro documento es
suficientemente grande, debemos considerar crear un nuevo paquete o una nueva clase. Para ello
hay que tener clara la diferencia entre uno y otro. En general, se puede decir que si nuestros comandos
involucran alterar la apariencia general del documento, entonces corresponde crear una nueva clase
(.cls). Si, por el contrario, deseamos que nuestros comandos funcionen en un amplio rango de
circunstancias, para diversas apariencias del documento, entonces lo adecuado es un paquete (.sty).
Consideremos por ejemplo la experiencia de los autores de estos apuntes. Para crear estos apuntes
necesitamos básicamente la clase book, con ciertas modificaciones: márgenes más pequeños, inclusión
automática de los paquetes amsmath, babel y graphicx, entre otros, y definición de ciertos ambientes
especı́ficos. Todo ello afecta la apariencia de este documento, cambiándola de manera apreciable,
pero a la vez de un modo que en general no deseamos en otro tipo de documento. Por ello lo hemos
compilado usando una clase adecuada, llamada mfm2.cls.
Por otro lado, uno de los autores ha necesitado escribir muchas tareas, pruebas y controles de
ayudantı́a en su vida, y se ha convencido de que su trabajo es más fácil creando una clase tarea.cls,
que sirve para esos tres propósitos, definiendo comandos que le permiten especificar fácilmente la
fecha de entrega de la tarea, o el tiempo disponible para una prueba, los nombres del profesor y el
ayudante, etc., una serie de comandos especı́ficos para sus necesidades.
Sin embargo, tanto en este documento que usa mfm2.cls, como en las tareas y pruebas que
usan tarea.cls, se utilizan algunos comandos matemáticos que no vienen con LATEX, pero que
son recurrentes, como \sen (la función seno en castellano), \modulo (el módulo de un vector), o
\TLaplace (la transformada de Laplace). Para que estos comandos estén disponibles en cualquier
tipo de documento, necesitamos reunirlos en un paquete, en este caso addmath.sty. De este modo,
mfm2.cls, tarea.cls o cualquier otra clase pueden llamar a este paquete y utilizar sus comandos.
Estructura básica.
La estructura básica de un paquete o una clase es:
a) Identificación: Información general (nombre del paquete, fecha de creación, etc.). (Obligatoria.)
b) Declaraciones preliminares: Opcionales, dependiendo del paquete o clase en cuestión.
c) Opciones: Comandos relacionados con el manejo de las opciones con las cuales el paquete o clase
pueden ser invocados. (Opcional.)
d) Más declaraciones: Aquı́ van los comandos que constituyen el cuerpo de la clase o paquete.
(Obligatoria: si no hay ninguna declaración, el paquete o clase no hace nada, naturalmente.)
La identificación está consituida por las siguientes dos lı́neas, que deben ir al comienzo del
archivo:
\NeedsTeXFormat{LaTeX2e}
\ProvidesPackage{<paquete>}[<fecha> <otra informacion>]
La primera lı́nea indica a LATEX que éste es un archivo para LATEX 2ε . La segunda lı́nea especifica
que se trata de un paquete, indicando el nombre del mismo (es decir, el nombre del archivo sin
extensión) y, opcionalmente, la fecha (en formato YYYY/MM/DD) y otra información relevante. Por
ejemplo, nuestro paquete addmath.sty comienza con las lı́neas:
\ProvidesPackage{addmath}[1998/09/30 Macros matematicos adicionales (VM)]
Si lo que estamos definiendo es una clase, usamos el comando \ProvidesClass. Para nuestra
clase mfm2.cls:
\ProvidesClass{mfm2}[2002/03/25 Estilo para apuntes MFM II (VM)]
A continuación de la identificación vienen los comandos que se desean incorporar a través de

este paquete o clase.
Como hemos dicho, addmath.sty contiene muchos nuevos comandos matemáticos que conside-
ramos necesario definir mientras escribı́amos estos apuntes. Veamos los contenidos de una versión
simplificada de dicho paquete:
\newcommand{\prodInt}[2]{\ensuremath \left(\, #1\, |\, #2\, \right ) }

\newcommand{\promedio}[1]{\langle #1 \rangle}
\newcommand{\intii}{\int_{-\infty}^{\infty}}
\newcommand{\grados}{\ensuremath{^\circ}}
\newcommand{\Hipergeometrica}[4]{{}_2F_1\left (#1, #2, #3\, ; #4\right )}
...
De este modo, incluyendo en nuestro documento el paquete con \usepackage{addmath}, varios

nuevos comandos están disponibles:
(x|y) \prodInt{x}{y}
hxi \promedio{x}
Z ∞
dz f (z) \intii dz\, f(z)
−∞
∠ ABC = 90◦ \angle\, ABC = 90\grados
2 F1 (a, b, c ; d) \Hipergeometrica{a}{b}{c}{d}
Incluyendo otros paquetes y clases

Los comandos \RequirePackage y \LoadClass permiten cargar un paquete o una clase, respec-
tivamente.6 . Esto es de gran utilidad, pues permite construir un nuevo paquete o clase aprovechando
la funcionalidad de otros ya existentes.
Ası́, nuestro paquete addmath.sty define bastantes comandos, pero nos gustarı́a definir va-
rios más que sólo pueden ser creados con las herramientas de AMS-LATEX. Cargamos entonces
en addmath.sty el paquete amsmath y otros relacionados, y estamos en condiciones de crear más
comandos:
\RequirePackage{amsmath}
\RequirePackage{amssymb}
\RequirePackage{euscript}
...
\newcommand{\norma}[1]{\ensuremath \left\lVert\, #1 \,\right\rVert}
\newcommand{\intC}{{\sideset{^*}{}\int}}
\DeclareMathOperator{\senh}{senh}
...
Por ejemplo:
kxk \norma{x}
∗Z
dz f (z) \intC dz \, f(z)
senh(2y) \senh (2y)
La posibilidad de basar un archivo .sty o .cls en otro es particularmente importante para
una clase, ya que contiene una gran cantidad de comandos y definiciones necesarias para compilar
el documento exitosamente. Sin embargo, un usuario normal, aun cuando desee definir una nueva
clase, estará interesado en modificar sólo parte del comportamiento. Con \LoadClass, dicho usuario
puede cargar la clase sobre la cual se desea basar, y luego introducir las modificaciones necesarias,
facilitando enormemente la tarea.
Por ejemplo, al preparar este documento fue claro desde el comienzo que se necesitaba esencial-
mente la clase book, ya que serı́a un texto muy extenso, pero también era claro que se requerı́an
ciertas modificaciones. Entonces, en nuestra clase mfm2.cls lo primero que hacemos es cargar la
clase book, más algunos paquetes necesarios (incluyendo nuestro addmath), y luego procedemos a
modificar o añadir comandos:
\LoadClass[12pt]{book}
\RequirePackage[spanish]{babel}
6
Estos comandos sólo se pueden usar en un archivo .sty o .cls Para documentos normales, la manera
de cargar un paquete es \usepackage, y para cargar una clase es \documentclass.
\RequirePackage{enumerate}
\RequirePackage{addmath}
En un archivo .sty o un .cls se pueden cargar varios paquetes con \RequirePackage. \LoadClass,
en cambio, sólo puede aparecer en un .cls, y sólo es posible usarlo una vez (ya que normalmente
clases distintas son incompatibles entre sı́).
Manejo de opciones
En el último ejemplo anterior, la clase mfm2 carga la clase book con la opción 12pt. Esto significa
que si nuestro documento comienza con \documentclass{mfm2}, será compilado de acuerdo a la
clase book, en 12 puntos. No es posible cambiar esto desde nuestro documento. Serı́a mejor que
pudiéramos especificar el tamaño de letra fuera de la clase, de modo que \documentclass{mfm2}
dé un documento en 10 puntos, y \documentclass[12pt]{mfm2} uno en 12 puntos. Para lograr
esto hay que poder pasar opciones desde la clase mfm2 a book.
El modo más simple de hacerlo es con \LoadClassWithOptions. Si mfm2.cls ha sido llamada
con opciones <opcion1>,<opcion2>, etc., entonces book será llamada con las mismas opciones.
Por tanto, basta modificar en mfm2.cls la lı́nea \LoadClass[12pt]{book} por:
\LoadClassWithOptions{book}
\RequirePackageWithOptions es el comando análogo para paquetes. Si una clase o un paquete

llaman a un paquete <paquete_base> y desean pasarle todas las opciones con las cuales han sido
invocados, basta indicarlo con:
\RequirePackageWithOptions{<paquete_base>}
El ejemplo anterior puede ser suficiente en muchas ocasiones, pero en general uno podrı́a llamar
a nuestra nueva clase, mfm2, con opciones que no tienen nada que ver con book. Por ejemplo,
podrı́amos llamarla con opciones spanish,12pt. En tal caso, deberı́a pasarle spanish a babel, y
12pt a book. Más aún, podrı́amos necesitar definir una nueva opción, que no existe en ninguna de
las clases o paquetes cargados por book, para modificar el comportamiento de mfm2.cls de cierta
manera especı́fica no prevista. Estas dos tareas, discriminar entre opciones antes de pasarla a algún
paquete determinado, y crear nuevas opciones, constituyen un manejo más avanzado de opciones.
A continuación revisaremos un ejemplo combinado de ambas tareas, extraido de la clase con la cual
compilamos este texto, mfm2.cls.
La idea es poder llamar a mfm2 con una opción adicional keys, que permita agregar al dvi
información sobre las etiquetas (dadas con \label) de ecuaciones, figuras, etc., que aparezcan en
el documento (veremos la utilidad y un ejemplo de esto más adelante). Lo primero es declarar una
nueva opción, con:
\DeclareOption{<opcion>}{<comando>}
<opcion> es el nombre de la nueva opción a declarar, y <comando> es la serie de comandos que se

ejecutan cuando dicha opción es especificada.
Ası́, nuestro archivo mfm2.cls debe ser modificado:
...
\DeclareOption{keys}{...}
...
\ProcessOptions\relax
...
Observamos que después de declarar la o las opciones (en este caso keys), hay que procesarlas,
con \ProcessOptions.7
Las lı́neas anteriores permiten que \documentclass{mfm2} y \documentclass[keys]{mfm2}
sean ambas válidas, ejecutándose o no ciertos comandos dependiendo de la forma utilizada.
Si ahora queremos que \documentclass[keys,12pt]{mfm2} sea una lı́nea válida, de-
bemos procesar keys dentro de mfm2.cls, y pasarle a book.cls las opciones restantes. El
siguiente es el código definitivo:
\newif\ifkeys\keysfalse
\DeclareOption{keys}{\keystrue}
\DeclareOption*{\PassOptionsToClass{\CurrentOption}{book}}
\ProcessOptions\relax
\LoadClass{book}
\RequirePackage[spanish]{babel}
\RequirePackage{amsmath}
\RequirePackage{theorem}
\RequirePackage{epsfig}
\RequirePackage{ifthen}
\RequirePackage{enumerate}
\RequirePackage{addmath}
\ifkeys\RequirePackage[notref,notcite]{showkeys}\fi
<nuevos comandos de la clase mfm2.cls>
Sin entrar en demasiados detalles, digamos que la opción keys tiene el efecto de hacer
que una cierta variable lógica \ifkeys, sea verdadera (cuarta lı́nea del código). La siguien-
te lı́nea (\DeclareOption*...) hace que todas las opciones que no han sido procesadas
(12pt, por ejemplo) se pasen a la clase book. A continuación se procesan las opciones con
\ProcessOptions, y finalmente se carga la clase book.
Las lı́neas siguientes cargan todos los paquetes necesarios, y finalmente se encuentran
todos los nuevos comandos y definiciones que queremos incluir en mfm2.cls.
Observemos que la forma particular en que se carga el paquete showkeys. Ésa es pre-
cisamente la función de la opción keys que definimos: showkeys.sty se carga con ciertas
opciones sólo si se da la opción keys.
¿Cuál es su efecto? Consideremos el siguiente texto de ejemplo, en que mfm2 ha sido
llamada sin la opción keys:
7
\relax es un comando de TEX que, esencialmente, no hace nada, ni siquiera introduce un espacio en
blanco, y es útil incluirlo en puntos crı́ticos de un documento, como en este ejemplo.
\documentclass[12pt]{mfm2}
\begin{document}
La opci\’on \verb+keys+ resulta muy \’util cuando tengo objetos numerados
autom\’aticamente, como una ecuaci\’on:
\begin{equation}
\label{newton}
\vec F = m \vec a \ .
\end{equation}
y luego quiero referirme a ella: Ec.\ \eqref{newton}.
En el primer caso, se ha compilado sin la opción keys, y en el segundo con ella. El efecto
es que, si se usa un \label en cualquier parte del documento, aparece en el margen derecho
una caja con el nombre de dicha etiqueta (en este caso, newton). Esto es útil para cualquier
tipo de documentos, pero lo es especialmente en textos como estos apuntes, muy extensos y
con abundantes referencias. En tal caso, tener un modo visual, rápido, de saber los nombres
de las ecuaciones sin tener que revisar trabajosamente el archivo fuente es una gran ayuda.
Ası́, versiones preliminares pueden ser compiladas con la opción keys, y la versión final sin
ella, para no confesar al lector nuestra mala memoria o nuestra comodidad.
Caso 1: \documentclass[12pt]{mfm2}
La opción keys resulta muy útil cuando tengo objetos nume-

rados automáticamente, como una ecuación:
F~ = m~a . (1)
y luego quiero referirme a ella: Ec. (1).
Caso 2: \documentclass[keys,12pt]{mfm2}
La opción keys resulta muy útil cuando tengo objetos nume-

rados automáticamente, como una ecuación:
F~ = m~a . (1) newton
y luego quiero referirme a ella: Ec. (1).

6.14. Errores y advertencias.

6.14.1. Errores.
Un mensaje de error tı́pico tiene la forma:
LaTeX error. See LaTeX manual for explanation.

Type H <return> for immediate help.
! Environment itemie undefined.
\@latexerr ...or immediate help.}\errmessage {#1}
\endgroup
l.140 \begin{itemie}
La primera lı́nea nos comunica que LATEX ha encontrado un error. A veces los errores
tienen que ver con procesos más internos, y son encontrados por TEX. Esta lı́nea nos informa
quién encontró el error.
La tercera lı́nea comienza con un signo de exclamación. Éste es el indicador del error. Nos
dice de qué error se trata.
Las dos lı́neas siguientes describen el error en términos de comandos de bajo nivel.
La lı́nea 6 nos dice dónde ocurrió el error: la lı́nea 140 en este caso. Además nos informa
del texto conflictivo: \begin{itemie}.
En realidad, el mensaje nos indica dónde LATEX advirtió el error por primera vez, que no
es necesariamente el punto donde el error se cometió. Pero la gran mayorı́a de las veces la
indicación es precisa. De hecho, es fácil darse cuenta, con la tercera lı́nea
(Environment itemie undefined)
y la sexta (\begin{itemie}) que el error consistió en escribir itemie en vez de itemize. La
información de LATEX es clara en este caso y nos dice correctamente qué ocurrió y dónde.
Luego viene un ?. LATEX está esperando una respuesta de nosotros. Tenemos varias alter-
nativas. Comentaremos sólo cuatro, tı́picamente usadas:
(a) h <Enter>
Solicitamos ayuda. TEX nos explica brevemente en qué cree él que consiste el error y/o
nos da alguna recomendación.
(b) x <Enter>
Abortamos la compilación. Deberemos volver al editor y corregir el texto. Es la opción
más tı́pica cuando uno tiene ya cierta experiencia, pues el mensaje basta para reconocer
el error.
(c) <Enter>
Ignoramos el error y continuamos la compilación. TEX hace lo que puede. En algunos
casos esto no tiene consecuencias graves y podremos llegar hasta el final del archivo
sin mayores problemas. En otros casos, ignorar el error puede provocar que ulteriores
comandos —perfectamente válidos en principio— no sean reconocidos y, ası́, acumular
6.14. ERRORES Y ADVERTENCIAS. 213
muchos errores más. Podemos continuar con <Enter> sucesivos hasta llegar al final de
la compilación.
(d) q <Enter>
La acción descrita en el punto anterior puede llegar a ser tediosa o infinita. q hace
ingresar a TEX en batchmode, modo en el cual la compilación prosigue ignorando todos
los errores hasta el final del archivo, sin enviar mensajes a pantalla y por ende sin que
debamos darle infinitos <Enter>.
Las opciones (c) y (d) son útiles cuando no entendemos los mensajes de error. Como
TEX seguirá compilando haciendo lo mejor posible, al mirar el dvi puede que veamos más
claramente dónde comenzaron a ir mal las cosas y, por tanto, por qué.
Como dijimos, LATEX indica exactamente dónde encontró el error, de modo que hemos de
ponerle atención. Por ejemplo, si tenemos en nuestro documento la lı́nea:
... un error inesperado\fotnote{En cualquier punto.}
puede decidir...
generarı́a el mensaje de error:
! Undefined control sequence.
l.249 ...un error inesperado\fotnote

{En cualquier punto.}
?
En la lı́nea de localización, LATEX ha cortado el texto justo después del comando inexis-
tente. LATEX no sólo indica la lı́nea en la cual detectó el error, sino el punto de ella donde ello
ocurrió. (En realidad, hizo lo mismo —cortar la lı́nea para hacer resaltar el problema— en el
caso expuesto en la pág. 212, pero ello ocurrió en medio de comandos de bajo nivel, ası́ que
no era muy informativo de todos modos.)
Errores más comunes.

Los errores más comunes son:
a) Comando mal escrito.
b) Paréntesis cursivos no apareados.
c) Uso de uno de los caracteres especiales #, $, %, &, _, {, }, ~, ^, \ como texto ordinario.
d) Modo matemático abierto de una manera y cerrado de otra, o no cerrado.
e) Ambiente abierto con \begin... y cerrado con un \end... distinto.
f) Uso de un comando matemático fuera de modo matemático.
g) Ausencia de argumento en un comando que lo espera.
h) Lı́nea en blanco en ambiente matemático.
Algunos mensajes de error.

A continuación, una pequeña lista de errores (de LATEX y TEX) en orden alfabético, y sus
posibles causas.
*
Falta \end{document}. (Dar Ctrl-C o escribir \end{document} para salir de la compilación.)
! \begin{...} ended by \end{...}

Error e) de la Sec. 6.14.1. El nombre del ambiente en \end{...} puede estar mal escrito,
sobra un \begin o falta un \end.
! Double superscript (o subscript).

3
Una expresión como x^2^3 o x_2_3. Si se desea obtener x2 (x23 ), escribir {x^2}^3 ({x_2}_3).
! Environment ... undefined.

\begin{...} con un argumento que corresponde a un ambiente no definido.
! Extra alignment tab has been changed.

En un tabular o array sobra un &, falta un \\, o falta una c, l ó r en el argumento
obligatorio.
! Misplaced alignment tab character &.

Un & aparece fuera de un tabular o array.
! Missing $ inserted.
Errores c), d), f), h) de la Sec. 6.14.1.
! Missing { (o }) inserted.
Paréntesis cursivos no apareados.
! Missing \begin{document}.
Falta \begin{document} o hay algo incorrecto en el preámbulo.
! Missing number, treated as zero.

Falta un número donde LATEX lo espera: \hspace{}, \vspace cm,
\setlength{\textwidth}{a}, etc.
! Something’s wrong -- perhaps a missing \item.

Posiblemente la primera palabra después de un \begin{enumerate} o
\begin{itemize} no es \item.
! Undefined control sequence.

Aparece una secuencia \<palabra>, donde <palabra> no es un comando.
6.14. ERRORES Y ADVERTENCIAS. 215
6.14.2. Advertencias.
La estructura de una advertencia de LATEX es:
LaTeX warning. <mensaje>.
Algunos ejemplos:
Label ‘...’ multiply defined.
Dos \label tienen el mismo argumento.
Label(s) may have changed. Rerun to get cross-references right.
Los números impresos por \ref y \pageref pueden ser incorrectos, pues los valores corres-
pondientes cambiaron respecto al contenido del aux generado en la compilación anterior.
Reference ‘...’ on page ... undefined.
El argumento de un \ref o un \pageref no fue definido por un \label.
TEX también envı́a advertencias. Se reconocen porque no comienzan con TeX warning.
Algunos ejemplos.
Overfull \hbox ...
TEX no encontró un buen lugar para cortar una lı́nea, y puso más texto en ella que lo
conveniente.
Overfull \vbox ...
TEX no encontró un buen lugar para cortar una página, y puso más texto en ella que lo
conveniente.
Underfull \hbox ...
TEX construyó una lı́nea con muy poco material, de modo que el espacio entre palabras puede
ser excesivo.
Underfull \vbox ...
TEX construyó una página con muy poco material, de modo que los espacios verticales (entre
párrafos) pueden ser excesivos.
Las advertencias de LATEX siempre deben ser atendidas. Una referencia doblemente defini-
da, o no compilar por segunda vez cuando LATEX lo sugiere, generará un resultado incorrecto
en el dvi. Una referencia no definida, por su parte, hace aparecer un signo ?? en el texto
final. Todos resultados no deseados, por cierto.
Las advertencias de TEX son menos decisivas. Un overfull o underfull puede redundar en
que alguna palabra se salga del margen derecho del texto, que el espaciado entre palabras en
una lı́nea sea excesivo, o que el espacio vertical entre párrafos sea demasiado. Los estándares
de calidad de TEX son altos, y por eso envı́a advertencias frecuentemente. Pero generalmente
los defectos en el resultado final son imperceptibles a simple vista, o por lo menos no son
suficientes para molestarnos realmente. A veces sı́, por supuesto, y hay que estar atentos.
Siempre conviene revisar el texto y prestar atención a estos detalles, aunque ello sólo tiene
sentido al preparar la versión definitiva del documento.
Parte II
Métodos Numéricos.
217
Capı́tulo 7
Preliminares.
versión final 4.3, 22 de Noviembre del 2007 1 .
7.1. Programas y funciones.

En esta sección nosotros escribiremos algunos programas simples usando Python, C++ y
Octave. En nuestro primer ejemplo, llamado orthog, probaremos si dos vectores son ortogo-
nales calculando su producto punto. Este simple programa lo bosquejamos a continuación
Inicializamos los vectores ~a y ~b.
Evaluamos el producto punto como ~a · ~b = a1 b1 + a2 b2 + a3 b3 .
Imprimir el producto punto y establecer si los vectores son ortogonales.
Programa de ortogonalidad en Python.

Escribimos una clase en Python de vectores en tres dimensiones en el archivo vector3d.py,
el constructor y sobrecargamos la multiplicación y la impresión
from math import sqrt
class Vec3:
def __init__(self, x=0, y=0, z=0):

self.x = x
self.y = y
self.z = z
def __mul__(self,new):
return self.x*new.x+self.y*new.y+self.z*new.z
def __repr__(self):
return ‘‘(%1.5f,%1.5f,%1.5f)’’ % (self.x,self.y,self.z)
1
Este capı́tulo está basado en el primer capı́tulo del libro: Numerical Methods for Physics, second edition
de Alejandro L. Garcia, editorial Prentice Hall
219
220 CAPÍTULO 7. PRELIMINARES.
Escribimos el programa, orthog, usando la clase anterior

from vector3d import *
def main():
x1=input(‘‘Ingrese la primera coordenada del 1er vector : ‘‘)

x2=input(‘‘Ingrese la segunda coordenada del 1er vector : ‘‘)
x3=input(‘‘Ingrese la tercera coordenada del 1er vector : ‘‘)
c=Vec3(x1,x2,x3)
x1=input(‘‘Ingrese la primera coordenada del 2do vector : ‘‘)

x2=input(‘‘Ingrese la segunda coordenada del 2do vector : ‘‘)
x3=input(‘‘Ingrese la tercera coordenada del 2do vector : ‘‘)
d=Vec3(x1,x2,x3)
if c*d==0:
print ‘‘Los vectores ingresados son ortogonales’’
else:
print ‘‘Los vectores ingresados no son ortogonales’’
if __name__ == ‘__main__’:
main()
Primero cambiamos los permisos del archivo orthog.py para que sea ejecutable y luego
usamos el programa
jrogan@huelen:~/programas_metodos_numericos/pyhton$ chmod 744 orthog.py%$
jrogan@huelen:~/programas_metodos_numericos/pyhton$ orthog.py%$
Ingrese la primera coordenada del 1er vector : 1
Ingrese la segunda coordenada del 1er vector : 0
Ingrese la tercera coordenada del 1er vector : 0
Ingrese la primera coordenada del 2do vector : 0
Ingrese la segunda coordenada del 2do vector : 1
Ingrese la tercera coordenada del 2do vector : 0
Los vectores ingresados son ortogonales
Programa de ortogonalidad en C++.

Ahora consideremos la versión en C++ del programa orthog, el cual prueba si dos vectores
son ortogonales mediante el cálculo de su producto punto. Primero escribiremos una clase
muy básica de vectores en tres dimensiones.
7.1. PROGRAMAS Y FUNCIONES. 221
Las declaraciones están en vector3d.h

#ifndef _vector_3d_h
#define _vector_3d_h
//
// Clase basica de vectores 3d
//
#include <iostream>
class Vector{
private:
double c_x;
double c_y;
double c_z;
public:
Vector():c_x(0),c_y(0),c_z(0) {} ;
Vector(double x, double y, double z):c_x(x),c_y(y),c_z(z) {} ;
~Vector() {} ;
double x() const {return c_x;};
double y() const {return c_y;};
double z() const {return c_z;};
};
double operator * (const Vector &, const Vector &) ;

std::istream & operator >> (std::istream &, Vector &) ;
#endif
La pequeña implementación necesaria para esta clase la escribimos en vector3d.cc el cual

es listado a continuación
#include "vector3d.h"
double operator * (const Vector & v1, const Vector &v2) {

return v1.x()*v2.x()+v1.y()*v2.y()+ v1.z()*v2.z() ;
}
std::istream & operator >> (std::istream & is, Vector & v) {
double x,y,z ;
is >> x >> y>>z ;
v= Vector(x,y,z) ;
return is;
}
Ahora estamos en condiciones de escribir el programa propiamente tal. Las primeras lı́neas
son
// orthog - Programa para probar si un par de vectores es ortogonal.

// Supondremos vectores en 3D.
#include ‘‘vector3d.h’’
Las primeras lı́neas son comentarios que nos recuerdan lo que el programa hace. La lı́nea
siguiente incluye las definiciones de nuestra recién creada clase. Luego incluı́mos una lı́nea
dice que vamos a usar el namespace std. A continuación comienza el programa
// orthog - Programa para probar si un par de vectores es ortogonal.

// Usaremos vectores en 3D.
int main()
{
Vector a, b;
cout << "Ingrese el primer vector : ";
cin >> a ;
cout << "Ingrese el segundo vector : ";
cin >> b ;
if(a*b==0) {
cout <<"Son ortogonales" << endl;
} else {
cout << "No son ortogonales"<< endl ;
}
return 0;
}
Declaramos dos objetos tipo Vector, a y b para almacenar los vectores que entran. La
instrucción de salida despliega sobre la pantalla:
Ingrese el primer vector :
La instrucción de entrada lee el Vector en a y luego, de la misma manera, el Vector b. Las

próximas lı́neas hacen el trabajo
if(a*b==0) {
cout <<"Son ortogonales" << endl;
} else {
cout << "No son ortogonales"<< endl ;
}
y despliega el resultados. Aquı́ los comandos de compilación y una salida tı́pica del programa.
jrogan@pucon:~$ g++ -Wall -o orthog orthog.cc vector3d.cc

jrogan@pucon:~$ orthog
Ingrese el primer vector : 1 0 0
Ingrese el segundo vector : 0 1 0
Son ortogonales
Programa de ortogonalidad en Octave.

Primero consideremos la versión en Octave del programa que llamaremos orthog.m. Las
primeras lı́neas de orthog son:
% orthog - Programa para probar si un par de vectores es ortogonal.
% Supondremos vectores en 3D.
clear all; % Borra la memoria
Las primeras dos lı́neas son comentarios; si tipeamos help orthog desde la lı́nea de comandos,
Octave desplegará estas lı́neas. El comando clear all en la tercera lı́nea borra la memoria.
Las próximas lı́neas del programa
%* Inicializa los vectores a y b
a= input(’Entre el primer vector: ’);
b= input(’Entre el segundo vector: ’);
Los vectores entran usando el comando input en estas lı́neas. Los comentarios que comienzan
con %* son aquellos que corresponden al bosquejo del programa que hicimos. En las lı́neas
siguientes se evalúa el producto punto.
%* Evalua el producto punto como la suma sobre el producto de los elementos
adotb=0;
for i=1:3
adotb=adotb+a(i)*b(i);
end
El ciclo for, usando el ı́ndice i, recorre las componentes de los vectores. Una manera hábil
de hacer lo mismo podrı́a ser usar
%* Evalua el producto punto como el producto de dos vectores
adotb=a*b’ ;
En este caso, hemos usado la multiplicación de matrices de Octave para calcular el producto
punto como el producto vectorial del vector fila a y el columna b’ (donde hemos usado el
operador Hermı́tico conjugado ’). Las últimas lı́neas del programa
%* Imprime el producto punto y si los vectores son ortogonales
if(adotb==0)
disp(’Los vectores son ortogonales’);
else
disp(’Los vectores no son ortogonales’);
printf(’Producto punto = %g \n’, adotb);
end
De acuerdo al valor de adotb el programa despliega una de las dos posibles respuestas. A
continuación la salida al ejecutar el help del programa
octave> help orthog
orthog is the file: /home/jrogan/orthog.m
orthog - Programa para probar si un par de vectores es ortogonal.

Supondremos vectores en 3D.
Additional help for builtin functions, operators, and variables

is available in the on-line version of the manual. Use the command
‘help -i <topic>’ to search the manual index.
Help and information about Octave is also available on the WWW

at http://www.che.wisc.edu/octave/octave.html and via the
[email protected] mailing list.
Ahora ejecutamos el programa con diferentes vectores.
octave> orthog
Entre el primer vector: [1 1 1]
Entre el segundo vector: [1 -2 1]
Los vectores son ortogonales
octave> orthog
Entre el primer vector: [1 1 1]
Entre el segundo vector: [2 2 2]
Los vectores no son ortogonales
Producto punto = 6
Interpolación.
Es bien sabido que dados tres pares (x, y), se puede encontrar una cuadrática que pasa
por los puntos deseados. Hay varias maneras de encontrar el polinomio y varias maneras de
escribirlo. La forma de Lagrange del polinomio es
(x − x2 )(x − x3 ) (x − x1 )(x − x3 ) (x − x1 )(x − x2 )
p(x) = y1 + y2 + y3 , (7.1)
(x1 − x2 )(x1 − x3 ) (x2 − x1 )(x2 − x3 ) (x3 − x1 )(x3 − x2 )
donde (x1 , y1 ), (x2 , y2 ), (x3 , y3 ), son los tres puntos por los que queremos pasar. Comúnmente
tales polinomios son usados para interpolar entre los puntos dados. A continuación el bosquejo
de un programa simple de interpolación, que llamaremos interp
Inicializa los puntos (x1 , y1 ), (x2 , y2 ) y (x3 , y3 ) para ser ajustados por el polinomio.
Establece el intervalo de la interpolación (desde xmı́n hasta xmáx )
Encuentra y ∗ para los valores deseados de x∗ , usando la función intrpf.
Finalmente, podemos graficar la curva dada por (x∗ , y ∗ ), y marcar los puntos originales
para comparar.
Programa de interpolación en Python.

Las primeras lı́neas de la versión en Python del programa interp son
# -*- coding: iso-8859-1 -*-
# interp - Programa para interpolar datos usando
# el polinomio de Lagrange cuadratico para tres puntos dados.
# Importa un modulo que permite graficar.
from pylab import *
# Definicion de la funcion que evalua el polinomio.
def intrpf(x,x_i,y_i):
t0=y_i[0]*(x-x_i[1])*(x-x_i[2])/((x_i[0]-x_i[1])*(x_i[0]-x_i[2]))
return t0+t1+t2
def main():
# Se ingresan los tres puntos y se almacenan en dos listas x_i e y_i
x_i=[]
y_i=[]
print "Ingrese tres puntos (x,y)"
x0=input("Coordenada x, primer punto : ")
y0=input("Coordenada y, primer punto : ")
x1=input("Coordenada x, segundo punto : ")
y1=input("Coordenada y, segundo punto : ")
x2=input("Coordenada x, tercer punto : ")
y2=input("Coordenada y, tercer punto : ")
x_i.append(x0)
x_i.append(x1)
x_i.append(x2)
y_i.append(y0)
y_i.append(y1)
y_i.append(y2)
# Se ingresa el intervalo donde se evaluara el polinomio
print "Ingrese intervalo para hacer la interpolacion"
x_min=input("Coordenada x minimo : ")
x_max=input("Coordenada x maximo : ")
# Grafica
t=arange(x_min,x_max,(x_max-x_min)/100.0)
plot(x_i, y_i,’ro’,t, intrpf(t,x_i,y_i))
title("Polinomio de interpolacion de Lagrange")
grid(True)
show()
if __name__==’__main__’:
main()
Usando el programa
jrogan@huelen:~/programas_metodos_numericos/pyhton$ interp.py
Ingrese tres puntos (x,y)
Coordenada x, primer punto : 0.5
Coordenada y, primer punto : 0.25
Coordenada x, segundo punto : 1
Coordenada y, segundo punto : 1
Coordenada x, tercer punto : 2
Coordenada y, tercer punto : 4
Ingrese intervalo para hacer la interpolacion
Coordenada x minimo : -3
Coordenada x maximo : 3
El uso de las instrucción plot en el programa levanta una ventana independiente con el
siguiente gráfico:
Figura 7.1: Salida gráfica del programa interp.

Programa de interpolación en C++.

Las primeras lı́neas de la versión en C++ del programa interp son
// interp - Programa para interpolar datos usando
// el polinomio de Lagrange cuadratico para tres puntos dados.
#include "NumMeth.h"
double intrpf(double xi, double x[], double y[]);

int main()
{
Comentarios más una instrucción para incluir el archivo de encabezamiento NumMeth.h, lis-
tado a continuación
#include <iostream>
#include <fstream>
#include <cmath>
#include <cstdlib>

La declaración double intrpf(..) afirma que el programa pretende llamar una función
intrpf, la cual tiene tres argumentos de tipo double y devuelve un double. Las próximas
lı́neas del programa
// Inicializa los puntos a ser ajustados con una cuadratica
double x[3], y[3] ;
cout << "Entre los puntos como pares x,y (e.g., [1 2])" << endl ;
for(int i=0; i<3; i++) {
cout << "x["<<i<<"] = ";
cin>> x[i];
cout << "y["<<i<<"] = ";
cin >> y[i];
}
// Establece el intervalo de interpolacion (desde x_min a x_max)

double xmin, xmax;
cout <<"Entre el valor minimo de x: "; cin >> xmin ;
cout <<"Entre el valor maximo de x: "; cin >> xmax ;
El programa pregunta por los puntos para ajustar el polinomio de Lagrange (7.1) y por el
intervalo de interpolación. Lo siguiente, los arreglos xi y yi son declarados:
// Encontrar yi para los valores deseados de interpolacion xi
// usando la funcion intrpf
int nplot= 100; // Numero de puntos para la curva interpolada
double * xi = new double[nplot] ; // Reserva memoria para
double * yi = new double[nplot] ; // estos arreglos.
Estas lı́neas también podrı́an reemplazarse por
int nplot = 100; // Numero de puntos para la curva interpolada

double xi[nplot], yi[nplot] ;
En ambos casos hay asignamiento dinámico de memoria, nplot podrı́a ser una entrada del
programa.
Los valores interpolados son calculados en un for
for(int i=0; i<nplot;i++) {

xi[i] = xmin+(xmax-xmin)*double(i)/double(nplot-1);
yi[i] = intrpf(xi[i], x, y); // Usando intrpf para interpolar
}
Notemos que xi[1]=xmı́n , xi[nplot]=xmáx , con valores equiespaciados entre ellos. Los va-
lores de yi (y ∗ = p(x∗ )) son evaluados usando la ecuación (7.1) en la función intrpf. La
salida del programa
// Imprime las variables para graficar: x, y, xi, yi

ofstream xOut("x.txt"), yOut("y.txt"), xiOut("xi.txt"), yiOut("yi.txt");
for(int i =0; i <3; i++) {
xOut << x[i] << endl;
yOut << y[i] << endl;
}
for(int i =1; i <=nplot; i++) {
xiOut << xi[i] << endl;
yiOut << yi[i] << endl;
}
xOut.close() ; yOut.close() ; xiOut.close(); yiOut.close() ;
Estos cuatro archivos de datos (x.txt, y.txt, etc.) son creados.

Desgraciadamente, C++ carece de una biblioteca gráfica estándar, ası́ que necesitamos
una aplicación gráfica adicional para graficar la salida. También podemos usar un pequeño
script en Octave:
#!/usr/bin/octave
load x.txt; load y.txt; load xi.txt; load yi.txt;
%* Grafica la curva dada por (xi,yi) y marca los puntos originales
xlabel(’x’);
ylabel(’y’);
title(’Interpolacion de tres puntos’);
gset nokey;
plot(x,y, ’*’,xi,yi,’-’);
pause
Al cual, incluso, podemos llamar desde el mismo programa mediante
system( "grafica.m" ) ;
Interpolacion de tres puntos

9
5
y
0
-3 -2 -1 0 1 2 3
x
Figura 7.2: Salida gráfica del programa interp.
La última lı́nea del programa
delete [] xi ; // Libera la memoria pedida con "new"

delete [] yi ; // Libera la memoria pedida con "new"
return 0;
}
Esta lı́nea no es absolutamente necesaria, por que al salir el programa liberará la memoria
de todas maneras. Sin embargo, se considera como buen estilo de programación, limpiar uno
la memoria que requirió durante la ejecución del programa.
La función intrpf, la cual evalúa el polinomio de Lagrange, comienza por las siguientes
lı́neas
double intrpf( double xi, double x[], double y[])

{
// Funcion para interpolar entre puntos
// usando polinomio de Lagrange (cuadratico)
// Entradas
// x Vector de las coordenadas x de los puntos dados (3 valores)
// y Vector de las coordenadas y de los puntos dados (3 valores)
// Salida
// yi El polinomio de interpolacion evaluado en xi
Especifica los argumentos de llamada y lo que devuelve. Todas las variables dentro de la
función son locales. El C++ pasa las variables por valor, por defecto, la función recibe una
copia que se destruye cuando termina la función, si se desea pasar una variable double a
por referencia debemos anteponerle el signo &, es decir, pasarla como double &a. De esta
manera la función puede modificar el valor que tenı́a la variable en el programa principal.
El resto de la función
//* Calcula yi=p(xi) usando Polinomio de Lagrange
double yi = (xi-x[2])*(xi-x[3])/((x[1]-x[2])*(x[1]-x[3]))*y[1]
+ (xi-x[1])*(xi-x[3])/((x[2]-x[1])*(x[2]-x[3]))*y[2]
+ (xi-x[1])*(xi-x[2])/((x[3]-x[1])*(x[3]-x[2]))*y[3];
return yi ;
Estas lı́neas evalúan el polinomio. Inicialmente pondremos esta función en el mismo archivo,
luego la podemos separar en otro archivo y escribir un Makefile que genere el ejecutable.
Programa de interpolación en Octave.

Las primeras lı́neas del programa
% interp - Programa para interpolar datos usando
% el polinomio de Lagrange cuadratico para tres puntos dados.
clear all;
%* Inicializa los puntos a ser ajustados con una cuadratica
disp(’Entre los puntos como pares x,y (e.g., [1 2])’);
for i=1:3
temp =input(’Ingrese el punto: ’);
x(i)=temp(1);
y(i)=temp(2) ;
end
%* Establece el intervalo de interpolacion (desde x_min a x_max)
xr = input (’Ingrese el intervalo de valores de x como [x_min x_max]: ’);
Aquı́ el programa lee los tres pares (x, y) y el intervalo de valores entre los cuales será inter-
polado.
Los valores interpolados y ∗ = p(x∗ ) son calculados por la función intrpf desde x∗ = xmı́n
a x∗ = xmáx . Estos valores de y ∗ (yi) son calculados en el ciclo.
%* Encontrar yi para los valores deseados de interpolacion xi
% usando la funcion intrpf
nplot= 100; % Numero de puntos para la curva interpolada
for i=1:nplot
xi(i) = xr(1)+(xr(2)-xr(1))*(i-1)/(nplot-1);
yi(i) = intrpf(xi(i), x, y); % Usando intrpf para interpolar
end
Finalmente, los resultados son graficados usando las funciones gráficas de Octave.
%* Grafica la curva dada por (xi,yi) y marca los puntos originales
xlabel(’x’);
ylabel(’y’);
title(’Interpolacion de tres puntos’);
gset nokey;
plot(x,y, ’*’,xi,yi,’-’);
7.2. ERRORES NUMÉRICOS. 231
Los puntos de la interpolación (x∗ , y ∗ ) son graficados con lı́nea segmentada y los datos
originales con cı́rculos, ver figura (7.2). El trabajo real es hecho por la función intrpf. Un
bosquejo de lo que queremos que haga esta función a continuación.
Entrada: ~x = [x1 x2 x3 ], ~y = [y1 y2 y3 ], y x∗ .
Salida: y ∗ .
Cálculo de y ∗ = p(x∗ ) usando el polinomio de Lagrange (7.1).
Las funciones en Octave están implementadas como en la mayorı́a de los lenguajes, excepto
que aquı́ cada función tiene que ir en un archivo separado. El nombre del archivo debe
coincidir con el nombre de la función (la función intrpf está en el archivo intrpf.m).
function yi=intrpf(xi,x,y)
% Funcion para interpolar entre puntos
% usando polinomio de Lagrange (cuadratico)
% Entradas
% x Vector de las coordenadas x de los puntos dados (3 valores)
% y Vector de las coordenadas y de los puntos dados (3 valores)
% Salida
% yi El polinomio de interpolacion evaluado en xi
La función intrpf tiene tres argumentos de entrada y uno de salida. El resto de la función
es directa, sólo evalúa el polinomio definido en (7.1). El cuerpo de la función a continuación
yi = (xi-x(2))*(xi-x(3))/((x(1)-x(2))*(x(1)-x(3)))*y(1) ...
+ (xi-x(1))*(xi-x(3))/((x(2)-x(1))*(x(2)-x(3)))*y(2) ...
+ (xi-x(1))*(xi-x(2))/((x(3)-x(1))*(x(3)-x(2)))*y(3);
return;
7.2. Errores numéricos.

7.2.1. Errores de escala.
Un computador almacena números de punto flotante usando sólo una pequeña cantidad
de memoria. Tı́picamente, a una variable de precisión simple (un float en C++) se le
asignan 4 bytes (32 bits) para la representación del número, mientras que una variable de
doble precisión (double en C++, por defecto en Python y Octave) usa 8 bytes. Un número de
punto flotante es representado por su mantisa y su exponente (por ejemplo, para 6.625×10−27
la mantisa decimal es 6.625 y el exponente es −27). El formato IEEE para doble precisión
usa 53 bits para almacenar la mantisa (incluyendo un bit para el signo) y lo que resta, 11
bit para el exponente. La manera exacta en que el computador maneja la representación de
los números no es tan importante como saber el intervalo máximo de valores y el número de
cifras significativas.
El intervalo máximo es el lı́mite sobre la magnitud de los números de punto flotante
impuesta por el número de bit usados para el exponente. Para precisión simple un valor
tı́pico es 2±127 ≈ 10±38 ; para precisión doble es tı́picamente 2±1024 ≈ 10±308 . Exceder el
intervalo de la precisión simple no es difı́cil. Consideremos, por ejemplo, la evaluación del
radio de Bohr en unidades SI,
4πε0 ~2
a0 = 2
≈ 5.3 × 10−11 [m] . (7.2)
me e
Mientras sus valores caen dentro del intervalo de un número de precisión simple, el intervalo
es excedido en el cálculo del numerador (4πε0 ~2 ≈ 1.24 × 10−78 [kg C2 m]) y del denominador
(me e2 ≈ 2.34 × 10−68 [kg C2 ]). La mejor solución para lidiar con este tipo de dificultades de
intervalo es trabajar en un conjunto de unidades naturales al problema (e.g. para problemas
atómicos se trabaja en las distancias en Ångstroms y la carga en unidades de la carga del
electrón).
Algunas veces los problemas de intervalo no son causados por la elección de las unida-
des, sino porque los números en el problema son inherentemente grandes. Consideremos un
importante ejemplo, la función factorial. Usando la definición
n! = n × (n − 1) × (n − 2) × . . . × 3 × 2 × 1 , (7.3)
es fácil evaluar n! en Python,
nFactorial=1;
for i in range(1,n+1):
nFactorial *=i
o en C++,
double nFactorial=1;
for(int i=1; i <=n; i++) nFactorial *=i ;
donde n es un número dado.
En Octave, usando el operador dos puntos este cálculo puede ser realizado como
nFactorial = prod(1:n);
donde prod(x) es el producto de los elementos del vector x y 1:n=[1,2. . . , n]. Infortunada-
mente, debido a problemas de intervalo, no podemos calcular n! para n > 170 usando estos
métodos directos de evaluación (7.3).
Una solución común para trabajar con números grandes es usar su logaritmo. Para el
factorial
log(n!) = log(n) + log(n − 1) + . . . + log(3) + log(2) + log(1) . (7.4)
En Octave, esto puede ser evaluado como
log_nFactorial = sum( log(1:n) ) ;
donde sum(x) es la suma de los elementos del vector x. Sin embargo, este esquema es compu-
tacionalmente pesado si n es grande. Una mejor estrategia es combinar el uso de logaritmos
con la fórmula de Stirling2
√

n −n 1 1
n! = 2nπn e 1+ + + ··· (7.5)
12n 288n2
2
M. Abramowitz and I. Stegun, Handbook of Mathematical Functions ( New York: Dover 1972).
7.2. ERRORES NUMÉRICOS. 233
o
1 1 1
log(n!) = log(2nπ) + n log(n) − n + log 1 + + + ··· . (7.6)
2 12n 288n2
Esta aproximación puede ser usada cuando n es grande (n > 30), de otra manera es preferible
la definición original.
Finalmente, si el valor de n! necesita ser impreso, podemos expresarlo como
n! = (mantisa) × 10(exponente) , (7.7)
donde el exponente es la parte entera de log10 (n!), y la mantisa es 10a donde a es la parte
fraccionaria de log10 (n!). Recordemos que la conversión entre logaritmo natural y logaritmo
en base 10 es log10 (x) = log10 (e) log(x).
7.2.2. Errores de redondeo.

Supongamos que deseamos calcular numéricamente f ′ (x), la derivada de una función
conocida f (x). En cálculo se aprendió que la fórmula para la derivada es
f (x + h) − f (x)
f ′ (x) = , (7.8)
h
en el lı́mite en que h → 0. ¿Qué sucede si evaluamos el lado derecho de esta expresión,
poniendo h = 0?. Como el computador no entiende que la expresión es válida sólo como un
lı́mite, la división por cero tiene varias posibles salidas. El computador puede asignar el valor,
Inf, el cual es un número de punto flotante especial reservado para representar el infinito. Ya
que el numerador es también cero el computador podrı́a evaluar el cociente siendo indefinido
(Not-a-Number), NaN, otro valor reservado. O el cálculo podrı́a parar y arrojar un mensaje
de error.
Claramente, poniendo h = 0 para evaluar (7.8) no nos dará nada útil, pero ¿si le ponemos
a h un valor muy pequeño, digamos h = 10−300 , usamos doble precisión? La respuesta aún
será incorrecta debido a la segunda limitación sobre la representación de números con punto
flotante: el número de dı́gitos en la mantisa. Para precisión simple, el número de dı́gitos
significantes es tı́picamente 6 o 7 dı́gitos decimales; para doble precisión es sobre 16 dı́gitos.
Ası́, en doble precisión, la operación 3 + 10−20 retorna una respuesta 3 por el redondeo;
usando h = 10−300 en la ecuación (7.8) casi con seguridad regresará 0 cuando evaluemos el
numerador.
La figura 7.3 ilustra la magnitud del error de redondeo en un cálculo tı́pico de derivada.
Definimos el error absoluto

′ f (x + h) − f (x)
∆(h) = f (x) −

. (7.9)
h
Notemos que ∆(h) decrece cuando h se hace más pequeño, lo cual es esperado, dado que
la ecuación (7.8) es exacta cuando h → 0. Por debajo de h = 10−10 , el error comienza a
incrementarse debido a efectos de redondeo. En valores menores de h el error es tan grande
0
10
−2
10
−4
∆(h)
10
−6
10
−8
10
−10
10 −20 −16 −12 −8 −4 0
10 10 10 10 10 10
h
Figura 7.3: Error absoluto ∆(h), ecuación (7.9), versus h para f (x) = x2 y x = 1.
que la respuesta carece de sentido. Volveremos en el próximo capı́tulo a la pregunta de cómo

mejorar el cálculo de la derivada numéricamente.
Para testear la tolerancia del redondeo, definimos εΓ como el más pequeño número que,
cuando es sumado a uno, regresa un valor distinto de 1. En Octave, la función integrada
eps devuelve εΓ ≈ 2.22 × 10−16 . En C++, el archivo de encabezamiento <cfloat> define
DBL_EPSILON (2.2204460492503131e-16) como εΓ para doble precisión.
Debido a los errores de redondeo la mayorı́a de los cálculos cientı́ficos usan doble precisión.
Las desventajas de la doble precisión son que requieren más memoria y que algunas veces (no
siempre) es más costosa computacionalmente. Los procesadores modernos están construidos
para trabajar en doble precisión, tanto que puede ser más lento trabajar en precisión simple.
Usar doble precisión algunas veces sólo desplaza las dificultades de redondeo. Por ejemplo, el
cálculo de la inversa de una matriz trabaja bien en simple precisión para matrices pequeñas
de 50 × 50 elementos, pero falla por errores de redondeo para matrices más grandes. La
doble precisión nos permite trabajar con matrices de 100 × 100, pero si necesitamos resolver
sistemas aún más grandes debemos usar un algoritmo diferente. La mejor manera de trabajar
es usar algoritmos robustos contra el error de redondeo.
Capı́tulo 8
Ecuaciones diferenciales ordinarias:

Métodos básicos.
versión final 4.1, 22 de Noviembre del 20071 .
En este capı́tulo resolveremos uno de los primeros problemas abordados por un estudiante
de fı́sica: el vuelo de un proyectil y, en particular, el de una pelota de baseball. Sin la resistencia
del aire el problema es fácil de resolver. Sin embargo, incluyendo un arrastre realista, nosotros
necesitamos calcular la solución numéricamente. Para analizar este problema definiremos
primero la diferenciación numérica. De hecho antes de aprender fı́sica uno aprende cálculo
ası́ que no debemos sorprendernos si este es nuestro punto de partida. En la segunda mitad del
capı́tulo nos ocuparemos de otro viejo conocido, el péndulo simple, pero sin la aproximación a
ángulos pequeños. Los problemas oscilatorios, tales como el péndulo, nos revelarán una falla
fatal en algunos de los métodos numéricos de resolver ecuaciones diferenciales ordinarias.
8.1. Movimiento de un proyectil.

8.1.1. Ecuaciones básicas.
Consideremos el simple movimiento de un proyectil, digamos un pelota de baseball. Para
describir el movimiento, nosotros debemos calcular el vector posición ~r(t) y el vector velocidad
~v (t) del proyectil. Las ecuaciones básicas de movimiento son
d~v 1 d~r
= F~a (~v ) − g ŷ , = ~v , (8.1)
dt m dt
donde m es la masa del proyectil. La fuerza debido a la resistencia del aire es F~a (~v ), la
aceleración gravitacional es g, e ŷ es un vector unitario en la dirección y. El movimiento es
bidimensional, tal que podemos ignorar la componente z y trabajar en el plano xy.
La resistencia del aire se incrementa con la velocidad del objeto, y la forma precisa para
F~a (~v ) depende del flujo alrededor del proyectil. Comúnmente, esta fuerza es aproximada por
1
F~a (~v ) = − Cd ρA | v | ~v , (8.2)
2
1
Este capı́tulo está basado en el segundo capı́tulo del libro: Numerical Methods for Physics, second edition
de Alejandro L. Garcia, editorial Prentice Hall
235
236 CAPÍTULO 8. EDO: MÉTODOS BÁSICOS.
donde Cd es el coeficiente de arrastre, ρ es la densidad del aire, y A es el área de la sección

transversal del proyectil. El coeficiente de arrastre es un parámetro adimensional que depende
de la geometrı́a del proyectil: entre más aerodinámico el objeto, el coeficiente es menor.
Para una esfera suave de radio R moviéndose lentamente a través del fluido, el coeficiente
de arrastre es dado por la Ley de Stokes,
12ν 24
Cd = = , (8.3)
Rv Re
donde ν es la viscosidad del fluido (ν ≈ 1.5 × 10−5 [m2 /s] para el aire) y Re = 2Rv/ν es
el adimensional número de Reynolds. Para un objeto del tamaño de una pelota de baseball
moviéndose a través del aire, la ley de Stokes es válida sólo si la velocidad es menor que
0.2 [mm/s] (Re ≈ 1).
A velocidades altas (sobre 20 [cm/s], Re> 103 ), la estela detrás de la esfera desarrolla
vórtices y el coeficiente de arrastre es aproximadamente constante (Cd ≈ 0.5) para un amplio
intervalo de velocidades. Cuando el número de Reynolds excede un valor crı́tico, el flujo en la
estela llega a ser turbulento y el coeficiente de arrastre cae dramáticamente. Esta reducción
ocurre porque la turbulencia rompe la región de bajas presiones en la estela detrás de la
esfera2 . Para una esfera suave este número crı́tico de Reynolds es aproximadamente 3 × 105 .
Para una pelota de baseball, el coeficiente de arrastre es usualmente más pequeño que el de
una esfera suave, porque las costuras rompen el flujo laminar precipitando el inicio de la
turbulencia. Nosotros podemos tomar Cd = 0.35 como un valor promedio para el intervalo
de velocidades tı́picas de una pelota de baseball.
Notemos que la fuerza de arrastre, ecuación (8.2), varı́a como el cuadrado de la magnitud
de la velocidad (Fa ∝ v 2 ) y, por supuesto, actúa en la dirección opuesta a la velocidad. La
masa y el diámetro de una pelota de baseball son 0.145 [kg] y 7.4 [cm]. Para una pelota de
baseball, el arrastre y la fuerza gravitacional son iguales en magnitud cuando v ≈ 40 [m/s].
Nosotros sabemos cómo resolver las ecuaciones de movimiento si la resistencia del aire es
despreciable. La trayectoria es
1
~r(t) = ~r1 + ~v1 t − gt2 ŷ , (8.4)
2
donde ~r1 ≡ ~r(0) y ~v1 ≡ ~v (0) son la posición y la velocidad inicial. Si el proyectil parte del
origen y la velocidad inicial forma un ángulo θ con la horizontal, entonces
2v12 v12
xmáx = sen θ cos θ , ymáx = sen2 θ , (8.5)
g 2g
son el alcance horizontal y la altura máxima. El tiempo de vuelo es
2v1
tf l = sen θ . (8.6)
g
Nuevamente estas expresiones son válidas sólo cuando no hay resistencia con el aire.
Es fácil demostrar que el máximo alcance horizontal se obtiene cuando la velocidad forma
un ángulo de 45◦ con la horizontal. Deseamos mantener esta información en mente cuando
construyamos nuestra simulación. Si se sabe la solución exacta para un caso especial, se debe
comparar constantemente que el programa trabaje bien para este caso.
2
D.J. Tritton, Physical Fluid Dynamics, 2d ed. (Oxford: Clarendon Press, 1988).
8.1. MOVIMIENTO DE UN PROYECTIL. 237
8.1.2. Derivada avanzada.

Para resolver las ecuaciones de movimiento (8.1) necesitamos un método numérico para
evaluar la primera derivada. La definición formal de la derivada es
f (t + τ ) − f (t)
f ′ (t) ≡ lı́m , (8.7)
τ →0 τ
donde τ es el incremento temporal o paso en el tiempo. Como ya vimos en el capı́tulo pasado
esta ecuación debe ser tratada con cuidado. La figura 7.3 ilustra que el uso de un valor
extremadamente pequeño para τ causa un gran error en el cálculo de (f (t + τ ) − f (t))/τ .
Especı́ficamente, los errores de redondeo ocurren en el cálculo de t + τ , en la evaluación de la
función f y en la sustracción del numerador. Dado que τ no puede ser elegido arbitrariamente
pequeño, nosotros necesitamos estimar la diferencia entre f ′ (t) y (f (t + τ ) − f (t))/τ para un
τ finito.
Para encontrar esta diferencia usaremos una expansión de Taylor. Como fı́sicos usualmente
vemos las series de Taylor expresadas como
τ 2 ′′
f (t + τ ) = f (t) + τ f ′ (t) + f (t) + . . . (8.8)
2
donde el sı́mbolo (. . . ) significa términos de más alto orden que son usualmente despreciados.
Una alternativa, forma equivalente de la serie de Taylor usada en análisis numérico es
τ 2 ′′
f (t + τ ) = f (t) + τ f ′ (t) +
f (ζ) . (8.9)
2
donde ζ es un valor entre t y t + τ . No hemos botado ningún término, esta expansión tiene
un número finito de términos. El teorema de Taylor garantiza que existe algún valor ζ para
el cual (8.9) es cierto, pero no sabemos cuál valor es este.
La ecuación previa puede ser rescrita
f (t + τ ) − f (t) 1 ′′
f ′ (t) = − τ f (ζ) , (8.10)
τ 2
donde t ≤ ζ ≤ t + τ . Esta ecuación es conocida como la fórmula de la derivada derecha o
derivada adelantada. El último término de la mano derecha es el error de truncamiento; este
error es introducido por cortar la serie de Taylor.
En otras palabras, si mantenemos el último término en (8.10), nuestra expresión para
′
f (t) es exacta. Pero no podemos evaluar este término porque no conocemos ζ, todo lo que
conocemos es que ζ yace en algún lugar entre t y t + τ . Ası́ despreciamos el término f ′′ (ζ)
(truncamos) y decimos que el error que cometemos por despreciar este término es el error de
truncamiento. No hay que confundir éste con el error de redondeo discutido anteriormente. El
error de redondeo depende del hardware, el error de truncamiento depende de la aproximación
usada en el algoritmo. Algunas veces veremos la ecuación (8.10) escrita como
f (t + τ ) − f (t)
f ′ (t) = + O(τ ) (8.11)
τ
donde el error de truncamiento es ahora especificado por su orden en τ , en este caso el error
de truncamiento es lineal en τ . En la figura 7.3 la fuente de error predominante en estimar
f ′ (x) como [f (x + h) − f (x)]/h es el error de redondeo cuando h < 10−10 y es el error de
truncamiento cuando h > 10−10 .
8.1.3. Método de Euler.

Las ecuaciones de movimiento que nosotros deseamos resolver numéricamente pueden ser
escritas como:
d~v d~r
= ~a(~r, ~v ) , = ~v , (8.12)
dt dt
donde ~a es la aceleración. Notemos que esta es la forma más general de las ecuaciones. En
el movimiento de proyectiles la aceleración es sólo función de ~v (debido al arrastre), en otros
problemas (e.g., órbitas de cometas) la aceleración dependerá de la posición.
Usando la derivada adelantada (8.11), nuestras ecuaciones de movimiento son
~v (t + τ ) − ~v (t)
+ O(τ ) = ~a(~r(t), ~v (t)) , (8.13)
τ
~r(t + τ ) − ~r(t)
+ O(τ ) = ~v (t) , (8.14)
τ
o bien
~v (t + τ ) = ~v (t) + τ~a(~r(t), ~v (t)) + O(τ 2 ) , (8.15)

~r(t + τ ) = ~r(t) + τ~v (t) + O(τ 2 ) . (8.16)
notemos que τ O(τ ) = O(τ 2 ). Este esquema numérico es llamado el método de Euler. Antes de
discutir los méritos relativos de este acercamiento, veamos cómo serı́a usado en la práctica.
Primero, introducimos la notación
fn = f (tn ) , tn = nτ , n = 0, 1, 2, . . . (8.17)
tal que f0 = f (t = 0). Nuestras ecuaciones para el método de Euler (despreciando el término
del error) ahora toma la forma
~vn+1 = ~vn + τ~an , (8.18)

~rn+1 = ~rn + τ~vn , (8.19)
donde ~an = ~a(~rn , ~vn ). El cálculo de la trayectoria podrı́a proceder ası́:
1. Especifique las condiciones iniciales, ~r0 y ~v0 .
2. Elija un paso de tiempo τ .
3. Calcule la aceleración dados los actuales ~r y ~v .
4. Use las ecuaciones (8.18) y (8.19) para calcular los nuevos ~r y ~v .
5. Vaya al paso 3 hasta que suficientes puntos de trayectoria hayan sido calculados.
El método calcula un conjunto de valores para ~rn y ~vn que nos da la trayectoria, al menos
en un conjunto discreto de valores. La figura 8.1 ilustra el cálculo de la trayectoria para un
único paso de tiempo.
vn x τ vn vn
an
τ an
vn+1
rn rn+1
Figura 8.1: Trayectoria de una partı́cula después de un único paso de tiempo con el método
de Euler. Sólo para efectos ilustrativos τ es grande.
8.1.4. Métodos de Euler-Cromer y de Punto Medio.

Una simple (y por ahora injustificada) modificación del método de Euler es usar las
siguientes ecuaciones:
~vn+1 = ~vn + τ~an , (8.20)

~rn+1 = ~rn + τ~vn+1 . (8.21)
Notemos el cambio sutil: La velocidad actualizada es usada en la segunda ecuación. Esta

fórmula es llamada método de Euler-Cromer3 . El error de truncamiento es aún del orden
de O(τ 2 ), no parece que hemos ganado mucho. Veremos que esta forma es marcadamente
superior al método de Euler en algunos casos.
En el método del punto medio usamos
~vn+1 = ~vn + τ~an , (8.22)

~vn+1 + ~vn
~rn+1 = ~rn + τ . (8.23)
2
Notemos que hemos promediado las dos velocidades. Usando la ecuación para la velocidad
en la ecuación de la posición, vemos que
1
~rn+1 = ~rn + τ~vn + ~an τ 2 , (8.24)
2
lo cual realmente hace esto lucir atractivo. El error de truncamiento es aún del orden de
τ 2 en la ecuación velocidad, pero para la posición el error de truncamiento es ahora τ 3 .
Realmente, para el movimiento de proyectiles este método trabaja mejor que los otros dos.
Infortunadamente, en otros sistemas fı́sicos este método da pobres resultados.
8.1.5. Errores locales, errores globales y elección del paso de tiem-

po.
Para juzgar la precisión de estos métodos necesitamos distinguir entre errores de trun-
camiento locales y globales. Hasta ahora, el error de truncamiento que hemos discutido ha
3
A. Cromer, “Stable solutions using the Euler approximation”, Am. J. Phys., 49 455-9 (1981).
sido el error local, el error cometido en un único paso de tiempo. En un problema tı́pico
nosotros deseamos evaluar la trayectoria desde t = 0 a t = T . El número de pasos de tiempo
es NT = T /τ ; notemos que si reducimos τ , debemos tomar más pasos. Si el error local es
O(τ n ), entonces estimamos el error global como
error global ∝ NT × (error local)

T (8.25)
= NT O(τ n ) = O(τ n ) = T O(τ n−1 ) .
τ
Por ejemplo, el método de Euler tiene un error local de truncamiento de O(τ 2 ), pero un error
global de truncamiento de O(τ ). Por supuesto, este análisis nos da sólo una estimación ya que
no sabemos si los errores locales se acumularán o se cancelarán (i.e. interferencia constructiva
o destructiva). El verdadero error global para un esquema numérico es altamente dependiente
del problema que se está estudiando.
Una pregunta que siempre aparece es ¿cómo elegir el τ ? Tratemos de responderla. Primero,
supongamos que los errores de redondeo son despreciables tal que sólo debemos preocuparnos
por los errores de truncamiento. Desde (8.10) y (8.16), el error local de truncamiento en el
cálculo de la posición usando el método de Euler es aproximadamente τ 2 r′′ = τ 2 a. Usando
sólo estimaciones del orden de magnitud, tomamos a ≈ 10 [m/s2 ], el error en un solo paso
en la posición es de 10−1 [m], cuando τ = 10−1 [s]. Si el tiempo de vuelo T ≈ 100 [s],
entonces el error global es del orden de metros. Si un error de esta magnitud es inaceptable
entonces debemos disminuir el paso en el tiempo. Finalmente usando un paso de tiempo
10−1 [s] no introducirı́amos ningún error significativo de redondeo dada la magnitud de los
otros parámetros del problema.
En el mundo real, a menudo no podemos hacer un análisis tan elegante por una variedad
de razones (ecuaciones complicadas, problemas con el redondeo, flojera, etc.). Sin embargo,
a menudo podemos usar la intuición fı́sica. Respóndase usted mismo “¿en qué escala de
tiempo el movimiento es casi lineal?”. Por ejemplo, para la trayectoria completa de una
pelota de baseball que es aproximadamente parabólica, el tiempo en el aire son unos pocos
segundos, entonces el movimiento es aproximadamente lineal sobre una escala de tiempo de
unos pocos centésimos de segundo. Para revisar nuestra intuición, nosotros podemos comparar
los resultados obtenidos usando τ = 10−1 [s] y τ = 10−2 [s] y, si ellos son suficientemente
cercanos, suponemos que todo está bien. A veces automatizamos la prueba de varios valores
de τ ; el programa es entonces llamado adaptativo (construiremos un programa de este tipo
más adelante). Como con cualquier método numérico, la aplicación ciega de esta técnica es
poco recomendada, aunque con sólo un poco de cuidado ésta puede ser usada exitosamente.
8.1.6. Programa de la pelota de baseball.

La tabla 8.1 bosqueja un simple programa, llamado balle, que usa el método de Euler
para calcular la trayectoria de una pelota de baseball. Antes de correr el programa, esta-
blezcamos algunos valores razonables para tomar como entradas. Una velocidad inicial de
| ~v1 | =15 [m/s] nos da una pelota que le han pegado débilmente. Partiendo del origen y
despreciando la resistencia del aire, el tiempo de vuelo es de 2.2 [s], y el alcance horizontal
es sobre los 23 [m] cuando el ángulo inicial θ = 45◦ . A continuación, mostramos la salida a
pantalla del programa balle en C++ cuando es corrido bajo estas condiciones:
Fijar la posición inicial ~r0 y la velocidad inicial ~v0 de la pelota de baseball.
Fijar los parámetros fı́sicos ( m, Cd , etc.).
Iterar hasta que la bola golpée en el piso o el máximo número de pasos sea completado.
• Grabar posición (calculada y teórica) para graficar.

• Calcular la aceleración de la pelota de baseball.
• Calcular la nueva posición y velocidad, ~rn+1 y ~vn+1 , Usando el método de Euler,
(8.18) y (8.19).
• Si la pelota alcanza el suelo (y < 0) para la iteración.
Imprimir el alcance máximo y el tiempo de vuelo.
Graficar la trayectoria de la pelota de baseball.
Cuadro 8.1: Bosquejo del programa balle, el cual calcula la trayectoria de una pelota de
baseball usando el método de Euler.
Movimiento de Proyectil
Método de Euler
Teoría (sin aire)
6
4
Altura [m]
0 5 10 15 20 25
Alcance [m]
Figura 8.2: Salida del programa balle para una altura inicial de 0 [m], una velocidad inicial
de 15 [m/s], y un paso de tiempo τ =0.1 [s]. No hay resistencia del aire. La lı́nea continua es
la teórica y los puntos son los calculados, la diferencia se debe a errores de truncamiento.
jrogan@huelen:~/programas$ balle
Ingrese la altura inicial [m] : 0
Ingrese la velocidad inicial [m/s]: 15
Ingrese angulo inicial (grados): 45
Ingrese el paso en el tiempo, tau en [s]: 0.1

Tiempo de vuelo: 2.2
Alcance: 24.3952
La salida en Octave debiera ser muy similar.

La trayectoria calculada por el programa es mostrada en la figura 8.2. Usando un paso
de τ = 0.1 [s], el error en el alcance horizontal es sobre un metro, como esperábamos del
error de truncamiento. A velocidades bajas los resultados no son muy diferentes si incluimos
la resistencia con el aire, ya que |F~a (~v1 )|/m ≈ g/7.
Ahora tratemos de batear un cuadrangular. Consideremos una velocidad inicial grande
| v1 | = 50 [m/s]. Debido a la resistencia, encontramos que el alcance es reducido a alrededor
de 125 [m], menos de la mitad de su máximo teórico. La trayectoria es mostrada figura 8.3,
notemos cómo se aparta de la forma parabólica.
En nuestras ecuaciones para el vuelo de una pelota de baseball no hemos incluido todos
los factores en el problema. El coeficiente de arrastre no es constante sino más bien una
complicada función de la velocidad. Además, la rotación de la pelota ayuda a levantar la
pelota (efecto Magnus).
Movimiento de Proyectil
Método de Euler
Teoría (sin aire)
60
40
Altura [m]
20
0
0 50 100 150 200 250
Alcance [m]
Figura 8.3: Salida del programa balle para una altura inicial de 1 [m], una velocidad inicial
de 50 [m/s], y un paso de tiempo τ =0.1 [s]. Con resistencia del aire.
8.2. Péndulo simple.

El movimiento de los péndulos ha fascinado a fı́sicos desde que Galileo fue hipnotizado
por la lámpara en la Catedral de Pisa. El problema es tratado en los textos de mecánica
básica pero antes de apresurarnos a calcular con el computador, revisemos algunos resultados
8.2. PÉNDULO SIMPLE. 243
básicos. Para un péndulo simple es más conveniente describir la posición en términos del
desplazamiento angular, θ(t). La ecuación de movimiento es
d2 θ g
2
= − sen θ , (8.26)
dt L
donde L es la longitud del brazo y g es la aceleración de gravedad. En la aproximación para
ángulo pequeño, sen θ ≈ θ, la ecuación (8.26) se simplifica a
d2 θ g
2
=− θ. (8.27)
dt L
Esta ecuación diferencial ordinaria es fácilmente resuelta para obtener

2πt
θ(t) = C1 cos + C2 , (8.28)
Ts
donde las constantes C1 y C2 están determinadas por los valores iniciales de θ y ω = dθ/dt.
El perı́odo para ángulos pequeños, Ts es
s
L
Ts = 2π . (8.29)
g
Esta aproximación es razonablemente buena para oscilaciones con amplitudes menores o

iguales a 20◦ .
Sin la aproximación para ángulos pequeños, la ecuación de movimiento es más difı́cil de
resolver. Sin embargo, sabemos de la experiencia que el movimiento es todavı́a periódico. En
efecto, es posible obtener una expresión para el perı́odo sin resolver explı́citamente θ(t). La
energı́a total es
1
E = mL2 ω 2 − mgL cos θ , (8.30)
2
donde m es la masa de la lenteja. La energı́a total es conservada e igual a E = −mgL cos θm ,
donde θm es el ángulo máximo. De lo anterior, tenemos
1
mL2 ω 2 − mgL cos θ = −mgL cos θm , (8.31)
2
o
2g
ω2 = (cos θ − cos θm ) . (8.32)
L
Ya que ω = dθ/dt,
dθ
dt = r . (8.33)
2g
(cos θ − cos θm )
L
En un perı́odo el péndulo se balancea de θ = θm a θ = −θm y regresa a θ = θm . Ası́, en medio
perı́odo el péndulo se balancea desde θ = θm a θ = −θm . Por último, por el mismo argumento,
en un cuarto de perı́odo el péndulo se balancea desde θ = θm a θ = 0, ası́ integrando ambos

lados de la ecuación (8.33)
s Z
T L θm dθ
= p . (8.34)
4 2g 0 (cos θ − cos θm )
Esta integral podrı́a ser reescrita en términos de funciones especiales usando la identidad
cos 2θ = 1 − 2 sen2 θ, tal que
s Z
L θm dθ
T =2 p . (8.35)
g 0 (sen2 θm /2 − sen2 θ/2)
Introduciendo K(x), la integral elı́ptica completa de primera especie,4

Z π/2
dz
K(x) ≡ √ , (8.36)
0 1 − x2 sen2 z
podrı́amos escribir el perı́odo como
s
L
T =4 K(sen θm /2) , (8.37)
g
usando el cambio de variable sen z = sen(θ/2)/ sen(θm /2). Para valores pequeños de θm ,
podrı́amos expandir K(x) para obtener
s
L 1 2
T = 2π 1+ θ + ... . (8.38)
g 16 m
Note que el primer término es la aproximación para ángulo pequeño (8.29).
8.2.2. Fórmulas para la derivada centrada.

Antes de programar el problema del péndulo miremos un par de otros esquemas para
calcular el movimiento de un objeto. El método de Euler está basado en la formulación de la
derivada derecha para df /dt dado por (8.7). Una definición equivalente para la derivada es
f (t + τ ) − f (t − τ )
f ′ (t) = lı́m . (8.39)
τ →0 2τ
Esta fórmula se dice centrada en t. Mientras esta fórmula parece muy similar a la ecuación
(8.7), hay una gran diferencia cuando τ es finito. Nuevamente, usando la expansión de Taylor,
1 1
f (t + τ ) = f (t) + τ f ′ (t) + τ 2 f ′′ (t) + τ 3 f (3) (ζ+ ) , (8.40)
2 6
1 1
f (t − τ ) = f (t) − τ f ′ (t) + τ 2 f ′′ (t) − τ 3 f (3) (ζ− ) , (8.41)
2 6
4
I.S. Gradshteyn and I.M. Ryzhik, Table of Integral, Series and Products (New York: Academic Press,
1965)
donde f (3) es la tercera derivada de f (t) y ζ± es un valor ente t y t ± τ . Restando las dos
ecuaciones anteriores y reordenando tenemos,
f (t + τ ) − f (t − τ ) 1 2 (3)
f ′ (t) = − τ f (ζ) , (8.42)
2τ 6
donde f (3) (ζ) = (f (3) (ζ+ ) + f (3) (ζ− ))/2 y t − τ ≤ ζ ≤ t + τ . Esta es la aproximación en la
primera derivada centrada. El punto clave es que el error de truncamiento es ahora cuadrático
en τ , lo cual es un gran progreso sobre la aproximación de las derivadas adelantadas que tiene
un error de truncamiento O(τ ).
Usando las expansiones de Taylor para f (t + τ ) y f (t − τ ) podemos construir una fórmula
centrada para la segunda derivada. La que tiene la forma
f (t + τ ) + f (t − τ ) − 2f (t) 1
f ′′ (t) = 2
− τ 2 f (4) (ζ) , (8.43)
τ 12
donde t − τ ≤ ζ ≤ t + τ . De nuevo, el error de truncamiento es cuadrático en τ . La mejor
manera de entender esta fórmula es pensar que la segunda derivada está compuesta de una
derivada derecha y de una derivada izquierda, cada una con incrementos de τ /2.
Usted podrı́a pensar que el próximo paso serı́a preparar fórmulas más complicadas que
tengan errores de truncamiento aún más pequeños, quizás usando ambas f (t ± τ ) y f (t ± 2τ ).
Aunque tales fórmulas existen y son ocasionalmente usadas, las ecuaciones (8.10), (8.42) y
(8.43) sirven como el “caballo de trabajo” para calcular las derivadas primera y segunda.
8.2.3. Métodos del “salto de la rana” y de Verlet.

Para el péndulo, las posiciones y velocidades generalizadas son θ y ω, pero para mantener
la misma notación anterior trabajaremos con ~r y ~v . Comenzaremos de las ecuaciones de
movimiento escritas como
d~v
= ~a(~r(t)) , (8.44)
dt
d~r
= ~v (t) . (8.45)
dt
Note que explı́citamente escribimos la aceleración dependiente solamente de la posición. Dis-
cretizando la derivada temporal usando la aproximación de derivada centrada da,
~v (t + τ ) − ~v (t − τ )
+ O(τ 2 ) = ~a(~r(t)) , (8.46)
2τ
para la ecuación de la velocidad. Note que aunque los valores de velocidad son evaluados en
t + τ y t − τ , la aceleración es evaluada en el tiempo t.
Por razones que pronto serán claras, la discretización de la ecuación de posición estará cen-
trada entre t + 2τ y t,
~r(t + 2τ ) − ~r(t)
+ O(τ 2 ) = ~v (t + τ ) . (8.47)
2τ
De nuevo usamos la notación fn ≡ f (t = nτ ), en la cual las ecuaciones (8.47) y (8.46) son

escritas como,
~vn+1 − ~vn−1
+ O(τ 2 ) = ~a(~rn ) , (8.48)
2τ
~rn+2 − ~rn
+ O(τ 2 ) = ~vn+1 . (8.49)
2τ
Reordenando los términos para obtener los valores futuros a la izquierda,
~vn+1 = ~vn−1 + 2τ~a(~rn ) + O(τ 3 ) , (8.50)

~rn+2 = ~rn + 2τ~vn+1 + O(τ 3 ) . (8.51)
Este es el método del “salto de la rana” (leap frog). Naturalmente, cuando el método es usado
en un programa, el término O(τ 3 ) no va y por lo tanto constituye el error de truncamiento
para el método.
El nombre “salto de la rana” es usado ya que la solución avanza en pasos de 2τ , con la
posición evaluada en valores pares (~r0 , ~r2 , ~r4 , . . . ), mientras que la velocidad está calculada en
los valores impares (~v1 , ~v3 , ~v5 , . . . ). Este entrelazamiento es necesario ya que la aceleración,
la cual es una función de la posición, necesita ser evaluada en un tiempo que está centrado
entre la velocidad nueva y la antigua. Algunas veces el esquema del “salto de la rana” es
formulado como
~vn+1/2 = ~vn−1/2 + τ~a(~rn ) , (8.52)

~rn+1 = ~rn + τ~vn+1/2 , (8.53)
con ~vn±1/2 ≡ ~v (t = (n ± 1/2)τ ). En esta forma, el esquema es funcionalmente equivalente al

método de Euler-Cromer.
Para el último esquema numérico de este capı́tulo tomaremos una aproximación diferente
y empezaremos con,
d~r
= ~v (t) , (8.54)
dt
d2~r
= ~a(~r) . (8.55)
dt2
Usando las fórmulas diferenciales centradas para la primera y segunda derivada, tenemos
~rn+1 − ~rn−1
+ O(τ 2 ) = ~vn , (8.56)
2τ
~rn+1 + ~rn−1 − 2~rn
2
+ O(τ 2 ) = ~an , (8.57)
τ
donde ~an ≡ ~a(~rn ). Reordenando términos,
~rn+1 − ~rn−1
~vn = + O(τ 2 ) , (8.58)
2τ
~rn+1 = 2~rn − ~rn−1 + τ 2~an + O(τ 4 ) . (8.59)
Estas ecuaciones, conocidas como el método de Verlet 5 , podrı́an parecer extrañas a pri-
mera vista, pero ellas son fáciles de usar. Suponga que conocemos ~r0 y ~r1 ; usando la ecuación
(8.59), obtenemos ~r2 . Conociendo ~r1 y ~r2 podrı́amos ahora calcular ~r3 , luego usando la ecua-
ción (8.58) obtenemos ~v2 , y ası́ sucesivamente.
Los métodos del “salto de la rana” y de Verlet tienen la desventaja que no son “autoini-
ciados”. Usualmente tenemos las condiciones iniciales ~r0 = ~r(t = 0) y ~v0 = ~v (t = 0), pero no
~v−1 = ~v (t = −τ ) [necesitado por el “salto de la rana” en la ecuación (8.50)] o ~r−1 = ~r(t = −τ )
[necesitado por Verlet en la ecuación (8.59)]. Este es el precio que hay que pagar para los
esquemas centrados en el tiempo.
Para lograr que estos métodos partan, tenemos una variedad de opciones. El método de
Euler-Cromer, usando la ecuación (8.53), toma ~v1/2 = ~v1 , lo cual es simple pero no muy
preciso. Una alternativa es usar otro esquema para lograr que las cosas partan, por ejemplo,
en el “salto de la rana” uno podrı́a tomar un paso tipo Euler para atrás, ~v−1 = ~v0 − τ~a0 .
Algunas precauciones deberı́an ser tomadas en este primer paso para preservar la precisión
del método; usando
τ2
~r−1 = ~r0 − τ~v0 + ~a(~r0 ) , (8.60)
2
es una buena manera de comenzar el método de Verlet.
Además de su simplicidad, el método del “salto de la rana” tiene propiedades favorables
(e.g. conservación de la energı́a). El método de Verlet tiene muchas ventajas. Primero, la
ecuación de posición tiene un error de truncamiento menor que otros métodos. Segundo, si la
fuerza es solamente una función de la posición y si nos preocupamos sólo de la trayectoria de
la partı́cula y no de su velocidad (como en muchos problemas de mecánica celeste), podemos
saltarnos completamente el cálculo de velocidad. El método es popular para el cálculo de las
trayectorias en sistemas con muchas partı́culas, e.g., el estudio de fluidos a nivel microscópico.
El algoritmo de Verlet, recien visto, no incorpora la velocidad en forma explı́cita. Una
variante, conocida como velocity Verlet, lo hace explı́citamente
1
~rn+1 = ~rn + τ~vn + τ 2~a(~rn ) (8.61)
2
τ
~vn+1 = ~vn + [~a(~rn ) + ~a(~rn+1 )] . (8.62)
2
Sin embargo, en ambas versiones del algoritmo sólo se consideran aceleraciones que de-
penden de las posiciones. Para enfretar un problema con aceleraciones que dependen tanto
de las posiciones como de las velocidades hay que usar la variante desarrollada por Martys y
Mountain de velocity Verlet 6 :
1
~rn+1 = ~rn + τ~vn + τ 2~a(~rn , ~vn ) (8.63)
2
~rn+1 − ~rn
~un+1/2 = (8.64)
τ
τ
~vn+1 = ~vn + ~a(~rn , ~vn ) + ~a(~rn+1 , ~un+1/2 ) , (8.65)
2
5
L. Verlet, “Computer experiments on classical fluid I. Thermodynamical properties of Lennard-Jones
molecules”, Phys. Rev. 159, 98-103 (1967).
6
N.S. Martys & R.D. Mountain, “Velocity Verlet algorithm for dissipative-particle-dynamics-based models
of suspensions”, Phys. Rev. E 59, 3733 (1999).
Seleccionar el método a usar: Euler o Verlet.
Fijar la posición inicial θ0 y la velocidad ω0 = 0 del péndulo.
Fijar los parámetros fı́sicos y otras variables.
Tomar un paso para atrás para partir Verlet; ver ecuación (8.60).
Iterar sobre el número deseado de pasos con el paso de tiempo y método numérico dado.
• Grabar ángulo y tiempo para graficar.

• Calcular la nueva posición y velocidad usando el método de Euler o de Verlet.
• Comprobar si el péndulo a pasado a través de θ = 0; si es ası́ usar el tiempo
transcurrido para estimar el perı́odo.
Estima el perı́odo de oscilación, incluyendo barra de error.
Graficar las oscilaciones como θ versus t.
Cuadro 8.2: Bosquejo del programa péndulo, el cual calcula el tiempo de evolución de un
péndulo simple usando el método de Euler o Verlet.
8.2.4. Programa de péndulo simple.

Las ecuaciones de movimiento para un péndulo simple son
dω dθ
= α(θ) =ω , (8.66)
dt dt
donde la aceleración angular α(θ) = −g sen θ/L. El método de Euler para resolver estas
ecuaciones diferenciales ordinarias es iterar las ecuaciones:
θn+1 = θn + τ ωn , (8.67)
ωn+1 = ωn + τ αn . (8.68)
Si estamos interesados solamente en el ángulo y no la velocidad, el método de Verlet sólo usa

la ecuación
θn+1 = 2θn − θn−1 + τ 2 αn . (8.69)
En vez de usar las unidades SI, usaremos las unidades adimensionales naturales del pro-
blema. Hay solamente dos parámetros en el problema, g y L y ellos siempre aparecen en la
razón g/L. Fijando esta razón a la unidad, el perı́odo para pequeñas amplitudes Ts = 2π.
En otras palabras, necesitamos solamente una unidad en el problema: una escala de tiempo.
Ajustamos nuestra unidad de tiempo tal que el perı́odo de pequeñas amplitudes sea 2π.
La tabla 8.2 presenta un bosquejo del programa pendulo, el cual calcula el movimiento
de un péndulo simple usando o el método de Euler o el de Verlet. El programa estima el
perı́odo por registrar cuando el ángulo cambia de signo; esto es verificar si θn y θn+1 tienen
signos opuestos probando si θn ∗ θn+1 < 0. Cada cambio de signo da una estimación para el
perı́odo, T̃k = 2τ (nk+1 − nk ), donde nk es el paso de tiempo en el cual el k-ésimo cambio de
signo ocurre. El perı́odo estimado de cada inversión de signo es registrado, y el valor medio
calculado como
M
D E 1 X
T̃ = T̃k , (8.70)
M k=1
donde M es el número de veces que

√ T̃ es evaluado. La barra de error para esta medición del
perı́odo es estimada como σ = s/ M , donde
v
u M
u 1 X D E2
s=t T̃k − T̃ , (8.71)
M − 1 k=1
es la desviación estándar de la muestra T̃ . Note que cuando el número de medidas se incre-

menta, la desviación estándar de la muestra tiende a una constante, mientras que la barra
de error estimado decrece.
Para comprobar el programa pendulo, primero tratamos con ángulos iniciales pequeños,
θm , ya que conocemos el perı́odo T ≈ 2π. Tomando τ = 0.1 tendremos sobre 60 puntos
por oscilación; tomando 300 pasos deberı́amos tener como cinco oscilaciones. Para θm = 10◦ ,
el método de Euler calcula un perı́odo estimado de hT̃ i = 6.375 ± 0.025 sobre un 1.5 %
mayor que el esperado T = 2π(1.002) dado por la ecuación (8.38). Nuestro error estimado
para el perı́odo es entorno a ±τ en cada medida. Cinco oscilaciones √ son 9 medidas de T̃ ,
ası́ que nuestro error estimado para el perı́odo deberı́a ser (τ /2)/ 9 ≈ 0.02. Notemos que la
estimación está en buen acuerdo con los resultados obtenidos usando la desviación estándar.
Hasta aquı́ todo parece razonable.
Infortunadamente si miramos el gráfico 8.4 nos muestra los problemas del método de Euler.
La amplitud de oscilación crece con el tiempo. Ya que la energı́a es proporcional al ángulo
máximo, esto significa que la energı́a total se incrementa en el tiempo. El error global de
truncamiento en el método de Euler se acumula en este caso. Para pasos de tiempos pequeños
τ = 0.05 e incrementos en el número de pasos (600) podemos mejorar los resultados, ver figura
8.5, pero no eliminamos el error. El método del punto medio tiene la misma inestabilidad
numérica.
Usando el método de Verlet con θm = 10◦ , el paso en el tiempo τ = 0.1 y 300 iteraciones
obtenemos los resultados graficados en 8.5. Estos resultados son mucho mejores; la amplitud
de oscilación se mantiene cerca de los 10◦ y hT̃ i = 6.275 ± 0.037. Afortunadamente el método
de Verlet, el del “salto de rana” y el de Euler-Cromer no sufren de la inestabilidad numérica
encontrada al usar el método de Euler.
Para θm = 90◦ , la primera corrección para la aproximación de ángulo pequeño, ecuación
(8.38), da T = 7.252. Usando el método de Verlet, el programa da un perı́odo estimado de
hT̃ i = 7.414 ± 0.014, lo cual indica que (8.38) es una buena aproximación (alrededor de un
2 % de error), aún para ángulos grandes. Para el ángulo muy grande de θm = 170◦ , vemos
la trayectoria en la figura 8.6. Notemos como la curva tiende a aplanarse en los puntos de
retorno. En este caso el perı́odo estimado es hT̃ i = 15.3333 ± 0.0667, mientras que (8.38) da
40
30
20
10
Angulo [grados]
−10
−20
−30
−40
−50
0 5 10 15 20 25 30
Tiempo
Figura 8.4: Salida del programa péndulo usando el método de Euler. El ángulo inicial es
θm = 10◦ , el paso en el tiempo es τ = 0.1, y 300 iteraciones fueron calculadas.
20
15
10
5
Angulo [grados]
−5
−10
−15
−20
−25
0 5 10 15 20 25 30
Tiempo
Figura 8.5: Salida del programa péndulo usando el método de Euler. El ángulo inicial es
θm = 10◦ , el paso en el tiempo es τ = 0.05 y 600 iteraciones fueron calculadas.
T = 9.740, indicando que esta aproximación para (8.37) deja de ser válida para este ángulo
tan grande.
15
10
Angulo [grados]
−5
−10
−15
0 5 10 15 20 25 30
Tiempo
Figura 8.6: Salida del programa péndulo usando el método de Verlet. El ángulo inicial es
200
150
100
Angulo [grados]
50
−50
−100
−150
−200
0 5 10 15 20 25 30
Tiempo
Figura 8.7: Salida del programa péndulo usando el método de Verlet. El ángulo inicial es
8.3. Listado de los programas en python.
8.3.1. balle.py
# -*- coding: iso-8859-1 -*-
import math
from pylab import *
def main():
Cd=0.35
rho=1.293 # [kg/m^3]
radio=0.037 # [m]
A=math.pi*radio*radio
m=0.145 # [kg]
g=9.8 # [m/s^2]
a=-Cd*rho*A/(2.0*m)
salida=open("salida.txt", "w")
salidaT=open("salidaT.txt", "w")
x0=0
y0=input("Ingrese la altura inicial [m] :")
v0=input("Ingrese la velocidad inicial [m/s]:")
theta0=input("Ingrese el angulo inicial (grados):")
flagRA=2
while flagRA !=0 and flagRA !=1:

flagRA=input("Con resistencia del aire, Si=1, No=0: ")
tau=input("Ingrese el paso en el tiempo, tau en [s]: ")
vxn=v0*math.cos(math.pi*theta0/180.0)
vyn=v0*math.sin(math.pi*theta0/180.0)
xn=x0
yn=y0
tiempo = -tau
l_xT=[]
l_yT=[]
l_xn=[]
l_yn=[]
while yn >= y0:
8.3. LISTADO DE LOS PROGRAMAS EN PYTHON. 253
tiempo = tiempo+tau
aux_c=math.cos(math.pi*theta0/180.0)
aux_s=math.sin(math.pi*theta0/180.0)
l_xT.append(x0+v0*aux_c*tiempo)
l_yT.append(y0+v0*aux_s*tiempo-g*tiempo*tiempo/2.0)
l_xn.append(xn)
l_yn.append(yn)
print >> salidaT,x0+v0*aux_c*tiempo,

print >> salidaT,y0+v0*aux_s*tiempo-g*tiempo*tiempo/2.0
print >> salida, xn, yn
if flagRA==0:
a=0.0
v=math.sqrt(vxn*vxn + vyn*vyn)
axn=a*v*vxn
ayn=a*v*vyn - g
xnp1 = xn + tau * vxn
ynp1 = yn + tau * vyn
vxnp1 = vxn + tau*axn
vynp1 = vyn + tau*ayn
vxn=vxnp1
vyn=vynp1
xn=xnp1
yn=ynp1
print "Tiempo de vuelo: ",tiempo

print "Alcance: ",xn
salida.close()
salidaT.close()
plot(l_xn, l_yn,’ro’,l_xT, l_yT,linewidth=1.0)

title("Trayectoria de balle")
grid(True)
show()
#
main()
8.3.2. pendulo.py
# -*- coding: iso-8859-1 -*-
import math
from matplotlib import rc
from pylab import *
rc(’text’, usetex=True)
def main():
respuesta = 2
while respuesta !=0 and respuesta != 1:
respuesta = input("Elija el metodo Euler=0 o Verlet=1 : ")
omega1=0
theta1=input("Ingrese el angulo inicial (en grados) : ")
theta1*=math.pi/180.0
tau = input("Ingrese el paso del tiempo : ")
pasos = input("Ingrese el numero de pasos : ")
periodo = []
salida = open("salidaPendulo.txt", "w")
theta0=theta1-tau*omega1-tau*tau*math.sin(theta1)
thetaNm1=theta0
thetaN=theta1
omegaN=omega1
nK=1
M=0
l_t=[]
l_theta=[]
for i in range(1,pasos):
alphaN=-math.sin(thetaN)
if respuesta==0: # Euler
thetaNp1=thetaN+tau*omegaN
omegaNp1=omegaN+tau*alphaN
else: # Verlet
thetaNp1=2.0*thetaN-thetaNm1+tau*tau*alphaN
omegaNp1=0.0 #solo por completitud
8.3. LISTADO DE LOS PROGRAMAS EN PYTHON. 255
l_t.append((i-1)*tau)
l_theta.append(thetaNp1*180/math.pi)
print >> salida, (i-1)*tau,thetaNp1*180/math.pi
if thetaNp1*thetaN<0:
if M==0:
M+=1
periodo.append(0.0)
nK=i
else:
M+=1
periodo.append(2.0*tau*(i-nK))
nK=i
thetaNm1=thetaN
thetaN=thetaNp1
omegaN=omegaNp1
Tprom=0
for i in range(1,M):
Tprom += periodo[i]
Tprom /= float(M-1)
ssr=0
for i in range(1,M):
ssr+=(periodo[i]-Tprom)*(periodo[i]-Tprom)
ssr/=float(M-2)
sigma=math.sqrt(ssr/float(M-1))
print "Periodo = ", Tprom, "+/-", sigma
salida.close()
plot(l_t, l_theta,’ro’)
xlabel(r’\textbf{\Large Tiempo (s)}’)
ylabel(r’\textbf{\Large\’Angulo (grados)}’)
title(r’\textbf{\Huge P\’endulo no lineal}’)
grid(True)
show()
#
main()
8.4. Listado de los programas en c++.
8.4.1. balle.cc
int main()
{
const double Cd=0.35;
const double rho=1.293; // [kg/m^3]
const double radio=0.037; // [m]
double A= M_PI*radio*radio ;
double m=0.145; // [kg]
double g=9.8; // [m/s^2]
double a = -Cd*rho*A/(2.0e0*m) ;
double v0, theta0, tau;

ofstream salida ("salida.txt") ;
ofstream salidaT ("salidaT.txt") ;
double x0, y0;

x0=0.0e0 ;
cout << "Ingrese la altura inicial [m] : ";
cin >> y0;
cout << "Ingrese la velocidad inicial [m/s]: ";
cin >> v0;
cout <<"Ingrese angulo inicial (grados): ";
cin >> theta0;
int flagRA = 2 ;
while (flagRA!=0 && flagRA !=1) {
cout <<"Con resistencia del aire, Si= 1, No= 0: ";
cin >> flagRA;
}
cout <<"Ingrese el paso en el tiempo, tau en [s]: ";
cin >> tau ;
double vxn=v0*cos(M_PI*theta0/180.0) ;
double vyn=v0*sin(M_PI*theta0/180.0) ;
double xn=x0 ;
double yn=y0 ;
double tiempo = -tau;
while( yn >= y0) {
tiempo +=tau ;
salidaT << x0+v0*cos(M_PI*theta0/180.0) *tiempo <<" " ;
salidaT << y0+v0*sin(M_PI*theta0/180.0) *tiempo -g*tiempo*tiempo/2.0e0<< endl;
8.4. LISTADO DE LOS PROGRAMAS EN C++. 257
salida << xn << " " << yn << endl;

if(flagRA==0) a=0.0e0 ;
double v=sqrt(vxn*vxn+vyn*vyn) ;
double axn= a*v*vxn ;
double ayn= a*v*vyn -g ;
double xnp1 = xn + tau*vxn ;
double ynp1 = yn + tau*vyn ;
double vxnp1 = vxn + tau*axn;
double vynp1 = vyn + tau*ayn;
vxn=vxnp1;
vyn=vynp1;
xn=xnp1 ;
yn=ynp1 ;
}
cout << "Tiempo de vuelo: " << tiempo<< endl;
cout << "Alcance: " << xn<<endl;
salida.close();
salidaT.close();
return 0;
}
8.4.2. pendulo.cc
int main()
{
int respuesta=2 ;
while(respuesta != 0 && respuesta !=1 ) {
cout << "Elija el metodo: Euler=0 y Verlet=1 : " ;
cin >> respuesta ;
}
double theta1 ;
double omega1 = 0.0e0;
cout << "Ingrese el angulo inicial (grados): ";
cin >> theta1 ;
theta1*=M_PI/180.0e0 ;
double tau ;
cout << "Ingrese el paso de tiempo: ";
cin >> tau ;
int pasos ;
cout << "Ingrese el numero de pasos: ";
cin >> pasos ;
double * periodo = new double[pasos] ;

ofstream salida ("salidaPendulo.txt");
double theta0= theta1-tau*omega1-tau*tau*sin(theta1) ;
double thetaNm1=theta0 ;
double thetaN=theta1 ;
double omegaN=omega1;
double thetaNp1, omegaNp1 ;
int nK=1;
int M=0 ;
for(int i=1; i< pasos; i++) {

double alphaN=-sin(thetaN);
if(respuesta==0) { // Euler
thetaNp1=thetaN+tau*omegaN ;
omegaNp1=omegaN+tau*alphaN ;
} else {
thetaNp1=2.0e0*thetaN-thetaNm1+tau*tau*alphaN ;
}
salida << (i-1)*tau<<" " <<thetaNp1*180/M_PI<< endl ;
if (thetaNp1*thetaN<0) {
if(M==0) {
periodo[M++]=0.0e0;
nK=i ;
} else {
periodo[M++] = 2.0e0*tau*double(i-nK);
nK=i ;
}
}
thetaNm1=thetaN ;
thetaN=thetaNp1 ;
omegaN=omegaNp1 ;
}
double Tprom=0.0e0;
for (int i=1; i < M; i++) Tprom+=periodo[i] ;
Tprom/=double(M-1) ;
double ssr=0.0 ;
for (int i=1; i < M; i++) ssr+=(periodo[i]-Tprom)* (periodo[i]-Tprom);
ssr/=double(M-2);
double sigma =sqrt(ssr/double(M-1)) ;
cout <<" Periodo = "<< Tprom << "+/-"<< sigma << endl ;
8.4. LISTADO DE LOS PROGRAMAS EN C++. 259
salida.close() ;
delete [] periodo;
return 0;
}
Capı́tulo 9
Ecuaciones Diferenciales
Ordinarias II: Métodos Avanzados.
versión final 4.0, 22 Noviembre 20071
En el capı́tulo anterior aprendimos cómo resolver ecuaciones diferenciales ordinarias usan-

do algunos métodos simples. En este capı́tulo haremos algo de mecánica celeste básica co-
menzando con el problema de Kepler. Al calcular la órbita de un satélite pequeño alrededor
de un cuerpo masivo (e.g un cometa orbitando el Sol), descubriremos que métodos mucho
más sofisticados son necesarios para manipular sistemas simples de dos cuerpos.
9.1. Órbitas de cometas.

Considere el problema de Kepler en el cual un pequeño satélite, tal como un cometa, orbita
el Sol. Usamos un sistema de coordenadas Copernicano y fijamos el Sol en el origen. Por ahora,
consideremos solamente la fuerza gravitacional entre el cometa y el Sol, y despreciemos todas
las otras fuerzas (e.g., fuerzas debidas a los planetas, viento solar). La fuerza sobre el cometa
es
GmM
F~ = − ~r , (9.1)
| ~r |3
donde ~r es la posición del cometa, m es su masa, M = 1.99 × 1030 [kg] es la masa del Sol, y
G = 6.67 × 10−11 [m3 /kg s2 ] es la constante gravitacional.
Las unidades naturales de longitud y tiempo para este problema no son metros ni segun-
dos. Como unidad de distancia usaremos la unidad astronómica [AU], 1 AU=1.496×1011 [m],
la cual es igual a la distancia media de la Tierra al Sol. La unidad de tiempo será el [año]
AU (el perı́odo de una órbita circular de radio 1 [AU]). En estas unidades, el producto
GM = 4π 2 [AU3 /año2 ]. Tomaremos la masa del cometa, m, como la unidad; en unidades
MKS la masa tı́pica de un cometa es 1015±3 [kg].
Ahora tenemos suficiente para ensamblar nuestro programa, pero antes hagamos una
rápida revisión de lo que sabemos de órbitas. Para un tratamiento completo podemos recurrir
1
Este capı́tulo está basado en el tercer capı́tulo del libro: Numerical Methods for Physics, second edition
de Alejandro L. Garcia, editorial Prentice Hall.
261
262 CAPÍTULO 9. EDO II: MÉTODOS AVANZADOS.
a algunos textos de mecánica estándar, tales como Symon2 o Landau y Lifshitz3 . La energı́a
total del satélite es
1 GM m
E = mv 2 − , (9.2)
2 r
donde r = | ~r | y v = | ~v |. Esta energı́a total es conservada, tal como el momento angular,
~ = ~r × (m~v ) .
L (9.3)
Ya que este problema es bidimensional, consideraremos el movimiento en el plano x-y. El

único componente distinto de cero del momento angular está en la dirección z.
Cuando la órbita es circular, en el sistema de referencia que gira con el satélite, la fuerza
centrı́fuga es compensada por la fuerza gravitacional,
mv 2 GM m
= , (9.4)
r r2
o r
GM
v= . (9.5)
r
Por colocar algunos valores, en una órbita circular en r = 1 [AU] la velocidad orbital es v = 2π
[AU/año] (cerca de 30.000 [km/h]). Reemplazando la ecuación (9.5) en (9.2), la energı́a total
en una órbita circular es
GM m
E=− . (9.6)
2r
En una órbita elı́ptica, los semiejes mayores y menores, a y b, son desiguales (figura 9.1). La
y
q
2b
r
x
Q
2a
Figura 9.1: Órbita elı́ptica alrededor del Sol.
excentricidad, e, está definida como

r
b2
e= 1− . (9.7)
a2
2
K. Symon, Mechanics (Reading Mass.: Addison-Wesley, 1971).
3
L. Landau and E. Lifshitz, Mechanics (Oxford: Pergamon, 1976).
9.1. ÓRBITAS DE COMETAS. 263
Nombre del Cometa T [años] e q [AU] i Primera pasada

Encke 3.30 0.847 0.339 12.4◦ 1786
Biela 6.62 0.756 0.861 12.6◦ 1772
Schwassmann-Wachmann 1 16.10 0.132 5.540 9.5◦ 1925
Halley 76.03 0.967 0.587 162.2◦ 239 a.c.
Grigg-Mellish 164.3 0.969 0.923 109.8◦ 1742
Hale-Bopp 2508.0 0.995 0.913 89.4◦ 1995
Cuadro 9.1: Datos orbitales de algunos cometas.
La excentricidad de la Tierra es e = 0.017, por lo tanto esta órbita está muy cercana de ser
circular. La distancia del Sol al perihelio (punto de mayor aproximación) es q = (1 − e)a; la
distancia del Sol al afelio es Q = (1 + e)a.
La ecuación (9.6) también se mantiene para una órbita elı́ptica, si reemplazamos el radio
con el semieje mayor; por lo tanto la energı́a total es
GM m
E=− . (9.8)
2a
Note que E ≤ 0. De las ecuaciones (9.2) y (9.8), encontramos que la velocidad orbital como
función de la distancia radial es
s
2 1
v = GM − . (9.9)
r a
La velocidad es máxima en el perihelio y mı́nima en el afelio, la razón entre las velocidades

está dada por Q/q. Finalmente, usando la conservación de momento angular, podrı́amos
derivar la tercera ley de Kepler,
4π 2 3
T2 = a , (9.10)
GM
donde T es el perı́odo de la órbita.
Los datos orbitales para unos pocos cometas bien conocidos están dados en la tabla 9.1.
La inclinación, i, es el ángulo entre el plano orbital del cometa y el plano eclı́ptico (el plano
de la órbita de los planetas). Cuando la inclinación es menor que los 90◦ , se dice que la órbita
es directa, cuando es mayor que 90◦ , se dice que la órbita es retrógrada (i.e., orbita el Sol en
la dirección opuesta a la de los planetas).
9.1.2. Programa orbita.

Un programa simple, llamado orbita, que calcula las órbitas para el problema de Kepler
usando varios métodos numéricos es propuesto en la tabla 9.2. El método de Euler, descrito
en el capı́tulo anterior, calcula la trayectoria del cometa como
~rn+1 = ~rn + τ~vn , (9.11)

~vn+1 = ~vn + τ~a(~rn ) , (9.12)
Fijar la posición y velocidad inicial del cometa.
Fijar los parámetros fı́sicos (m, G, etc.).
Iterar sobre el número deseado de pasos usando el método numérico especificado.
• Grabar posición y la energı́a para graficar.

• Calcular la nueva posición y velocidad usando:
◦ Método de Euler (9.11), (9.12) o;
◦ Método de Euler-Cromer (9.13), (9.14) o;
◦ Método Runge-Kutta de cuarto orden (9.30), (9.31) o;
◦ Método de Runge-Kutta adaptativo.
Graficar la trayectoria del cometa.
Graficar la energı́a del cometa versus el tiempo.
Cuadro 9.2: Bosquejo del programa orbita, el cual calcula la trayectoria de un cometa usando
varios métodos numéricos.
donde ~a es la aceleración gravitacional. De nuevo, discretizamos el tiempo y usamos la nota-

ción fn ≡ f (t = (n − 1)τ ), donde τ es el paso tiempo.
El caso de prueba más simple es una órbita circular. Para un radio orbital de 1 [AU], la
ecuación (9.5) da una velocidad tangencial de 2π [AU/año]. Unos 50 puntos por revolución
orbital nos darı́a una suave curva, tal que τ = 0.02 [años] (o cercano a una semana) es
un paso de tiempo razonable. Con esos valores, el programa orbita usando el método de
Euler, da los resultados mostrados en la figura 9.2. Inmediatamente vemos que la órbita no es
circular, pero una espiral hacia fuera. La razón es clara desde el gráfico de energı́a; en vez de
ser constante, la energı́a total aumenta continuamente. Este tipo de inestabilidad se observa,
también, en el método de Euler para el péndulo simple. Afortunadamente hay una solución
simple a este problema: el método Euler-Cromer para calcular la trayectoria
~vn+1 = ~vn + τ~a(~rn ) , (9.13)
~rn+1 = ~rn + τ~vn+1 . (9.14)
Note que el sólo cambio del método de Euler en que primero calculamos la nueva velocidad,
~vn+1 , y luego la usamos en el cálculo de la nueva posición. Para las mismas condiciones
iniciales y paso de tiempo, el método de Euler-Cromer da resultados mucho mejores, como
los mostrados en la figura 9.3. La órbita es casi circular, y la energı́a total se conserva.
Las energı́as potencial y cinética no son constantes, pero este problema podrı́a ser mejorado
usando un paso de tiempo pequeño. El programa órbita también da la opción de usar el
método de Runge-Kutta, el cual es descrito en las próximas dos secciones.
Aunque el método de Euler-Cromer hace un buen trabajo para bajas excentricidades,
tiene problemas con órbitas más elı́pticas, como se muestra en la figura 9.4. Note que si la
9.1. ÓRBITAS DE COMETAS. 265
90 o
30
Energía Cinética
Energía Potencial
Energía [M AU*AU/año*año]
Energía Total
20
10
180o 0o
−10
−20
−30
−40
0 0.5 1 1.5 2 2.5 3 3.5 4
3 2 1 0 1 2 3
Distancia [AU] 270o Tiempo [años]
Figura 9.2: Gráfico de la trayectoria y la energı́a desde el programa orbita usando el método
de Euler. La distancia radial inicial es 1 [AU] y la velocidad tangencial inicial es 2π [AU/año].
El paso en el tiempo es τ = 0.02 [años]; y 200 pasos son calculados. Los resultados están en
desacuerdo con la predicción teórica de una órbita circular con energı́a total constante.
energı́a llega a ser positiva; el satélite alcanza la velocidad de escape. Si bajamos el paso de
tiempo desde τ = 0.02 [años] a τ = 0.005 [años] obtenemos mejores resultados, como los
mostrados en la figura 9.5. Estos resultados no son del todo perfectos; la órbita puede ser
una elipse cerrada, pero todavı́a tiene una notable deriva espúria.
En este punto usted se podrı́a estar preguntando, “¿Por qué estamos estudiando este
problema?, si la solución analı́tica es bien conocida”. Es verdad que hay problemas mecánicos
celestes más interesantes (e.g., el efecto de perturbaciones sobre la órbita, problema de tres
cuerpos). Sin embargo, antes de hacer los casos complicados podrı́amos, siempre, chequear
los algoritmos de problemas conocidos. Suponga que introducimos una pequeña fuerza de
arrastre sobre el cometa. Podrı́amos pecar de inocentes creyendo que la precisión de la figura
9.5 fue un fenómeno fı́sico más que un artefacto numérico.
Claramente, el método de Euler-Cromer hace un trabajo inaceptable de rastreo de las

órbitas más elı́pticas. Los resultados mejoran si achicamos el paso de tiempo, pero enton-
ces sólo podemos rastrear unas pocas órbitas. Suponga que deseamos rastrear cometas para
posibles impactos con la Tierra. Un gran cometa impactando sobre la Tierra serı́a más des-
tructivo que una guerra nuclear. Muchos cometas tienen órbitas extremadamente elı́pticas y
perı́odos de cientos de años. Esta amenaza desde el espacio exterior motiva nuestro estudio
de métodos más avanzados para resolver ecuaciones diferenciales ordinarias.
90 o
30
Energía [M AU*AU/año*año]
20
Energía Cinética
10
Energía Potencial
Energía Total
0
180o 0o −10
−20
−30
−40
−50
1.5 1 0.5 0 0.5 1 1.5 0 0.5 1 1.5 2 2.5 3 3.5 4
Distancia [AU] 270o Tiempo [años]
de Euler-Cromer. Los parámetros son los mismos que en la figura 9.2. Los resultados están en
un acuerdo cualitativo al menos con la predicción teórica de una órbita circular con energı́a
total constante.
90o
200 Energía Cinética

Energía [M AU*AU/años*años]
Energía Potencial
Energía Total
100
180 o 0o
0
−100
−200
270 o 0 1 2 3 4
30 20 10 0 10 20 30
Distancia [AU] Tiempo [años]
de Euler-Cromer. La distancia radial inicial es 1 [AU] y la velocidad tangencial inicial es
π [AU/año]. El paso en el tiempo es τ = 0.02 [años]; y 200 pasos son calculados. Debido al
error numérico el cometa alcanza la velocidad de escape, la posición final es 35 [AU] y la
energı́a total es positiva.
9.2. MÉTODOS DE RUNGE-KUTTA. 267
90 o
300
Energía Cinética
200 Energía Potencial
Energía Total
100
180o 0o 0
−100
−200
−300
270o
1 0.5 0 0.5 1 0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1
Distancia [AU] Tiempo [años]
de Euler-Cromer. Los parámetros son los mismos que en la figura 9.4 excepto que el paso de
tiempo es más pequeño τ = 0.005 [años]. Los resultados son mejores, pero aún presenta una
precesión espúria.
9.2. Métodos de Runge-Kutta.

9.2.1. Runge-Kutta de segundo orden.
Ahora miremos uno de los métodos más populares para resolver numéricamente las ecua-
ciones diferenciales ordinarias: Runge-Kutta. Primero trabajaremos las fórmulas generales de
Runge-Kutta y luego las aplicaremos especı́ficamente a nuestro problema del cometa. De esta
manera será fácil usar el método Runge-Kutta para otros sistemas fı́sicos. Nuestra ecuación
diferencial ordinaria general toma la forma
d~x
= f~(~x(t), t) , (9.15)
dt
donde el vector de estado x(t) = [x1 (t), x2 (t), . . . xN (t)] es la solución deseada. En el problema
de Kepler tenemos
~x(t) = [rx (t), ry (t), vx (t), vy (t)] , (9.16)
y

~ drx dry dvx dvy
f (~x(t), t) = , , , ,
dt dt dt dt (9.17)
= [vx (t), vy (t), Fx (t)/m, Fy (t)/m] ,
donde rx , vx , y Fx son las componentes x de la posición, la velocidad y la fuerza respectiva-

mente (y lo mismo para la componente y). Note que en el problema de Kepler, la función f
no depende explı́citamente del tiempo sino que sólo depende de ~x(t).
Nuestro punto de partida es el método simple de Euler; en forma vectorial podrı́a ser
escrito como
~x(t + τ ) = ~x(t) + τ f~(~x, t) . (9.18)
Consideremos la primera fórmula de Runge-Kutta:

1 1
~x(t + τ ) = ~x(t) + τ f~ ~x t + τ , t + τ ,
∗
(9.19)
2 2
donde
1 1
~x t + τ ≡ ~x(t) + τ f~(~x, t) .
∗
(9.20)
2 2
Para ver de dónde viene esta fórmula, consideremos por el momento el caso de una
variable. Sabemos que la expansión de Taylor
dx(ζ)
x(t + τ ) = x(t) + τ ,
dt (9.21)
= x(t) + τ f (x(ζ), ζ) ,
es exacta para algún valor de ς entre t y t + τ , como se vio en la ecuación (8.10). La fórmula
de Euler toma ς = t; Euler-Cromer usa ς = t en la ecuación de velocidad y ς = t + τ en la
ecuación de posición. Runge-Kutta usa ς = t+ 21 τ , lo cual pareciera ser una mejor estimación.
1

Sin embargo, x t + 2 τ no es conocida, podemos aproximarla de la manera simple: usando
1
un paso de Euler calculamos x t + 2 τ y usando esta como nuestra estimación de x t + 12 τ .
∗

A continuación un ejemplo simple usando la fórmula Runge-Kutta. Consideremos la ecua-

ción
dx
= −x , x(t = 0) = 1 . (9.22)
dt
La solución de la ecuación (9.22) es x(t) = e−t . Usando el método de Euler con un paso de
tiempo de τ = 0.1, tenemos
x(0.1) = 1 + 0.1(−1) = 0.9 ,
x(0.2) = 0.9 + (0.1)(−0.9) = 0.81 ,
x(0.3) = 0.81 + 0.1(−0.81) = 0.729 ,
x(0.4) = 0.729 + 0.1(−0.729) = 0.6561 .
Ahora tratemos con Runge-Kutta. Para hacer una correcta comparación usaremos un paso
de tiempo mayor para Runge-Kutta τ = 0.2 porque hace el doble de evaluaciones de f (x).
Por la fórmula de Runge-Kutta presentada arriba,
x∗ (0.1) = 1 + 0.1(−1) = 0.9 ,
x(0.2) = 1 + 0.2(−0.9) = 0.82 ,
x∗ (0.3) = 0.82 + 0.1(−0.82) = 0.738
x(0.4) = 0.82 + 0.2(−0.738) = 0.6724 .
Podemos comparar esto con la solución exacta x(0.4) = exp(−0.4) ≈ 0.6703. Claramente,
Runge-Kutta lo hace mucho mejor que Euler; los errores porcentuales absolutos son 0.3 % y
2.1 % respectivamente.
9.2.2. Fórmulas generales de Runge-Kutta.

La fórmula discutida arriba no es la única posible para un Runge-Kutta de segundo orden.
Aquı́ hay una alternativa:
1
~x(t + τ ) = ~x(t) + τ [f~(~x(t), t) + f~(~x ∗ (t + τ ), t + τ )] , (9.23)
2
donde
~x ∗ (t + τ ) ≡ ~x(t) + τ f~(~x(t), t) . (9.24)
Para entender este esquema, consideremos nuevamante el caso en una variable. En nuestra
fórmula original, estimamos que f (x(ς), ς) como 21 [f (x, t) + f (x ∗ (t + τ ), t + τ )].
Estas expresiones pueden ser deducidas usando la expansión de Taylor con dos variables,
∞ n
X 1 ∂ ∂
f (x + h, t + τ ) = h +τ f (x, t) , (9.25)
n=0
n! ∂x ∂t
donde todas las derivadas son evaluadas en (x, t). Para una fórmula general de Runge-Kutta
de segundo orden queremos obtener una expresión de la siguiente forma
x(t + τ ) = x(t) + w1 τ f (x(t), t) + w2 τ f (x∗ , t + ατ ) , (9.26)
donde
x∗ ≡ x(t) + βτ f (x(t), t) . (9.27)
Hay cuatro coeficientes no especificados: α, β, w1 y w2 . Note que cubrimos las ecuaciones

(9.19) y (9.20) eligiendo los valores
1 1
w1 = 0 , w2 = 1 α= , β= , (9.28)
2 2
y las ecuaciones (9.23) y (9.24) eligiendo
1 1
w1 = , w2 = , α=1, β=1. (9.29)
2 2
Deseamos seleccionar cuatro coeficientes tal que tengamos una precisión de segundo orden;
esto es deseamos calzar la serie de Taylor a través de los términos de la segunda derivada.
Los detalles del cálculo se proponen como un ejercicio, pero cualquier grupo de coeficientes
satisfacen las relaciones siguientes w1 + w2 = 1, αw2 = 1/2 y α = β darán un esquema
Runge-Kutta de segundo orden. El error de truncamiento local es O(τ 3 ), pero la expresión
explı́cita no tiene una forma simple. No está claro que un esquema sea superior al otro ya
que el error de truncamiento, siendo una función complicada de f (x, t), variará de problema
a problema.
9.2.3. Runge-Kutta de cuarto orden.

Presentamos las fórmulas de Runge-Kutta de segundo orden porque es fácil de comprender
su construcción. En la práctica, sin embargo, el método más comúnmente usado es la siguiente
fórmula de cuarto orden:
1 h i
~x(t + τ ) = ~x(t) + τ F~1 + 2F~2 + 2F~3 + F~4 , (9.30)
6
donde
F~1 = f~(~x, t) ,

~ ~ 1 ~ 1
F2 = f ~x + τ F1 , t + τ ,
2 2
(9.31)
~ ~ 1 ~ 1
F3 = f ~x + τ F2 , t + τ ,
2 2
F~4 = f~(~x + τ F~3 , t + τ ) .
El siguiente extracto del Numerical Recipes4 resume mejor el estado que las fórmulas de
arriba tienen en el mundo del análisis numérico:
Para muchos usuarios cientı́ficos, el método de Runge-Kutta de cuarto orden no es

sólo la primera palabra en esquemas de integración para ecuaciones diferenciales
ordinarias, si no que es la última también. De hecho, usted puede ir bastante lejos
con este viejo caballito de batalla, especialmente si los combina con un algorı́tmo
de paso adaptativo. . . Bulirsch-Stoer o los métodos predictor-corrector pueden ser
mucho más eficientes para problemas donde se require una alta precisión. Estos
métodos son los finos caballos de carrera mientras que Runge-Kutta es el fiel
caballo de tiro.
Usted se preguntará, ¿por qué fórmulas de cuarto orden y no de orden superior? Bien, los
métodos de orden superior tienen un error de truncamiento mejor, pero también requieren
más cálculo, esto es, más evaluaciones de f (x, t). Hay dos opciones, hacer más pasos con un τ
pequeño usando un método de orden inferior o hacer pocos pasos con un τ más grande usando
un método de orden superior. Ya que los métodos de Runge-Kutta de órdenes superiores son
muy complicados, el esquema de cuarto orden dado anteriormente es muy conveniente. Entre
paréntesis, el error de truncamiento local para Runge-Kutta de cuarto orden es O(τ 5 ).
Para implementar métodos de cuarto orden para nuestro problema de la órbita, usaremos
la función rk4 (tabla 9.3). Esta función toma como datos: el estado actual del sistema, ~x(t); el
paso de tiempo para ser usado, τ ; el tiempo actual, t; la función f~(~x(t), t; λ); donde λ es una
lista de parámetros usados por f~. La salida es el nuevo estado del sistema, ~x(t + τ ), calculado
por el método de Runge-Kutta. Usando Runge-Kutta de cuarto orden da los resultados
mostrados en la figura 9.6, la cual es mucho mejor que las obtenidas usando el método de
Euler-Cromer (figura 9.5).
4
W. Press, B. Flannery, S. Tukolsky and W. Vetterling, Numerical Recipes in fortran, 2nd ed. (Cam-
bridge: Cambridge University Press 1992).
Entradas: ~x(t), t, τ , f~(~x, t; λ), y λ.
Salidas: ~x(t + τ ).
Evaluación F~1 , F~2 , F~3 y F~4 usando ecuación (9.31).
Cálculo de ~x(t + τ ) usando Runge-Kutta de cuarto orden, usando ecuación (9.30).
Cuadro 9.3: Bosquejo de la función rk4, la cual evalúa un paso simple usando el método
Runge-Kutta de cuarto orden.
Entradas: ~x(t), t (no se usa), GM .
Salidas: d~x(t)/dt.
Evalúa la aceleración ~a = −(GM~r/ | ~r |3 ).
Retorno: d~x(t)/dt = [vx , vy , ax , ay ].
Cuadro 9.4: Bosquejo de la función gravrk, la cual es usada por la función Runge-Kutta para
evaluar las ecuaciones de movimiento para el problema de Kepler.
9.2.4. Pasando funciones a funciones. (Sólo c++)

La función de Runge-Kutta rk4 es muy simple, pero introduce un elemento de progra-
mación que no hemos usado antes. La función f~(~x, t; λ) está introducida como un parámetro
de entrada a rk4. Esto nos permite usar rk4 para resolver diferentes problemas cambiando
simplemente la definición de f~ (como lo haremos en la última sección). Para el problema de
Kepler, la función gravrk (tabla 9.4) define la ecuación de movimiento devolviendo dx/dt,
ecuación (9.17).
En C++ el puntero a la función f~(~x, t; λ) es pasado como parámetro a rk4. El programa
orbita llama a rk4 como
rk4( state, nState, time, tau, gravrk, param) ;
donde el vector de estado es ~x = [rx , ry , vx , vy ]. En el inicio del archivo, la función gravrk es

declarada con el prototipo
void gravrk( double * x, double t, double param, double * deriv );
La primera lı́nea de rk4 es
void rk4(double * x, int nX, double t, double tau,

void (*derivsRK) (double *, double, double, double *) , double param)
90 o
300
Energía Cinética
Energía Potencial
Energía Total
200
100
o
180 0o 0
−100
−200
−300
1 0.5 0 0.5 1 0 0.2 0.4 0.6 0.8 1.0
Distancia [AU] o Tiempo [años]
270
de Runge-Kutta. La distancia radial inicial es 1 [AU] y la velocidad tangencial inicial es
π [AU/año]. El paso en el tiempo es τ = 0.005 [años]; y 200 pasos son calculados. Comparemos
con la figura 9.5.
Cuando es llamado por orbita, esta función recibe un puntero a gravrk en la variable
derivsRK. Dentro de rk4, la sentencia
(*derivsRK)( x, t, param, F1 ) ;
es equivalente a
gravrk( x, t, param, F1 ) ;
ya que dervsRK apunta a gravrk.
9.3. Métodos adaptativos

9.3.1. Programas con paso de tiempo adaptativo.
Ya que el método de Runge-Kutta de cuarto orden es más preciso (errores de truncamiento
pequeños), hace un mejor trabajo dentro de una órbita altamemente elı́ptica. Aún para una
distancia inicial al afelio de 1 [AU] y una velocidad inicial en el afelio de π/2 [AU/año] usando
un paso tiempo tan pequeño como τ = 0.0005 [años] (≈ 4 12 [hrs]), la energı́a total varı́a sobre
el 7 % por órbita. Si pensamos la fı́sica, llegamos a que realizar una integración con un paso
pequeño es sólo necesaria cuando el cometa haga su acercamiento más próximo, punto en el
cual su velocidad es máxima. Cualquier error pequeño en la trayectoria cuando rodea al Sol
causa una gran desviación en la energı́a potencial.
La idea ahora es diseñar un programa que use un paso de tiempo pequeño cuando el come-
ta está cerca del Sol y pasos de tiempo grande cuando está lejos. Tal como está, normalmente
9.3. MÉTODOS ADAPTATIVOS 273
tenemos sólo una idea apróximada de lo que τ pudiera ser; ahora tenemos que seleccionar un
τmı́n y un τmáx y una manera de intercambiar entre ellos. Si tenemos que hacer esto por prueba
y error manual, podrı́a ser peor que haciéndolo por la fuerza bruta calculando con un paso
de tiempo pequeño toda la trayectoria. Idealmente, deseamos estar completamente liberados
de tener que especificar un paso de tiempo. Deseamos tener una trayectoria calculada de la
misma posición inicial hasta algún tiempo final con la seguridad de que la solución es correcta
a una precisión especificada
Los programas adaptativos continuamente monitorean la solución y modifican el paso de
tiempo para asegurar que se mantenga la precisión especificada por el usuario. Esos programas
pueden hacer algunos cálculos extras para optimizar la elección de τ , en muchos casos este
trabajo extra vale la pena. Aquı́ está una manera para implementar esta idea: dado el estado
actual ~x(t), el programa calcula ~x(t + τ ) como siempre, y luego repite el cálculo haciendolo
en dos pasos, cada uno con paso de tiempo τ2 . Visualmente, esto es
paso grande
x b(t+ τ)
x (t)
x (t+τ/2) x s (t+ τ)
paso pequeño paso pequeño
La diferencia entre las dos respuestas, ~xb (t+τ ) y ~xs (t+τ ), estima el error de truncamiento
local. Si el error es tolerable, el valor calculado es aceptado y un valor mayor de τ es usado
en la próxima iteración. Por otra parte, si el error es muy grande, la respuesta es rebotada, el
paso de tiempo es reducido y el procedimiento es repetido hasta que se obtenga una respuesta
aceptable. El error de truncamiento estimado para el actual paso de tiempo puede guiarnos
en seleccionar en nuevo paso de tiempo para la próxima iteración.
9.3.2. Función adaptativa de Runge-Kutta.

Aquı́ mostramos cómo una iteración adaptativa puede ser implementada para un esquema
de Runge-Kutta de cuarto orden: llamemos ∆ al error de truncamiento; sabemos que ∆ ∝ τ 5
para un esquema Runge-Kutta de cuarto orden. Supongamos que el paso de tiempo actual
τant da un error de ∆c = | ~xb − ~xs |; esta es nuestra estimación para el error de truncamiento.
Dado que deseamos que el error sea menor o igual que el error ideal especificado por el
usuario, le llamamos ∆i ; luego, el nuevo paso de tiempo estimado es
1/5
∆i
τest = τ . (9.32)
∆c
Ya que esto es sólo una estimación, el nuevo paso de tiempo es τnuevo = S1 τest , donde S1 < 1.
Esto nos hace sobreestimar el cambio cuando disminuimos τ y subestimar el cambio cuan-
do lo aumentamos. Malogramos los esfuerzos computacionales cada vez que rebotamos una
respuesta y necesitamos reducir el paso de tiempo, por lo tanto es mejor ajustar τnuevo < τest .
Podrı́amos poner un segundo factor de seguridad, S2 < 1, para asegurarse que el programa
no sea demasiado entusiasta en aumentar o disminuir precipitadamente el paso de tiempo.
Con ambas precauciones, el nuevo paso de tiempo es


S2 τant
 si S1 τest > S2 τant
τnuevo = τ /S2 si S1 τest < τant /S2 . (9.33)

S1 τest en otro caso

Entradas: ~x(t), t, τ , ∆i , f~(~x, t; λ), y λ.
Salidas: x(t′ ), t′ , τnuevo .
Fijar las variables iniciales
Iterar sobre el número deseado de intentos para satisfacer el error lı́mite.
• Tomar dos pequeños pasos de tiempo.

• Tomar un único paso grande de tiempo.
• Calcule el error de truncamiento estimado.
• Estime el nuevo valor de τ (incluyendo factores de seguridad).
• Si el error es aceptable, regresar los valores calculados.
Mostrar un mensaje de error si el error lı́mite nunca es satisfecho.
Cuadro 9.5: Bosquejo de la función rka, la cual evalúa un único paso usando un método
adaptativo de Runge-Kutta de cuarto orden.
Esto obliga a asegurar que nuestro nueva estimación para τ nunca aumente o decrezca
por más que un factor S2 . Por supuesto, este nuevo τ podrı́a ser insuficientemente pequeño,
y tendrı́amos que continuar reduciendo el paso de tiempo; pero al menos sabrı́amos que no
ocurrirá de un modo incontrolado.
Este procedimiento no es “a prueba de balas”, los errores de redondeo llegan a ser signi-
ficativos en pasos de tiempos muy pequeños. Por esta razón la iteración adaptativa podrı́a
fallar para encontrar un paso de tiempo que de la precisión deseada. Debemos mantener esta
limitación en mente cuando especifiquemos el error aceptable. Una función de Runge-Kutta
adaptativa, llamada rka, es esbozada en la tabla 9.5. Note que los datos de entrada en la
secuencia de llamada son los mismos que para rk4, excepto por la suma de ∆i , el error ideal
especificado. Las salidas del rka son el nuevo estado del sistema, ~x(t′ ); el tiempo nuevo, t′ y
el nuevo paso de tiempo, τ nuevo, el cual podrı́a ser usado la próxima vez que sea llamada
la rka.
Usando el método de Runge-Kutta adaptativo, el programa orbita da los resultados en
la figura 9.7 para una órbita altamente elı́ptica. Notemos que el programa toma muchos más
pasos en el perihelio que en el afelio. Podemos comparar con los resultados usando el método
de Runge-Kutta no adaptativo (figura 9.6) en el cual los pasos en el perihelio son ampliamente
9.3. MÉTODOS ADAPTATIVOS 275
90 o 1500
Energía Cinética
Energía Potencial
Energía Total
1000
500
180o 0o 0
−500
−1000
−1500
o 0 0.05 0.1 0.15 0.2 0.25
270
1 0.5 0 0.5 1
Distancia [AU] Tiempos [años]
de Runge-Kutta adaptativo. La distancia radial inicial es 1 [AU] y la velocidad tangencial
inicial es π/2 [AU/año]. El paso inicial en el tiempo es τ = 0.1 [años]; y 40 pasos son
calculados.
0.1
0.01
Tau [aæos]
0.001
0.0001
0.01 0.1 1
Distancia [Au]
Figura 9.8: Paso de tiempo como función de la distancia radial desde el programa orbita
usando el método de Runge-Kutta adaptativo. Los paramétros son los mismos de la figura
9.7.
espaciados. Una gráfica de los pasos de tiempo versus la distancia radial (figura 9.8) muestra
que τ varı́a casi tres órdenes de magnitud.√Interesantemente esta gráfica revela una relación
exponencial aproximada de la forma τ ∝ r3 . Por supuesto esta dependencia nos recuerda
la tercera ley de Kepler, ecuación (9.10). Esperamos alguna dispersión en los puntos, ya que
nuestra rutina adaptada solamente estima el paso de tiempo óptimo.
9.4. Listados del programa.
9.4.1. orbita.py
# -*- coding: iso-8859-1 -*-
import sys
import math
from pylab import *
import numpy
GM=4.0e0*math.pi*math.pi
masaCometa = 1.0e0
adaptErr = 1.0e-3
def gravrk(x,t):
global GM
vX=x[2]
vY=x[3]
mod_r= math.sqrt(x[0]*x[0]+x[1]*x[1])
aX= -GM*x[0]/(mod_r*mod_r*mod_r)
aY= -GM*x[1]/(mod_r*mod_r*mod_r)
## Retorna la derivada
return numpy.array( [vX,vY,aX,aY] )
def rk4( x, tiempo, tau):
## Evaluemos F1=f(x,t)
F1 = gravrk(x,tiempo)
half_tau = tau/2.0e0
t_half = tiempo+half_tau
t_full = tiempo+tau
## Evaluamos F2=f(x+tau*F1/2, t+tau/2)

xtemp = x + half_tau*F1
F2 = gravrk(xtemp, t_half)
## Evaluamos F3=f(x+tau*F2/2, t+tau/2)

9.4. LISTADOS DEL PROGRAMA. 277
xtemp = x + half_tau*F2
F3 = gravrk(xtemp, t_half)
## Evaluamos F4=f(x+tau*F3, t+tau)

xtemp = x + tau*F3
F4 = gravrk(xtemp, t_full)
## Retornamos x(t+tau)
return x + tau*(F1+F4+2.0*(F2+F3))/6.0
def rka( x ):
global adaptErr
tiempo = x[4]
tSave = tiempo
tau=x[5]
## factores de seguridad
safe1 = 0.9
safe2 = 4.0
maxTray=100
for iTray in range(0,maxTray):

## Tomemos dos pequennos pasos en el tiempo
half_tau = 0.5*tau
xSmall = numpy.array( [x[0],x[1],x[2],x[3]] )
xSmall=rk4( xSmall, tSave, half_tau)
tiempo = tSave + half_tau
xSmall=rk4( xSmall, tiempo, half_tau)
## Tomemos un solo tiempo grande
xBig = numpy.array( [x[0],x[1],x[2],x[3]] )
xBig=rk4( xBig, tSave, tau)
## Calculemos el error de truncamiento estimado

erroRatio = 0.0e0
eps = 1.0e-16
for i in range(0,4):
scale = adaptErr * (math.fabs(xSmall[i]) + fabs(xBig[i]))/2.0e0
xDiff = xSmall[i] - xBig[i]
ratio = fabs(xDiff)/(scale+eps)
if erroRatio <= ratio :
erroRatio=ratio
## Estimamos el nuevo valor de tau (incluyendo factores de seguridad)

tau_old= tau
tau = safe1*tau_old*math.pow(erroRatio, -0.20)
if tau <= tau_old/safe2 :

tau=tau_old/safe2
if tau >= safe2*tau_old :

tau=safe2*tau_old
## Si el error es aceptable regrese los valores computados

if erroRatio < 1 :
return numpy.array( [xSmall[0],xSmall[1],xSmall[2],xSmall[3], tiempo, tau] )
else:
print "Error: Runge-Kutta adaptativo fallo"
sys.exit()
def main():
salidaO = open("Orbita.txt","w")
salidaE = open("Energia.txt","w")
salidaT = open("Tau.txt","w")
r0 = input("Ingrese la distancia radial inicial [AU]: ")

vT = input("Ingrese la velocidad tangencial inicial [AU/annos]: ")
x0=r0
y0=0.0e0
vx0=0.0e0
vy0=vT
##
## Suponemos angulo inicial nulo
##
metodo = 0
while metodo < 1 or metodo > 4:
print "Ingrese el metodo a usar :"
print "\t Metodo de Euler \t\t\t[1]"
print "\t Metodo de Euler-Cromer \t\t[2]"
print "\t Metodo de Runge-Kutta 4 orden \t\t[3]"
print "\t Metodo de Runge-Kutta adaptativo \t[4]"
metodo=input("elija : ")
tau= input("Ingrese paso en el tiempo: ")

numPasos = input("Ingrese el numero de pasos: ")
xN= x0
yN= y0
vxN=vx0
vyN=vy0
tiempo = 0.0e0
l_r=[]
l_theta=[]
l_tiempo=[]
l_Ek=[]
l_Ep=[]
l_ET=[]
l_distancia=[]
l_tau=[]
for pasos in range(0,numPasos):

r = math.sqrt(xN*xN+yN*yN)
v2 =vxN*vxN+vyN*vyN
theta= math.atan2(yN, xN)
l_r.append(r)
l_theta.append(theta)
print >> salidaO, theta, r
Ek = masaCometa*v2/2.0e0
Ep = -GM*masaCometa/r
ET= Ep+Ek
l_tiempo.append(tiempo)
l_Ek.append(Ek)
l_Ep.append(Ep)
l_ET.append(ET)
print >> salidaE, tiempo, Ek, Ep, ET
modr3=math.pow(xN*xN+yN*yN, 3.0/2.0)
axN= -GM*xN/modr3
ayN= -GM*yN/modr3
if metodo==1: ## Euler
vxNp1=vxN+tau*axN
vyNp1=vyN+tau*ayN
xNp1= xN+tau* vxN
yNp1= yN+tau* vyN
tiempo += tau
elif metodo==2: ## Euler-Cromer
vxNp1=vxN+tau*axN
vyNp1=vyN+tau*ayN
xNp1= xN+tau* vxNp1
yNp1= yN+tau* vyNp1
tiempo += tau
elif metodo==3: ## Runge-Kutta 4to Orden
x= numpy.array( [xN,yN,vxN,vyN] )
x_new = rk4( x, tiempo, tau)
xNp1=x_new[0]
yNp1=x_new[1]
vxNp1=x_new[2]
vyNp1=x_new[3]
tiempo += tau
elif metodo==4: ## Runge-Kutta 4to Orden Adaptativo
x= numpy.array( [xN,yN,vxN,vyN, tiempo, tau] )

x_new = rka( x )
distancia = math.sqrt( x_new[0]*x_new[0]+x_new[1]*x_new[1])

tiempo=x_new[4]
tau=x_new[5]
l_distancia.append(distancia)
l_tau.append(tau)
print >> salidaT, distancia, tau
xNp1=x_new[0]
yNp1=x_new[1]
vxNp1=x_new[2]
vyNp1=x_new[3]
xN=xNp1
yN=yNp1
vxN=vxNp1
vyN=vyNp1
salidaO.close()
salidaE.close()
salidaT.close()
figure(1)
ax = axes([0.1, 0.1, 0.8, 0.8], polar=True, axisbg=’#d5de9c’)
polar(l_theta, l_r, color=’#ee8d18’, lw=2)
title(r’\textbf{\Huge \’Orbita}’)
figure(2)
linea_Ek = plot(l_tiempo, l_Ek)
setp(linea_Ek, color=’b’, linewidth=1.0)
linea_Ep = plot(l_tiempo, l_Ep)
setp(linea_Ep, color=’g’, linewidth=1.0)
linea_ET = plot(l_tiempo, l_ET)
setp(linea_ET, color=’r’, linewidth=1.0)
legend((r’Energ\’ia Cin\’etica’, r’Energ\’ia Potencial’, r’Energ\’ia Total’),
’upper right’, shadow=True)
xlabel(r’\textbf{\Large Tiempo (a\~nos)}’)
ylabel(r’\textbf{\Large Energ\’ia (M*AU$^2$/a\~no$^2$)}’)
title(r’\textbf{\Huge Energ\’ia}’)
grid(True)
if metodo == 4:
figure(3)
loglog(l_distancia,l_tau,"b+")
xlabel(r’\textbf{\Large Distancia (AU)}’)
ylabel(r’\textbf{\Large $\tau$ (a\~no)}’)
title(r’\textbf{\Huge Variaci\’on del paso de tiempo}’)
grid(True)
show()
#
main()
9.4.2. orbita.cc
const double GM=4.0e0*M_PI*M_PI ;

const double masaCometa = 1.0e0 ;
const double adaptErr = 1.0e-3;
void rk4(double * x, int nX, double t, double tau,

void(*derivsRK)(double *, double, double, double *),
double param)
{
double * F1=new double [nX] ;

double * xtemp=new double [nX] ;
// Evaluemos F1=f(x,t)
(*derivsRK) (x, t, param, F1) ;
double half_tau = tau/2.0e0;

double t_half = t+half_tau ;
double t_full = t+tau ;
// Evaluamos F2=f(x+tau*F1/2, t+tau/2)

for(int i=0; i<nX; i++) xtemp[i]=x[i]+half_tau*F1[i] ;
(*derivsRK) (xtemp, t_half, param, F2) ;

for(int i=0; i<nX; i++) xtemp[i]=x[i]+half_tau*F2[i] ;
(*derivsRK) (xtemp, t_half, param, F3) ;
// Evaluamos F4=f(x+tau*F3, t+tau)

for(int i=0; i<nX; i++) xtemp[i]=x[i]+tau*F3[i] ;
(*derivsRK) (xtemp, t_full, param, F4) ;
// Retornamos x(t+tau)
for(int i=0; i<nX; i++) x[i] += tau*(F1[i]+F4[i]+2.0e0*(F2[i]+F3[i]))/6.0e0 ;
delete [] F1; delete [] F2; delete [] F3; delete [] F4;

delete [] xtemp ;
}
void rka ( double * x, int nX, double & t, double & tau, double erro,
void(*derivsRK)(double *, double, double, double *),
double param)
{
double tSave = t ;
double safe1 = 0.9, safe2 = 4.0 ; //factores de seguridad
double * xSmall = new double[nX] ;

double * xBig = new double[nX] ;
int maxTray=100 ;
for (int iTray=0; iTray<maxTray; iTray++) {
// Tomemos dos peque\~nos pasos en el tiempo
double half_tau = 0.5*tau ;
for (int i =0; i < nX; i++) xSmall[i]=x[i] ;
rk4( xSmall, nX, tSave, half_tau, derivsRK, param) ;

t= tSave + half_tau ;
rk4( xSmall, nX, t, half_tau, derivsRK, param) ;
// Tomemos un solo tiempo grande
for (int i =0; i < nX; i++) xBig[i]=x[i] ;
rk4( xBig, nX, tSave, tau, derivsRK, param) ;
// Calculemos el error de truncamiento estimado

double erroRatio = 0.0e0 ;
double eps = 1.0e-16 ;
for (int i = 0 ; i < nX; i++) {
double scale = erro * (fabs(xSmall[i]) + fabs(xBig[i]))/2.0e0 ;
double xDiff = xSmall[i] - xBig[i] ;
double ratio = fabs(xDiff)/(scale+eps) ;
erroRatio = (erroRatio > ratio ) ? erroRatio:ratio ;
}
// Estimamos el nuevo valor de tau (incluyendo factores de seguridad)
double tau_old= tau ;
tau = safe1*tau_old*pow(erroRatio, -0.20) ;
tau = (tau > tau_old/safe2) ? tau:tau_old/safe2 ;
tau = (tau < safe2*tau_old) ? tau:safe2*tau_old ;
// Si el error es aceptable regrese los valores computados

if ( erroRatio < 1 ) {
for (int i =0 ; i < nX; i++) x[i]=xSmall[i] ;
return ;
}
}
cout << "Error: Runge-Kutta adaptativo fallo" << endl ;
exit(-1) ;
}
void gravrk( double * x, double t, double param, double * deriv)

{
double gm=param ;
double rX=x[0], rY=x[1];
double vX=x[2], vY=x[3] ;
double mod_r= sqrt(rX*rX+rY*rY) ;
double aX= -gm*rX/(mod_r*mod_r*mod_r) ;
double aY= -gm*rY/(mod_r*mod_r*mod_r) ;
// Retorna la derivada
deriv[0] = vX;
deriv[1] = vY;
deriv[2] = aX;
deriv[3] = aY;
}
int main()
{
ofstream salidaO ("Orbita.txt") ;
ofstream salidaE ("Energia.txt") ;
ofstream salidaT ("Tau.txt") ;
double r0 ;
cout << "Ingrese la distancia radial inicial [AU]: " ;
cin >> r0 ;
double vT ;
cout << "Ingrese la velocidad tangencial inicial [AU/annos]: " ;
cin >> vT ;
double x0=r0 ;
double y0=0.0e0;
double vx0=0.0e0 ;
double vy0=vT;
//
// Suponemos angulo inicial nulo
//
int metodo = 0 ;
while( metodo < 1|| metodo > 4 ) {
cout << "Ingrese el metodo a usar :" << endl ;
cout << "\t Metodo de Euler \t\t\t[1]" << endl;
cout << "\t Metodo de Euler-Cromer \t\t[2]" << endl;
cout << "\t Metodo de Runge-Kutta 4 orden \t\t[3]" << endl;
cout << "\t Metodo de Runge-Kutta adaptativo \t[4]" << endl;
cout << "elija: " ;
cin >> metodo ;
}
double tau ;
cout << "Ingrese paso en el tiempo: " ;
cin >> tau ;
int numPasos ;
cout << "Ingrese el numero de pasos: " ;
cin >> numPasos ;
double param=GM ;
const int dimX= 4;
double * x = new double[dimX] ;
double xN= x0;

double yN= y0;
double vxN=vx0;
double vyN=vy0;
double vxNp1, vyNp1, xNp1, yNp1;
double tiempo = 0.0e0 ;
for(int pasos=0; pasos < numPasos; pasos++) {

double r =sqrt(xN*xN+yN*yN) ;
double v2 =vxN*vxN+vyN*vyN ;
double theta= atan2(yN, xN) ;
salidaO << theta << " " << r << endl ;
double Ep = -GM*masaCometa/r ;
double Ek = masaCometa*v2/2.0e0 ;
double ET= Ep+Ek ;
salidaE<< tiempo << " " << Ek<< " " << Ep<<" " << ET << endl ;
double modr3=pow(xN*xN+yN*yN, 3.0e0/2.0e0) ;

double axN= -GM*xN/modr3 ;
double ayN= -GM*yN/modr3 ;
switch( metodo ) {
case 1: { // Euler
vxNp1=vxN+tau*axN ;
vyNp1=vyN+tau*ayN ;
xNp1= xN+tau* vxN ;
yNp1= yN+tau* vyN ;
tiempo += tau ;
}
break ;
case 2: { // Euler-Cromer
vxNp1=vxN+tau*axN ;
vyNp1=vyN+tau*ayN ;
xNp1= xN+tau* vxNp1 ;
yNp1= yN+tau* vyNp1 ;
tiempo += tau ;
}
break ;
case 3: { // Runge-Kutta 4to Orden
x[0] = xN;
x[1] = yN;
x[2] = vxN;
x[3] = vyN;
rk4( x, dimX, tiempo, tau, gravrk, param);
xNp1=x[0] ;
yNp1=x[1];
vxNp1=x[2];
vyNp1=x[3];
tiempo += tau ;
}
break ;
case 4: {
x[0] = xN;
x[1] = yN;
x[2] = vxN;
x[3] = vyN;
rka( x, dimX, tiempo, tau, adaptErr, gravrk, param);
double distancia = sqrt( x[0]*x[0]+x[1]*x[1]) ;
salidaT<< distancia << " " <<tau << endl ;
xNp1=x[0] ;
yNp1=x[1];
vxNp1=x[2];
vyNp1=x[3];
}
}
xN=xNp1 ;
yN=yNp1 ;
vxN=vxNp1 ;
vyN=vyNp1 ;
}
salidaO.close() ;
salidaE.close() ;
salidaT.close() ;
delete [] x;
return 0;
}
Otra versión del programa, esta vez con clases
9.4.3. vector4d.h
#ifndef _vector_4d_h
#define _vector_4d_h
//
// Clase basica de vectores 4d para Runge-Kutta
//
#include <iostream>
class Vector{
private:
double c_t;
double c_x;
double c_y;
double c_z;
public:
Vector():c_t(0),c_x(0),c_y(0),c_z(0) {} ;
Vector(double t,double x, double y, double z):c_t(t),c_x(x),c_y(y),c_z(z) {} ;
void set(double,double, double, double);
double componente(int);
~Vector() {} ;
double t() const {return c_t;};
double x() const {return c_x;};
double y() const {return c_y;};
double z() const {return c_z;};
};
Vector operator + (const Vector &, const Vector &) ;

Vector operator - (const Vector &, const Vector &) ;
Vector operator * (double, const Vector &) ;
Vector operator / (const Vector &, double) ;
double operator * (const Vector &, const Vector &) ;
#endif
9.4.4. vector4d.cc
void Vector::set(double t, double x, double y, double z) {

c_t=t;
c_x=x;
c_y=y;
c_z=z;
}
double Vector::componente(int i) {
double d=0;
if (i==0) {
d=c_t;
} else if(i==1) {
d=c_x;
} else if(i==2) {
d=c_y;
} else if(i==3) {
d=c_z;
} else {
std::cout << "Error en componente"<< std::endl;
exit(-1);
}
return d;
}
Vector operator + (const Vector & v1, const Vector &v2) {

return Vector(v1.t()+v2.t(),v1.x()+v2.x(),v1.y()+v2.y(),v1.z()+v2.z()) ;
}
Vector operator - (const Vector & v1, const Vector &v2) {
return Vector(v1.t()-v2.t(),v1.x()-v2.x(),v1.y()-v2.y(),v1.z()-v2.z()) ;
}
Vector operator * (double r, const Vector &v) {
return Vector(r*v.t(),r*v.x(),r*v.y(),r*v.z()) ;
}
Vector operator / (const Vector & v, double r) {
return Vector(v.t()/r,v.x()/r,v.y()/r,v.z()/r) ;
}
double operator * (const Vector & v1, const Vector &v2) {

return v1.t()*v2.t()+v1.x()*v2.x()+v1.y()*v2.y()+ v1.z()*v2.z() ;
}
9.4.5. orbita2.cc
const double GM=4.0e0*M_PI*M_PI ;

const double masaCometa = 1.0e0 ;
const double adaptErr = 1.0e-3;
Vector rk4(Vector, double, double);

Vector rka ( Vector, double & , double &);
Vector gravrk( Vector, double );
int main()
{
ofstream salidaO ("Orbita.txt") ;
ofstream salidaE ("Energia.txt") ;
ofstream salidaT ("Tau.txt") ;
double r0 ;
cout << "Ingrese la distancia radial inicial [AU]: " ;
cin >> r0 ;
double vT ;
cout << "Ingrese la velocidad tangencial inicial [AU/a\~nos]: " ;
cin >> vT ;
double x0=r0 ;
double y0=0.0e0;
double vx0=0.0e0 ;
double vy0=vT;
//
// Suponemos angulo inicial nulo
//
int metodo = 0 ;
while( metodo < 1|| metodo > 4 ) {
cout << "Ingrese el m\’etodo num\’erico a usar :" << endl ;
cout << "\t M\’etodo de Euler \t\t\t[1]" << endl;
cout << "\t M\’etodo de Euler-Cromer \t\t[2]" << endl;
cout << "\t M\’etodo de Runge-Kutta 4 orden \t\t[3]" << endl;
cout << "\t M\’etodo de Runge-Kutta adaptativo \t[4]" << endl;
cout << "elija: " ;
cin >> metodo ;
}
double tau ;
cout << "Ingrese paso en el tiempo: " ;
cin >> tau ;
int numPasos ;
cout << "Ingrese el n\’umero de pasos: " ;
cin >> numPasos ;
Vector x;
double xN= x0;

double yN= y0;
double vxN=vx0;
double vyN=vy0;
double vxNp1, vyNp1, xNp1, yNp1;
double tiempo = 0.0e0 ;
for(int pasos=0; pasos < numPasos; pasos++) {

double r =sqrt(xN*xN+yN*yN) ;
double v2 =vxN*vxN+vyN*vyN ;
double theta= atan2(yN, xN) ;
salidaO << theta << " " << r << endl ;
double Ep = -GM*masaCometa/r ;
double Ek = masaCometa*v2/2.0e0 ;
double ET= Ep+Ek ;
salidaE<< tiempo << " " << Ek<< " " << Ep<<" " << ET << endl ;
double modr3=pow(xN*xN+yN*yN, 3.0e0/2.0e0) ;

double axN= -GM*xN/modr3 ;
double ayN= -GM*yN/modr3 ;
switch( metodo ) {
case 1: { // Euler
vxNp1=vxN+tau*axN ;
vyNp1=vyN+tau*ayN ;
xNp1= xN+tau* vxN ;
yNp1= yN+tau* vyN ;
tiempo += tau ;
}
break ;
case 2: { // Euler-Cromer
vxNp1=vxN+tau*axN ;
vyNp1=vyN+tau*ayN ;
xNp1= xN+tau* vxNp1 ;
yNp1= yN+tau* vyNp1 ;
tiempo += tau ;
}
break ;
case 3: { // Runge-Kutta 4to orden
x.set(xN,yN,vxN,vyN);
Vector x_new=rk4( x, tiempo, tau);
xNp1=x_new.t() ;
yNp1=x_new.x();
vxNp1=x_new.y();
vyNp1=x_new.z();
tiempo += tau ;
}
break ;
case 4: {
x.set(xN,yN,vxN,vyN); // Runge-Kutta 4to orden adaptativo
Vector x_new=rka( x, tiempo, tau);
double distancia = sqrt( x_new.t()*x_new.t()+x_new.x()*x_new.x()) ;
salidaT<< distancia << " " <<tau << endl ;
xNp1=x_new.t() ;
yNp1=x_new.x();
vxNp1=x_new.y();
vyNp1=x_new.z();
}
}
xN=xNp1 ;
yN=yNp1 ;
vxN=vxNp1 ;
vyN=vyNp1 ;
}
salidaO.close() ;
salidaE.close() ;
salidaT.close() ;
return 0;
}
Vector rk4(Vector x, double t, double tau)

{
// Evaluemos F1=f(x,t)
Vector F1 = gravrk(x, t) ;
double half_tau = tau/2.0e0;

double t_half = t+half_tau ;
double t_full = t+tau ;

Vector xtemp=x+half_tau*F1;
Vector F2 = gravrk(xtemp, t_half) ;

xtemp=x+half_tau*F2 ;
Vector F3 = gravrk(xtemp, t_half) ;
// Evaluamos F4=f(x+tau*F3, t+tau)

xtemp=x+tau*F3 ;
Vector F4 = gravrk(xtemp, t_full) ;
// Retornamos x(t+tau)
Vector x_new = x + tau*(F1+F4+2.0e0*(F2+F3))/6.0e0 ;

return x_new;
}
Vector rka ( Vector x, double & t, double & tau)

{
double tSave = t ;
double safe1 = 0.9, safe2 = 4.0 ; //factores de seguridad
int maxTray=100 ;
for (int iTray=0; iTray<maxTray; iTray++) {
// Tomemos dos peque\~nos pasos en el tiempo
double half_tau = 0.5*tau ;
Vector xSmall = x ;
xSmall=rk4( xSmall, tSave, half_tau) ;
t= tSave + half_tau ;
xSmall=rk4( xSmall, t, half_tau) ;
// Tomemos un solo tiempo grande
Vector xBig = x;
xBig=rk4( xBig, tSave, tau) ;
// Calculemos el error de truncamiento estimado

double erroRatio = 0.0e0 ;
double eps = 1.0e-16 ;
for (int i = 0 ; i < 4; i++) {
double scale = adaptErr * (fabs(xSmall.componente(i))
+ fabs(xBig.componente(i)))/2.0e0 ;
double xDiff = xSmall.componente(i) - xBig.componente(i) ;
double ratio = fabs(xDiff)/(scale+eps) ;
if (erroRatio <= ratio ) erroRatio=ratio ;
}
// Estimamos el nuevo valor de tau (incluyendo factores de seguridad)
double tau_old= tau ;
tau = safe1*tau_old*pow(erroRatio, -0.20) ;
if (tau <= tau_old/safe2) tau=tau_old/safe2 ;
if(tau >= safe2*tau_old) tau=safe2*tau_old ;
// Si el error es aceptable regrese los valores computados

if ( erroRatio < 1 ) {
return xSmall;
}
}
cout << "Error: Runge-Kutta adaptativo fallo" << endl ;
exit(-1) ;
}
Vector gravrk( Vector v, double t)

{
double mod_r= sqrt(v.t()*v.t()+v.x()*v.x()) ;
double aX= -GM*v.t()/(mod_r*mod_r*mod_r) ;
double aY= -GM*v.x()/(mod_r*mod_r*mod_r) ;
// Retorna la derivada
return Vector(v.y(),v.z(),aX,aY);
}
Capı́tulo 10
Resolviendo sistemas de ecuaciones.

versión final 3.1, 22 Noviembre 20071
En este capı́tulo aprenderemos a cómo resolver sistemas de ecuaciones de ambos tipos,

lineal y no lineal. Ya conocemos los algoritmos básicos para los sistemas lineales: eliminar
variables hasta que tengamos una sola ecuación con una sola incógnita. Para sistemas no-
lineales desarrollamos un esquema iterativo que en cada paso resuelve una versión linealizada
de estas ecuaciones. Para mantener la continuidad, la discusión será motivada por el cálculo
del estado estacionario, un importante tema en ecuaciones diferenciales ordinarias.
10.1. Sistemas de ecuaciones lineales.

10.1.1. Estado estacionario de EDO.
En el capı́tulo pasado, nosotros vimos cómo resolver ecuaciones diferenciales ordinarias
de la forma
d~x
= f~(~x, t) , (10.1)
dt
donde ~x = [x1 , x2 , . . . , xN ]. Dada una condición inicial para las N variables xi (t) = 0, nosotros
podemos calcular la serie de tiempo xi (t) por una variedad de métodos (e.g. Runge-Kutta).
Los ejemplos que hemos estudiado hasta aquı́ han sido aquellos conocidos como sistemas
autónomos donde f~(~x, t) = f~(~x), esto es, f~ no depende explı́citamente del tiempo. Para
sistemas autónomos, a menudo existe una importante clase de condiciones iniciales para las
cuales xi (t) = xi (0) para todo i y t. Estos puntos, en el espacio N -dimensional de nuestras
variables, son llamados estado estacionario. Si nosotros partimos de un estado estacionario nos
quedamos ahı́ para siempre. Localizar los estados estacionarios para ecuaciones diferenciales
ordinarias es importante, ya que ellos son usados en el análisis de bifurcaciones.2
Es fácil ver que ~x ∗ = [x∗1 , x∗2 , . . . , x∗N ] es un estado estacionario si y sólo si
f~(~x ∗ ) = 0 , (10.2)
o
fi (x∗1 , x∗2 , . . . , x∗N ) = 0 , para todo i, (10.3)
1
Este capı́tulo está basado en el cuarto capı́tulo del libro: Numerical Methods for Physics, second edition
2
R. Seydel, From Equilibrium to Chaos, Practical Bifurcation and Stability Analysis (New York: Elsevier,
1988).
293
294 CAPÍTULO 10. RESOLVIENDO SISTEMAS DE ECUACIONES.
ya que esto implica que d~x ∗ /dt = 0. Localizar los estados estacionarios se reduce al problema
de resolver N ecuaciones con N incógnitas xi ∗ . Este problema es también llamado “encontrar
las raices de f (x)”.
Como un ejemplo, consideremos el péndulo simple; el estado está descrito por el ángulo
θ y la velocidad angular ω. Los estados estacionarios se encuentran al resolver las ecuaciones
no lineales
g
− sen θ∗ = 0 , ω ∗ = 0 . (10.4)
L
Las raices son θ∗ = 0, ±π, ±2π, . . . y ω ∗ = 0. Por supuesto que no todos los sistemas son tan
fáciles de resolver.
Deberı́a ser claro que encontrar raices tiene muchas más aplicaciones que calcular los
estados estacionario. En este capı́tulo consideraremos una variedad de maneras para resolver
ambos sistemas lineales y sistemas no lineales. En esta sección y en la próxima consideraremos
sistemas lineales, dejando los sistemas no lineales para la parte final del capı́tulo.
10.1.2. Eliminación Gaussiana.

El problema de resolver fi ({xj }) = 0 se divide en dos importantes clases. En esta sección
consideramos el caso fácil cuando fi ({xj }) es una función lineal. El problema en ese caso se
reduce a resolver un sistema de N ecuaciones con N incógnitas.
a11 x1 + a12 x2 + . . . + a1N xN − b1 = 0
a21 x1 + a22 x2 + . . . + a2N xN − b2 = 0
.. .. .. .. (10.5)
. . . .
aN 1 x1 + aN 2 x2 + . . . + aN N xN − bN = 0 ,
o en forma matricial
Ǎ ~x − ~b = 0 , (10.6)
donde      
a11 a12 . . . x1 b1
Ǎ = a21 a22 . . . ,
  x2 
~x =   , ~b = 
b2  .

(10.7)
.. .. . . .. ..
. . . . .
Sabemos cómo resolver este conjunto de ecuaciones. Combinando las ecuaciones para
eliminar variables hasta que tengamos una sola ecuación con una sola incógnita. Hagamos
un ejemplo simple para revisar cómo el procedimiento trabaja. Tomemos las ecuaciones
x1 + x2 + x3 = 6 ,
−x1 + 2x2 = 3, (10.8)
2x1 + x3 = 5 .
Deseamos eliminar x1 de la segunda y de la tercera ecuación. Para llevar a cabo esto, primero
sumamos la primera y la segunda y después restamos dos veces la primera a la tercera. Esto
nos da
x1 + x2 + x3 = 6,
3x2 + x3 = 9, (10.9)
−2x2 − x3 = −7 .
10.1. SISTEMAS DE ECUACIONES LINEALES. 295
Ahora, eliminamos x2 de la última ecuación multiplicando la segunda ecuación por − 23 y la

restamos de la tercera, dándonos
x1 + x2 + x3 = 6,
3x2 + x3 = 9, (10.10)
− 13 x3 = −1 .
Este procedimiento es llamado eliminación hacia adelante. Si se tienen N ecuaciones, elimi-

namos x1 de las ecuaciones 2 hasta la N , luego eliminamos x1 y x2 de las ecuaciones 3 hasta
la N , y ası́ sucesivamente. La última ecuación sólo contendrá la variable xN .
Volviendo al ejemplo, es ahora trivial resolver la tercera ecuación resultando x3 = 3.
Podemos ahora sustituir este valor en la segunda ecuación obteniendo 3x2 + 3 = 9, tal que
x2 = 2. Finalmente, introduciendo los valores de x2 y x3 en la primera ecuación obtenemos
x1 = 1. Este segundo procedimiento es llamado sustitución hacia atrás. Deberı́a ser claro
cómo esto trabaja con sistemas grandes de ecuaciones. Usando la última ecuación obtenemos
xN , éste es usado en la penúltima ecuación para obtener xN −1 y ası́ seguimos.
Este método de resolver sistemas de ecuaciones lineales por eliminación hacia adelante
y luego sustitución hacia atrás es llamado eliminación Gaussiana.3 Esta es una secuencia
rutinaria de pasos que es simple para un computador realizar sistemáticamente. Para N
ecuaciones con N incógnitas, el tiempo de computación para eliminación Gaussiana va como
N 3 . Afortunadamente, si el sistema es esparcido o ralo4 (la mayorı́a de los coeficientes son
cero), el tiempo de cálculo puede ser considerablemente reducido.
10.1.3. Pivoteando.
La eliminación Gaussiana es un procedimiento simple, sin embargo, se debe estar conciente
de sus riesgos. Para ilustrar la primera fuente de problemas, consideremos el conjunto de
ecuaciones
ǫx1 + x2 + x3 = 5 ,
x1 + x2 = 3, (10.11)
x1 + x3 = 4 .
En el lı́mite ǫ → 0 la solución es x1 = 1, x2 = 2, x3 = 3. Para estas ecuaciones, el primer
paso de la eliminación hacia adelante podrı́a partir por multiplicar la primera ecuación por
(1/ǫ) y sustrayéndola de la segunda y tercera ecuaciones, lo que da
ǫx1 + x2 + x3 = 5,
(1 − 1/ǫ)x2 − (1/ǫ)x3 = 3 − 5/ǫ , (10.12)
−(1/ǫ)x2 + (1 − 1/ǫ)x3 = 4 − 5/ǫ .
Por supuesto, si ǫ = 0 tenemos grandes problemas, ya que el factor 1/ǫ estalla. Aún si ǫ 6= 0,
pero es pequeño, vamos a tener serios problemas de redondeo. Supongamos que 1/ǫ es tan
3
G.E. Forsythe and C.B. Moler, Computer Solution of Linear Algebraic System (Upper Saddle River, N.J.:
Prentice-Hall, 1967).
4
sparse
grande que (C − 1/ǫ) → −1/ǫ, donde C es del orden de la unidad. Nuestras ecuaciones,
después del redondeo, llegan a ser
ǫx1 + x2 + x3 = 5,
−(1/ǫ)x2 − (1/ǫ)x3 = −5/ǫ , (10.13)
−(1/ǫ)x2 − (1/ǫ)x3 = −5/ǫ .
En este punto está claro que no podemos proceder ya que la segunda y la tercera ecuación en
(10.13) son ahora idénticas; no tenemos más que tres ecuaciones independientes. El próximo
paso de eliminación serı́a transformar la tercera ecuación en (4.13) en la tautologı́a 0 = 0.
Afortunadamente, hay una solución simple: intercambiar el orden de las ecuaciones antes
de realizar la eliminación. Cambiando las ecuaciones primera y segunda en (10.11),
x1 + x2 = 3,
ǫx1 + x2 + x3 = 5 , (10.14)
x1 + x3 = 4 .
El primer paso de la eliminación hacia adelante nos da las ecuaciones
x1 + x2 = 3,
(1 − ǫ)x2 + x3 = 5 − 3ǫ , (10.15)
−x2 + x3 = 4 − 3 .
El redondeo elimina los términos proporcionales a ǫ, dando
x1 + x2 = 3,
x2 + x3 = 5 , (10.16)
−x2 + x3 = 1 .
El segundo paso de eliminación hacia adelante elimina x2 de la tercera ecuación en (10.16)

usando la segunda ecuación,
x1 + x2 = 3,
x2 + x3 = 5 , (10.17)
2x3 = 6 .
Se puede comprobar fácilmente que la sustitución hacia atrás da x1 = 1, x2 = 2, y x3 = 3, la

cual es la respuesta correcta en el lı́mite ǫ → 0.
Los algoritmos que reordenan las ecuaciones cuando ellas sitúan elementos pequeños en la
diagonal son llamados pivotes. A menudo si todos los elementos de una matriz son inicialmente
de una magnitud comparable, el procedimiento de eliminación hacia adelante podrı́a producir
pequeños elementos sobre la diagonal principal. El precio de pivotear es sólo un par de lı́neas
extras en el programa, pero es esencial usar pivoteo para todas, no sólo para las matrices más
pequeñas. Aún con el pivoteo, no podemos garantizar estar a salvo de problemas de redondeo
si se trata de matrices muy grandes.
10.1.4. Determinantes.
Es fácil obtener el determinante de una matriz usando la eliminación Gaussiana. Después
de completar la eliminación hacia adelante, uno simplemente calcula el producto de los coe-
ficientes de los elementos diagonales. Tomamos nuestro ejemplo original, ecuación (10.8). La
matriz es  
1 1 1
Ǎ = −1 2 0 . (10.18)
2 0 1
Completada la eliminación hacia adelante, ecuación (10.10), el producto de los coeficientes de
los elementos diagonales es (1)(3)(− 13 ) = −1, el cual, usted puede comprobar, es el determi-
nante de Ǎ. Este método es sutı́lmente más complicado cuando se usa el pivoteo. Si el número
de pivoteos es impar, el determinante es el producto negativo de los coeficientes de los elemen-
tos de la diagonal. Ahora deberı́a ser obvio que la regla de Cramer es computacionalmente
una manera ineficiente para resolver el conjunto de ecuaciones lineales.
10.1.5. Eliminación Gaussiana en Octave.

No necesitamos escribir un programa en Octave para realizar la eliminación Gaussiana
con pivoteo. En vez de esto nosotros podemos usar las capacidades de manipulación de
matrices que viene con Octave. En Octave, la eliminación Gaussiana es una rutina primitiva,
tal como las funciones seno o raı́z cuadrada. Como con cualquier rutina “enlatada”, usted
deberı́a entender, en general, como trabaja y reconocer posibles problemas, especialmente los
computacionales (e.g., ¿poner sqrt(-1) retorna un número imaginario o un error?).
Octave implementa la eliminación de Gauss usando los operadores slash / y backslash \.
El sistema de ecuaciones lineales ~x Ǎ = ~b donde ~x y ~b son vectores fila, se resuelve usando
el operador slash como ~x = ~b/Ǎ. El sistema de ecuaciones lineales Ǎ ~x = ~b donde ~x y ~b son
vectores columna, se resuelve usando el operador backslash como ~x = ~b\Ǎ. Como un ejemplo,
tomemos la ecuación (10.11) con ǫ = 0, escrito en forma matricial
    
0 1 1 x1 5
1 1 0 x2  = 3 (10.19)
1 0 1 x3 4
Usando Octave en forma interactiva la solución es ilustrada a continuación:

octave> A=[0 1 1; 1 1 0; 1 0 1];
octave> b=[5;3;4];
octave> x=A\b;
octave> disp(x);
1
2
3
Claramente, Octave usa pivoteo en este caso. Los operadores slash y backslash pueden ser
usados de la misma manera en programas. El comando en Octave para el determinante de
una matriz es det(A).
10.1.6. Eliminación Gaussiana con C++ de objetos matriciales.

El uso de arreglos multidimensionales en C++ no es del todo comodo. Las maneras usuales
de declarar un arreglo de M × N de números con punto flotante en doble precisión son:
const int M=3, N=3;

double A[M][N] ;
para asignación estática de memoria y
int M, N
. . . // Se fijan valores a M y N
double * * A = new double * [M] ; // asignacion de un vector de punteros
for(int i=0;i<M;i++) {
A[i] = new double [N] ; // asignacion de memoria para cada fila
}
para un reserva dinámica (no olvide desasignar cada fila con un delete[]). Una asignación
estática es simple pero rı́gida, ya que las dimensiones son constantes fijas. Cuando el arreglo
estático es pasado a una función, esta función deberı́a declarar algún arreglo con el mismo
número de columnas de acuerdo al arreglo a ser indexado apropiadamente. Una asignación
dinámica es flexible pero es difı́cil de manejar, aunque los detalles pueden ser escondidos
dentro de funciones separadas. Accesar elementos fuera de los contornos del arreglo es un
error de programación común (bug) el cual es difı́cil de rastrear con arreglos dinámicos.
C++ nos permite corregir estas deficiencias creando nuestros propios tipos de variables.
Estas variables definidas por el usuario son llamadas clases de objetos. De aquı́ en adelante
usaremos la clase Matrix para declarar arreglos de una o dos dimensiones de números de punto
flotante. Esta clase está enteramente declarada dentro del archivo de cabecera Matrix.h e
implementada dentro de Matrix.cc. Algunos ejemplos de declaración de objetos de Matrix
son
int M=3, N=2 ;

Matrix A(M,N), b(N), x(3) ;
Aunque esto se parece a una asignación de arreglo estático, note que las dimensiones no son
constantes fijas. Tanto vectores unidimensionales como matrices bidimensionales pueden ser
declarados; las anteriores son tratadas como matrices de una sola columna. Los valores en
estas variables pueden ser fijados por la declaración de asignamiento
A(0,0)=0; A(0,1)=1; A(0,2)=1;

A(1,0)=1; A(1,1)=1; A(1,2)=0;
A(2,0)=1; A(2,1)=0; A(2,2)=1;
b(1)=5; b(2)=3; b(3)=4.
El formato para el objeto Matrix es A(i, j) en vez de A[i][j], para distinguirlos de los arreglos
C++ convencionales.
Un objeto Matrix conoce sus dimensiones, y usted puede obtenerlas usando las funciones
miembros nRow() y nCol(). Por ejemplo:
Entradas: Ǎ, ~b.
Salidas: ~x, det Ǎ.
Fija el factor de escala, si = maxj (| Ai,j |) para cada fila.
Itera sobre las filas k = 1, . . . , (N − 1).
• Selecciona la fila a pivotear a partir de maxj (| Aj,k |)/sk .

• Realiza pivoteos usando la lista de ı́ndice de filas.
• Realiza la eliminación hacia adelante.
Calcula el determinante det Ǎ, como producto de los elementos de la diagonal.
Realiza la sustitución hacia atrás.
Cuadro 10.1: Bosquejo de la función ge, la cual resuelve un sistema de ecuaciones lineales
Ǎ ~x = ~b por eliminación Gaussiana. La función también devuelve el determinante de Ǎ.
int m = A.nRow(), n = A.nCol() ;

asigna m y n a las dimensiones de A. La verificación de los contornos se realiza cada vez que
un objeto Matrix es indexado. Las lı́neas
Matrix newA(3, 7) ; // Una matriz no cuadrada de 3 por 7
newA(4,5) = 0; // Fuera de los limites
produce el mensaje de error: Indice de fila fuera de los limites cuando el programa
es corrido. Esto significa que al menos uno de los ı́ndices i no satisface la condición 0 < i ≤ N .
Los objetos Matrix automáticamente liberan la memoria que les fue asignada cuando ellos
exceden su alcance (scope), por lo tanto no es necesario invocar delete.
Para asignar todos los elementos de un objeto Matrix a un valor dado usamos la función
miembro set(double x ), por ejemplo A.set(1.0). Una matriz entera puede ser asignada a
otra del mismo tamaño (e.g., Matrix C(3,3); C=A;). Sin embargo, a diferencia de las matri-
ces de Octave, operaciones aritméticas como 2*A no están aún implementadas. Operaciones
de este tipo deberı́an ser llevadas a cabo elemento por elemento, tı́picamente usando ciclos
for.
La rutina de eliminación Gaussiana ge, la cual usa los objetos tipo Matrix, es descrita
en la tabla 10.1. Declarando y asignando la matriz A y los vectores b y x como arriba, un
programa puede llamar esta rutina como
double determ = ge(A, b, x) ; // Eliminacion Gaussiana
cout << x(1) << ", " << x(2) << ", " << x(3) << endl ;
cout << "Determinante = " << determ << endl ;
para resolver el sistema lineal Ǎ ~x = ~b y calcular el determinante de Ǎ.
10.2. Matriz inversa.

10.2.1. Matriz inversa y eliminación Gaussiana.
En la sección previa hemos revisado cómo resolver un conjunto de ecuaciones simultáneas
por eliminación de Gauss. Sin embargo, si usted está familiarizado con el álgebra lineal,
probablemente podrı́a escribir la solución de
Ǎ ~x = ~b , (10.20)
como
~x = Ǎ−1 ~b , (10.21)
donde Ǎ−1 es la matriz inversa de Ǎ. No nos deberı́a sorprender que el cálculo de la matriz
inversa esté relacionada al algoritmo para resolver un conjunto de ecuaciones lineales. Usual-
mente la inversa de una matriz es calculada por aplicaciones repetidas de eliminaciones de
Gauss (o una variante de descomposición llamada LU).
La inversa de una matriz está definida por la ecuación
Ǎ Ǎ−1 = Iˇ , (10.22)
donde Iˇ es la matriz identidad  

1 0 0 ...
0 1 0 . . .
Iˇ = 0 . (10.23)
 
0 1 . . .
.. .. ..
 
..
. . . .
Definiendo los vectores columna
..
     
1 0
0 1 .
ê1 = 0 , ê2 = 0 , ... , êN = 0 , (10.24)
     
0
.. ..
   
. . 1
podrı́amos escribir la matriz identidad como una vector fila de los vectores columna
Iˇ = ê1 ê2 . . . êN .

(10.25)
Si resolvemos el conjunto de ecuaciones lineales,
Ǎ ~x1 = ê1 . (10.26)
El vector solución ~x1 es la primera columna de la inversa Ǎ−1 . Si procedemos de esta manera
con los otros êi calcularemos todas las columnas de Ǎ−1 . En otras palabras, nuestra ecuación
para la matriz inversa ǍǍ−1 = Iˇ es resuelta escribiéndola como

Ǎ ~x1 ~x2 . . . ~xN = ê1 ê2 . . . êN . (10.27)
10.2. MATRIZ INVERSA. 301
Entradas: Ǎ.
Salidas: Ǎ−1 , det Ǎ.
Matriz b̌ es inicializada a la matriz identidad.
Fija el factor de escala, si = maxj (| Ai,j |) para cada fila.
Itera sobre las filas k = 1, . . . , (N − 1).
• Selecciona la fila a pivotear a partir de maxj (| Aj,k |)/sj .

• Realiza pivoteos usando la lista de ı́ndice de filas.
• Realiza la eliminación hacia adelante.
Calcula el determinante detǍ, como producto de los elementos de la diagonal.
Realiza la sustitución hacia atrás.
Cuadro 10.2: Bosquejo de la función inv, la cual calcula el inverso de una matriz y su
determinante.
Después de calcular los ~x, construimos Ǎ−1 como
 
(~x1 )1 (~x2 )1 . . . (~xN )1
 x1 )2
(~ (~x2 )2 . . . (~xN )2 
Ǎ−1

= ~x1 ~x2 . . . ~xN =  .. .. ..  (10.28)

 . ...
. . 
(~x1 )N (~x2 )N . . . (~xN )N
donde(~xi )j es el elemento j de ~xi .

La tabla 10.2 muestra la función inv para calcular la inversa de una matriz. En Octave,
inv(A) es una función internamente construida que regresa a la matriz inversa de A . Es
posible resolver un sistema de ecuaciones lineales usando la matriz inversa, pero hacer esto
es usualmente sobrepasarse. Una excepción podrı́a ser el caso donde deseamos resolver un
número de problemas similares en el cual la matriz Ǎ es fija pero el vector ~b toma muchos
valores diferentes. Finalmente, aquı́ hay una fórmula manual para tener presente: la inversa
de una matriz 2 × 2 es

−1 1 a22 −a12
Ǎ = . (10.29)
a11 a22 − a12 a21 −a21 a11
Para matrices mayores las fórmulas rápidamente llegan a ser muy desordenadas.
10.2.2. Matrices singulares y patológicas.

Antes que regresemos a la Fı́sica, discutamos otro posible riesgo en resolver sistemas de
ecuaciones lineales. Consideremos las ecuaciones
x1 + x2 = 1
. (10.30)
2x1 + 2x2 = 2
Note que realmente no tenemos dos ecuaciones independientes, ya que la segunda es sólo el
doble de la primera. Estas ecuaciones no tienen una solución única. Si tratamos de hacer una
eliminación hacia adelante, obtenemos
x1 + x2 = 1
, (10.31)
0 = 0
y no se puede hacer nada más.

Otra manera de mirar este problema es ver que la matriz

1 1
Ǎ = (10.32)
2 2
no tiene inversa. Una matriz sin inversa se dice que es singular. Una matriz singular tam-
bién tiene un determinante nulo. Las matrices singulares no siempre son evidentes. ¿Podrı́a
adivinar si esta matriz  
1 2 3
4 5 6
7 8 9
es singular?
Aquı́ está lo que pasa en Octave cuando tratamos de resolver (10.30)
octave:1> A=[1 1; 2 2];

octave:2> b=[1; 2];
octave:3> x=A\b;
warning: matrix singular to machine precision, rcond = 0
Dependiendo de su compilador, la rutina inv de C++ probablemente retorne infinito o de

un mensaje de error. En algunos casos la rutina calcula una inversa para una matriz singular,
pero naturalmente la respuesta es espuria.
Algunas veces la matriz no es singular pero está tan cerca de serlo que los errores de
redondeo podrı́an “empujarla al abismo”. Un ejemplo trivial serı́a

1+ǫ 1
, (10.33)
2 2
donde ǫ es un número muy pequeño. A una matriz se le dice patológica cuando está muy
cerca de ser singular.
Si usted sospecha que está tratrando con ~
una matriz patológica cuando resuelve Ǎ~x = b,
entonces calcule el error absoluto, Ǎ~x − ~b / ~b para comprobar si ~x es una solución precisa.

10.2. MATRIZ INVERSA. 303
Formalmente, la condición numérica está definida como la “distancia” normalizada entre

una matriz y la matriz singular más cercana5 . Hay una variedad de maneras para definir
la distancia, dependiendo del tipo de norma usada. La función de Octave cond(A) regresa
la condición numérica de una matriz A. Una matriz con una gran condición numérica es
patológica. Un pequeño determinante puede algunas veces advertirnos que la matriz podrı́a
ser patológica, pero la condición numérica es el criterio real.6
10.2.3. Osciladores armónicos acoplados.

En el comienzo de este capı́tulo, discutimos el problema de encontrar los estados es-
tacionarios de ecuaciones diferenciales ordinarias. Un ejemplo canónico de un sistema con
interacciones lineales es el caso de osciladores armónicos acoplados. Consideremos el sistema
mostrado en la figura 10.1; las constantes de resorte son k1 , . . . , k4 . La posición de los blo-
ques, relativas a la pared izquierda, son x1 , x2 y x3 . La distancia entre las paredes es LP , y las
longitudes naturales de los resortes son L1 , . . . , L4 . Los bloques son de ancho despreciable.
Lp
x2
x1
Figura 10.1: Sistema de bloques acoplados por resortes anclados entre paredes.
La ecuación de movimiento para el bloque i es

dxi dvi 1
= vi , = Fi , (10.34)
dt dt mi
donde Fi es la fuerza neta sobre el bloque i. En el estado estacionario, las velocidades vi , son
nulas y las fuerzas netas, Fi son cero. Esto es justo el caso de equilibrio estático. Nuestro
trabajo ahora es encontrar las posiciones en reposo de las masas. Explı́citamente las fuerzas
netas son
F1 = −k1 (x1 − L1 ) + k2 (x2 − x1 − L2 )
F2 = −k2 (x2 − x1 − L2 ) + k3 (x3 − x2 − L3 ) (10.35)
F3 = −k3 (x3 − x2 − L3 ) + k4 (Lp − x3 − L4 )
o en forma matricial,
      
F1 −k1 − k2 k2 0 x1 −k1 L1 + k2 L2
F2  =  k2 −k2 − k3 k3  x2  −  −k2 L2 + k3 L3  . (10.36)
F3 0 k3 k3 − k 4 x3 −k3 L3 + k4 (L4 − Lp )
5
S. Conte and C. de Boor, Elementary Numerical Analysis (New York: McGraw-Hill, 1980).
6
G.H. Golub and C.F. van Loan, Matrix computation 2d ed. (Baltimore Johns Hopkins University Press,
1989).
Por conveniencia, abreviaremos la ecuación de arriba como F~ = Ǩ~x − ~b. En forma matricial
las simetrı́as son claras, y vemos que no serı́a difı́cil extender el problema a un sistema más
grande de osciladores acoplados. En el estado de equilibrio estático las fuerzas netas son
iguales a cero, ası́ obtenemos el resto de las posiciones de las masas resolviendo Ǩ~x − ~b.
10.3. Sistemas de ecuaciones no lineales.

10.3.1. Método de Newton en una variable.
Ahora que sabemos cómo resolver sistemas de ecuaciones lineales, procederemos al caso
más general (y más desafiante) de resolver sistemas de ecuaciones no lineales. Este problema
es difı́cil, tanto que consideraremos primero el caso de una variable. Deseamos resolver para
x∗ tal que
f (x∗ ) = 0 . (10.37)
donde f (x∗ ) es ahora una función general. Hay un número de métodos disponibles para
encontrar raices en una variable. Quizás usted conozca algunos métodos como el de bisección
o de la secante u otros algoritmos. También hay algoritmos especializados para cuando f (x)
es un polinomio (e.g., función de roots en Octave). En vez de utilizar todos estos esquemas,
nos concentraremos en el más simple y útil de los métodos para el caso general de N variables.
El método de Newton7 está basado en la expansión de Taylor de f (x) entorno a la raı́z
∗
x . Supongamos que hacemos una estimación acerca de la localización de la raı́z; llamamos
a esta estimación x1 . Nuestro error podrı́a ser escrito como δx = x1 − x∗ o x∗ = x1 − δx.
Escribiendo la expansión de Taylor de f (x∗ ),
df (x1 )
f (x∗ ) = f (x1 − δx) = f (x1 ) − δx + O(δx2 ) . (10.38)
dx
Note que si x∗ es una raı́z, f (x∗ ) = 0, ası́ podemos resolver para δx
f (x1 )
δx = + O(δx2 ) . (10.39)
f ′ (x1 )
Despreciamos el término O(δx2 ) (este será nuestro error de truncamiento) y usamos la ex-
presión resultante de δx para corregir nuestra estimación inicial. La nueva estimación es
f (x1 )
x2 = x1 − δx = x1 − . (10.40)
f ′ (x1 )
Este procedimiento podrı́a ser iterado como
f (xn )
xn+1 = xn − , (10.41)
f ′ (xn )
para mejorar nuestra estimación hasta obtener la precisión deseada.
El procedimiento iterativo descrito más arriba puede entenderse mejor gráficamente (figu-
ra 10.2). Note que en cada paso usamos la derivada de f (x) para dibujar la lı́nea tangente a
7
F.S. Acton, Numerical Methods that Work (New York: Harper&Row, 1970).
10.3. SISTEMAS DE ECUACIONES NO LINEALES. 305
f(x)
x2 x* x
x1 x3
Figura 10.2: Representación gráfica del método de Newton.
la función. Donde esta lı́nea tangente intersecta el eje x es nuestra siguiente estimación de la
raı́z. Efectivamente, estamos linealizando f (x) y resolviendo el problema lineal. Si la función
es bien comportada, pronto será aproximadamente lineal en alguna vecindad cerca de la raı́z
x∗ .
Unas pocas notas acerca del método de Newton: primero, cuando converge, encuentra una
raı́z muy rápidamente; pero, desafortunadamente, algunas veces diverge (e.g., f ′ (xn ) ≈ 0) y
falla. Para funciones bien comportadas, este método es garantizado que converger si estamos
suficientemente cerca de la raı́z. Por esta razón algunas veces está combinada con un algoritmo
más lento pero que asegura encontrar la raı́z, tal como la bisección. Segundo, si hay varias
raices, la raı́z a la cual el método converge depende de la estimación inicial (que podrı́a no
ser la raı́z deseada). Hay procedimientos (e.g., “deflation”) para encontrar múltiples raices
usando el método de Newton. Finalmente, el método es más lento cuando se encuentran
raices tangentes, tales como para f (x) = x2 .
10.3.2. Método de Newton multivariable.

No es difı́cil generalizar el método de Newton a problemas de N variables. Ahora nuestra
incógnita ~x = [x1 , x2 , . . . , xN ] es un vector fila, y deseamos encontrar los ceros (raices) de
la función vector fila
f~(~x) = [f1 (~x) , f2 (~x) , . . . , fN (~x)] . (10.42)
De nuevo, hacemos una estimación inicial para ubicar la raı́z, llamamos a esta estimación ~x1 .
Nuestro error podrı́a ser esrito como δ~x = ~x1 − ~x ∗ o ~x ∗ = ~x1 − δ~x. Usando la expansión de
Taylor de f~(~x1 ),
f~(~x ∗ ) = f~(~x1 − δ~x) = f~(~x1 ) − δ~x Ď(~x1 ) + O(δ~x 2 ) , (10.43)
donde Ď es el Jacobiano, definido como
∂fj (~x)
Dij (~x) = . (10.44)
∂xi
Ya que ~x ∗ es la raı́z, f~(~x ∗ ) = 0, como antes podrı́amos resolverla para δ~x. Despreciando el
término de error, podemos escribir la ecuación (10.43) como
f~(~x1 ) = δ~x Ď(~x1 ) , (10.45)
o
δ~x = f~(~x1 ) Ď−1 (~x1 ) . (10.46)
Nuestra nueva estimación es
~x2 = ~x1 − δ~x = ~x1 − f~(~x1 ) Ď−1 (~x1 ) . (10.47)
Este procedimiento puede ser iterado para mejorar nuestra estimación hasta que sea obtenida
la precisión deseada. Ya que Ď cambia en cada iteración, podrı́a ser desgastador calcular su
inversa. En cambio, usamos la eliminación Gaussiana sobre la ecuación (10.45) para resolver
para δ~x, y calcular la nueva estimación como ~x2 = ~x1 − δ~x.
10.3.3. Programa del método de Newton.

Para demostrar el método de Newton, lo usaremos para calcular estados estacionarios del
modelo de Lorenz.
A principios de la década de 1960 el meteorólogo del MIT, Ed Lorenz, encontró que el
tiempo es intrı́nsecamente impredecible, no por su complejidad, sino por la naturaleza no
lineal de las ecuaciones que lo gobiernan. Lorenz formuló un modelo simple del clima global,
reduciendo el problema a un sistema de ecuaciones diferenciales ordinarias de 12 variables.
Él observó que este sistema tenı́a un comportamiento aperiódico y que era extremadamente
sensible a las condiciones iniciales. Estudiemos un modelo de Lorenz simplificado a tres
variables
dx
= σ(y − x) ,
dt
dy
= rx − y − xz , (10.48)
dt
dz
= xy − bz ,
dt
donde σ, r y b son contantes positivas. Estas ecuaciones simples fueron originalmente desa-
rrolladas como un modelo para un fluido con convección. La variable x mide la razón de con-
vección, y y z miden los gradientes de temperaturas horizontales y verticales. Los parámetros
σ y b dependen de las propiedades del fluido y de la geometrı́a del contenedor; comúnmente,
los valores σ = 10 y b = 8/3 son usados. El parámetro r es proporcional al gradiente de
temperatura aplicado.
Un programa que encuentra las raices de este sistema de ecuaciones usando el método
de Newton, al que llamamos newtn, es esbozado en la tabla 10.3. Este programa llama la
función fnewt (tabla 10.4), la cual, dado un ~x = [x , y , z] regresa
   
σ(y − x) −σ σ 0
f~ = rx − y − xz  , Ď = r − z −1 −x . (10.49)
xy − bz y x −b
10.3. SISTEMAS DE ECUACIONES NO LINEALES. 307
Conjunto inicial de estimaciones ~x1 y parámetros λk .
Itera sobre el número de pasos deseados.
• Evalúa la función f~(~xn ; λk ) y su Jacobiano Ď.

• Encuentra δ~x por la eliminación Gaussiana [ver (10.45)].
• Actualiza la estimación para la raı́z usando ~xn+1 = ~xn − δ~x.
Imprime la estimación final de la raı́z.
Cuadro 10.3: Descripción del programa newtn, el cual encuentra una raı́z para un conjunto
de ecuaciones.
√ √
√ σ = 10 y b = 8/3, las tres raı́ces son [x, y, z] = [0, 0, 0], [6 2, 6 2, 27] y
Para√ r = 28,
[−6 2, −6 2, 27].
Un√ejemplo
√ de la salida de newtn está dada más abajo; note que el programa obtiene la
raı́z [6 2, 6 2, 27].
octave:1> newtn
newtn is the file: ~/cursos/MFM1.apuntes2/programas/newtn.m
newtn - Programa para resolver un sistema de ecuaciones no lineales

usando el metodo de Newton. Las ecuaciones estan definidas en fnewt
Entre la estimacion inicial (vector columna): [50; 50; 50]

Entre los parametros a: [28 10 8/3]
Despues de 10 iteraciones la raiz es
8.4853 8.4853 27.0000
Otras condiciones iniciales convergen a otras raices. Por ejemplo, comenzando

√ √por [2, 2, 2],
convergemos a la raı́z [0, 0, 0]; si comenzamos en [5, 5, 5], converge a [−6 2, −6 2, 27]. Co-
menzando por el punto [4, 4, 15], el método converge a una raı́z sólo después de hacer una
excursión increı́blemente distante del origen.
10.3.4. Continuación.
La primera dificultad con el método de Newton es la necesidad de dar una buena estima-
ción inicial para la raı́z. A menudo nuestro problema es de la forma
f~(~x ∗ ; λ) = 0 , (10.50)
donde λ es algún parámetro en el problema. Supongamos que conocemos una raı́z ~x0∗ para el
valor λ0 pero necesitamos encontrar una raı́z para un valor diferente de λa . Intuitivamente,
si λa ≈ λ0 , entonces ~x0∗ deberı́a ser una buena estimación inicial para encontrar ~xa∗ usando
Entradas: ~x = [x, y, z], λ = [r, σ, b].

~ Ď.
Salidas: f,
Evalúa f~ por el modelo de Lorenz [(10.49)].
Evalúa el Jacobiano Ď para el modelo de Lorenz.
Cuadro 10.4: Descripción de la función fnewt, la cual es usada por newtn para encontrar los
estados estables de la ecuación de Lorenz.
el método de Newton. Pero si λa 6≈ λ0 , ¿hay alguna manera para hacer uso de nuestra raı́z
conocida?
La respuesta es sı́ y la técnica es conocida como continuación. La idea es acercarse poco
a poco a λa definiendo la siguiente secuencia de λ :
i
λi = λ0 + (λa − λ0 ) , (10.51)
N
para i = 1, . . . . . . ., N . Usando el método de Newton, resolvemos f (~x1∗ ; λ1 ) = 0 con ~x0∗
como la estimación inicial. Si N es suficientemente grande, entonces λ1 ≈ λ0 y el método
podrı́a converger rápidamente. Luego usamos ~x1∗ como una estimación inicial para resolver
f (~x2∗ ; λ2 ) = 0; la secuencia continúa hasta alcanzar nuestro valor deseado en λa . La técnica
de continuación tiene un beneficio adicional que podemos usar cuando estamos interesados
en conocer no sólo una raı́z simple, sino conocer como ~x ∗ varı́a con λ.

10.4.1. Manejo de matrices en Python.
# -*- coding: iso-8859-1 -*-
from numpy import *
A= array( [[0,1,1], [1,1,0], [1,0,1]] ) # Matriz

b= array( [[5],[3],[4]] ) # vector columna
c= array( [5,3,4] ) # vector fila
print A
print b
print c
print linalg.solve(A,b) # Resuelve Ax=b

print linalg.solve(A,c) # Resuelve Ax=c
print linalg.det(A) # Determinante matriz
print linalg.inv(A) # Inversa de la matriz
10.4.2. Programa newtn en Python.

from numpy import *
def fnewt(x,a):
f = array( [a[1]*(x[1]-x[0]),
a[0]*x[0]-x[1]-x[0]*x[2],
x[0]*x[1]-a[2]*x[2]])
D = array( [[-a[1], a[1], 0],
[a[0]-x[2], -1, -x[0]],
[x[1], x[0],-a[2]]])
return (f,D)
def main():
x = input("Ingrese la estimacion inicial x_1, x_2, x_3 : ")
x0=array(x)
t = input("Ingrese los parametros r, sigma, b : ")
a=array(t)
nStep=10
for i in range(0,nStep):
f, D = fnewt(x,a)
dx = linalg.solve(D,f)
x=x-dx
print "Despues de %d iteraciones la raiz es" % nStep

print x
# end main
main()
10.4.3. Definición de la clase Matrix.

//
// Clase de Matrices doubles
//
#ifndef _Matrix_h
#define _Matrix_h
#include <iostream>
#include <string>
class Matrix {
private:
int nFilP ;
int nColP ;
int dimP ;
double * dataP ;
void copy(const Matrix &) ;
public:
Matrix() ;
Matrix( int, int = 1, double = 0.0e0) ;
Matrix( const Matrix &) ;
~Matrix() ;
Matrix & operator = (const Matrix &) ;
double & operator () (int, int =0) ;
int nRow () const;
int nCol () const ;
void set(double) ;
double maximoF(int) const ;
void pivot(int,int) ;
void multi(double, int, int ) ;
};
ostream & operator << (ostream &, Matrix );

void error ( int, string="Error") ;
Matrix operator * (Matrix, Matrix) ;

Matrix operator + (Matrix, Matrix) ;
Matrix operator - (Matrix, Matrix) ;
#endif
10.4.4. Implementación de la clase Matrix.

//
// Implementacion de la clase Matrix
#include "Matrix.h"
#include <cassert>
#include <cstdlib>
// Funcion privada de copia

void Matrix::copy(const Matrix & mat) {
nFilP=mat.nFilP ;
nColP=mat.nColP ;
dimP = mat.dimP ;
dataP = new double[dimP] ;
for(int i =0 ; i< dimP; i++) dataP[i]=mat.dataP[i] ;
}
// Constructor default Crea una matriz de 1 por 1 fijando su valor a cero

Matrix::Matrix() {
Matrix(1) ;
}
// Constructor normal Crea una matriz de N por M

// y fija sus valores a cero o a un valor ingresado
Matrix::Matrix(int nF, int nC, double v) {
error(nF>0 && nC >0, "Una de las dimensiones no es positiva" ) ;
nFilP= nF ;
nColP = nC ;
dimP = nFilP*nColP ;
dataP = new double[dimP] ;
assert(dataP != 0) ; // Habia memoria para reservar
for (int i=0; i < dimP; i++) dataP[i]=v ;
}
// Constructor de copia
Matrix::Matrix( const Matrix & mat) {

this->copy(mat) ;
// this permite acceder a la misma vartiable como un todo
// *this representa la variable, y this un puntero a ella
// -> nos permite elegir miembros de la clase pero cuando tenemos el puntero
// a la variable y no su valor
}
// Destructor
Matrix::~Matrix() {
delete [] dataP ; // Libera la memoria
}
// Operador Asignacion, sobrecarga del = para que funcione con Matrix

Matrix & Matrix::operator= (const Matrix & mat) {
if( this == &mat ) return *this ; // Si ambos lados son iguales no hace nada
delete [] dataP ; // borra la data del lado izquierdo
this-> copy(mat) ;
return * this ;
}
// Funciones simples que retornan el numero de filas y de columnas

// el const al final indica que no modifican ningun miembro de la clasa
int Matrix::nRow() const {return nFilP; }
int Matrix::nCol() const {return nColP;}
// operador Parentesis
// Permite accesar los valores de una matriz via el par (i,j)
// Ejemplo a(1,1)=2*b(2,3)
// Si no se especifica la columna la toma igual a 0
double & Matrix::operator() (int indF, int indC) {
error(indF>-1 && indF< nFilP, "Indice de fila fuera de los limites") ;
error(indC>-1 && indC<nColP, "Indice de columna fuera de los limites" ) ;
return dataP[indC+nColP*indF] ;
}
void Matrix::set(double value) {

for(int i=0; i<dimP; i++) dataP[i]=value ;
}
double Matrix::maximoF(int indF) const {

error(indF>-1 && indF< nFilP, "Indice de fila fuera en maximoF") ;
double max= dataP[nColP*indF];
for(int i=nColP*indF; i<nColP*(indF+1); i++ ) {
max = (max > fabs(dataP[i]) ) ? max : fabs(dataP[i]) ;

}
return max ;
}
void Matrix::pivot(int indF1, int indF2) {

error(indF1>-1 && indF1< nFilP, "Primer indice de fila fuera en Pivot") ;
error(indF2>-1 && indF2< nFilP, "Segundo indice de fila fuera en Pivot") ;
if(indF1==indF2) return ;
double paso ;
int ind1, ind2 ;
for (int i = 0; i < nColP; i++ ) {
ind1 = nColP*indF1+i ;
paso = dataP[ind1] ;
dataP[ind1] = dataP[ind2] ;
dataP[ind2] = paso ;
}
}
void Matrix::multi(double fact, int indF1, int indF2 ) {

int ind1, ind2 ;
for (int i = 0; i < nColP; i++ ) {
dataP[ind2] += fact*dataP[ind1] ;
}
}
//
// IOSTREAM <<
//
ostream & operator << (ostream & os, Matrix mat ) {
for(int indF=0; indF < mat.nRow(); indF++) {
os << "| " ;
for(int indC=0; indC<mat.nCol(); indC++) {
os << mat(indF,indC) << " ";
}
os << "|"<<endl ;
}
return os ;
}
void error ( int i, string s) {

if(i) return ;
cout << s<<"\a" <<endl ;
exit(-1);
}
Matrix operator * (Matrix A , Matrix B) {

int nColA = A.nCol() ;
int nColB = B.nCol() ;
int nFilA = A.nRow() ;
int nFilB = B.nRow() ;
error(nColA == nFilB, "No se pueden multiplicar por sus dimensiones") ;
Matrix R(nFilA , nColB ) ;
for (int indF = 0; indF<nFilB; indF++){
for (int indC=0; indC<nColA; indC++){
double sum = 0.0 ;
for (int k=0; k < nColA; k++ ) sum += A(indF, k) * B(k, indC) ;
R(indF, indC) = sum ;
}
}
return R ;
}
Matrix operator + (Matrix A , Matrix B) {

error(nFilA == nFilB && nColA== nColB, "tienen dimensiones distintas") ;
Matrix R(nFilA , nColA ) ;
R(indF, indC) = A( indF, indC) + B(indF, indC);
}
}
return R ;
}
Matrix operator - (Matrix A , Matrix B) {

error(nFilA == nFilB && nColA== nColB, "tienen dimensiones distintas") ;
Matrix R(nFilA , nColA ) ;

R(indF, indC) = A( indF, indC) - B(indF, indC);
}
}
return R ;
}
10.4.5. Función de eliminación Gaussiana ge.

//
// Eliminacion Gaussiana.
//
#include "Matrix.h"
double ge( Matrix A, Matrix b, Matrix & x)

{
int nFil = A.nRow() ;
int nCol = A.nCol() ;
Matrix si (nFil) ;
for ( int indF= 0; indF < nFil ; indF++) si(indF)= A.maximoF(indF) ;

double determinante=1.0e0 ;
for (int indC= 0; indC< nCol-1; indC++) {
// pivoteo
double max = A(indC,indC)/si(indC) ;
int indicePivot = indC ;
for (int i = indC+1; i < nCol ; i++){
if( A(i, indC)/si(i) > max ) {
max = A(i,indC)/si(i) ;
indicePivot = i ;
}
}
if(indicePivot != indC) {
A.pivot(indC, indicePivot) ;
b.pivot(indC, indicePivot) ;
determinante *= -1.0e0 ;
}
double Ad= A(indC,indC) ;
for (int indF=indC+1; indF< nFil; indF++ ) {
double factor = - A(indF, indC)/Ad ;
A.multi(factor, indC, indF);
b.multi(factor, indC, indF);
}
}
for (int indF= nFil-1; indF >=0; indF--) {
double sum =0.0e0 ;
for (int i = indF+1; i < nCol; i++) sum += A(indF, i)*x(i) ;
x(indF) = b(indF)/A(indF, indF) - sum /A(indF, indF);
}
double determ = 1.0e0 ;
for (int i = 0; i < nCol; i++) determ *= A(i,i) ;
return determinante*determ ;
}
10.4.6. Función para inversión de matrices inv.

//
// Invierte una matriz
//
#include "Matrix.h"
double inv( Matrix A, Matrix & invA) {

error(nFil==nCol, "Matriz no es cuadrada");
Matrix e(nFil) ;
Matrix x(nFil) ;
double deter = 0.0e0 ;
invA.set(0.0e0) ;
for(int indC=0; indC < nCol; indC++) {
e.set(0.0e0) ;
e(indC) = 1.0e0;
deter = ge( A, e, x) ;
error(fabs(deter)>1.0e-10, " Determinante Singular" );
for (int indF=0; indF< nFil; indF++) invA(indF, indC) = x(indF) ;
}
return deter ;
}
10.4.7. Programa newtn en Octave.

% newtn - Programa para resolver un sistema de ecuaciones no lineales
% usando el metodo de Newton. Las ecuaciones estan definidas en fnewt
suppress_verbose_help_message=1;
clear all; help newtn;
x0=input(’Entre la estimacion inicial (vector columna): ’);

x=x0;
a=input(’Entre los parametros a: ’);
nStep =10;
for iStep=1:nStep
[f D] = fnewt(x,a) ;
dx=D\f ;
x=x-dx;
end
fprintf(’Despues de %g iteraciones la raiz es \n’, nStep);
disp(x’);
Función fnewt en Octave.

function [f,D] = fnewt(x,a)
f(1)=a(2)*(x(2)-x(1));
f(2)= a(1)*x(1)-x(2)-x(1)*x(3);
f(3)=x(1)*x(2)-a(3)*x(3) ;
D(1,1)=-a(2);
D(2,1)=a(1)-x(3);
D(3,1)=x(2);
D(1,2)=a(2);
D(2,2)=-1;
D(3,2)=x(1);
D(1,3)=0;
D(2,3)=-x(1);
D(3,3)=-a(3);
return
10.4.8. Programa newtn en c++.
#include <iostream>
#include "Matrix.h"
void fnewt( Matrix & f, Matrix & D, Matrix xN, Matrix lambda )
{
double r= lambda(0) ;
double s= lambda(1) ;
double b=lambda(2) ;
double x=xN(0) ;
double y=xN(1) ;
double z=xN(2) ;
f(0) = s*(y-x) ;
f(1) = r*x-y-x*z ;
f(2) = x*y-b*z ;
D(0,0) = -s ;
D(1,0) = r-z ;
D(2,0) = y ;
D(0,1) = s ;
D(1,1)= -1.0e0 ;
D(2,1) = x ;
D(0,2)=0.0e0 ;
D(1,2)= -x ;
D(2,2) =-b ;
}
double ge( Matrix A, Matrix b, Matrix & x)

{
Matrix si (nFil) ;
for ( int indF= 0; indF < nFil ; indF++) si(indF)= A.maximoF(indF) ;
double determinante=1.0e0 ;
for (int indC= 0; indC< nCol-1; indC++) {
double max = A(indC,indC)/si(indC) ; // pivoteo
int indicePivot = indC ;
for (int i = indC+1; i < nCol ; i++){
if( A(i, indC)/si(i) > max ) {
max = A(i,indC)/si(i) ;
indicePivot = i ;
}
}
if(indicePivot != indC) {
A.pivot(indC, indicePivot) ;
b.pivot(indC, indicePivot) ;
determinante *= -1.0e0 ;
}
double Ad= A(indC,indC) ;
for (int indF=indC+1; indF< nFil; indF++ ) {
double factor = - A(indF, indC)/Ad ;
A.multi(factor, indC, indF);
b.multi(factor, indC, indF);
}
}
for (int indF= nFil-1; indF >=0; indF--) {
double sum =0.0e0 ;
for (int i = indF+1; i < nCol; i++) sum += A(indF, i)*x(i) ;
x(indF) = b(indF)/A(indF, indF) - sum /A(indF, indF);
}
double determ = 1.0e0 ;
for (int i = 0; i < nCol; i++) determ *= A(i,i) ;
return determinante*determ ;
}
int main()
{
Matrix D(3,3) ;
Matrix f(3) ;
Matrix lambda(3), xN(3), xNp1(3), dx(3) ;
cout <<"Ingrese r , Sigma, b : " ;
cin >> lambda(0) >> lambda(1) >> lambda(2) ;
cout << "Ingrese estimacion inicial : " ;
cin>> xN(0) >> xN(1) >> xN(2) ;
int iteraciones ;
cout << "Ingrese numero de iteraciones : " ;
cin >> iteraciones ;
for (int itera = 0; itera < iteraciones; itera ++ ) {
f.set(0.0e0) ;
D.set(0.0e0) ;
dx.set(0.0e0) ;
fnewt(f, D, xN, lambda ) ;
ge(D, f, dx) ;
xNp1=xN-dx ;
xN=xNp1 ;
cout << xN(0)<< " " << xN(1) << " " << xN(2) << endl ;
}
cout << xN <<endl ;
return 0;
}
Capı́tulo 11
Análisis de datos.
versión 3.0, 02 de Diciembre 20031
A menudo se destaca que los sistemas fı́sicos simulados sobre un computador son similares
al trabajo experimental. La razón de esta analogı́a es hecha ya que la simulación computacio-
nal produce datos en muchas maneras similares a los experimentos de laboratorio. Sabemos
que en el trabajo experimental uno a menudo necesita analizar los resultados y esto es igual
en las simulaciones numéricas. Este capı́tulo cubre parcialmente algunos tópicos en el análisis
de datos.
11.1. Ajuste de curvas.

11.1.1. El calentamiento global.
En el presente, parece que predicciones sobre el tiempo de largo alcance y precisas nunca
se llevarán a cabo. La razón es a causa de las ecuaciones gobernantes que son altamente
no lineales y sus soluciones son extremadamente sensibles a las condiciones iniciales (ver el
modelo de Lorenz). Por otra parte, las predicciones generales acerca del clima terrestre son
posibles. Se pueden predecir si habrá o no condiciones de sequı́a en África en los próximos
años, aunque no la cantidad de precipitaciones de un dı́a en particular.
El calentamiento global es un importante tópico actualmente debatido en los foros de in-
vestigación sobre clima. El calentamiento es culpa de los gases de invernadero, tal como es el
dióxido de carbono en la atmósfera. Estos gases calientan la Tierra porque son transparentes
a la radiación de onda corta que llega desde el Sol, pero opacas a la radiación infrarroja desde
la Tierra. Cientı́ficos y legisladores todavı́a están debatiendo la amenaza del calentamiento
global. Sin embargo, nadie se pregunta qué concentraciones de gases invernadero están en
aumento. Especı́ficamente, los niveles de dióxido de carbono han estado firmemente aumen-
tados desde la revolución industrial. La figura 11.1 muestra el aumento en la concentración
de dióxido de carbono durante los años ochenta, medidos en Mauna Loa, Hawai.
El estudio del calentamiento global ha producido una vasta cantidad de datos, tanto medi-
ciones prácticas, como datos de simulaciones computacionales. En este capı́tulo estudiaremos
algunas técnicas básicas para analizar y reducir tales conjuntos de datos. Por ejemplo, para
los datos mostrados en la figura 11.1, ¿cuál es la razón estimada de crecimiento de la concen-
1
Este capı́tulo está basado en el quinto capı́tulo del libro: Numerical Methods for Physics, second edition
321
322 CAPÍTULO 11. ANÁLISIS DE DATOS.
355
350
CO2 (ppm)
345
340
335
1982 1984 1986 1988 1990
Año
Figura 11.1: Dióxido de carbono (en partes por millón) medida en Mauna Loa, Hawai desde
1981 a 1990. Barra de error estimada es σ0 = 0.16 [p.p.m.] .
tración de CO2 por año?. Esta es la primera pregunta que motiva nuestro estudio de ajustes
de curvas.
11.1.2. Teorı́a general.

El tipo más simple de análisis de datos es ajustar una curva. Suponga que tenemos un
conjunto de datos de N puntos (xi , yi ). Deseamos ajustar estos datos a una función Y (x; {aj }),
donde {aj } es un conjunto de M parámetros ajustables. Nuestro objetivo es encontrar los
valores de esos parámetros, para los cuales la función ajusta mejor los datos. Intuitivamente,
esperamos que si nuestro ajuste de la curva es bueno, un gráfico del conjunto de datos (xi , yi )
y la función Y (x; {aj }) mostrarán la curva pasando cerca de los puntos (ver figura 11.2).
Podemos cuantificar esta sentencia midiendo la distancia entre un punto y la curva.
∆i = Y (xi ; {aj }) − yi . (11.1)
Nuestro criterio de ajuste para la curva será que la suma de los cuadrados de los errores
sea un mı́nimo; esto es, necesitamos encontrar {aj } que minimice la función
N
X N
X
D({aj }) = ∆2i = [Y (xi ; {aj}) − yi ]2 . (11.2)
i=1 i=1
11.1. AJUSTE DE CURVAS. 323
σi Y(x;{aj })
yi
∆i
xi
Figura 11.2: Ajuste de datos a una curva.
Esta técnica nos dará el ajuste de los cuadrados mı́nimos; esta no es la única manera de
obtener un ajuste de la curva, pero es la más común. El método de los mı́nimos cuadrados
fue el primero usado por Gauss para determinar las órbitas de los cometas a partir de los
datos observados.
A menudo, nuestros datos tienen una barra de error estimada (o intervalo de seguridad),
el cual escribimos como yi ± σi . En este caso podrı́amos modificar nuestro criterio de ajuste
tanto como para dar un peso menor a los puntos con más error. En este espı́ritu definimos
N 2 N
2
X ∆i X [Y (xi ; {aj }) − yi ]2
χ ({aj }) = = . (11.3)
i=1
σi i=1
σi2
La función chi-cuadrado es la función de ajuste más comúnmente usada, porque si los errores
son distribuidos gaussianamente, podemos hacer sentencias estadı́sticas concernientes a la
virtud del ajuste.
Antes de continuar, debemos destacar que discutiremos brevemente la validación de la
curva de ajuste. Usted puede ajustar cualquier curva para cualquier conjunto de datos, pero
esto no significa que los resultados sean significativos. Para establecer un significado tene-
mos que preguntarnos lo siguiente: ¿cuál es la probabilidad de que los datos, dado el error
experimental asociado con cada uno de los puntos, sean descritos por la curva?. Desafortu-
nadamente, las hipótesis de prueba ocupan una porción significativa de un curso estadı́stico
y están fuera de los objetivos de estos apuntes.2
11.1.3. Regresión lineal.

Primero consideremos ajustar el conjunto de datos con una lı́nea recta,
Y (x; {a1 , a2 }) = a1 + a2 x . (11.4)

2
W. Mendenhall, R.L. Scheaffer, and D.D. Wackerly, Mathematical Statistics with Applications (Boston:
Duxbury Press, 1981).
Este tipo de ajuste de curva es también conocido como regresión lineal. Deseamos determinar
a1 y a2 tal que
N
X 1
χ2 (a1 , a2 ) = 2
(a1 + a2 xi − yi )2 , (11.5)
i=1
σi
es minimizada. El mı́nimo es encontrado diferenciando (11.5) y ajustando la derivada a cero:

N
∂χ2 X 1
=2 (a1 + a2 xi − yi ) = 0 , (11.6)
∂a1 σ2
i=1 i
N
∂χ2 X 1
=2 (a1 + a2 xi − yi ) xi = 0 , (11.7)
∂a2 σ2
i=1 i
a1 S + a2 Σx − Σy = 0 (11.8)
a1 Σx + a2 Σx2 − Σxy = 0 , (11.9)
donde
N N N
X 1 X xi X yi
S≡ , Σx ≡ , Σy ≡ ,
σ2
i=1 i
σ2
i=1 i
σ2
i=1 i
N N N
(11.10)
X x2 i
X yi2 X xi yi
Σx2 ≡ , 2
Σy ≡ , Σxy ≡ .
i=1
σi2 σ2
i=1 i i=1
σi2
Puesto que las sumas pueden ser calculadas directamente de los datos, ellas son constantes
conocidas. De este modo tenemos un conjunto lineal de dos ecuaciones simultáneas en las
incógnitas a1 y a2 . Estas ecuaciones son fáciles de resolver:
ΣyΣx2 − ΣxΣxy SΣxy − ΣxΣy

a1 = , a2 = . (11.11)
SΣx2 − (Σx)2 SΣx2 − (Σx)2
Note que si σi es una constante, esto es, si el error es el mismo para todos los datos, los σ se
cancelan en las ecuaciones (11.11). En este caso, los parámetros, a1 y a2 , son independientes
de la barra de error. Es común que un conjunto de datos no incluya las barras de error
asociadas. Todavı́a podrı́amos usar las ecuaciones (11.11) para ajustar los datos si tenemos
que los σi son constantes (σi =1 siendo la elección más simple).
Lo siguiente es obtener una barra de error asociado, σaj , para el parámetro aj de la curva
de ajuste. Usando la ley de la propagación de errores,3
N 2
X ∂aj
σa2j = σi2 , (11.12)
i=1
∂yi
3
P. Bevington, Data Reduction an Error Analysis for the Physical Sciences 2d ed. (New York: McGraw-
Hill, 1992).
e insertando las ecuaciones (11.11), después de un poco de álgebra obtenemos

s s
Σx2 S
σa1 = , σa2 = . (11.13)
SΣx2 − (Σx)2 SΣx2 − (Σx)2
Note que σaj es independiente de yi . Si las barras de error de los datos son constantes
(σi = σ0 ), el error en los parámetros es
s s
σ0 hx2 i σ0 1
σa1 =√ , σa2 =√ , (11.14)
N hx2 i − hxi2 N hx2 i − hxi2
donde
N N
1 X 2 1 X 2
hxi = xi , hx i = x . (11.15)
N i=1 N i=1 i
Finalmente, si nuestro conjunto de datos no tiene un conjunto de barras de error asociadas,

podrı́amos estimar σ0 a partir de la diferencia muestral de los datos,
N
1 X
σ02 ≈s = 2
[yi − (a1 + a2 xi )]2 , (11.16)
N − 2 i=1
donde s es la desviación estándar de la muestra. Note que esta varianza muestral está nor-
malizada por N − 2, puesto que hemos extraı́do dos parámetros a1 y a2 , de los datos.
Muchos problemas de ajuste de curva no lineales, pueden ser transformados en problemas
lineales por un simple cambio de variable. Por ejemplo,
Z(x; {α, β}) = αeβx , (11.17)
podrı́a ser reescrita como las ecuaciones (11.4) usando el cambio de variable
ln Z = Y , ln α = a1 , β = a2 . (11.18)
Similarmente, para ajustar una potencia de la forma
Z(t; {α, β}) = αtβ , (11.19)
usamos el cambio de variable
ln Z = Y , ln t = x , ln α = a1 , β = a2 . (11.20)
Estas transformaciones deberı́an ser familiares debido a que se usan para graficar datos en
escala semi logarı́tmica o escalas log-log.
11.1.4. Ajuste general lineal de mı́nimos cuadrados.

El procedimiento de ajuste de mı́nimos cuadrados es fácil de generalizar para funciones
de la forma
M
X
Y (x; {aj }) = a1 Y1 (x) + a2 Y2 (x) + . . . + aM YM (x) = aj Yj (x) . (11.21)
j=1
Para encontrar los óptimos parámetros procedemos como antes encontrando el mı́nimo de
χ2 ,
N
(M )2
∂χ2 ∂ X 1 X
= ak Yk (x) − yi =0, (11.22)
∂aj ∂aj i=1 σi2 k=1
o (M )
N
X 1 X
Yj (xi ) ak Yk (x) − yi = 0 , (11.23)
σ2
i=1 i k=1
por lo tanto
N X
M N
X Yj (xi )Yk (xi ) X Yj (xi )yi
ak = , (11.24)
i=1 k=1
σi2 i=1
σi2
para j = 1, . . . , M . Este conjunto de ecuaciones es conocida como las ecuaciones normales
del problema de los mı́nimos cuadrados.
Las ecuaciones normales son más fáciles de trabajar en forma matricial. Primero, defina-
mos la matriz de diseño Ǎ, como
 
Y1 (xi )/σ1 Y2 (xi )/σ1 . . .
Yj (xi )
Ǎ = Y1 (xi )/σ2 Y2 (xi )/σ2 . . . , Aij = . (11.25)
 
.. .. .. σi
. . .
Note que la matriz de diseño no depende de yi , los valores de datos, pero depende de xi , esto
es, sobre el diseño del experimento (donde las mediciones son tomadas). Usando la matriz de
diseño, podemos escribir (11.24) como
N X
M N
X X yi
Aij Aik ak = Aij , (11.26)
i=1 k=1 i=1
σi
o en forma matricial,
(ǍT Ǎ)~a = ǍT~b , (11.27)
donde el vector ~b está definido como bi = yi /σi y ǍT es la traspuesta de la matriz de diseño.
Esta ecuación es fácil de resolver para el parámetro vector ~a,
~a = (ǍT Ǎ)−1 ǍT~b . (11.28)
Usando este resultado y la ley de propagación de errores, en la ecuación (11.12), encontramos

que el error estimado en el parámetro aj es
p
σaj = Cjj (11.29)
donde Č = (ǍT Ǎ)−1 .

Una aplicación común de esta formulación general lineal de ajuste de mı́nimos cuadrados
es el ajuste de los datos polinomiales,
Y (x; {aj }) = a1 + a2 x + a3 x2 + . . . + aM xM −1 . (11.30)
La matriz de diseño tiene elementos Aij = aj xj−1

I /σi , el cual es un tipo de matriz de Vander-
monde. Desafortunadamente estas matrices son notoriamente patológicas, por lo tanto sea
cuidadoso para M > 10.
11.1.5. Bondades del ajuste.

Podemos fácilmente ajustar cada punto de los datos si el número de parámetros, M , es
igual al número de puntos de los datos, N . En este caso ya sea que hemos construido una
teorı́a trivial o no hemos tomado suficientes datos. En vez de eso, supongamos el escenario
más común en el cual N ≫ M . Porque cada dato de punto tiene un error, no esperemos que
la curva pase exactamente a través de los datos. Sin embargo, preguntemos, con las barras
de error dadas, ¿cuan probable es que la curva en efecto describa los datos?. Por supuesto, si
no se tienen barras de error no hay nada que se pueda decir acerca de la bondad del ajuste.
El sentido común sugiere que si el ajuste es bueno, entonces el promedio de la diferencia
deberı́a ser aproximadamente igual a la barra de error,
| yi − Y (xi ) | ≈ σi . (11.31)
Colocando esto dentro de nuestra definición para χ2 , la ecuación (11.3), da χ2 ≈ N . Sin

embargo, sabemos que entre más parámetros usamos, más fácil es ajustar la curva; el ajuste
puede ser perfecto si M = N . Esto sugiere que nuestra regla práctica para que un ajuste sea
bueno es
χ2 ≈ N − M . (11.32)
Por supuesto, este es sólo un crudo indicador, pero es mejor que una simple ojeada a la curva.
Un análisis completo podrı́a usar χ estadı́stico para asignar una probabilidad de que los datos
sean ajustados por la curva.
Si encontramos que χ2 ≫ N − M , entonces una de dos: no hemos usado una función
apropiada, Y (x), para nuestro ajuste de curva o las barras de errores, σI , son demasiado
pequeñas. Por otra parte, si χ2 ≪ N − M , el ajuste es tan espectacularmente bueno que
podemos esperar que las barras de error sean realmente demasiado grandes.
Habitualmente la calidad de un ajuste se mide por el coeficiente de correlación adimen-
sional que es un número que varı́a entre 0 y 1, correspondiendo a 1 un mejor ajuste.
S(a1 y − a2 xy) − ( y)2

P P P
2
r = P P . (11.33)
S y 2 − ( y)2
Capı́tulo 12
Integración numérica básica

versión final 4.2, 22 de Noviembre del 2007
En este capı́tulo veremos algunos métodos básicos para realizar cuadraturas (evaluar
integrales numéricamente).
12.1. Definiciones
Consideremos la integral
Z b
I= f (x) dx . (12.1)
a
Nuestra estrategia para estimar I es evaluar f (x) en unos cuantos puntos, y ajustar una curva
simple a través de estos puntos. Primero, subdividamos el intervalo [a, b] en N subintervalos.
Definamos los puntos xi como
x0 = a, xN = b, x0 < x1 < x2 < · · · < xN −1 < xN .
La función f (x) sólo se evalúa en estos puntos, de modo que usamos la notación fi ≡ f (xi ),
ver figura 12.1.
f(x)
x0=a x1 x2 xi xN=b
Figura 12.1: Subintervalos.
329
330 CAPÍTULO 12. INTEGRACIÓN NUMÉRICA BÁSICA
12.2. Regla trapezoidal

El método más simple de cuadratura es la regla trapezoidal. Conectamos los puntos fi
con lı́neas rectas, y la función lineal formada por la sucesión de lı́neas rectas es nuestra curva
aproximante. La integral de esta función aproximante es fácil de calcular, pues es la suma de
fi
f(x)
fi+1
Ti
xi xi+1 x
Figura 12.2: Sucesión de lı́neas rectas como curva aproximante.
las áreas de trapecios. El área de un trapecios es
1
Ti = (xi+1 − xi )(fi+1 + fi ) .
2
La integral es entonces calculada como la suma de las áreas de los trapecios:
I ≃ IT = T0 + T1 + · · · + TN −1 .
Las expresiones son más simples si tomamos puntos equidistantes. En este caso el espa-
ciado entre cada par de puntos es
b−a
h= ,
N
de modo que xi = a + ih. El área de un trapecio es entonces
1
Ti = h(fi+1 + fi ) ,
2
y la regla trapezoidal para puntos equiespaciados queda
1 1
IT (h) = hf0 + hf1 + hf2 + · · · + hfN −1 + hfN
2 2
N −1
1 X
= h(f0 + fN ) + h fi (12.2)
2 i=1
12.3. INTERPOLACIÓN CON DATOS EQUIDISTANTES. 331
12.3. Interpolación con datos equidistantes.

Para el caso de puntos xi = a + ih que están igualmente espaciados podemos plantear
un formalismo más general. Primero que todo, ajustemos un polinomio de grado N a un
conjunto de N + 1 datos xi , fi , no necesariamente equidistantes, de la forma:
PN (x) = b0 + b1 (x − x0 ) + · · · + bN (x − x0 )(x − x1 ) · · · (x − xN −1 ) . (12.3)
Determinemos los coeficientes usando los datos:
b0 = f0 = f (x0 )
f1 − f0
b1 = ≡ f [x1 , x0 ]
x − x0
1
f2 − f1 f1 − f0 f [x2 , x1 ] − f [x1 , x0 ]
b2 = − /(x2 − x0 ) = ≡ f [x2 , x1 , x0 ]
x2 − x1 x1 − x0 x2 − x0
..
.
bN = f [xN , xN −1 , xN −2 , . . . , x1 , x0 ] ,
donde hemos usado la definición recurrente
f [xN , xN −1 , xN −2 , . . . , x1 ] − f [xN −1 , xN −2 , . . . , x1 , x0 ]
f [xN , xN −1 , xN −2 , . . . , x1 , x0 ] ≡ .
xN − x0
La expresión anterior es conocida como la n-ésima diferencia dividida finita. Usando estas
definiciones podemos escribir el polinomio de interpolación (12.3) de la siguiente manera:
PN (x) = f0 + f [x1 , x0 ](x − x0 ) + f [x2 , x1 , x0 ](x − x1 )(x − x0 ) + · · ·
+f [xN , xN −1 , xN −2 , . . . , x1 , x0 ](x − x0 )(x − x1 ) · · · (x − xN −1 ) ,
Este polinomio es conocido como el polinomio de interpolación por diferencias divididas de
Newton. Analicemos estos f [. . .] para el caso equiespaciado,
f1 − f0 ∆f0
f [x1 , x0 ] = = .
x1 − x0 1!h
El segundo
f2 − f1 f1 − f0
−
x − x1 x1 − x0 f (x2 ) − 2f (x1 ) + f (x0 ) ∆2 f0
f [x2 , x1 , x0 ] = 2 = = .
x2 − x0 2h2 2!h2
En general tenemos (puede probarse por inducción) que
∆N f0
.
f [xN , xN −1 , xN −2 , . . . , x1 , x0 ] =
N !hN
Luego podemos escribir la llamada fórmula hacia adelante de Newton-Gregory, definiendo
α = (x − x0 )/h de la siguiente manera
∆2 f (x0 ) ∆N f (x0 )
fN (x) = f (x0 ) + ∆f (x0 )α + α(α − 1) + · · · + α(α − 1) · · · (α − N + 1) + RN ,
2! N!
(12.4)
el error de truncamiento viene dado por
f (N +1) (ξ) N +1
RN = h α(α − 1)(α − 2) · · · (α − N ) ,
(N + 1)!
para algún ξ ∈ [a, b].
12.4. Reglas de cuadratura

La integral (12.1) puede ser evaluada separándola en una suma de integrales sobre pe-
queños intervalos que contengan dos o tres puntos, luego usando el polinomio de interpolación
adecuado para el número de puntos escogidos podemos evaluar aproximadamente cada inte-
gral. Para terminar el proceso debemos sumar todas las integrales parciales. Usemos sólo dos
puntos, y entre esos dos puntos aproximamos la función por el polinomio de interpolación de
dos puntos, i.e. por una recta, figura 12.3 (a).
Z xi+1 Z xi+1
∆f (xi ) h2

x − xi
Ii (h) = f (x) dx ≈ f (xi ) + ∆f (xi ) dx = f (xi )h + ,
xi xi h h 2
usando que ∆f (xi ) = f (xi+1 ) − f (xi ) podemos dar una expresión para la integral
f (xi+1 ) + f (xi )
Ii (h) ≈ h. (12.5)
2
f(x) (a) f(x) (b)
xi xi+1 xi xi+1 xi+2

Figura 12.3: Aproximaciones, (a) lineal, (b) cuadrática.
Si consideramos intervalos que contengan tres puntos podemos usar la aproximación a

segundo orden, es decir esta vez aproximamos nuestra función por un polinomio de segundo
grado, figura 12.3 (b).
Z xi+2 Z xi+2
(x − xi ) ∆2 f (xi ) (x − xi ) (x − xi − h)

Ii (h) = f (x) dx ≈ f (xi ) + ∆f (xi ) + dx ,
xi xi h 2 h h
12.4. REGLAS DE CUADRATURA 333
integrando obtenemos
∆f (xi ) 4h2 ∆2 f (xi ) 8h3 4h3

Ii (h) ≈ 2hf (xi ) + + − ,
h 2 2h2 3 2
usando la expresión para ∆f (xi ) = f (xi+1 )−f (xi ) y para ∆2 f (xi ) = f (xi+2 )−2f (xi+1 )+f (xi )
tenemos
h
Ii (h) ≈ (f (xi ) + 4f (xi+1 ) + f (xi+2 )) . (12.6)
3
Se puede continuar encontrando expresiones usando aproximaciones de orden mayor, sin
embargo, las fórmulas (12.5) y (12.6) son, sin duda, las más usadas.
A continuación, para evaluar la integral finita (12.1) debemos sumar las integrales par-
ciales para ambos casos. Partamos sumando (12.5)
b N −1 Z xi+1 N −1
f (xi+1 ) − f (xi )
Z X X
I= f (x) dx = f (x) dx ≈ h ≡ IT (h) ,
a i=0 xi i=0
2
haciendo la suma tenemos

N −1
h X
IT (h) = [f (a) + f (b)] + h f (xi ) , regla trapezoidal. (12.7)
2 i=1
Ahora evaluemos la integral finita, (12.1), usando la descomposición en integrales de tres

puntos ecuación (12.6)
b N −2 xi+2 N −2
h
Z X′ Z X′
I= f (x) dx = f (x) dx ≈ [f (xi ) + 4f (xi+1 ) + f (xi+2 )] ≡ Is (h) ,
a i=0 xi i=0
3
X′
donde significa que el ı́ndice i de la suma se incrementa en dos en cada oportunidad. Si
hacemos la suma tenemos

2h f (a) f (b)
Is (h) = + 2f (x1 ) + f (x2 ) + 2f (x3 ) + f (x4 ) + 2f (x5 ) + . . . + . (12.8)
3 2 2
La cual es conocida como la regla de Simpson. Notemos que se necesita un número impar de
puntos equiespaciados para aplicar esta regla.
Se puede estimar el error cometido en cada caso integrando el término (12.3) que corres-
ponde al error de truncamiento de la expansión. Evaluemos el error para el caso trapezoidal
en que cortamos la expansión a primer orden, por lo tanto el error corresponde
Z xi+1 2
d f (ξ) h2 (x − xi ) (x − xi − h)
ǫT (h) = dx ,
xi dx2 2! h h
haciendo el cambio de variable u = x − xi tenemos
1 d2 f (ξ) h
3
h3 1 d2 f (ξ) h3 d2 f (ξ)

h
Z
ǫT (h) = u(u − h) du = − = −
2 dx2 0 3 2 2 dx2 12 dx2
este es el error en cada integral entre xi y xi+1 , para obtener el error total en la integral entre
a y b tenemos que multiplicar por el número de intervalos (N ),
h3 d2 f (ξ) (b − a)h2 d2 f (ξ) h2 ′

I − IT (h) = N ǫT (h) = −N = − = − (f (b) − f ′ (a)) .
12 dx2 12 dx2 12
La expresión para el error en el método trapezoidal nos queda
1 2 ′
I − IT (h) = − h [f (b) − f ′ (a)] + O(h4 ) . (12.9)
12
Vemos que el error es proporcional a h2 , y que la regla trapezoidal tendrá problemas
Rb√ cuando
la derivada diverge en los extremos del intervalo. Por ejemplo, la integral 0 x dx es pro-
blemática. En el caso de la integral de Simpson se puede probar que el error es proporcional
a h4 .
Como ejemplo, consideremos la función error
Z x
2 2
erf(x) = √ e−y dy . (12.10)
π 0
Para x = 1, erf(1) ≃ 0.842701. La regla trapezoidal con N = 5 da 0.83837, que es correcto

en los dos primeros decimales. La regla de Simpson, con los mismos 5 puntos, da 0.84274,
con cuatro decimales correctos . Por supuesto, el integrando en este ejemplo es muy suave y
bien comportado lo cual asegura que los métodos funcionaran bien.
12.5. Integración de Romberg

Una pregunta usual es cuántas subdivisiones del intervalo realizar. Un modo de decidir es
repetir el cálculo con un intervalo más pequeño. Si la respuesta no cambia apreciablemente,
la aceptamos como correcta (sin embargo, esto no evita que podamos ser engañados por fun-
ciones patológicas o escenarios inusuales). Con la regla trapezoidal, si el número de paneles es
una potencia de dos, podemos dividir el tamaño del intervalo por dos sin tener que recalcular
todos los puntos.
Definamos la secuencia de tamaños de intervalo,
1 1
h1 = (b − a) , h2 = (b − a) , . . . , hn = n−1 (b − a) . (12.11)
2 2
Para n = 1 sólo hay un panel, luego
1 1
IT (h1 ) = (b − a)[f (a) + f (b)] = h1 [f (a) + f (b)] .
2 2
Para n = 2 se añade un punto interior, luego
1
IT (h2 ) = h2 [f (a) + f (b)] + h2 f (a + h2 )
2
1
= IT (h1 ) + h2 f (a + h2 ) .
2
12.5. INTEGRACIÓN DE ROMBERG 335
Hay una fórmula recursiva para calcular IT (hn ) usando IT (hn−1 ):

2n−2
1 X
IT (hn ) = IT (hn−1 ) + hn f [a + (2i − 1)hn ] . (12.12)
2 i=1
El segundo término del lado derecho da la contribución de los puntos interiores que se han
agregado cuando el tamaño del intervalo es reducido a la mitad.
Usando el método recursivo descrito, podemos agregar paneles hasta que la respuesta
parezca converger. Sin embargo, podemos mejorar notablemente este proceso usando un
método llamado integración de Romberg. Primero veamos la mecánica, y después explicaremos
por qué funciona. El método calcula los elementos de una matriz triangular:
R1,1 – – –
R2,1 R2,2 – –
R=R (12.13)
3,1 R3,2 R3,3 –
.. .. .. ..
. . . .
La primera columna es simplemente la regla trapezoidal recursiva:
Ri,1 = IT (hi ) . (12.14)
Las sucesivas columnas a la derecha se calculan usando la fórmula de extrapolación de Ri-

chardson:
1
Ri+1,j+1 = Ri+1,j + j [Ri+1,j − Ri,j ] . (12.15)
4 −1
La estimación más precisa para la integral es el elemento RN,N .
El programa romberg.cc calcula la integral erf(1) usando el método de Romberg. Con
N = 3, se obtiene la tabla
0.771743 0 0
0.825263 0.843103 0
0.838368 0.842736 0.842712
R3,3 da el resultado exacto con 4 decimales, usando los mismos 4 paneles que antes usamos
con la regla trapezoidal (y que ahora reobtenemos en el elemento R3,1 ).
Es útil que el programa entregue toda la tabla y no sólo el último término, para tener
una estimación del error. Como en otros contextos, usar una tabla demasiado grande puede
no ser conveniente pues errores de redondeo pueden comenzar a degradar la respuesta.
Para entender por qué el esquema de Romberg funciona, consideremos el error para la
regla trapezoidal, ET (hn ) = I − IT (hn ). Usando (12.9),
1 2 ′
ET (hn ) = − hn [f (b) − f ′ (a)] + O(h4n ) .
12
Como hn+1 = hn /2,
1 2 ′
ET (hn+1 ) = − h [f (b) − f ′ (a)] + O(h4n ) .
48 n
Consideremos ahora la segunda columna de la tabla de Romberg. El error de truncamiento

para Rn+1,2 es:

1
I − Rn+1,2 = I − IT (hn+1 ) + [IT (hn+1 ) − IT (hn )]
3
1
= ET (hn+1 ) + [ET (hn+1 ) − ET (hn )]
3
1 1 1 1
=− + − h2n [f ′ (b) − f ′ (a)] + O(h4n )
48 3 48 12
= O(h4n )
Notemos cómo el término h2n se cancela, dejando un error de truncamiento de orden h4n . La
siguiente columna (la tercera) de la tabla de Romberg cancela este término, y ası́ sucesiva-
mente.
12.6. Cuadratura de Gauss.

Consideremos el problema de cuadratura sin considerar puntos fijos equidistantes, sino
que pensamos en hacer una elección adecuada de puntos y pesos para cada punto, tal que
nuestra integral pueda aproximarse como:
Z b
f (x) dx ≈ w1 f (x1 ) + . . . + wN f (xn ) , (12.16)
a
aquı́ los xi son un conjunto de puntos elegidos de manera inteligente tal que disminuyan el
error y los wi son sus pesos respectivos, no necesariamente iguales unos con otros.
f(x) (a) f(x) (b)
Figura 12.4: (a) Ilustración de la regla trapezoidal que une los dos puntos extremos por una
recta. (B) Estimación mejorada al elegir inteligentemente los puntos.
El nombre que reciben esta clase de técnicas es Cuadratura de Gauss, la más común de
ellas es la conocida como de Gauss-Legendre, y es útil para un intervalo finito, el cual es
mapeado mediante un cambio de variables al intervalo [−1, 1]. R ∞Existen otras cuadraturas
como la de Gauss-Laguerre óptima para integrales de la forma 0 e−x f (x) dx.
12.6. CUADRATURA DE GAUSS. 337
±xi wi ±xi wi
N=2 N=8
0.57735 02692 1.00000 00000 0.18343 46425 0.36268 37834
N=3 0.52553 24099 0.31370 66459
0.00000 00000 0.88888 88889 0.79666 64774 0.22238 10345
0.77459 66692 0.55555 55556 0.96028 98565 0.10122 85363
N=4 N=12
0.33998 10436 0.65214 51549 0.12523 34085 0.24914 70458
0.86113 63116 0.34785 48451 0.36783 14990 0.23349 25365
N=5 0.58731 79543 0.20316 74267
0.00000 00000 0.56888 88889 0.76990 26742 0.16007 83285
0.53846 93101 0.47862 86705 0.90411 72564 0.10693 93260
0.90617 98459 0.23692 68850 0.98156 06342 0.04717 53364
Cuadro 12.1: Puntos y pesos para integración de Gauss-Legendre.
Para evaluar (12.1), debemos mapear el intervalo [a, b] en el intervalo [−1, 1] mediante el
cambio de variable x = 21 (b + a) + 21 (b − a)z, quedándonos
b 1
b−a
Z Z
f (x) dx = f (z) dz , (12.17)
a 2 −1
esta última integral puede ser evaluada usando diferentes conjuntos de puntos y pesos,
Z 1
f (z) dz ≈ w1 f (x1 ) + . . . + wN f (xn ) . (12.18)
−1
En la tabla 12.1 presentamos los conjuntos con N = 2, 3, 4, 8 y 12 puntos. Los puntos xi

corresponden a los ceros del Polinomio de Legendre PN de grado N y los pesos vienen dados
por
2
wi = 2
1 = 1, 2, . . . , N
(1 − xi )[(d/dx)PN (xi )]2
Como ejemplo, consideremos la función error
Z x
2 2
erf(x) = √ e−y dy , (12.19)
π 0
para x = 1, es decir,
1
2
Z
2
erf(1) = √ e−y dy . (12.20)
0 π
Haciendo el cambio de variable sugerido y = 21 (b + a) + 12 (b − a)z = 12 + z2 y dy = dz/2, la
integral queda
Z 1 Z 1
1 −(1+z)2 /4
erf(1) ≃ 0.842701 = √ e dz = g(z) dz . (12.21)
−1 π −1
Evaluemos con el conjunto de dos puntos

Z 1
erf(1) = g(z) dz ≃ g(−0.57735 02692) + g(+0.57735 02692) = 0.84244189252125179 ,
−1
(12.22)
tres decimales correctos. Ahora con el conjunto de tres puntos,
Z 1
erf(1) = g(z) dz ≃ 0.55555 55556 × g(−0.77459 66692)
−1
+ 0.88888 88889 × g(0.00000 00000)
+ 0.55555 55556 × g(+0.77459 66692) = 0.84269001852936587 ,
(12.23)
tres decimales correctos. Finalmente con el conjunto de cuatro puntos

Z 1
erf(1) = g(z) dz ≃ 0.34785 48451 × g(−0.86113 63116)
−1
+ 0.65214 51549 × g(−0.33998 10436)
+ 0.65214 51549 10436 × g(+0.33998 10436)
+ 0.34785 48451 × g(+0.86113 63116) = 0.84270117131761124 ,
(12.24)
los seis decimales correctos.
12.7. Bibliografı́a
Numerical Methods for Physics, second edition de Alejandro L. Garcia, editorial Pren-
tice Hall.
Métodos Numéricos Aplicados en Ingenierı́a de Jean-Marie Ledanois, Aura López de

Ramos, José Antonio Pimentel M. y Filipo F. Pironti Lubrano, editorial Mc Graw
Hill.
Métodos Numéricos para Ingenieros Steven C. Chapra y Raymond P. Canale, editorial

Mc Graw Hill.
12.8.1. Programa trapecio.py

# -*- coding: iso-8859-1 -*-
import sys
import math
from matplotlib.patches import Polygon
from pylab import *
import numpy
def integrando(x):
return (2.0/math.sqrt(math.pi))*math.exp(-x*x)
def main():
a=0.0
b=1.0
print "Regla trapezoidal para erf(1)"

N=input("Ingrese el numero de puntos : ")
h=(b-a)/float(N-1)
suma=0.0
for i in range(2,N):
x=a+(i-1)*h
suma+=integrando(x)
I=h*((integrando(a)+integrando(b))/2.0 +suma)
print "Valor aproximado: erf(1) : ",I
print "Valor exacto : ertf(1)= 0.842701 "
ax = subplot(111)
l_t=[]
l_fdt=[]
# Graficando
for t in arange(a,b,0.01):
l_t.append(t)
l_fdt.append(integrando(t))
plot(l_t, l_fdt, color=’b’,linewidth=1)

# make the shaded region
verts = [(a,0)] + zip(l_t,l_fdt) + [(b,0)]

poly = Polygon(verts, facecolor=’0.8’, edgecolor=’k’)
ax.add_patch(poly)
text(0.5 * (a + b), 0.5,

r"${\rm erf}(1)=\frac{2}{\sqrt{\pi}} \int_0^1 \, e^{-t^2}\,dt$",
horizontalalignment=’center’,fontsize=20)
xlabel(r’\textbf{\Large $t$}’)
ylabel(r’\textbf{\Large erf($t$)}’)
title(r’\textbf{\Huge Integrado con Trapecio}’)
grid(True)
show()
#
main()
12.8.2. Programa romberg.py

#!/usr/bin/python
from math import *
def integrando(x):
return (2.0/sqrt(pi))*exp(-x*x)
a = 0.0
b = 1.0
suma = 0.0
print "Integracion de Romberg para erf(1)"

N=input("Dimension de tabla: ")
R=[]
for i in range(N):
R.append( [0.0] * N )
h=b-a
np=1
for i in range(N):
if i==0:
R[0][0]=h*(integrando(a)+integrando(b))/2.0
else:
suma=0
j=1
for j in range(1,np,2):
x=a+j*h
suma+=integrando(x)
R[i][0]=R[i-1][0]/2.0 + h*suma
h/=2
np*=2
m=1.0
for j in range(1,N):
m*=4.0
for i in range(j,N):
R[i][j] = R[i][j-1] + (R[i][j-1]-R[i-1][j-1])/(m-1.0)
print "Tabla R"

print
for i in range(N):
for j in range(N):
print R[i][j],
print
print
print "Valor aproximado: erf(1) ~= ", R[N-1][N-1]

print "Valor exacto: erf(1) = 0.842701"
12.8.3. Programa trapecio.cc

double integrando(double);
int main(){
double a=0, b=1,x;
int N;
double h;
double I, suma=0;
cout << "Regla trapezoidal para erf(1)" << endl;
cout << "Numero de puntos: " ;

cin >> N;
h = (b-a)/(N-1);
x = a+(i-1)*h;
suma+=integrando(x);
}
I = h*((integrando(a)+integrando(b))/2.0 + suma);
cout << "Valor aproximado: erf(1) ~= " << I << endl;
cout << "Valor exacto: erf(1) = 0.842701" << endl;
}
double integrando(double x){

return (2.0/sqrt(M_PI))*exp(-x*x);
}
12.8.4. Programa romberg.cc

#include <iomanip.h>
double integrando(double);
int main(){
double a=0, b=1,x;
int N,np;
double h;
double suma=0;
cout << "Integracion de Romberg para erf(1)" << endl;
cout << "Dimension de tabla: " ;
cin >> N;
double ** R = new double * [N];
R[i] = new double[N];
}

for (int j=0;j<N;j++){
R[i][j] = 0 ;
}
}
h = (b-a); // Ancho del intervalo

np = 1; // Numero de paneles
for (int i=0;i<N;i++,h/=2,np*=2){
if (i==0){
R[0][0] = h*(integrando(a)+integrando(b))/2.0;
}
else {
suma = 0;
for (int j=1;j<=np-1;j+=2){
x = a+j*h;
suma += integrando(x);
}
R[i][0] = R[i-1][0]/2.0 + h*suma;
}
}
int m = 1;
m *= 4;
for (int i=j;i<N;i++){
R[i][j] = R[i][j-1] + (R[i][j-1]-R[i-1][j-1])/(m-1);
}
}
cout << "Tabla R" << endl << endl;

cout << /*setprecision(6) << */ setw(8) << R[i][j] << " ";
}
cout << endl;
}
cout << endl;

cout << "Valor aproximado: erf(1) ~= " << R[N-1][N-1] << endl;
cout << "Valor exacto: erf(1) = 0.842701" << endl;

delete [] R[i];
}
delete [] R;
}
double integrando(double x){

return (2.0/sqrt(M_PI))*exp(-x*x);
}
Parte III
Apéndices.
345
Apéndice A
Transferencia a diskettes.
La filosofı́a de diferentes unidades (A:, B:,. . . ) difiere de la estructura única del sistema
de archivos que existe en unix. Son varias las alternativas que existen para la transferencia
de información a diskette.
Una posibilidad es disponer de una máquina win9x con ftp instalado y acceso a red.
Empleando dicha aplicación se pueden intercambiar archivos entre un sistema y el otro.
Existe un conjunto de comandos llamados mtools disponible en multitud plataformas,

que permiten el acceso a diskettes en formato win9x de una forma muy eficiente.
mdir a: Muestra el contenido de un diskette en a:.
mcopy file a: Copia el archivo file del sistema de archivos unix en un diskette en
a:.
mcopy a:file file Copia el archivo a:file del diskette en el sistema de archivos
unix con el nombre file.
mdel a:file Borra el archivo a:file del diskette.
Con a: nos referimos a la primera diskettera /dev/fd0 y luego al archivo que se en-
cuentra en el diskette. Su nombre se compone de a:filename. Si se desea emplear el
caracter comodı́n para un conjunto de archivos del diskette, estos deben rodearse de
dobles comillas para evitar la actuación del shell (p.e. mcopy ‘‘a:*.dat’’). La opción
-t realiza la conversión necesaria entre unix y win9x, que se debe realizar sólo en
archivos de texto.
Una alternativa final es montar el dispositivo /dev/fd0 en algún directorio, tı́picamente

/floppy, considerando el tipo especial de sistema de archivos que posee vfat y luego
copiar y borrar usando comandos unix. Esta forma suele estar restringida sólo a root,
el comando:
mount -t vfat /dev/fd0 /floppy
no puede ser dado por un usuario. Sin embargo, el sistema aceptará el comando
mount /floppy de parte del usuario. Una vez terminado el trabajo con el floppy éste
debe ser desmontado, antes de sacarlo, mediante el comando: umount /floppy.
347
348 APÉNDICE A. TRANSFERENCIA A DISKETTES.
Apéndice B
Las shells csh y tcsh.
Son dos de los Shells interactivos más empleados. Una de las principales ventajas de tcsh
es que permite la edición de la lı́nea de comandos, y el acceso a la historia de órdenes usando
las teclas de cursores.1
B.1. Comandos propios.

Los comandos propios o intrı́nsecos, Built-In Commands, son aquéllos que proporciona el
propio shell 2 .
alias name def
Asigna el nombre name al comando def.
history
Muestra las últimas órdenes introducidas en el shell. Algunos comandos relacionados con el
Command history son:
!!
Repite la última orden.
!n
Repite la orden n-ésima.
!string
Repite la orden más reciente que empiece por la cadena string.
!?string
Repite la orden más reciente que contenga la cadena string.
∧
str1∧ str2 o !!:s/str1/str2/
(substitute) Repite la última orden reemplanzando la primera ocurrencia de la cadena
str1 por la cadena str2.
1
bash también lo permite.
2
A diferencia de los comandos que provienen de un ejecutable situado en alguno de los directorios de la
variable PATH.
349
350 APÉNDICE B. LAS SHELLS CSH Y TCSH.
!!:gs/str1/str2/
(global substitute) Repite la última orden reemplazando todas las ocurrencias de la
cadena str1 por la cadena str2.
!$
Es el último argumento de la orden anterior que se haya tecleado.
repeat count command

Repite count veces el comando command.
rehash
Rehace la tabla de comandos (hash table).
set variable = VALUE
Asigna el valor de una variable del shell.
set
Muestra el valor de todas las variables.
setenv VARIABLE VALUE
Permite asignar el valor de una variable de entorno.
source file
Ejecuta las órdenes del fichero file en el shell actual.
unset variable
Borra la asignación del valor de una variable del shell.
unsetenv VARIABLE VALUE
Borra la asignación del valor de una variable de entorno.
umask value
Asigna la máscara para los permisos por omisión.
unalias name
Elimina un alias asignado.
B.2. Variables propias del shell.

Existe un conjunto de variables denominadas shell variables, que permiten modificar el
funcionamiento del shell.
filec (FILE Completion)
Es una variable toggle que permite que el shell complete automáticamente el nombre de un
archivo o un directorio3 . Para ello, si el usuario introduce sólo unos cuantos caracteres de
un archivo y pulsa el TAB, el shell completa dicho nombre. Si sólo existe una posibilidad, el
3
bash permite no sólo completar ficheros/directorios sino también comandos.
B.2. VARIABLES PROPIAS DEL SHELL. 351
completado es total y el shell deja un espacio tras el nombre. En caso contrario hace sonar
un pitido. Pulsando Ctrl-D el shell muestra las formas existentes para completar.
prompt
Es una variable de cadena que contiene el texto que aparece al principio de la lı́nea de
comandos.
savehist
Permite definir el número de órdenes que se desea almacenar al abandonar el shell. Esto
permite recordar las órdenes que se ejecutaron en la sesión anterior.
352 APÉNDICE B. LAS SHELLS CSH Y TCSH.
Apéndice C
Editores tipo emacs.
Los editores tipo emacs se parecen mucho y en su mayorı́a sus comandos son los mismos.
Para ejemplificar este tipo de editores nos centraremos en XEmacs, pero los comandos y
descripciones se aplican casi por igual a todos ellos. Los editores tipo emacs constan de tres
zonas:
La zona de edición: donde aparece el texto que está siendo editado y que ocupa la
mayor parte de la pantalla.
La zona de información: es una barra que esta situada en la penúltima lı́nea de la

pantalla.
La zona de introducción de datos: es la última lı́nea de la pantalla.
Emacs es un editor que permite la edición visual de un archivo (en contraste con el modo
de edición de vi). El texto se agrega o modifica en la zona de edición, usando las teclas
disponibles en el teclado.
Además, existen una serie de comandos disponibles para asistir en esta tarea.
La mayorı́a de los comandos de emacs se realizan empleando la tecla de CONTROL o la
tecla META1 . Emplearemos la nomenclatura: C-key para indicar que la tecla key debe de
ser pulsada junto con CONTROL y M-key para indicar que la tecla META debe de ser pulsada
junto a key. En este último caso NO es necesario pulsar simultáneamente las teclas ESC y
key, pudiendo pulsarse secuencialmente ESC y luego key, sin embargo, si se usa ALT como
META deben ser pulsadas simultáneamente. Observemos que en un teclado normal hay unos
50 caracteres (letras y números). Usando SHIFT se agregan otros 50. Ası́, usando CONTROL
y META, hay unos 50 · 4 = 200 comandos disponibles. Además, existen comandos especiales
llamados prefijos, que modifican el comando siguiente. Por ejemplo, C-x es un prefijo, y si C-s
es un comando (de búsqueda en este caso), C-x C-s es otro (grabar archivo). Ası́, a través
de un prefijo, se duplican el número de comandos disponibles sólo con el teclado, hasta llegar
a unos 200 · 2 = 400 comandos en total.
Aparte de estos comandos accesibles por teclas, algunos de los cuales comentaremos a
continuación, existen comandos que es posible ejecutar por nombre, haciendo ası́ el número
de comandos disponibles virtualmente infinito.
1
Dado que la mayorı́a de los teclados actuales no poseen la tecla META se emplea ya sea ESC o ALT.
353
354 APÉNDICE C. EDITORES TIPO EMACS.
Revisemos los comandos más usuales, ordenados por tópico.
Abortar y deshacer
En cualquier momento, es posible abortar la operación en curso, o deshacer un comando
indeseado:
C-g abortar
C-x u deshacer
Archivos
C-x C-f cargar archivo

C-x i insertar archivo
C-x C-s grabar archivo
C-x C-w grabar con nombre
C-x C-c salir
Ventanas
Emacs permite dividir la pantalla en varias ventanas. En cada ventana se puede editar
texto e ingresar comandos independientemente. Esto es útil en dos situaciones: a) si necesi-
tamos editar un solo archivo, pero necesitamos ver su contenido en dos posiciones distintas
(por ejemplo, el comienzo y el final de archivos muy grandes); y b) si necesitamos editar o ver
varios archivos simultáneamente. Naturalmente, aunque son independientes, sólo es posible
editar un archivo a la vez. A la ventana en la cual se encuentra el cursor en un momento
dado le llamamos la “ventana actual”.
C-x 2 dividir ventana actual en 2 partes, con lı́nea horizontal

C-x 3 dividir ventana actual en 2 partes, con lı́nea vertical
C-x 1 sólo 1 ventana (la ventana actual, eliminando las otras)
C-x 0 elimina sólo la ventana actual
C-x o cambia el cursor a la siguiente ventana
El cambio del cursor a una ventana cualquiera se puede hacer también rápidamente a
través del mouse.
Comandos de movimiento
Algunos de estos comandos tienen dos teclas asociadas, como se indica a continuación.
355
C-b o ← izquierda un carácter C-f o → derecha un carácter

C-p o ↑ arriba una lı́nea C-n o ↓ abajo una lı́nea
C-a o Home principio de la lı́nea C-e o End fin de la lı́nea
M-< o C-Home principio del documento M-> o C-End fin del documento
M-f o M-→ avanza una palabra M-b o M-← retrocede una palabra
C-v o Page Up avanza una página M-v o Page Down retrocede una página
M-g (número) salta a la lı́nea (número) C-l refresca la pantalla
Comandos de inserción y borrado

Al ser un editor en modo visual, las modificaciones se pueden hacer en el texto sin nece-
sidad de entrar en ningún modo especial.
C-d o Deleteborra un carácter después del cursor

Backspace borra un carácter antes del cursor
C-k borra desde la posición del cursor hasta el fin de lı́nea
(no incluye el cambio de lı́nea)
M-d borra desde el cursor hacia adelante, hasta que termina una palabra
M-Backspace borra desde el cursor hacia atrás, hasta que comienza una palabra
C-o Inserta una lı́nea en la posición del cursor
Mayúsculas y minúsculas
M-u Cambia a mayúscula desde la posición del cursor hasta el fin de la palabra

M-l Cambia a minúscula desde la posición del cursor hasta el fin de la palabra
M-c Cambia a mayúscula el carácter en la posición del cursor y
a minúscula hasta el fin de la palabra
Por ejemplo, veamos el efecto de cada uno de estos comandos sobre la palabra EmAcS, si
el cursor está sobre la letra E (¡el efecto es distinto si está sobre cualquier otra letra!):
M-u : EmAcS −→ EMACS

M-l : EmAcS −→ emacs
M-c : EmAcS −→ Emacs
Transposición
Los siguientes comandos toman como referencia la posición actual del cursor. Por ejemplo,
C-t intercambia el carácter justo antes del cursor con el carácter justo después.
C-t Transpone dos caracteres

M-t Transpone dos palabras
C-x C-t Transpone dos lı́neas
Búsqueda y reemplazo
C-s Búsqueda hacia el fin del texto

C-r Búsqueda hacia el inicio del texto
M- % Búsqueda y sustitución (pide confirmación cada vez)
M-& Búsqueda y sustitución (sin confirmación)
Definición de regiones y reemplazo

Uno de los conceptos importantes en emacs es el de región. Para ello, necesitamos dos
conceptos auxiliares: el punto y la marca. El punto es simplemente el cursor. Especı́ficamente,
es el punto donde comienza el cursor. Ası́, si el cursor se encuentra sobre la letra c en emacs,
el punto está entre la a y la c. La marca, por su parte, es una señal que se coloca en algún
punto del archivo con los comandos apropiados. La región es el espacio comprendido entre el
punto y la marca.
Para colocar una marca basta ubicar el cursor en el lugar deseado, y teclear C-Space o
C-@. Esto coloca la marca donde está el punto (en el ejemplo del párrafo anterior, quedarı́a
entre las letras a y c. Una vez colocada la marca, podemos mover el cursor a cualquier otro
lugar del archivo (hacia atrás o hacia adelante respecto a la marca). Esto define una cierta
ubicación para el punto, y, por tanto, queda definida la región automáticamente.
La región es una porción del archivo que se puede manipular como un todo. Una región se
puede borrar, copiar, pegar en otro punto del archivo o incluso en otro archivo; una región se
puede imprimir, grabar como un archivo distinto; etc. Ası́, muchas operaciones importantes
se pueden efectuar sobre un bloque del archivo.
Por ejemplo, si queremos duplicar una región, basta con definir la región deseada (ponien-
do la marca y el punto donde corresponda) y teclear M-w. Esto copia la región a un buffer
temporal (llamado kill buffer). Luego movemos el cursor al lugar donde queremos insertar el
texto duplicado, y hacemos C-y. Este comando toma el contenido del kill buffer y lo inserta
en el archivo. El resultado final es que hemos duplicado una cierta porción del texto.
Si la intención era mover dicha porción, el procedimiento es el mismo, pero con el comando
C-w en vez de M-w. C-w también copia la región a un kill buffer, pero borra el texto de la
pantalla.
Resumiendo:
C-Space o C-@ Comienzo de región

M-w Copia región
C-w Corta región
C-y Pega región
El concepto de kill buffer es mucho más poderoso que lo explicado recién. En realidad,
muchos comandos, no sólo M-w y C-w, copian texto en un kill buffer. En general, cualquier
comando que borre más de un carácter a la vez, lo hace. Por ejemplo, C-k borra una lı́nea.
Lo que hace no es sólo borrarla, sino además copiarla en un kill buffer. Lo mismo ocurre
con los comandos que borran palabras completas (M-d, M-Backspace), y muchos otros. Lo
357
interesante es que C-y funciona también en todos esos casos: C-y lo único que hace es tomar
el último texto colocado en un kill buffer (resultado de la última operación que borró más de
un carácter a la vez), y lo coloca en el archivo. Por lo tanto, no sólo podemos copiar o mover
“regiones”, sino también palabras o lı́neas. Más aún, el kill buffer no es borrado con el C-y,
ası́ que ese mismo texto puede ser duplicado muchas veces. Continuará disponible con C-y
mientras no se ponga un nuevo texto en el kill buffer.
Además, emacs dispone no de uno sino de muchos kill buffers. Esto permite recuperar
texto borrado hace mucho rato. En efecto, cada vez que se borra más de un carácter de una
vez, se una un nuevo kill buffer. Por ejemplo, consideremos el texto:
La primera linea del texto,

la segunda linea,
y finalmente la tercera.
Si en este párrafo borramos la primera lı́nea (con C-k), después borramos la primera
palabra de la segunda (con M-d, por ejemplo), y luego la segunda palabra de la última,
entonces habrá tres kill buffers ocupados:
buffer 1 : La primera linea del texto,

buffer 2 : la
buffer 3 : finalmente
Al colocar el cursor después del punto final, C-y toma el contenido del último kill buffer
y lo coloca en el texto:
segunda linea,
y la tercera. finalmente
Si se teclea ahora M-y, el último texto recuperado, finalmente, es reemplazado por el

penúltimo texto borrado, y que está en el kill buffer anterior:
segunda linea,
y la tercera. la
Además, la posición de los kill buffers se rota:
buffer 1 : finalmente
buffer 2 : La primera linea del texto,
buffer 3 : la
Sucesivas aplicaciones de M-y después de un C-y rotan sobre todos los kill buffers (que
pueden ser muchos). El editor, ası́, conserva un conjunto de las últimas zonas borradas durante
la edición, pudiendo recuperarse una antigua a pesar de haber seleccionado una nueva zona,
o borrado una nueva palabra o lı́nea. Toda la información en los kill buffers se pierde al salir
de emacs (C-c).
Resumimos entonces los comandos para manejo de los kill buffers:
C-y Copia el contenido del último kill buffer ocupado

M-y Rota los kill buffers ocupados
Definición de macros
La clave de la configurabilidad de emacs está en la posibilidad de definir nuevos comandos
que modifiquen su comportamiento o agreguen nuevas funciones de acuerdo a nuestras nece-
sidades. Un modo de hacerlo es a través del archivo de configuración $HOME/.emacs, para lo
cual se sugiere leer la documentación disponible en la distribución instalada. Sin embargo, si
sólo necesitamos un nuevo comando en la sesión de trabajo actual, un modo más simple es
definir una macro, un conjunto de órdenes que son ejecutados como un solo comando. Los
comandos relevantes son:
C-x ( Comienza la definición de una macro

C-x ) Termina la definición de una macro
C-x e Ejecuta una macro definida
Todas las sucesiones de teclas y comandos dados entre C-x ( y C-x ) son recordados por
emacs, y después pueden ser ejecutados de una vez con C-x e.
Como ejemplo, consideremos el siguiente texto, con los cinco primeros lugares del ránking
ATP (sistema de entrada) al 26 de marzo de 2002:
1 hewitt, lleyton (Aus)

2 kuerten, gustavo (Bra)
3 ferrero, juan (Esp)
4 kafelnikov, yevgeny (Rus)
5 haas, tommy (Ger)
Supongamos que queremos: (a) poner los nombres y apellidos con mayúscula (como de-
berı́a ser); (b) poner las siglas de paı́ses sólo en mayúsculas.
Para definir una macro, colocamos el cursor al comienzo de la primera lı́nea, en el 1,
y damos C-x (. Ahora realizamos todos los comandos necesarios para hacer las tres tareas
solicitadas para el primer jugador solamente: M-f (avanza una palabra, hasta el espacio antes
de hewitt; M-c M-c (cambia a Hewitt, Lleyton); M-u (cambia a AUS); Home (vuelve el
cursor al comienzo de la lı́nea); ↓ (coloca el cursor al comienzo de la lı́nea siguiente, en el 2).
Los dos últimos pasos son importantes, porque dejan el cursor en la posición correcta para
ejecutar el comando nuevamente. Ahora terminamos la definición con C-x ). Listo. Si ahora
ejecutamos la macro, con C-x e, veremos que la segunda lı́nea queda modificada igual que
la primera, y ası́ podemos continuar hasta el final:
1 Hewitt, Lleyton (AUS)

2 Kuerten, Gustavo (BRA)
3 Ferrero, Juan (ESP)
4 Kafelnikov, Yevgeny (RUS)
5 Haas, Tommy (GER)
359
Comandos por nombre

Aparte de los ya comentados existen muchas otras órdenes que no tienen necesariamente
una tecla asociada (bindkey) asociada. Para su ejecución debe de teclearse previamente:
M-x
y a continuación en la zona inferior de la pantalla se introduce el comando deseado. Em-
pleando el TAB se puede completar dicho comando (igual que en bash).
De hecho, esto sirve para cualquier comando, incluso si tiene tecla asociada. Por ejemplo,
ya sabemos M-g n va a la lı́nea n del documento. Pero esto no es sino el comando goto-line,
y se puede también ejecutar tecleando: M-x goto-line n.
Repetición
Todos los comandos de emacs, tanto los que tienen una tecla asociada como los que se
ejecutan con nombre, se pueden ejecutar más de una vez, anteponiéndoles un argumento
numérico con
M-(number)
Por ejemplo, si deseamos escribir 20 letras e, basta teclear M-20 e. Esto es particularmente
útil con las macros definidos por el usuario. En el ejemplo anterior, con el ránking ATP,
después de definir la macro quedamos en la lı́nea 2, y en vez de ejecutar C-x e 4 veces,
podemos teclear M-4 C-x e, con el mismo resultado, pero en mucho menos tiempo.
Para terminar la discusión de este editor, diremos que es conveniente conocer las secuencias
de control básico de emacs:
C-a, C-e, C-k, C-y, C-w, C-t, C-d, etc.,
porque funcionan para editar la lı́nea de comandos en el shell, como también en muchos
programas de texto y en ventanas de diálogo de las aplicaciones X Windows. A su vez, los
editores jed, xjed, jove también usan por defecto estas combinaciones.
Apéndice D
Una breve introducción a

Octave/Matlab
D.1. Introducción
Octave es un poderoso software para análisis numérico y visualización. Muchos de sus
comandos son compatibles con Matlab. En estos apuntes revisaremos algunas caracterı́sticas
de estos programas. En realidad, el autor de este capı́tulo ha sido usuario durante algunos años
de Matlab, de modo que estos apuntes se han basado en ese conocimiento, considerando los
comandos que le son más familiares de Matlab. En la mayorı́a de las ocasiones he verificado
que los comandos descritos son también compatibles con Octave, pero ocasionalmente se
puede haber omitido algo. . . .
Matlab es una abreviación de Matrix Laboratory. Los elementos básicos con los que se
trabaja con matrices. Todos los otros tipos de variables (vectores, texto, polinomios, etc.),
son tratados como matrices. Esto permite escribir rutinas optimizadas para el trabajo con
matrices, y extender su uso a todos los otros tipos de variables fácilmente.
D.2. Interfase con el programa

Con Octave/Matlab se puede interactuar de dos modos: un modo interactivo, o a través
de scripts. Al llamar a Octave/Matlab (escribiendo octave en el prompt, por ejemplo), se
nos presenta un prompt. Si escribimos a=1, el programa responderá a=1. Alternativamente,
podemos escribir a=3; (con punto y coma al final), y el programa no responderá (elimina
el eco), pero almacena el nuevo valor de a. Si a continuación escribimos a, el programa
responderá a=3. Hasta este punto, hemos usado el modo interactivo.
Alternativamente, podemos introducir las instrucciones anteriores en un archivo, llamado,
por ejemplo, prueba.m. En el prompt, al escribir prueba, y si nuestro archivo está en el path
de búsqueda del programa, las lı́neas de prueba.m serán ejecutadas una a una. Por ejemplo,
si el archivo consta de las siguientes cuatro lı́neas:
a=3;
a
361
362 APÉNDICE D. UNA BREVE INTRODUCCIÓN A OCTAVE/MATLAB
a=5
a
el programa responderá con
a=3
a=5
a=5
prueba.m corresponde a un script. Todas las instrucciones de Octave/Matlab pueden ejecu-

tarse tanto en modo interactivo como desde un script. En Linux se puede ejecutar un archivo
de comandos Octave de modo stand-alone incluyendo en la primera lı́nea:
#!/usr/bin/octave -q.
D.3. Tipos de variables

D.3.1. Escalares
A pesar de que éstos son sólo un tipo especial de matrices (ver subsección siguiente),
conviene mencionar algunas caracterı́sticas especı́ficas.
– Un número sin punto decimal es tratado como un entero exacto. Un número con punto
decimal es tratado como un número en doble precisión. Esto puede no ser evidente
en el output. Por default, 8.4 es escrito en pantalla como 8.4000. Tras la instrucción
format long, sin embargo, es escrito como 8.40000000000000. Para volver al formato
original, basta la instrucción format.
– Octave/Matlab acepta números reales y complejos. La unidad imaginaria es i: 8i y

8*i definen el mismo número complejo. Como i es una varible habitualmente usada
en iteraciones, también está disponible j como un sinónimo. Octave/Matlab distinguen
entre mayúsculas y minúsculas.
– Octave/Matlab representa de manera especial los infinitos y cantidades que no son

números. inf es infinito, y NaN es un no-número (Not-a-Number). Por ejemplo, escribir
a=1/0 no arroja un error, sino un mensaje de advertencia, y asigna a a el valor inf.
Análogamente, a=0/0 asigna a a el valor NaN.
D.3.2. Matrices
Este tipo de variable corresponde a escalares, vectores fila o columna, y matrices conven-
cionales.
Construcción
Las instrucciones:
a = [1 2 ; 3 4]
D.3. TIPOS DE VARIABLES 363
ó
a = [1, 2; 3, 4]

1 2
definen la matriz . Las comas (opcionales) separan elementos de columnas distintas,
3 4
y los punto y coma separan elementos de filas distintas. El vector fila (1 2) es
b = [1 2]

1
y el vector columna es
2
c = [1;2]
Un número se define simplemente como d = [3] ó d = 3.
Nota importante: Muchas funciones de Octave/Matlab en las páginas siguientes acep-
tan indistintamente escalares, vectores filas, vectores columnas, o matrices, y su output es
un escalar, vector o matriz, respectivamente. Por ejemplo, log(a) es un vector fila si a es un
vector fila (donde cada elemento es el logaritmo natural del elemento correspondiente en a),
y un vector columna si a es un vector columna. En el resto de este manual no se advertira
este hecho, y se pondrán ejemplos con un solo tipo de variable, en el entendido que el lector
está conciente de esta nota.
Acceso y modificación de elementos individuales

Accesamos los elementos de cada matriz usando los ı́ndices de filas y columnas, que parten
de uno. Usando la matriz a antes definida, a(1,2) es 2. Para modificar
un elemento, basta
1 2
escribir, por ejemplo, a(2,2) = 5. Esto convierte a la matriz en . En el caso especial
3 5
de vectores filas o columnas, basta un ı́ndice. (En los ejemplos anteriores, b(2) = c(2) = 2.)
Una caracterı́stica muy importante del programa es que toda matriz es redimensionada
automáticamente cuando se intenta modificar un elemento que sobrepasa las dimensiones
actuales de la matriz, llenando con ceros los lugares necesarios. Por ejemplo, si b = [1 2],
y en seguida intentamos la asignación b(5) = 8, b es automáticamente convertido al vector
fila de 5 elementos [1 2 0 0 8].
Concatenación de matrices

1 2 7
Si a = ,b= 5 6 ,c= , entonces
3 4 8
d = [a c]

1 2 7
d=
3 4 8
d = [a; b]
 
1 2
d = 3 4 
5 6
d = [a [0; 0] c]

1 2 0 7
d=
3 4 0 8
D.3.3. Strings
Las cadenas de texto son casos particulares de vectores fila, y se construyen y modifican
de modo idéntico.
Construcción
Las instrucciones
t = [’un buen texto’]

t = ["un buen texto"]
t = ’un buen texto’
t = "un buen texto"
definen el mismo string t.

r = t(4)
r = ’b’
t(9) = ’s’
texto = ’un buen sexto’
Concatenación
t = ’un buen texto’;
t1 = [t ’ es necesario’]
t1 = ’un buen texto es necesario’
D.3.4. Estructuras
Las estructuras son extensiones de los tipos de variables anteriores. Una estructura consta
de distintos campos, y cada campo puede ser una matriz (es decir, un escalar, un vector o
una matriz), o una string.
Construcción
Las lı́neas
persona.nombre = ’Eduardo’
persona.edad = 30
persona.matriz_favorita = [2 8;10 15];
D.4. OPERADORES BÁSICOS 365
definen una estructura con tres campos, uno de los cuales es un string, otro un escalar, y otro
una matriz:
persona =
{
nombre = ’Eduardo’;
edad = 30;
matriz_favorita = [2 8; 10 15];
}

s = persona.nombre
s = ’Eduardo’
persona.nombre = ’Claudio’
persona.matriz_favorita(2,1) = 8
persona =
{
nombre = ’Claudio’;
edad = 30;
matriz_favorita = [2 8; 8 15];
}
D.4. Operadores básicos

D.4.1. Operadores aritméticos
Los operadores +, -, * corresponden a la suma, resta y multiplicación convencional de
matrices. Ambas matrices deben tener la misma dimensión, a menos que una sea un escalar.
Un escalar puede ser sumado, restado o multiplicado de una matriz de cualquier dimensión.
.* y ./ permiten multiplicar y dividir elemento por elemento. Por ejemplo, si

1 2 5 6
a= b=
3 4 7 8
entonces
c = a.*b

5 12
c=
21 32
c = a./b

0.2 0.3333
c=
0.42857 0.5
Si b es un escalar, a.*b y a./b equivalen a a*b y a/b.

a^b es a elevado a b, si b es un escalar. a.^b eleva cada elemento de a a b.
a’ es la matriz a† (traspuesta y conjugada)
a.’ es la matriz traspuesta de a.
D.4.2. Operadores relacionales

Los siguientes operadores están disponibles:
< <= > >= == ~=
El resultado de estas operaciones es 1 (verdadero) ó 0 (falso). Si uno de los operandos
es una matriz y el otro un escalar, se compara el escalar con cada elemento de la matriz.
Si ambos operandos son matrices, el test se realiza elemento por elemento; en este caso, las
matrices deben ser de igual dimensión. Por ejemplo,
a = [1 2 3];
b = [4 2 1];
c = (a<3);
d = (a>=b);
c = (1, 1, 0)
d = (0, 1, 1)
D.4.3. Operadores lógicos

Los siguientes sı́mbolos corresponden a los operadores AND, OR y NOT:
& | ~
El resultado de estas operaciones es 1 (verdadero) ó 0 (falso).
D.4.4. El operador :
Es uno de los operadores fundamentales. Permite crear vectores y extraer submatrices.
: crea vectores de acuerdo a las siguientes reglas:

j:k es lo mismo que [j,j+1,...,k], si j<=k.
j:i:k es lo mismo que [j,j+i,j+2*i,...,k], si i>0 y j<k, o si i<0 y j>k.
: extrae submatrices de acuerdo a las siguientes reglas:
A(:,j) es la j-ésima columna de A.
A(i,:) es la i-ésima fila de A.
A(:,:) es A.
A(:,j:k) es A(:,j), A(:,j+1), . . . , A(:,k).
A(:) son todos los elementos de A, agrupados en una única columna.
D.5. COMANDOS MATRICIALES BÁSICOS 367
D.4.5. Operadores de aparición preferente en scripts

Los siguientes operadores es más probable que aparezcan durante la escritura de un script
que en modo interactivo.
% : Comentario. El resto de la lı́nea es ignorado.
... : Continuación de lı́nea. Si una lı́nea es muy larga y no cabe en la pantalla, o por alguna
otra razón se desea dividir una lı́nea, se puede usar el operador ... . Por ejemplo,
m = [1 2 3 ...
4 5 6];
es equivalente a
m = [1 2 3 4 5 6];
D.5. Comandos matriciales básicos

Antes de revisar una a una diversas familias de comandos disponibles, y puesto que las
matrices son el elemento fundamental en Octave/Matlab, en esta sección reuniremos algunas
de las funciones más frecuentes sobre matrices, y cómo se realizan en Octave/Matlab.
Op. aritmética +, -, *, .*, ./ (ver subsección D.4.1)
Conjugar conj(a)
Trasponer a.’
Trasponer y conjugar a’
Invertir inv(a)
Autovalores, autovectores [v,d]=eig(a) (ver subsección D.6.5)
Determinante det(a)
Extraer elementos : (ver subsección D.4.4)
Traza trace(a)
Dimensiones size(a)
Exponencial exp(a) (elemento por elemento)
expm(a) (exponencial matricial)
D.6. Comandos
En esta sección revisaremos diversos comandos de uso frecuente en Octave/Matlab. Esta
lista no pretende ser exhaustiva (se puede consultar la documentación para mayores detalles),
y está determinada por mi propio uso del programa y lo que yo considero más frecuente
debido a esa experiencia. Insistimos en que ni la lista de comandos es exhaustiva, ni la lista
de ejemplos o usos de cada comando lo es. Esto pretende ser sólo una descripción de los
aspectos que me parecen más importantes o de uso más recurrente.
D.6.1. Comandos generales
clear Borra variables y funciones de la memoria

clear Borra todas las variables en memoria

clear a Borra la variable a
disp Presenta matrices o texto

disp(a) presenta en pantalla los contenidos de una matriz, sin imprimir el nombre de la
matriz. a puede ser una string.
disp(’ c1 c2’); c1 c2
disp([.3 .4]); 0.30000 0.40000
load, save Carga/Guarda variables desde el disco
save fname a b Guarda las variables a y b en el archivo fname

load fname Lee el archivo fname, cargando las definiciones de variables
en él definidas.
size,length Dimensiones de una matriz/largo de un vector

Si a es una matrix de n × m:
d = size(a) d = [m,n]
[m,n] = size(a) Aloja en m el número de filas, y en n el de columnas
Si b es un vector de n elementos, length(b) es n.
who Lista de variables en memoria
quit Termina Octave/Matlab
D.6.2. Como lenguaje de programación

Control de flujo
for
n=3; a=[1 4 9]
for i=1:n
a(i)=i^2;
end
Para Octave el vector resultante es columna en vez de fila.
Observar el uso del operador : para generar el vector [1 2 3]. Cualquier vector se puede
utilizar en su lugar: for i=[2 8 9 -3], for i=10:-2:1 (equivalente a [10 8 6 4 2]), etc.
son válidas. El ciclo for anterior se podrı́a haber escrito en una sola lı́nea ası́:
for i=1:n, a(i)=i^2; end
D.6. COMANDOS 369
if, elseif, else

Ejemplos:
a) if a~=b, disp(a); end
b) if a==[3 8 9 10]
b = a(1:3);
end
c) if a>3
clear a;
elseif a<0
save a;
else
disp(’Valor de a no considerado’);
end
Naturalmente, elseif y else son opcionales. En vez de las expresiones condicionales

indicadas en el ejemplo pueden aparecer cualquier función que dé valores 1 (verdadero) ó 0
(falso).
while
while s
comandos
end
Mientras s es 1, se ejecutan los comandos entre while y end. s puede ser cualquier
expresión que dé por resultado 1 (verdadero) ó 0 (falso).
break
Interrumpe ejecución de ciclos for o while. En loops anidados, break sale del más interno
solamente.
Funciones lógicas
Además de expresiones construidas con los operadores relacionales ==, <=, etc., y los
operadores lógicos &, | y ~, los comandos de control de flujo anteriores admiten cualquier
función cuyo resultado sea 1 (verdadero) ó 0 (falso). Particularmente útiles son funciones
como las siguientes:
all(a) 1 si todos los elementos de a son no nulos, y 0 si alguno es
cero
any(a) 1 si alguno de los elementos de a es no nulo
isempty(a) 1 si a es matriz vacı́a (a=[])
Otras funciones entregan matrices de la misma dimensión que el argumento, con unos o
ceros en los lugares en que la condición es verdadera o falsa, respectivamente:
finite(a) 1 donde a es finito (no inf ni NaN)
isinf(a) 1 donde a es infinito
isnan(a) 1 donde a es un NaN
Por ejemplo, luego de ejecutar las lı́neas
x = [-2 -1 0 1 2];
y = 1./x;
a = finite(y);
b = isinf(y);
c = isnan(y);
se tiene
a = [1 1 0 1 1]
b = [0 0 1 0 0]
c = [0 0 0 0 0]
Otra función lógica muy importante es find:
find(a) Encuentra los ı́ndices de los elementos no nulos de a.
Por ejemplo, si ejecutamos las lı́neas
x=[11 0 33 0 55];
z1=find(x);
z2=find(x>0 & x<40);
obtendremos
z1 = [1 3 5]
z2 = [1 3]
find también puede dar dos resultados de salida simultáneamente (más sobre esta posi-
bilidad en la sección D.6.2), en cuyo caso el resultado son los pares de ı́ndices (ı́ndices de fila
y columna) para cada elemento no nulo de una matriz
y=[1 2 3 4 5;6 7 8 9 10];
[z3,z4]=find(y>8);
da como resultado
z3 = [2;2];
z4 = [4;5];
z3 contiene los ı́ndice de fila y z4 los de columna para los elementos no nulos de la matriz
2 4
y>8. Esto permite construir, por ejemplo, la matriz z5=[z3 z4] = , en la cual cada
2 5
fila es la posición de y tal que la condición y>8 es verdadera (en este caso, es verdadera para
los elementos y(2,4) e y(2,5)).
D.6. COMANDOS 371
Funciones definidas por el usuario

Octave/Matlab puede ser fácilmente extendido por el usuario definiendo nuevas funciones
que le acomoden a sus propósitos. Esto se hace a través del comando function.
Podemos definir (en modo interactivo o dentro de un script), una función en la forma
function nombre (argumentos)

comandos
endfunction
argumentos es una lista de argumentos separados por comas, y comandos es la sucesión

de comandos que serán ejecutados al llamar a nombre. La lista de argumentos es opcional,
en cuyo caso los paréntesis redondos se pueden omitir.
A mediano y largo plazo, puede ser mucho más conveniente definir las funciones en ar-
chivos especiales, listos para ser llamados en el futuro desde modo interactivo o desde cual-
quier script. Esto se hace escribiendo la definición de una función en un script con extensión
.m. Cuando Octave/Matlab debe ejecutar un comando o función que no conoce, por ejem-
plo, suma(x,y),busca en los archivos accesibles en su path de búsqueda un archivo llamado
suma.m, lo carga y ejecuta la definición contenida en ese archivo.
Por ejemplo, si escribimos en el script suma.m las lı́neas
function s=suma(x,y)
s = x+y;
el resultado de suma(2,3) será 5.
Las funciones ası́ definidas pueden entregar más de un argumento si es necesario (ya hemos
visto algunos ejemplos con find y size). Por ejemplo, definimos una función que efectúe un
análisis estadı́stico básico en stat.m:
function [mean,stdev] = stat(x)

n = length(x);
mean = sum(x)/n;
stdev = sqrt(sum((x-mean).^2/n));
Al llamarla en la forma [m,s] = stat(x), si x es un vector fila o columna, en m quedará el

promedio de los elementos de x, y en s la desviación estándard.
Todas las variables dentro de un script que define una función son locales, a menos que
se indique lo contrario con global. Por ejemplo, si un script x.m llama a una función f, y
dentro de f.m se usa una variable a que queremos sea global, ella se debe declarar en la
forma global a tanto en f.m como en el script que la llamó, x.m, y en todo otro script que
pretenda usar esa variable global.
D.6.3. Matrices y variables elementales

Matrices constantes importantes
Las siguientes son matrices que se emplean habitualmente en distintos contextos, y que
es útil tener muy presente:
eye(n) Matriz identidad de n × n

ones(m,n) Matriz de m × n, con todos los elementos igual a 1.
rand(m,n) Matriz de m × n de números al azar, distribuidos uniforme-
mente.
randn(m,n) Igual que rand, pero con distribución normal (Gaussiana).
zeros(m,n) Igual que ones, pero con todos los elementos 0.
Matrices útiles para construir ejes o mallas para graficar

Las siguientes son matrices se emplean habitualmente en la construcci’on de gráficos:
v = linspace(min,max,n) Vector cuyo primer elemento es min, su último elemento
es max, y tiene n elementos equiespaciados.
v = logspace(min,max,n) Análogo a linspace, pero los n elementos están espa-
ciados logarı́tmicamente.
[X,Y] = meshgrid(x,y) Construye una malla del plano x-y. Las filas de X son
copias del vector x, y las columnas de Y son copias del
vector y.
Por ejemplo:
x = [1 2 3];
y = [4 5];
[X,Y] = meshgrid(x,y);
da
1 2 3 4 4 4
X= , Y = .
1 2 3 5 5 5
Notemos que al tomar sucesivamente los distintos pares ordenados (X(1,1),Y(1,1)), (X(1,2),Y(1,2)),
(X(1,3),Y(1,3)), etc., se obtienen todos los pares ordenados posibles tales que el primer ele-
mento está en x y el segundo está en y. Esta caracterı́stica hace particularmente útil el
comando meshgrid en el contexto de gráficos de funciones de dos variables (ver secciones
D.6.7, D.6.7).
Constantes especiales
Octave/Matlab proporciona algunos números especiales, algunos de los cuales ya mencio-
namos en la sección D.3.1.
√
i, j Unidad imaginaria ( −1 )
inf Infinito
NaN Not-A-Number
pi El número π (= 3.1415926535897 . . .)
Funciones elementales
Desde luego, Octave/Matlab proporciona todas las funciones matemáticas básicas. Por
ejemplo:
D.6. COMANDOS 373
a) Funciones sobre números reales/complejos
abs Valor absoluto de números reales, o módulo de números imaginarios

angle
Ángulo de fase de un número imaginario
conj Complejo conjugado
real Parte real
imag Parte imaginaria
sign Signo
sqrt Raı́z cuadrada
b) Exponencial y funciones asociadas
cos, sin, etc. Funciones trigonométricas

cosh, sinh, etc. Funciones hiperbólicas
exp Exponencial
log Logaritmo
c) Redondeo
ceil Redondear hacia +∞

fix Redondear hacia cero
floor Redondear hacia −∞
round Redondear hacia el entero más cercano
Funciones especiales
Además, Octave/Matlab proporciona diversas funciones matemáticas especiales. Algunos
ejemplos:
bessel Función de Bessel
besselh Función de Hankel
beta Función beta
ellipke Función elı́ptica
erf Función error
gamma Función gamma
Ası́, por ejemplo, bessel(alpha,X) evalúa la función de Bessel de orden alpha, Jα (x),
para cada elemento de la matriz X.
D.6.4. Polinomios
Octave/Matlab representa los polinomios como vectores fila. El polinomio
p = cn xn + · · · + c1 x + c0
es representado en Octave/Matlab en la forma

p = [c_n, ..., c1, c0]
Podemos efectuar una serie de operaciones con los polinomios ası́ representados.
poly(x) Polinomio cuyas raı́ces son los elementos de x.
polyval(p,x) Evalúa el polinomio p en x (en los elementos de x si éste es
un vector)
roots(p) Raı́ces del polinomio p
D.6.5. Álgebra lineal (matrices cuadradas)

Unos pocos ejemplos, entre los comandos de uso más habitual:
det Determinante
rank Número de filas o columnas linealmente independientes
trace Traza
inv Matriz inversa
eig Autovalores y autovectores
poly Polinomio caracterı́stico
Notar que poly es la misma función de la sección D.6.4 que construye un polinomio de
raı́ces dadas. En el fondo, construir el polinomio caracterı́stico de una matriz es lo mismo,
y por tanto tiene sentido asignarles la misma función. Y no hay confusión, pues una opera
sobre vectores y la otra sobre matrices cuadradas.
El uso de todos estos comandos son autoexplicativos, salvo eig, que se puede emplear de
dos modos:
d = eig(a)
[V,D] = eig(a)
La primera forma deja en d un vector con los autovalores de a. La segunda, deja en D una
matriz diagonal con los autovalores, y en V una matiz cuyas columnas son los autovalores, de
modo que A*V = V*D. Por ejemplo, si a =[1 2; 3 4], entonces

5.37228
d=
−0.37228
y
5.37228 . . . 0 0.41597 . . . −0.82456 . . .
D= , V = .
0 −0.37228 . . . 0.90938 . . . 0.56577 . . .
La primera columna de V es el autovector de a asociado al primer autovalor, 5.37228 . . ..
D.6.6. Análisis de datos y transformada de Fourier

En Octave/Matlab están disponibles diversas herramientas para el análisis de series de
datos (estadı́stica, correlaciones, convolución, etc.). Algunas de las operaciones básicas son:
a) Máximos y mı́nimos
Si a es un vector, max(a) es el mayor elemento de a. Si es una matriz, max(a) es un vector
fila, que contiene el máximo elemento para cada columna.
D.6. COMANDOS 375
a = [1 6 7; 2 8 3; 0 4 1]
b = max(a) b = (2 8 7)
Se sigue que el mayor elemento de la matriz se obtiene con max(max(a)).
min opera de modo análogo, entregando los mı́nimos.
b) Estadı́stica básica
Las siguientes funciones, como min y max, operan sobre vectores del modo usual, y sobre
matrices entregando vectores fila, con cada elemento representando a cada columna de la
matriz.
mean Valor promedio

median Mediana
std Desviación standard
prod Producto de los elementos
sum Suma de los elementos
c) Orden
sort(a) ordena los elementos de a en orden ascendente si a es un vector. Si es una matriz,
ordena cada columna.
 
1 −3 0
b = sort([1 3 9; 8 2 1; 4 -3 0]); b = 4 2 1
8 3 9
d) Transformada de Fourier
Por último, es posible efectuar transformadas de Fourier directas e inversas, en una o dos
dimensiones. Por ejemplo, fft y ifft dan la transformada de Fourier y la transformada
inversa de x, usando un algoritmo de fast Fourier transform (FFT). Especı́ficamente, si
X=fft(x) y x=ifft(X), y los vectores son de largo N:
N
(j−1)(k−1)
X
X(k) = x(j)ωN ,
j=1
N
1 X −(j−1)(k−1)
x(j) = X(k)ωN ,
N k=1
donde ωN = e−2πi/N .
D.6.7. Gráficos
Una de las caracterı́sticas más importantes de Matlab son sus amplias posibilidades gráfi-
cas. Algunas de esas caracterı́sticas se encuentran también en Octave. En esta sección revi-
saremos el caso de gráficos en dos dimensiones, en la siguiente el caso de tres dimensiones, y
luego examinaremos algunas posibilidades de manipulación de gráficos.
Gráficos bidimensionales
Para graficar en dos dimensiones se usa el comando plot. plot(x,y) grafica la ordenada
y versus la abscisa x. plot(y) asume abscisa [1,2,...n], donde n es la longitud de y.
Ejemplo: Si x=[2 8 9], y=[6 3 2], entonces
plot(x,y)
Figura D.1: Gráfico simple.
Por default, Octave utiliza gnuplot para los gráficos. Por default, los puntos se conectan
con una lı́nea roja en este caso. El aspecto de la lı́nea o de los puntos puede ser modificado.
Por ejemplo, plot(x,y,’ob’) hace que los puntos sean indicados con cı́rculos (’o’) azules
(’b’, blue). Otros modificadores posibles son:
- lı́nea (default) r red
. puntos g green
@ otro estilo de puntos b blue
+ signo más m magenta
* asteriscos c cyan
o cı́rculos w white
x cruces
Dos o más gráficos se pueden incluir en el mismo output agregando más argumentos a
plot. Por ejemplo: plot(x1,y1,’x’,x2,y2,’og’,x3,y3,’.c’).
Los mapas de contorno son un tipo especial de gráfico. Dada una función z = f (x, y),
nos interesa graficar los puntos (x, y) tales que f = c, con c alguna constante. Por ejemplo,
consideremos
2 2
z = xe−x −y , x ∈ [−2, 2], y ∈ [−2, 3] .
Para obtener el gráfico de contorno de z, mostrando los niveles z = −.3, z = −.1, z = 0,
z = .1 y z = .3, podemos usar las instrucciones:
x = -2:.2:2;
y = -2:.2:3;
[X,Y] = meshgrid(x,y);
D.6. COMANDOS 377
Z = X.*exp(-X.^2-Y.^2);
contour(Z.’,[-.3 -.1 0 .1 .3],x,y); # Octave por default (gnuplot)
contour(x, y, Z.’,[-.3 -.1 0 .1 .3]); # Octave con plplot y Matlab
Figura D.2: Curvas de contorno.
Las dos primeras lı́neas definen los puntos sobre los ejes x e y en los cuales la función
será evaluada. En este caso, escojimos una grilla en que puntos contiguos están separados por
.2. Para un mapa de contorno, necesitamos evaluar la función en todos los pares ordenados
(x, y) posibles al escoger x en x e y en y. Para eso usamos meshgrid (introducida sin mayores
explicaciones en la sección D.6.3). Luego evaluamos la función [Z es una matriz, donde cada
elemento es el valor de la función en un par ordenado (x, y)], y finalmente construimos el
mapa de contorno para los niveles deseados.
Gráficos tridimensionales
También es posible realizar gráficos tridimensionales. Por ejemplo, la misma doble gaus-
siana de la sección anterior se puede graficar en tres dimensiones, para mostrarla como una
superficie z(x, y). Basta reemplazar la última instrucción, que llama a contour, por la si-
guiente:
mesh(X,Y,Z)
Observar que, mientras contour acepta argumentos dos de los cuales son vectores, y el
tercero una matriz, en mesh los tres argumentos son matrices de la misma dimensión (usamos
X, Y, en vez de x, y).
Nota importante: Otro modo de hacer gráficos bi y tridimensionales es con gplot
y gsplot (instrucciones asociadas realmente no a Octave sino a gnuplot, y por tanto no
equivalentes a instrucciones en Matlab). Se recomienda consultar la documentación de Octave
para los detalles.
Figura D.3: Curvas de contorno.
Manipulación de gráficos
Los siguientes comandos están disponibles para modificar gráficos construidos con Octa-
ve/Matlab:
a) Ejes
axis([x1 y1 x2 y2]) Cambia el eje x al rango (x1, x2), y el eje y al rango (y1, y2).
b) Tı́tulos
title(s) Tı́tulo (s es un string)

xlabel(s) Tı́tulo del eje x, y, z.
ylabel(s)
zlabel(s)
c) Grillas
grid Incluye o borra una grilla de referencia en un gráfico bidimen-

sional. grid ‘‘on’’ coloca la grilla y grid ‘‘off’’ la saca.
grid equivale a grid ‘‘on’’.
Al usar gnuplot, el gráfico mostrado en pantalla no es actualizado automáticamente.

Para actualizarlo y ver las modificaciones efectuadas, hay que dar la instrucción replot.
Los siguientes comandos permiten manipular las ventanas gráficas:

D.6. COMANDOS 379
hold Permite “congelar” la figura actual, de modo que sucesivos

comandos gráficos se superponen sobre dicha figura (nor-
malmente la figura anterior es reemplazada por la nueva).
hold on activa este “congelamiento”, y hold off lo desacti-
va. hold cambia alternativamente entre el estado on y off.
closeplot Cierra la ventana actual.
Finalmente, si se desea guardar un gráfico en un archivo, se puede proceder del siguiente
modo si Octave está generando los gráficos con gnuplot y se trabaja en un terminal con
XWindows. Si se desea guardar un gráfico de la función y = x3 , por ejemplo:
x = linspace(1,10,30);
y = x.^3;
plot(x,y);
gset term postscript color
gset output ‘‘xcubo.ps’’
replot
gset term x11
Las tres primeras lı́neas son los comandos de Octave/Matlab convencionales para graficar.
Luego se resetea el terminal a un terminal postscript en colores (gset term postscript si
no deseamos los colores), para que el output sucesivo vaya en formato postscript y no a
la pantalla. La siguiente lı́nea indica que la salida es al archivo xcubo.ps. Finalmente, se
redibuja el gráfico (con lo cual el archivo xcubo.ps es realmente generado), y se vuelve al
terminal XWindows para continuar trabajando con salida a la pantalla.
Debemos hacer notar que no necesariamente el gráfico exportado a Postscript se verá igual
al resultado que gnuplot muestra en pantalla. Durante la preparación de este manual, nos
dimos cuenta de ello al intentar cambiar los estilos de lı́nea de plot. Queda entonces advertido
el lector.
D.6.8. Strings
Para manipular una cadena de texto, disponemos de los siguientes comandos:
lower Convierte a minúsculas
upper Convierte a mayúsculas
Ası́, lower(’Texto’) da ’texto’, y upper(’Texto’) da ’TEXTO’.
Para comparar dos matrices entre sı́, usamos strcmp:
strcmp(a,b) 1 si a y b son idénticas, 0 en caso contrario
Podemos convertir números enteros o reales en strings, y strings en números, con los
comandos:
int2str Convierte entero en string
num2str Convierte número en string
str2num Convierte string en número
Por ejemplo, podemos usar esto para construir un tı́tulo para un gráfico:
s = [’Intensidad transmitida vs. frecuencia, n = ’, num2str(1.5)];

title(s);
Esto pondrá un tı́tulo en el gráfico con el texto:

Intensidad transmitida vs. frecuencia, n = 1.5.
D.6.9. Manejo de archivos

Ocasionalmente nos interesará grabar el resultado de nuestros cálculos en archivos, o
utilizar datos de archivos para nuevos cálculos. El primer paso es abrir un archivo:
archivo = fopen(’archivo.dat’,’w’);
Esto abre el archivo archivo.dat para escritura (’w’), y le asigna a este archivo un número
que queda alojado en la variable archivo para futura referencia.
Los modos de apertura posibles son:
r Abre para lectura
w Abre para escritura, descartando contenidos anteriores si los
hay
a Abre o crea archivo para escritura, agregando datos al final
del archivo si ya existe
r+ Abre para lectura y escritura
w+ Crea archivo para lectura y escritura
a+ Abre o crea archivo para lectura y escritura, agregando datos
al final del archivo si ya existe
En un archivo se puede escribir en modo binario:
fread Lee datos binarios
fwrite Escribe datos binarios
o en modo texto
fgetl Lee una lı́nea del archivo, descarta cambio de lı́nea
fgets Lee una lı́nea del archivo, preserva cambio de lı́nea
fprintf Escribe datos siguiendo un formato
fscanf Lee datos siguiendo un formato
Referimos al lector a la ayuda que proporciona Octave/Matlab para interiorizarse del
uso de estos comandos. Sólo expondremos el uso de fprintf, pues el formato es algo que
habitualmente se necesita tanto para escribir en archivos como en pantalla, y fprintf se
puede usar en ambos casos.
La instrucción
fprintf(archivo,’formato’,A,B,...)
D.6. COMANDOS 381
imprime en el archivo asociado con el identificador archivo (asociado al mismo al usar fopen,
ver más arriba), las variables A, B, etc., usando el formato ’formato’. archivo=1 corresponde
a la pantalla; si archivo se omite, el default es 1, es decir, fprintf imprime en pantalla si
archivo=1 o si se omite el primer argumento.
’formato’ es una string, que puede contener caracters normales, caracteres de escape o
especificadores de conversión. Los caracteres de escape son:
\n New line
\t Horizontal tab
\b Backspace
\r Carriage return
\f Form feed
\\ Backslash
\’ Single quote
Por ejemplo, la lı́nea
fprintf(’Una tabulacion\t y un \’\’original\’\’ cambio de linea\n aqui\n’)
da como resultado
Una tabulacion y un ’’original’’ cambio de linea
aqui
Es importante notar que por default, el cambio de lı́nea al final de un fprintf no existe,
de modo que, si queremos evitar salidas a pantalla o a archivo poco estéticas, siempre hay
que terminar con un \n.
Los especificadores de conversión permiten dar formato adecuado a las variables numéricas
A, B, etc. que se desean imprimir. Constan del caracter %, seguido de indicadores de ancho
(opcionales), y caracteres de conversión. Por ejemplo, si deseamos imprimir el número π con
5 decimales, la instrucción es:
fprintf(’Numero pi = %.5f\n’,pi)
El resultado:
Numero pi = 3.14159
Los caracteres de conversión pueden ser
%e Notación exponencial (Ej.: 2.4e-5)
%f Notación con punto decimal fijo (Ej.: 0.000024)
%g %e o %f, dependiendo de cuál sea más corto (los ceros no
significativos no se imprimen)
Entre % y e, f, o g según corresponda, se pueden agregar uno o más de los siguientes
caracteres, en este orden:
Un signo menos (-), para especificar alineamiento a la izquierda (a la derecha es el

default).
Un número entero para especificar un ancho mı́nimo del campo.
Un punto para separar el número anterior del siguiente número.
Un número indicando la precisión (número de dı́gitos a la derecha del punto decimal).
En el siguiente ejemplo veremos distintos casos posibles. El output fue generado con las
siguientes instrucciones, contenidas en un script:
a = .04395;
fprintf(’123456789012345\n’);
fprintf(’a = %.3f.\n’,a);
fprintf(’a = %10.2f.\n’,a);
fprintf(’a = %-10.2f.\n’,a);
fprintf(’a = %4f.\n’,a);
fprintf(’a = %5.3e.\n’,a);
fprintf(’a = %f.\n’,a);
fprintf(’a = %e.\n’,a);
fprintf(’a = %g.\n’,a);
El resultado:
12345678901234567890
a = 0.044.
a = 0.04.
a = 0.04 .
a = 0.043950.
a = 4.395e-02.
a = 0.043950.
a = 4.395000e-02.
a = 0.04395.
En la primera lı́nea, se imprimen tres decimales. En la segunda, dos, pero el ancho mı́nimo
es 10 caracteres, de modo que se alı́nea a la derecha el output y se completa con blancos. En
la tercera lı́nea es lo mismo, pero alineado a la izquierda. En la cuarta lı́nea se ha especificado
un ancho mı́nimo de 4 caracteres; como el tamaño del número es mayor, esto no tiene efecto
y se imprime el número completo. En la quinta lı́nea se usa notación exponencial, con tres
decimal (nuevamente, el ancho mı́nimo especificado, 5, es menor que el ancho del output,
luego no tiene efecto). Las últimas tres lı́neas comparan el output de %f, %e y %g, sin otras
especificaciones.
Si se desean imprimir más de un número, basta agregar las conversiones adecuadas y los
argumentos en fprintf. Ası́, la lı́nea
fprintf(’Dos numeros arbitrarios: %g y %g.\n’,pi,exp(4));
da por resultado
Dos numeros arbitrarios: 3.14159 y 54.5982.

D.6. COMANDOS 383
Si los argumentos numéricos de fprintf son matrices, el formato es aplicado a cada

columna hasta terminar la matriz. Por ejemplo, el script
x = 1:5;
y1 = exp(x);
y2 = log(x);
a = [x; y1; y2];
fprintf = (’%g %8g %8.3f\n’,a);
da el output
1 2.71828 0.000
2 7.38906 0.693
3 20.0855 1.099
4 54.5982 1.386
5 148.413 1.609
Apéndice E
Asignación dinámica.
La reserva de memoria para la matriz podemos hacerla en forma dinámica ocupando el

operador new que pedirá al sistema la memoria necesaria, si está disponible el sistema se
la asignará. Como con cualquier puntero, una vez desocupado el arreglo debemos liberar la
memoria con el comando delete.
#include <iostream>
int main()
{
cout<<"Ingrese la dimension deseada :" ;
int dim ;
cin >> dim ;
double * matriz = new double[dim] ; // Reserva la memoria
for(int i=0; i < dim; i++) {
cout << "Ingrese elemento "<< i <<" : ";
cin >> matriz[i] ;
}
for (int i=0;i<dim;i++){

cout << matriz[i] << ", ";
}
cout << endl;
delete [] matriz; // Libera la memoria reservada

return 0;
}
Este ejemplo permite apreciar una gran ventaja del uso de punteros, al permitirnos liberarnos
de definir la dimensión de una matriz como una constante. Aquı́, dim es simplemente un int.
La asignación dinámica permite definir matrices cuya dimensión se determina recién durante
la ejecución.
Observemos finalmente que la liberación de memoria, en el caso de arreglos, se hace con
el operador delete [], no delete como en los punteros usuales.
385
386 APÉNDICE E. ASIGNACIÓN DINÁMICA.
E.1. Arreglos dinámicos bidimensionales.

También es posible definir arreglos bidimensionales dinámicamente. En el siguiente ejem-
plo, se define una matriz de 200 filas y 400 columnas, inicializándose sus elementos a cero, y
finalmente se borra:
int main()
{
int width;
int height;
width = 200;
height = 400;
double ** matriz = new double * [width];
for (int i=0;i<width;i++){

matriz[i] = new double[height];
}

for (int j=0;j<height;j++){
matriz[i][j] = 0;
}
}

delete [] matriz[i];
}
delete [] matriz;
return 0;
}
Primero se crea, con new, un puntero (matriz) de dimensión 200, que representará las
filas. Cada uno de sus elementos (matriz[i]), a su vez, será un nuevo puntero, de dimensión
400, representando cada columna. Por tanto, matriz debe ser un puntero a puntero (de
dobles, en este caso), y ası́ es definido inicialmente (double ** ...). Esto puede parecer
extraño a primera vista, pero recordemos que los punteros pueden ser punteros a cualquier
objeto, en particular a otro puntero. Luego se crean los punteros de cada columna (primer
ciclo for). A continuación se llenan los elementos con ceros (segundo ciclo for). Finalmente,
se libera la memoria, en orden inverso a como fue asignada: primero se libera la memoria de
cada columna de la matriz (delete [] matriz[i], tercer ciclo for), y por último se libera
la memoria del puntero a estos punteros (delete [] matriz).
Apéndice F
make y Makefile.
make es un comando particularmente útil cuando se trata de hacer tareas repetitivas y que
involucran a un número posiblemente grande de archivos distintos para producir un resultado
final. La idea es sencilla: dar el comando make significa, básicamente, decirle al sistema:
“haga todo lo que sea necesario hacer para crear una versión actualizada del resultado final,
considerando que algunos de los archivos necesarios para producirlo pueden haber cambiado
desde la última vez”. A través de algunos ejemplos simples veamos cómo es posible traducir
este mandato en instrucciones que un computador pueda entender.
F.1. Un ejemplo sencillo en C++

Consideremos un programa sencillo en C++, hola.cc que sólo dice “Hola”:
#include <iostream>
int main() {
cout << "Hola" << endl;
return 0;
}
El comando g++ -o hola hola.cc creará un ejecutable a partir de esta fuente. Por su-
puesto, al dar nuevamente el comando g++ -o hola hola.cc el proceso de compilación
comenzará nuevamente. Esto no es muy eficiente, porque hola sólo depende de hola.cc, y
no necesita ser recreado a menos que hola.cc sea modificado.
Usemos, en cambio, el comando make. Creemos el archivo hola.cc (si ya existe, modifi-
quémoslo agregándole un espacio en blanco, por ejemplo), y luego ejecutemos el comando:
user@hostname:~$ make hola
La siguiente lı́nea es escrita en el terminal:
g++ hola.cc -o hola
387
388 APÉNDICE F. MAKE Y MAKEFILE.
y un ejecutable hola es generado.

Ahora ejecutemos nuevamente make:
user@hostname:~$ make hola

make: ‘hola’ is up to date.
Esta vez make no tiene ningún efecto. Ésa es toda la gracia de make: darse cuenta de
qué necesita ser recreado, porque sabe qué resultado depende de qué archivo fuente.
F.2. Creando un Makefile

En el ejemplo anterior, make detectó automáticamente que hola depende de hola.cc. En
realidad, lo que ocurre es que existen una serie de reglas predefinidas. En este caso, make
buscó en el directorio actual un archivo del cual pudiera depender hola, encontró a hola.cc,
y ejecutó g++ con las opciones adecuadas. Pero si hubiera encontrado un hola.f, hubiera
entendido que debı́a ejecutar el compilador de Fortran. A veces estas reglas son insuficientes y
uno debe decirle a make explı́citamente cómo proceder con cada dependencia. O simplemente
no deseamos confiar en el azar. Cualquiera que sea el caso, podemos extender o modificar las
reglas de make usando un Makefile.
La estrategia, nuevamente, es sencilla: cree en el directorio de trabajo un archivo Makefile,
con las instrucciones necesarias (en este apéndice hay algunos ejemplos). Cuando make sea
ejecutado, leerá este archivo y procederá en consecuencia.
El siguiente es un Makefile para el ejemplo sencillo de la Sec. F.1:
hola: hola.cc
g++ -o $@ $<
La sintaxis es la siguiente:
– hola: es un target (blanco). Indica que la siguiente regla sirve para generar el archivo
hola.
– Luego de los dos puntos, vienen las dependencias de hola. En este caso, sólo es hola.cc.
– En la segunda lı́nea, viene la regla para generar hola. Aquı́ se han usado dos variables
predefinidas de make (hay muchas más): $@ es el target de la regla, y $< es la dependencia
de la regla. En este caso, entonces, una vez que make reemplaza dichas variables, la regla
queda como g++ -o hola hola.cc, que es por supuesto lo que queremos.
Un punto muy importante: En la regla, antes de los caracteres g++, no hay 8 espacios
en blanco, sino un carácter de tabulación, TAB. De hecho, si uno reemplazara ese TAB por
8 espacios, make se darı́a cuenta. La versión 3.81 de GNU make, por ejemplo, entrega el
siguiente mensaje al intentar ejecutarlo:
user@localhost:~$ make
Makefile:2: *** missing separator (did you mean TAB instead of 8 spaces?). Stop.
F.2. CREANDO UN MAKEFILE 389
Este Makefile hace exactamente lo mismo que en la Sec. F.1, pero ahora no necesitamos
descansar en las dependencias default: make hola busca el target hola en el archivo Makefile
en el directorio actual, y revisa sus dependencias. Si alguna de las dependencias es más
reciente que el archivo hola, entonces ejecuta las lı́neas que constituyen la regla. (En el
ejemplo analizado, la regla consta de una sola lı́nea, pero podrı́a ser por supuesto más de una
lı́nea si para generar el target se debe ejecutar más de un comando.)
Observemos que, puesto que make toma decisiones sólo en base a las fechas de modificación
de los archivos, para probar que las reglas funcionan adecuadamente no es necesario editar
hola.cc. Basta con touch hola.cc, con lo cual la fuente aparecerá como más reciente que
el ejecutable.
En un mismo Makefile puede haber más de una regla. Por ejemplo:
hola: hola.cc
g++ -o $@ $<
chao.dvi: chao.tex
latex $<
En este caso, además del ejecutable hola, podemos generar un archivo chao.dvi, compi-
lando con LATEX el archivo chao.tex. Es claro, entonces, que un solo Makefile nos permite
generar muchos archivos distintos, con una única lı́nea de comando, del tipo make <target>.
Si se omite el argumento, make ejecuta el primer target que encuentra en el Makefile. Por
ello, puede ser útil, dependiendo de la aplicación, poner al principio un target que simplemente
genere todos los archivos necesarios:
all:
make hola
make chao
hola: hola.cc
g++ -o $@ $<
chao.dvi: chao.tex
latex $<
Ası́, el comando make, sin argumentos, compilará lo necesario para obtener los archivos finales
actualizados.
Notamos que all es un target especial, pues no tiene dependencias. Es decir, se ejecuta
incondicionalmente. Otro uso habitual de un target sin dependencias es el siguiente:
all:
make hola
make chao
hola: hola.cc
g++ -o $@ $<
chao.dvi: chao.tex
latex $<
clean:
rm hola chao.dvi chao.log chao.aux
Ahora, make clean borra todos los productos de compilación y archivos auxiliares que
hayan podido generarse, quedando sólo lo importante: las fuentes, y el propio Makefile.
F.3. Un ejemplo con varias dependencias: LATEX

En el ejemplo anterior, el resultado final, hola, depende de un solo archivo, hola.cc. Es
posible, sin embargo, que el archivo a generar tenga más de una dependencia, y que incluso
esas dependencias deban generarse a partir de otras dependencias. Ilustraremos esto con un
ejemplo en LATEX.
Consideremos el siguiente archivo, texto.tex:
\usepackage{graphicx}
\begin{document}
Una figura:
\includegraphics{figura.eps}
\end{document}
El archivo compilado, texto.dvi, depende de texto.tex, por cierto, pero también de

figura.eps. Un Makefile adecuado para esta situación es:
texto.dvi: texto.tex figura.eps

latex texto
clean:
rm texto.dvi texto.log texto.aux
¿Qué pasa ahora si figura.eps, a su vez, es generada a partir de otros archivos fuente? Por
ejemplo, digamos que creamos, con xfig, el archivo figura.fig. En principio, si editamos
la figura, podemos no sólo grabarla como un archivo fig, sino también como un archivo
postscript, con lo cual la figura queda actualizada. Existe otro modo, un poco más eficiente:
en xfig grabamos sólo la versión fig, y generamos el eps con la lı́nea de comandos:
username@host:~$ fig2dev -L eps figura.fig figura.eps

F.4. VARIABLES DEL USUARIO Y PATRONES 391
Ahora podemos incluir este comando como una regla adicional en el Makefile:
texto.dvi: texto.tex figura.eps

latex texto
figura.eps: figura.fig
fig2dev -L eps $< $@
clean:
rm texto.dvi texto.log texto.aux figura.eps
Para cada dependencia declarada, make verifica si existe alguna regla para construirla. En
el caso de texto.tex no la hay, ası́ que continúa. Para figura.eps la hay: verifica la fecha
de modificación de figura.fig, y determina si es necesario actualizar figura.eps. Ahora
que todas las dependencias de texto.dvi están actualizadas, revisa si es necesario actualizar
texto.dvi.
Son claras entonces las ventajas de make: Un proyecto dado, por complicado que sea, se
puede escribir en términos de productos finales y dependencias, posiblemente múltiples, y
posiblemente encadenadas. Naturalmente, proyectos más complicados tendrán un Makefile
más complicado. Pero una vez construido éste, el producto final se obtiene simplemente con
el comando make.1
Observemos, adicionalmente, que en el último Makefile agregamos al target clean la
orden de borrar figura.eps. Ahora dicho archivo puede ser generado siempre a partir de
figura.fig, por tanto no es necesario mantenerlo en disco.
F.4. Variables del usuario y patrones

En nuestro ejemplo sencillo de Makefile de la sección anterior, hemos usado dos varia-
bles internas del sistema, $< y $@. Hay más, por supuesto, y sugerimos leer la documen-
tación de make para ello. Pero además, el usuario puede definir sus propias variables. Por
ejemplo, supongamos ahora que nuestro archivo LATEX necesita dos figuras, figura.eps
y otra_figura.eps, ambas provenientes de sendos archivos fig. Debemos modificar el
Makefile en tres puntos:
Agregar la dependencia otra_figura.eps a texto.dvi.
Agregar una regla para construir otra_figura.eps a partir de otra_figura.fig.
Agregar otra_figura.eps a la lista de archivos a borrar con make clean.
Es claro que este proceso es cada vez más engorroso mientras más figuras tenga un archi-
vo. Aquı́ es donde es útil definir variables de usuario, para evitar modificar tantas veces el
1
El software distribuido en forma de código fuente habitualmente hace uso de esta herramienta. Ası́,
independiente de la complejidad del software, el usuario simplemente debe dar un solo comando, make, para
obtener el ejecutable final.
Makefile, con la consiguiente ganancia de tiempo y reducción de la probabilidad de come-

ter errores. Definiremos entonces una variable figuras, para agrupar a los archivos eps de
figuras. La sintaxis es parecida a la de bash, tanto para definir la variable como para usarla:
figuras=figura.eps otra_figura.eps
texto.dvi: texto.tex $(figuras)

latex texto
figura.eps: figura.fig
otra_figura.eps: otra_figura.fig
clean:
rm texto.dvi texto.log texto.aux $(figuras)
De este modo, agregar más figuras implica sólo dos modificaciones: agregar un valor a la
definición de figuras, y agregar la regla correspondiente.
Pero aún es posible una simplificación adicional: si todas las figuras eps van a venir de
fig, ¿será posible que make entienda eso de una vez y para siempre, y no tener que darle
reglas redundantes? Sı́, es posible, y eso se logra gracias a los patrones, simbolizados con el
carácter especial %. Observemos el siguiente Makefile, equivalente al anterior:
figuras=figura.eps otra_figura.eps
texto.dvi: texto.tex $(figuras)

latex texto
$(figuras):%.eps:%.fig
clean:
rm texto.dvi texto.log texto.aux $(figuras)
Se ha puesto una dependencia en la forma $(figuras):%.eps:%.fig. Esto significa lo

siguiente: de todos los nombres contenidos en la variable $(figuras), seleccione los eps.
Cada eps, a su vez, depende de un archivo que se llama igual, pero con extensión fig. El
patrón % representa en este caso, al nombre sin extensión del archivo.
Ası́, este Makefile permite, para todas las figuras (variable figuras), crear los eps a
partir de los fig correspondientes, a través de la misma regla (fig2dev). Ahora sı́, agregar
más figuras es trivial: basta con modificar sólo una lı́nea del Makefile, la definición de
figuras. El tiempo invertido y las posibilidades de error ahora son mı́nimos.
Naturalmente, estrategias similares se pueden emplear si deseamos generar, en vez de un
dvi, un pdf. En tal caso, las figuras deben ser convertidas a pdf:
F.5. C++: PROGRAMANDO CON MÁS DE UN ARCHIVO FUENTE 393
figuras=figura.pdf otra_figura.pdf
texto.pdf: texto.tex $(figuras)

pdflatex texto
$(figuras):%.pdf:%.fig
fig2dev -L pdf $< $@
clean:
rm texto.pdf texto.log texto.aux $(figuras)
F.5. C++: Programando con más de un archivo fuente

Hasta el momento, hemos centrado la mayor parte de la discusión en un ejemplo de
LATEX, pero el uso de make es por supuesto mucho más general, y el mismo tipo de ideas se
pueden usar para cualquier tipo de proyecto en que se deben realizar tareas automáticas y
posiblemente en secuencia. En lo que sigue, continuaremos la discusión con un ejemplo en
C++. No introduciremos conceptos nuevos de make que los vistos en secciones anteriores,
sino que veremos cómo se pueden utilizar en un proyecto de programación más complicado,
consistente en varios archivos fuentes.
En principio, un programa en C++, o en cualquier lenguaje de programación, puede
constar de un solo archivo que contenga todas las instrucciones necesarias. Para escribir
"Hola mundo" en pantalla se requieren unas pocas lı́neas de código, que pueden estar con-
tenidas en un archivo hola.cc. En ese caso, se puede crear un ejecutable hola a partir de
dicha fuente, en la forma
user@hostname:~$ g++ hola.cc -o hola
Sin embargo, cuando el programa es un poco más complicado, puede ser necesario, y de
hecho es aconsejable, dividir el programa en varios archivos fuentes. Ası́, si nuestro programa
hola usa una función auxiliar, PrintHola(), para enviar el mensaje a pantalla, una posibili-
dad es poner la declaración de dicha función en un header , que podemos llamar, por ejemplo,
print_hola.h, y su implementación en el correspondiente archivo print_hola.cc. En ese
caso, además de incluir en el archivo hola.cc una lı́nea del tipo #include "print_hola.h",
es neceario cambiar la lı́nea de compilación a:
user@hostname:~$ g++ print_hola.cc hola.cc -o hola
El ejemplo anterior puede parecer banal, pero es una situación usual cuando se construye
un programa en C++ usando clases. En ese caso, si se define una clase Complejo, para utilizar
números complejos, entonces las declaraciones de la clase y sus funciones asociadas estarán
en un archivo llamado, por ejemplo, complejo.h, y la implementación correspondiente en
complejo.cc.
Ya que mencionamos este ejemplo, imaginemos un programa llamado "mi_gran_programa",
que dice "Hola mundo" (usando la función PrintHola() anterior), y sabe manipular matri-
ces de números complejos. Los números complejos están definidos con la clase Complejo, en
complejo.h y complejo.cc, y las matrices con la clase Matriz, en matriz.h y matriz.cc.

La lı́nea de compilación serı́a, entonces,
user@hostname:~$ g++ print_hola.cc complejo.cc matriz.cc \
mi_gran_programa.cc -o mi_gran_programa
¡Ya ni siquiera nos cabe en una lı́nea! Y no es un programa tan complicado. Ahora
el problema: si realizo una pequeña modificación en complejo.cc, hay que dar toda esta
lı́nea de compilación de nuevo. No sólo eso, sino que el compilador es obligado a leer y
codificar los contenidos de print_hola.cc, print_hola.h, complejo.cc y complejo.h, y
mi_gran_programa.cc, a pesar de que ninguno de ellos fue modificado. Esto, claramente, es
un desperdicio de recursos, que va a ser más evidente mientras más archivos fuentes (*.cc)
compongan en proyecto, o mientras más grandes sean dichos archivos.
Podemos intuir, con lo que ya sabemos, que éste es el tı́pico problema en que make nos
será de gran ayuda. Pero antes, debemos conocer un poco más cómo es el proceso de creación
de un ejecutable en C++.
En realidad, crear un ejecutable consta de dos procesos: compilación y linkeo. El linkeo es
el proceso mediante el cual se “une” un código fuente con código proveniente de librerı́as del
sistema o generadas por el propio usuario, para agregar funcionalidad inexistente en el código
fuente. ¿Complicado? No tanto. El sencillo programa hola.cc envı́a un mensaje a pantalla,
pero en realidad no contiene el código necesario para ello, salvo la llamada a la función cout,
que no está definida en hola.cc. El código necesario se encuentra en una librerı́a del sistema.
Entonces, el comando g++ primero compila el código fuente en hola.cc, convirtiéndolo a un
lenguaje más cercano a la máquina, y luego lo linkea, en este caso a las librerı́as del sistema.
Sólo entonces se tiene un ejecutable con toda la funcionalidad deseada.
Ahora podemos ver que, para no tener que pasar por todos los archivos fuentes cada
vez que se hace una modificación en uno de ellos, hay que separar compilación y linkeo.
Primero, generamos object files (archivos con extensión .o), a partir de cada archivo fuente,
compilando con la opción -c:
user@hostname:~$ g++ -c print_hola.cc -o print_hola.o
user@hostname:~$ g++ -c complejo.cc -o complejo.o
user@hostname:~$ g++ -c matriz.cc -o matriz.o
Finalmente linkeamos los tres object files, junto al código que contiene a main(), para generar
el ejecutable final:
user@hostname:~$ g++ print_hola.o complejo.o matriz.o hola.cc -o hola
Esto genera exactamente el mismo ejecutable que la larga lı́nea de comandos anterior. Pero
ahora, si modificamos complejo.cc, basta con rehacer el correspondiente object file y linkear
todo nuevamente:
user@hostname:~$ g++ -c complejo.cc -o complejo.o
user@hostname:~$ g++ print_hola.o complejo.o matriz.o hola.cc -o hola
Como vemos, no es necesario que el compilador vuelva a leer los archivos matriz.cc y
print_hola.cc. Esto reduce el tiempo de compilación considerablemente si los archivos fuen-
te son numerosos o muy grandes.
F.6. UN EJEMPLO COMPLETO 395
Ahora podemos automatizar todo este proceso a través del comando make. Basta con
construir un Makefile con las siguientes condiciones:
El ejecutable final (hola) depende de los object files involucrados, y se construye lin-
keándolos entre sı́.
Cada object file depende de su respectiva fuente (archivos .cc y .h), y se construye
compilando con g++ -c).
make clean puede borrar todos los object files y el ejecutable final, pues se pueden
construir a partir de las fuentes.
Usando lo aprendido en las subsecciones anteriores (dependencias, variables de usuario e

internas, patrones), podemos construir el siguiente Makefile, que hace lo pedido:
objects=print_hola.o complejo.o matriz.o
hola: $(objects)
g++ $(objects) hola.cc -o $@
$(objects):%.o:%.cc %.h
g++ -c $< -o $@
clean:
rm hola $(objects)
Observémos cómo hemos usado los patrones para crear dependencias múltiples: cada
archivo o depende de dos archivos con el mismo nombre, pero con extensiones cc y h.
Ya con este Makefile, de ahora en adelante, crear el ejecutable hola será mucho más
sencillo: editar los archivos fuentes y dar el comando make.
F.6. Un ejemplo completo

Terminamos nuestra discusión del comando make con un ejemplo completo, un Makefile
para compilar un programa de dinámica molecular llamado embat:
############################################################
# Makefile for C++ program EMBAT
# Embedded Atoms Molecular Dynamics
#
# You should do a "make" to compile
############################################################
#Compiler name
CXX = g++
#Linker name
LCC = g++
#Compiler flags you want to use

MYFLAGS = -Wall
OPFLAGS = -O4
CPPFLAGS = $(MYFLAGS) $(OPFLAGS)
#Library flags you want to use

MATHLIBS = -lm
CLASSLIBS= -lg++
LIBFLAGS = $(MATHLIBS) $(CLASSLIBS)
############################################################
OBJFILES = embat.o lee2.o crea100.o errores.o\

archivos.o azar.o lista.o rij.o\
escribir2.o velver.o cbc.o force.o\
fMetMet.o fDf.o relaja.o funciones.o\
initvel.o leerfns.o spline.o
embat : $(OBJFILES)
$(LCC) -o embat $(OBJFILES) $(LIBFLAGS)
$(OBJFILES): %.o:%.cc
$(CXX) -c $(CPPFLAGS) $< -o $@
############################################################
clean:
rm embat $(OBJFILES)
############################################################
Podemos reconocer varias de las técnicas discutidas en las secciones anteriores. El eje-
cutable embat se construye a partir de ciertos OBJFILES, que se construyen compilando los
archivos cc respectivos. Se compila usando g++, desplegando todos los warnings (opción
Wall), con nivel de optimización 4 (opción O4), y usando las librerı́as matemáticas de C++
(opción m). Observamos también algunos aspectos adicionales:
Se pueden poner lı́neas de comentarios con #.
Todos los compiladores y opciones de compilación y linkeo se han puesto dentro de

variables (p. ej. CXX, LCC, MYFLAGS, MATHLIBS, etc. Esto permite mayor flexibilidad a
futuro. Por ejemplo, podrı́amos desear compilar con una versión más reciente, o más
antigua, del compilador, o cambiar el nivel de optimización (variable OPFLAGS). Con
el Makefile anterior, es posible hacerlo sólo cambiando una lı́nea: la definición de la
variable correspondiente.
F.6. UN EJEMPLO COMPLETO 397
El carácter \ indica continuación de lı́nea. En este caso, en vez de definir OBJFILES en

una sola lı́nea de muchos caracteres (lo que probablemente no será cómodo de ver en
un editor de texto o en un terminal), se separa en lı́neas conectadas por \.
Apéndice G
Herramientas básicas en el uso de

L.A.M.P.
L.A.M.P. es la sigla popular para referirse al uso conjunto: Linux+Apache+Mysql+PHP

(también ésta ultima se reemplaza por Python o Perl) .
G.1. Objetivo.
Se espera que tras leer este apéndice el lector interesado sea capaz de:
Elaborar sus propias paginas web utilizando PHP, a partir de las cuales se pueda
intercambiar información de manera segura mediante el sistema gestor de base de datos
MySql.
G.2. Prerequisitos
Conocimiento básico sobre qué es un navegador, es decir, tener cierto tiempo utilizándo-
lo.
Tener instalados y operando conjuntamente los siguientes programas:
• Apache 1.3 o superior.

• MySql 4 o superior.
• PHP 4 o superior.
G.3. Breve referencia sobre paginas web.

Un navegador es un software que mediante la conexión a Internet interpreta scripts pre-
sentes en el servidor web, desplegando el resultado en pantalla. Dichos scripts normalmente
se encuentran escritos en lenguaje html.
La gran ventaja que ofrecen las páginas web son los llamados hipervı́nculos o links: objetos
que permiten saltar entre diferentes páginas web de manera fácil. Gracias a los links existen
399
400 APÉNDICE G. HERRAMIENTAS BÁSICAS EN EL USO DE L.A.M.P.
los “árboles de páginas”: diferentes scripts interconectados mediante links correspondientes

a un mismo dominio1 . Una página como la anteriormente descrita es capaz de desplegar
información en un navegador o recibirla a través de formularios. Este tipo de páginas reciben
el nombre de páginas estáticas, es decir, si se quiere cambiar la información desplegada, se
está obligado a modificar el script en html.
En contraste, existen páginas que cambian su información dependiendo de cuándo o cómo
son ejecutadas, recibiendo el nombre de páginas dinámicas. Para lograr el dinamismo, el
servidor, tras leer una serie de archivos, genera un nuevo código en html a tiempo de ejecución.
Ejemplos de dichas páginas son aquellas visitadas a diario por cualquier persona: buscadores,
bancos en lı́nea, correos electrónicos revisados desde un navegador, etc. Para generar este
tipo de páginas existen muchos lenguajes de programación, sin embargo, el más utilizado y
sobre la que se introducirá aquı́ es el lenguaje PHP.
G.3.1. Ejemplos
Página Estática en html.
• Archivo hola.html
<html>
<title> :::::El Clasico Hola mundo::: </title>
<body> Hola mundo! </body>
</html>
El ejemplo anterior corresponde a lo más simple en una página web en html ; notar que el
script está estructurado mediante el uso de etiquetas del tipo: <algo> .... </algo>.
Página Dinámica en PHP
• Archivo hola.php
<html>
<?php $h="Hola mundo!"; ?>
<title> :::::El Clasico <?php echo $h; ?>::: </title>
<body> <?php echo $h; ?> </body>
</html>
Si se procede a ejecutar ambos scripts probablemente no se aprecie ninguna diferencia;

sin embargo, el proceso que se ha llevado a cabo por el servidor establece fuertes diferencias
entre ambos códigos. Notar que el código en PHP se encuentra inserto por completo en el
código html. Por lo anterior, es necesario tener, al menos, un conocimiento básico de html
para comenzar a programar en PHP.
1
Nombre del sitio Internet.
G.4. ADMINISTRADOR DE BASES DE DATOS. 401
G.4. Administrador de Bases de datos.

Una base de datos es una manera ordenada de guardar cualquier tipo de información
para, de este modo, facilitar su búsqueda posterior. El encargado de buscar la información
de manera efectiva es el administrador de la base de datos; en nuestro caso, el administrador
corresponderá al software MySql. La información de la base de datos se almacena en matrices
llamadas tablas, conformadas por columnas definidas. Las diferentes filas de una tabla se van
constituyendo conforme se agregan nuevos registros; la información contenida en los registros
corresponde a un conjunto de strings o números.
G.5. Servidor Web.

Un servidor Web es un software que opera en la máquina remota. El servidor posee la
información contenida en la página y su función es proporcionar al internauta el contenido de
ésta. Para efectos de este apéndice, esto se reduce a interpretar el código en PHP y generar
en tiempo de ejecución el nuevo script en html.
Creando scripts.
En las secciones posteriores se listarán los comandos que permiten generar scripts, el
modo de chequearlos y, de esta forma, aprender mediante ensayo y error es:
crear la carpeta ~/public_html.
Escribir un script en el directorio antes citado utilizando algún editor2 .
abrir el navegador e ir a la URL http://nombredelhost/~nombredelusuario/pathdelscript.
Luego de seguir estos pasos, el navegador desplegará en la pantalla la ejecución del script.
Es importante señalar que el navegador no acusa errores de manera tan implacable como
compiladores u otros intérpretes (p.ej. Python), por lo cual se recomienda ser especialmente
riguroso.
G.6. Páginas Básicas en html.

Prácticamente todo el código en html corresponde a aspectos estéticos de la página, sobre
lo cual no se profundizará. Entre los objetivos que se buscan alcanzar en este apéndice, presen-
tan especial relevancia los formularios, pues permiten introducir información proporcionada
por un internauta a la base de datos.
2
Existen varios editores especializados en lenguajes web sobre los cuales conviene averiguar un poco.
G.6.1. Estructura de una página en html.

Si bien el navegador es capaz de interpretar correctamente código en html escrito sin
seguir las reglas, es importante al menos saber algunas.
Todo el diseño de la página se encuentra entre etiquetas del tipo <algo> .... </algo>.
Las más relevantes y que le dan estructura son:
<html>: Esta etiqueta delimita en qué parte del script comienza y termina el código en
html.
<title>: Lo que se escriba dentro de esta etiqueta conformará el tı́tulo de la página,

es decir, el nombre que aparecerá en el tı́tulo de la ventana del navegador.
<head>: Contiene etiquetas y contenidos del encabezado. Principalmente datos que no

aparecen en la página, pero que son relevantes.
<body>: Contiene la información que será desplegada en la pantalla, ya sea texto imáge-
nes, sonido, etc.
Cabe destacar que ninguna de las etiquetas mencionadas es obligatoria; puede precindirse
de ellas si tan sólo se quiere escribir texto sin ninguna estructura.
G.6.2. Algo de estilo.

Las etiquetas utilizadas para dar estilo al texto dentro del cuerpo de la página (i.e.
etiqueta <body>) son:
Propiedades del texto.

<p>: Delimita un párrafo que finalizará al cerrarse la etiqueta. Esta etiqueta admite
opciones especiales de alineación tales como: <p align="center">, la cual centra el
párrafo. Las variantes obvias de las otras alineaciones son dejadas al lector.
<h1>:Delimita un tı́tulo de porte variable en dependencia del número que se ponga

acompañando a la letra h, dicho número debe estar entre 1 y 6.
<br>: Introduce un salto de lı́nea. A diferencia de las etiquetas anteriores, ésta no tiene
una etiqueta de cerrado.
<hr>:Introduce una lı́nea horizontal. Al igual que en la etiqueta anterior, ésta es des-
apareada.
<b>: Todo lo escrito dentro de esta etiqueta quedará en negritas.
<em>: Convierte en itálica todo el texto dentro de esta etiqueta.
<u>: Subraya el texto dentro de la etiqueta.
<sub>: Convierte en subı́ndice los caracteres dentro de esta etiqueta.

G.6. PÁGINAS BÁSICAS EN HTML. 403
<sup>: Convierte en superı́ndice los caracteres delimitados por la etiqueta.
<font>: Etiqueta que permite definir atributos sobre el texto, tales como el porte o el
color. Por ejemplo, si se requiere texto en rojo: <font color="red">.
Propiedades globales de la Página.

Con las etiquetas anteriormente explicadas es posible crear una página con información
de manera relativamente ordenada, mas no estética. Un primer paso en esta última dirección
es lo que se tratará a continuación.
Todos los atributos globales corresponden a opciones de la etiqueta <body>. Lo que se
hará es definir los colores de: el texto, los links, links ya usados y el fondo. En html los colores
se especifican mediante un código (para conocer el código correspondiente a cada color puede
consultarse la tabla de colores (G.2) al final de este apéndice3 ).Lo anterior puede apreciarse
en el siguiente ejemplo:
<body bgcolor="#000000" text="#ffffff" link="#ffff33" alink="#ffffcc">
El campo bgcolor corresponde al color de fondo; text al color del texto; link y alink, a los
colores de los links por visitar y visitados respectivamente.
Alternativamente, es posible poner una foto de fondo de página, simplemente hay que
suplir bgcolor por:
<body background="fondo.jpg">
Se recomienda poner fotos pequeñas que sean visualmente agradables como mosaicos, de
lo contrario, puede variar el cómo se vean dependiendo del navegador, además de hacer más
pesada la página. El siguiente ejemplo utiliza las herramientas desarrolladas.
Ejemplo
• Archivo ejemplo2.html
<html>
<title> :::Herramientas de estilo::: </title>
<body bgcolor="#336699" text="#000033" link="#660000" alink="#33ff00">
<h1 align="center" > <font color="red">
Sobre lo que se hablará en esta página estática
</font> </h1>
<p align="right">
<em> ...Aquı́ por ejemplo una cita para comenzar</em>
</p>
<br>
<p algin="center">
Escribiendo la parte medular de la página.....<br>
Es posible escribir una formula sin caracteres especiales como la siguiente:
3
La cual por razones obvias debe ser vista a color.
<p align="center">(a<sub>11</sub>+a<sub>22</sub>+....)
<sup>2</sup>=(traza)<sup>2</sup></p>
<p align="left"> Finalmente, se espera un manejo
<b> básico </b> de <em> html </em> si se ha logrado comprender
<u> este ejemplo por completo </u></p>
</body>
</html>
Otros recursos.
Como se señaló en la introducción, la caracterı́stica más relevante de una página web es
su capacidad de interconexión con otras mediante links. Asimismo, existen otros recursos
ampliamente usados que mejoran el aspecto y orden de una página en html.
Insertando una imagen

Para insertar una imagen existe una etiqueta desapareada4 , en ésta debe darse el path
relativo del archivo gráfico de la siguiente forma:
<img src="path">
También se pueden especificar atributos adicionales, tales como: la alineación, el espacio

vertical y horizontal utilizado por la foto:
<img src="path" align="left" hspace="20" vspace="30">
En la orden anterior, la imagen (dentro del espacio que puede utilizar) se encuentra
alineada a la izquierda y tiene un marco de "20" horizontal por "30" vertical.
Links.
El enlace, es decir, el espacio de la página donde el cursor del mouse cambia y permite
acceder a la página siguiente, puede corresponder tanto a texto como a una imagen:
Enlace en el texto: Para esto existe la etiqueta:
<a href="path_a_la_página_en_cuestion">texto clickeable del link</a>
Los path pueden ser relativos5 si se trata de material presente en la misma máquina;
de tratarse de un enlace externo a la página, debe especificarse la URL completa.
Enlace sobre una imagen: Opera exactamente de la misma manera que un enlace
de texto y solo cambia el argumento dentro de la etiqueta.
<a href="path_a_la_página_en_cuestion"><img src="path"></a>

4
No tiene otra etiqueta de cierre
5
Respecto al código que se está ejecutando
Tablas.
Una tabla permite administrar el espacio en una página de manera eficiente y es especial-
mente útil cuando se quiere una página ordenada y sin muchas caracterı́sticas gráficas. La
tabla es delimitada por la etiqueta <table>, dentro de ésta, las filas quedan delimitadas por
la etiqueta <tr>. A su vez, el elemento de cada columna queda atrapado en la etiqueta <td>.
Dentro de los elementos de la tabla es posible utilizar prácticamente cualquier etiqueta. A
continuación, un esquema sobre cómo se programa una tabla:
<table>
<tr> <td> "a11"</td> <td>"a12"</td> <td>"a13"</td> <td>"a14"</td> </tr>
<tr> <td> "a21"</td> <td> "a22"</td> <td> "a23"</td> <td> "a24"</td> </tr>
</table>
Figura G.1: Esquema de una tabla en html, utilizando los elementos de una matriz.
G.6.3. Formularios.
Toda la preparación previa que se ha llevado a cabo tiene como fin el proveer de interfaz
gráfica a la página dinámica. El instrumento que permitirá recibir información desde el visi-
tante son los formularios, el qué se hace con dicha información escapa de las posibilidades de
html. Para procesar la información debe recurrirse a otros lenguajes.
Manejo de la información utilizando el formulario.

Todo formulario se encuentra definido dentro de la etiqueta <form>, la cual contiene
algunos atributos que especifican qué hacer con la información. Sin entrar en complicaciones,
sólo se señalará que para poder recuperar la información contenida en un formulario deben
definirse los siguientes atributos:
<form method="post" action="path_del_archivo_que_recupera_las_variables.php">

El atributo method="post" determina de qué forma es almacenada la información; el
atributo action="archivo.php", indica el nombre del archivo al cual es exportada dicha
información.
Diseño de formularios.
Existen una serie de formularios que deben escogerse según lo requiera la clase de página
que se éste programando. A continuación se listan las etiquetas para implementar los de
mayor uso, recuérdese que se está dentro de un formulario y por lo tanto dentro de una
etiqueta <form>.
Cajas de texto: Para crear una dentro del formulario basta escribir:
<input type="text" name="Nombre_de_la_información">
Si bien son válidas otras etiquetas adicionales, cabe destacar que el atributo type tam-
bién admite otras alternativas de rellenado tales como password, el cual oculta el texto
introducido. Usualmente, la información recaudada en los formularios es procesada de
manera algorı́tmica, por lo que conviene dar menos libertad sobre qué información es
ingresada por el usuario. Para ello se le hace optar, como se muestra en los 3 siguientes
diseños de formularios.
Listado de opciones: La sintaxis es la siguiente:
<select name="escoga">
<option value="op1">nombrealt1</option>
</select>
Recordar que el listado de opciones debe estar dentro de la etiqueta de formulario, de

lo contrario, la información obtenida de éste no irá a ningún lado. El atributo value
corresponde al nombre que se ha asignado a esa alternativa al procesar la información,
es decir, si por ejemplo la nombrealt1 es escogida, se registrará op1 como valor de la
variable escoja cuando se procese el formulario.
Botones de radio: La gran ventaja de éste sistema es que se obliga al internauta a
optar, la sintaxis es:
<input type="radio" name="escoja" value="op1">nombrealt1

<br>
<input type="radio" name="escoja" value="op2">nombrealt2
Sobra decir que un formulario puede también ser mixto, es decir, contener listados de
opciones cajas de textos y/o botones de radio.
Envió de la información.
Una vez que se ha finalizado la definición del formulario, debe agregarse un botón que
envı́e la información, el cual corresponde a otro input type. Adicionalmente, si el formulario
es muy largo es posible agregar un botón que ponga el formulario en blanco. Las sintaxis son
las siguientes:
Botón de envió de la información: <input type="submit" value="boton_de_envio">
Botón de reseteo: <input type="reset" value="resetear">
Ejemplos
Con las nuevas herramientas es posible construir páginas como las expuestas en los si-
guientes ejemplos: usando el primer ejemplo de esta sección como un archivo de nombre
ejemplo2.html, se puede construir un pequeño árbol de páginas con los siguientes 2 scripts.
El primer script requiere una foto llamada inicio.jpg en el directorio local.
<html>
<title> :::Utilizando los nuevos recursos::: </title>
<body bgcolor="#666666" text="#660000" link="#66FF00" alink="#660066">
<hr>
<table align="center"><tr><td><a href="ejemplo2.html"> ejemplo<br>
anterior </a></td><td> <a href="ejemplo4.html">
<img src="inicio.jpg" align="center" hspace="30" vspace="20"></a>
</td> <td> <a href="http://www.uchile.cl">enlace externo</a>
</td>
</tr></table> <hr>
</body>
</html>
<html>
<title>.::Ejemplo del uso de formularios tipo caja de texto::.</title>
<body bgcolor="#000000" text="#FFFFFF" link="#66FF00" alink="#00FF99">
<br>
<h2 align="center"> Complete con sus datos y gane!<h2>
<form " method="post" action="procesa.php">
<table align="center">
<tr><td> Nombre:</td><td><input type="text" name="Nombre"></td></tr>
<tr> <td>e-mail:</td><td> <input type="text" name="email"></td></tr>
<tr><td>Telefono:</td><td> <input type="number" name="fono"></td></tr>
<tr><td>Dirección:</td><td> <input type="text" name="direc"></td></tr>
<tr><td></td><td><input type="submit" value="enviar"></td></tr>
</form>
</table>
</body>
</html>
Ejemplo de formularios, tipo listado de alternativas:

• Archivo ejemplo4b.html
<html><title>::Listado de opciones:::</title>
<body bgcolor="#000000" text="#FFFFFF" link="#66FF99" alink="#660033">
<h1 algin="left"><u>Particulas subatomicas</u></h1>
<form method="post" action="psa.php">

<table><tr><td>Particula subatomica:</td>
<td><select name="psa"><option value="proton">protón</option>
<option value="neutron">neutrón</option><option value="electron">electrón</option>
</td></tr><tr><td></td><td>
<input type="submit" value="ver"></td></table></form></body></html>
A partir de estas herramientas básicas en la programación de páginas html, es posible
comenzar a introducir elementos que cambien dentro de la página a tiempo de ejecución. Esto
es, la programación en PHP. Sin embargo, primero debe explorarse brevemente el lenguaje
que permite comunicarse con la base de datos.
G.7. MySql.
G.7.1. Iniciando sesión.
MySql es un administrador de base de datos que tiene una estructura de usuarios similar
a la de UNIX: existe un superusuario llamado root y los usuarios ordinarios, cada uno con su
propia cuenta. Se supondrá en los siguientes ejemplos la posesión de una cuenta cuyo nombre
de usuario es lamp y de palabra clave bd. Para comenzar a interactuar con el administrador
de bases de datos, hay que iniciar una sesión en éste desde la consola del siguiente modo:
usa@host:$mysql -u lamp -p
Enter password:
Welcome to the MySQL monitor. Commands end with ; or \g.
Your MySQL connection id is 6 to server version: 4.0.24_Debian-10sarge2-log
Type ’help;’ or ’\h’ for help. Type ’\c’ to clear the buffer.
mysql>
La orden que se da desde la consola es: usa@host:$mysql -u lamp -p, que quiere decir:
“comienza una sesión de MySql con el nombre de usuario lamp (-u lamp) y pide el password
(-p)”. La última lı́nea corresponde al prompt de MySql.
G.7.2. Creando una base de datos.

A partir de aquı́ puede interactuarse con MySql ; para hacerlo debe conocerse el lenguaje
de interacción llamado Sql, del cual tan sólo se enseñarán las ordenes básicas. Cabe destacar
que todo lo que se escriba en la consola de MySql debe finalizar con “;”. El primer paso es
crear una base de datos, de nombre base, para ello debe introducirse la orden:
mysql> create database base;
Una vez creada la base de datos se puede comenzar a trabajar. Un usuario de MySql
puede tener varias bases de datos dentro de su cuenta, es por ello que cada vez que éste se
conecte a MySql ( i.e. se loguee) debe escoger la base de datos que utilizará; desde la consola
esto se hace escribiendo:
G.7. MYSQL. 409
mysql> connect base;
G.7.3. Creando tablas.

La base de datos será completamente inútil si no se han creado tablas. Probablemente
esto constituye el paso más complicado en el abordaje de un problema a solucionar con una
base de datos, pues es en la estructura de las tablas que quedará plasmado el esquema bajo
el cual operará lo que se programe. Por ello se recomienda fuertemente pensar este punto
antes que cualquier otro. Para crear una tabla debe especificarse (Al menos): el nombre de
la tabla, el nombre de cada campo y el tipo de cada campo. Supóngase el caso simple de
una tabla con teléfonos llamada “agenda”, esta tabla debe contener al menos dos campos:
nombres, que contenga texto, y teléfono, que contenga números. Para crear tal tabla debe
introducirse:
mysql> create table agenda(nombre text, telefono int);
O en general:
mysql> create table nombretabla(campo1 tipo, campo2 tipo,.......,campo_i tipo);

Podrı́a juzgarse el ejemplo demasiado simple, pues no queda claro de cuántos tipos pueden
ser los campos en una tabla; como la intención no es extenderse, se recomienda instalar el
script en PHP llamado phpmyadmin 6 , el cual permite una administración de la base de
datos desde el navegador de una forma bastante más intuitiva y didáctica que simplemente
interactuando con la consola. No se debe abusar del uso de esta interfase, pues es fundamental
conocer la sintaxis para interactuar con la base de datos ya que justamente son éstas órdenes
las que se incluyen en los scripts.
G.7.4. Interactuando con la Tabla.

Teniendo la capacidad para crear bases de datos y, dentro de éstas, crear tablas, lo que
resta es aprender a: insertar, buscar y remover registros de una tabla. Para ilustrar estas
acciones se continuará con el ejemplo de la agenda telefónica.
Escribiendo nuevos registros en la tabla: sentencia7 INSERT.
Supóngase que se quiere ingresar un nuevo usuario llamado “Pedro” de número telefóni-
co “5437896”. Para ello debe escribirse en la consola:
mysql> insert into agenda(nombre,telefono) values ("Pedro",5437896);
o en general:
mysql> insert into nombre_tabla(campo1,campo2,.....,campoj,..)

values (valcampo1,valcampo2,....,valcampoj,...);
6
Disponible para la distribución Debian GNU/Linux.
7
Tanto MySql como html no son sensibles a las mayúsculas al escribir scripts.
Notar que los string deben ir entre comillas dobles o simples, no ası́ los números. Si se
escribe dos veces el mismo registro, la base de datos guardará dos registros diferentes
con exactamente la misma información y los diferenciará por su fecha de ingreso.
Removiendo registros: sentencia DELETE.

Supóngase que se quiere borrar exclusivamente a Pedro; para ello debe escribirse:
mysql> delete from agenda where nombre=’Pedro’;
Notar la aparición de la condición WHERE, la cual especifica a quién borrar; de truncar

la sentencia antes de esta condición, MySql borrará todos los registros de la tabla.
Como es de esperarse, se podria haber identificado a quién se querı́a eliminar mediante
cualquier otro campo. El administrador se podrı́a preguntar cómo borrar la cantidad
de usuarios que quiera de manera efectiva haciendo algo similar a lo que permite bash,
esto es posible y fácilmente deducible de la sentencia select.
Buscando registros en la base de datos: sentencia SELECT.

La sintaxis de la sentencia SELECT es la siguiente:
mysql> select nomcampo from nomtabla where condiciones;
Un par de ejemplos para ilustrar lo anterior:
• Seleccionar todos los elementos: mysql> select * from agenda;

Listará todos los elementos de la agenda.
• Seleccionar todos los nombres de la agenda: mysql> select nombre from agenda;
Listará todos los nombres de la agenda (ı́dem con los teléfonos).
• Seleccionar el par (teléfono, nombre) del usuario “Andrea”:
mysql> select telefono,nombre from agenda where nombre=’Andrea’;
• Operadores lógicos: también es posible ser más especı́fico mediante operadores
lógicos como OR o AND, los cuales funcionan como se esperarı́a. Esto sirve para,
por ejemplo, corroborar la existencia de un registro. Supóngase que se conoce el
teléfono “5534126” y se tiene la sospecha de que pertenece a “Andrea”. Para ello
puede digitarse:
mysql> select * from agenda where nombre=’Andrea’ and telefono= 5534126;

Si no retorna ningún registro quiere decir que Andrea no tiene ese número. Alter-
nativamente, para obtener más información se puede escribir:
mysql> select * from agenda where nombre=’Andrea’ or telefono= 5534126;

Listará todos los registros que cumplan alguna o ambas condiciones.
• Mostrar registros que contengan información diferente:
G.7. MYSQL. 411
mysql> select ncampos DISTINCT FROM ntabla where condiciones
• Orden:
La mayorı́a de las veces es necesario saber parcialmente de qué forma vendrán
los datos listados, para ello es necesario introducir un orden y una tolerancia, de
esta forma es posible controlar exactamente qué hacer aparecer en el resultado de
la búsqueda. Supóngase que se quieren mostrar todos los elementos de la agenda
ordenados alfabéticamente por nombre, para esto hay que escribir:
mysql> select * from agenda order by nombre;
Queda claro que hace la condición ORDER BY. Supóngase que se desea invertir el
orden y poner los últimos 3 registros, para ello debe escribirse:
mysql> select * from agenda order by nombre desc limit 3;
La condición DESC exige un orden descendente, mientras que LIMIT, acompañado

de un entero, da la cantidad máxima de registros que pueden aparecer como resul-
tado de la búsqueda. Resulta especialmente importante hacer órdenes con núme-
ros, pues permiten utilizar comparadores aritméticos. Supóngase que se tiene una
tabla llamada usuarios que contiene los campos edad y nombre de personas. Para
encontrar los mayores de edad deberı́a escribirse:
mysql> select * from usuarios where edad >= 18;
Actualización de datos, sentencia: UPDATE.
Esta sentencia permite la actualización de los datos, es decir, toma un registro viejo
y le modifica algún campo. Supóngase que en el ejemplo de la agenda telefónica se
quiere cambiar el teléfono a un usuario llamado “Juan”, quien tiene un nuevo teléfono
“8571646”. Para hacerlo debe introducirse la orden:
mysql> update agenda set telefono=8571646 where nombre=’Juan’;
Es evidente la función de SET en la sintaxis; de no especificarse WHERE y truncarse la

frase, se cambiarı́a el teléfono de todos los registros por el nuevo número.
Funciones sobre los campos.

Existen, además, funciones que pueden aplicarse sobre los campos, las cuales pueden
investigarse utilizando phpmyadmin. Se verá un ejemplo simple: en presencia de una tabla
con información importante como contraseñas, serı́a necesario algún sistema de seguridad
sobre ellas. Para esto existe la función PASSWORD, la cual encripta el argumento. La tabla
se llama registrados y contiene 2 campos: Nombre tipo texto y clave tipo VARCHAR. Se sabe
como crear una tabla e insertar registros. La siguiente sintaxis muestra la diferencia hecha
por la función PASSWORD:
mysql> create table registrados (nombre text, clave VARCHAR(20));

mysql> insert into registrados (nombre, clave) values (’andres’,’te45’);
mysql> select * from registrados;
+--------+-------+
| nombre | clave |
+--------+-------+
| andres | te45 |
+--------+-------+
1 row in set (0.00 sec)
Se procede a encriptar la clave.
mysql> update registrados set clave=PASSWORD(’te45’) where nombre=’andres’;

mysql> select * from registrados;
+--------+------------------+
| nombre | clave |
+--------+------------------+
| andres | 37d3b95821add054 |
+--------+------------------+
Se ha expuesto lo más básico para poder interactuar con la base de datos. El conocimiento
de esta sintaxis volverá más rápidos, seguros y eficientes lo programado; sin embargo, el
alcance del apéndice utilizará tan sólo las herramientas aquı́ expuestas.
G.8. Programación en PHP.

Los 2 lenguajes antes vistos no tienen relación entre sı́ y, de hecho, no podrán funcionar
en conjunto de no ser por el lenguaje PHP. Este lenguaje es interpretado por un módulo del
servidor web, por ello, el código en PHP nunca abandona el servidor, es decir, el internauta
no puede ver la fuente en PHP visitando la página.
Para el estudiante de este apéndice se espera un aprendizaje muy rápido de PHP por su
similitud con bash y C++. En lo sucesivo, todo el trabajo de PHP será comunicarse con la
base de datos y manipular los recursos de html de manera dinámica.
G.8.1. Lenguaje PHP.

Como ya fue señalado en la introducción, el lenguaje en PHP se encuentra inserto dentro
del html. Esto significa que el script está escrito principalmente en html con trozos en PHP.
Todo el código en PHP queda delimitado por las etiquetas:
<?php... aqui todo el codigo en php .... ?>.
Al igual que en bash, las variables van antecedidas por un sı́mbolo $, por otra parte, al
igual que en C++ cada lı́nea de código debe ir finalizada por un “;”.
Si se regresa con esta nueva visión sobre el primer ejemplo de página dinámica expuesto
en este apéndice, se tendrá:
G.8. PROGRAMACIÓN EN PHP. 413
Página Dinámica en PHP

• Archivo hola.php
<html>
<?php $h="Hola mundo!";?>
<title> :::::El Clasico <?php echo $h; ?>::: </title>
<body> <?php echo $h; ?> </body>
</html>
Lo que ocurre al escribir esta página en el navegador es lo siguiente: el servidor web

procesa el script interpretando el código delimitado en PHP, generando a tiempo de ejecución
el siguiente nuevo script en html, el que es interpretado por el navegador.
<html>
<title> :::::El clasico Hola Mundo!:::</title>
<body> Hola Mundo! </body>
</html>
Debe quedar completamente claro que el código en PHP jamás abandona el servidor web,
por lo tanto, el código en PHP se encuentra inserto dentro del html y no viceversa. Dentro
de un script en html es posible, las veces que sea necesario y donde sea necesario, escribir
código en PHP.
G.8.2. Variables.
Las variables en PHP pueden ser string, números o arreglos. Para desplegar en pantalla
una variable se utiliza la instrucción echo. El ejemplo anterior constituye un caso simple de
esto.
G.8.3. Recuperando variables desde un formulario.

En el formulario del ejemplo 4, éste enviaba vı́a post las variables al archivo procesa.php.
Ahora se procederá a crear dicho archivo operando sobre las variables.
Ejemplo
• Archivo procesa.php
<html><title> recuperando las variables </title>

<h2 align="center"> La información tirada a pantalla<h2>
<p align="center"> Tu nombre es <b><?php echo $_POST[’Nombre’];?></b>
,vives en <b> <?php echo $_POST[’direc’]; ?> </b>.
Tu e-mail es <b> <?php echo $_POST[’correo’]; ?> </b>
, además tu teléfono es <?php echo $_POST[’fono’];?></p></body> </html>
Este archivo simplemente toma las variables y las despliega en pantalla. Se debe notar
que la información contenida en un formulario queda contenida en el grupo de variables
$_POST[’nombredelavariable’]. Con este conocimiento es posible rehacer todo ejercicio
propuesto en el capı́tulo de C++ donde se pidan variables y opere con ellas en PHP. Cabe
destacar todo lo que es posible mezclar html y PHP.
G.8.4. Control de flujo.

Las sintaxis de los controles de flujo más usuales en PHP son exactamente iguales a los ya
conocidos de C++. A continuación se dan ejemplos de los bucles while y if respectivamente.
Cabe destacar que el uso de “.” pega los string.
ejemplo while
<?php $i=1;
$j="Ejemplo de un bucle haciendo iteraciones, iteracion no :";?>
<html><body bgcolor="#336699" text="000033" link="660000" alink="#33ff00">
<h2 align=’center’> LOOP <em> while </em>. </h2>
<p align="right">
<?php while($i<10)//comentario en php
{echo $j . $i; $i++; ?> <br> <?php } ?>
</p></body></html>
ejemplo if
El condicional if logra que el script haga diferentes cosas según el valor de alguna variable.
A fin de economizar código, a continuación se ejemplificará el uso del control de flujo if
procesando la información introducida en el formulario del ejemplo4b.html. La idea es tener
la información contenida en variables diferentes y que ésta sea desplegada en la pantalla
según se elija. La sintaxis del if es exactamente igual que en C++. • Archivo psa.php
<?php
$opcion=$_POST[’psa’];
//proton
$pmasa="1,672 * 10^27 kg";
$pcarga="1,60217653(14)*10^(-19)C";
$ps="-";
//neutron
$nmasa="1,672 * 10^27 kg";
$ncarga="0";
$ns="no tiene carga";
//electron
$emasa="9,10 * 10^(-31) kg";
$ecarga="1,60217653(14)*10^(-19)C";
$es="-";
//general
$masa;
$carga;
$signo;
if ($opcion=="proton")
{$masa=$pmasa;
$carga=$pcarga;
$signo=$ps;}
else if ($opcion=="electron")
{$masa=$emasa;
$carga=$ecarga;
$signo=$es;}
else
{$masa=$nmasa;
$carga=$ncarga;
$signo=$ns;}
?>
<html><title> informacion</title>
<body bgcolor="#000000" text="#FFFFFF" link="#66FF99" alink="#660033">
<table><tr><td>La particula: </td><td> <?php echo $opcion; ?> </td></tr>
<tr><td>tiene una masa de :</td><td> <?php echo $masa; ?> </td></tr>
<tr><td>tiene una carga de signo :</td><td> <?php echo $signo; ?> </td></tr>
<tr><td>tiene una cantidad de carga :</td><td> <?php echo $carga; ?> </td></tr>
</table></html>
G.8.5. Función require.

Al igual que en todos los demás lenguajes estudiados en este curso, PHP posee funciones
intrı́nsecas a él o que pueden crearse. En este apéndice tan sólo se hará uso de funciones que
vienen ya incluidas en el lenguaje, pues son las primeras que deben conocerse. La función
require pide como argumento algún archivo cuando se ejecuta el código. La función se encarga
de incluir el archivo y evaluarlo dentro del código. Si el archivo en cuestión resulta ser más
código, éste será ejecutado. Usualmente, esto es utilizado para pedir formularios; el uso de
esta función se ejemplifica ampliamente en el ejemplo final.
G.8.6. Sesión.
PHP tiene la capacidad de definir variables globales sobre un conjunto de páginas a
elección; para ello debe realizarse una sesion. Éstas son usualmente utilizadas cuando se posee
una estructura de usuarios. Para poder crear una sesión debe contarse con: un árbol de páginas
ya armado, una página donde se inicie la sesión, y una página donde se termine la sesión. Para
ilustrar el uso de las sesiones se considerarán 4 páginas: el formulario del ejemplo4.html; el
ejemplo anterior procesa.php(con un par de modificaciones) como página de inicio de sesión;
una nueva página ejemplo5.php, que gracias a la sesión es capaz de recuperar las variables;
y una página de cierre de sesión salir.php, la cual vuelve al ejemplo4.html. Es importante
adquirir el hábito de generar árboles de páginas lo más intuitivos posible, pues éstas suelen
ser usadas por personas con poco o nulo conocimiento de su construcción y gran parte de su
éxito radicará en su simpleza. Sin más preámbulos, los ejemplos son los siguientes:
Ejemplos.
• Nuevo archivo procesa.php
<?php
session_start();//inicio de la sesión
header("Cache-control: private");
//esta lı́nea se escribe para no borrar los formularios como lo hace i.e.
?>
<html><title> recuperando las variables </title>
<h2 align="center"> La información tirada a pantalla<h2>
<p align="center"> Tu nombre es <b><?php echo $_POST[’Nombre’];?>
</b>, vives en <b> <?php echo $_POST[’direc’]; ?> </b>. Tu e-mail es <b>
<?php echo $_POST[’correo’]; ?>
</b>, además tu teléfono es <?php echo $_POST[’fono’];?> </p>
<h1 align="center"> <a href="ejemplo5.php"> <font color="red">
Aqui para seguir </font></a></h1>
</body>
</html>
<?php
$_SESSION[’nombre’]= $_POST[’Nombre’];
$_SESSION[’mail’]= $_POST[’correo’];
//Definiendo las variables globales de session.?>
• Archivo ejemplo5.php
<?php
session_start();
?>
<html>
<body bgcolor="#000000" text="#FFFFFF" link="66FF00" alink="00FF99">
<table align="center">
<tr><td> <b>
Las variables aun se recuperan y son:
</b></td></tr>
<tr><td> <b>
El nombre era: <em>
<?php echo $_SESSION[’nombre’]; ?>
</em> </b></td> </tr>
<tr><td> <b>
El correo era: <em>
<?php echo $_SESSION[’mail’]; ?> </em>

</b></td></tr>
<h1 align="center">
<a href="salir.php">
<font color="red">
finalizar sesión.
</font></a></h1>
</table>
</body>
</html>
• archivo salir.php
<?php
session_start();
session_unset();
header("Location:ejemplo4.html");
echo"<html></html>";
exit;
?>
Un par de comentarios sobre los ejemplos: la función session_start() debe ser lo primero
que aparezca en el script, es decir, lo primero registrado por el servidor. Para definir una
variable de sesión basta asignarla como $_SESSION[’nombre’] la cual existe como variable
global para todas las páginas que integren la sesión a partir desde donde fue definida la
variable. Para salir se utiliza la función session_uset(), la cual destruye todas las variables
de la sesión. En el ejemplo salir.php se ha utilizado un método que permite redireccionar
la página de manera automática sobre el cual no se profundizará. Usualmente, por razones
de seguridad, se requiere un árbol de páginas que sea cerrado, para ello simplemente basta
definir una variable de sesión en la página de entrada y luego, en cada nueva página que
integre la sesión, anteponer un condicional if que chequee que esa variable exista, es decir,
chequea que se haya pasado por la primera de las páginas. Por ejemplo, si se define la variable
de sesión $_SESSION[’estado’]="conectado"; en la primera página, una forma de definir
el condicional es:
if ( $_SESSION[’estado’]!= ’conectado’ )
{die( "Ud no esta logueado!.Click aqui para <a href=’ejemplo4.html’>volver</a>");}
Esto quiere decir que si la variable de sesión ’estado’ es diferente de conectado, niegue la
entrada a la página y despliegue este mensaje. De lo contrario, se continuará procesando el
código.
G.8.7. PHP interactuando con MySql.

Si se ha seguido el apéndice hasta aquı́ con éxito, el camino está casi completo. Para lograr
el objetivo final tan sólo deben introducirse un par de funciones de PHP que permitirán la
conexión a MySql. Para esto se esquematizarán los pasos que todo script que se conecta a la
base de datos debe seguir:
1. Conectarse a MySql.
2. Escoger la base.
3. Determinar si se escribe o se lee desde la base de datos.
4. Escribir la petición como variable en un string.
5. Enviarla (si habı́a que escribir en la base de datos, con esto es suficiente).
6. Si se está leyendo desde la base de datos, convertir el resultado en un arreglo y operar

sobre la parte de él que se necesite.
Siguiendo la numeración respectiva, utilizando el nombre de usuario y contraseña de MySql

antes citado, las funciones son:
1. $conexion=mysql_connect(’localhost’,’lamp’, ’bd’)or
die(’No es posible conectar’.mysql_error());
Se conecta al servidor de MySql local bajo el usuario “lamp”. Podrı́a parecer en principio
un poco inseguro que aparezca la clave del usuario explı́citamente en el script; sin
embargo, recuérdese que esta parte del script está escrita en lenguaje PHP y por lo
tanto jamás abandona la máquina donde se encuentra el script.
2. mysql_select_db(’nombredelabase’)or die (’Base no encontrada’);

Notar que, a diferencia del ı́tem anterior, aquı́ la selección de base no se almacena como
variable.
3. Para leer o escribir en la base de datos, basta crear una variable de string con la sin-
taxis de lo requerido en lenguaje sql. Por ejemplo, supóngase que se quiere escribir en
la agenda un nombre guardado en la variable $nombre y un teléfono almacenado en la
variable $telefono; la sintaxis es:
$p="insert into agenda(nombre, telefono) values (’$nombre’,’$telefono’)";
4. Por otra parte, si quiere escogerse un registro particular, por ejemplo el número te-
lefónico del usuario $usuario , la sintaxis es:
$u="select nombre,telefono from agenda where nombre=’$usuario’";
5. Independiente de si se quiera leer o escribir, si la petición está en una variable $p, esta
se ejecuta en MySql mediante la orden:
$pedido=mysql_query($p) or die (’no se pudo’);
6. Supóngase que se pidió un registro, lo que se obtendrá de vuelta en la variable $pedido

no es un número ni un arreglo. Para poder operar con la información, primero debe
convertirse en un arreglo. Dos maneras diferentes de hacerlo son:
$fila=mysql_fetch_row($pedido);
$arreglo=mysql_fetch_array($pedido);
G.9. EJEMPLO FINAL. 419
En ambos casos, el arreglo se recorre de la misma manera que en C++. Por ejemplo,
en el primer caso, si quiere obtenerse el primer elemento, éste corresponderá a la va-
riable $fila[0].En contraste, el segundo caso, permite seleccionar los elementos del
arreglo por su nombre dentro de la tabla de MySql. Por ejemplo, si tenemos una tabla
con los campos nombre, dirección, entonces los elementos del arreglo corresponden
a $arreglo[’nombre’] y $arreglo[’dirección’] respectivamente. En la práctica es
mucho más utilizada esta representación que la de row, pues es más fácil identificar
los elementos. Finalmente, cabe señalar que en ambos casos, los arreglos respectivos,
contienen un sólo registro, pese a que el query, contenga más de uno. Para obtener
todos los registros arrojados por el query, basta recorrerlo con un while, de la siguiente
forma.
//suponiendo conectado a la base,

//y con la sentencia sql escrita en un string.
$pedido=mysql_query($sentencia_mysql);
//supongáse que el query de arriba devuelve más de un registro,
// para obtener cada uno basta hacer
while($miarreglo=mysql_fetch_array($pedido){echo $miarreglo[’campo’];}
?>
Lo anterior desplegará en pantalla el contenido de los sucesivos registros en el campo

campo. Lo anterior, también funciona para mysql_fetch_row.
Con esta sección se da por finalizado el apéndice; sin embargo, se ha escrito un
ejemplo final para ver puestas en práctica las herramientas aquı́ expuestas. Se invita al
lector a tomarlo como una prueba final de si logró un aprendizaje real.
G.9. Ejemplo Final.

Se espera haber recorrido con éxito todos los tópicos de una manera superficial. A fin de
aclarar cualquier concepto que para el lector haya quedado poco claro, se llevará a cabo un
ejemplo simple, el cual debe cumplir el siguiente objetivo: un sistema en lı́nea donde estu-
diantes que cursen un ramo puedan averiguar sus notas y promedio de manera personalizada
mediante una clave. Se hubiera esperado un ejemplo más cientı́fico, sin embargo, todas las
herramientas de este apéndice apuntan a tareas administrativas más que a otra cosa.
G.9.1. Paso I: Estructura de las tablas.

Para todo el ejemplo se tiene el mismo nombre y clave de usuario en MySql que en los
ejemplos anteriores. El sistema debe contener una base de datos llamada “ramo” y dentro de
ésta, por lo menos, dos tablas: una con los nombres y contraseñas de los diferentes alumnos,
es decir, dos campos y otra con el nombre de cada estudiante y las notas de las respectivas
evaluaciones. Para poner una cota superior se crearán 8 campos de evaluación. Adicional-
mente, se creará una tabla que contenga tanto el nombre como la clave del administrador de
este sistema. La creación de la base de datos y las respectivas tablas en la consola de MySql
son por lo tanto:
mysql>create database ramo;

mysql>connect ramo;
mysql>create table alumnos(Nombre text,clave varchar(20));
mysql>create table notas(Nombre text ,nota1 float, nota2 float, nota3 float,
nota4 float, nota5 float, nota6 float, nota7 float, nota8 float);
mysql> create table administrador(Nombre text, clave varchar(20));
mysql> insert into administrador(Nombre,clave)
values ("administrador", password("admin"));
Ésta es toda la sintaxis que es necesario hacer desde la consola de MySql. Ahora toca
“pensar el árbol de páginas” y la comunicación que tendrán éstas con la base de datos.
G.9.2. Paso II: árbol de páginas.

El árbol de páginas debe surgir de manera natural a partir de los objetivos que debe
cumplir lo que se está programando. Éste se reducirá a formularios que permitan introducir
información, la cual será procesada por otro script en PHP. Si bien existen 2 clases de
usuarios (el administrador y los usuarios corrientes), todos deben pasar por una página que
les permita “entrar” en el sistema, es decir, ’loguearse’. El archivo expuesto a continuación
es simplemente un formulario que envı́a la información a logueo.php para ser procesada.
• Archivo log.html
<html><title> Bienvenido </title><body bgcolor="#66FFFF" text="#660000">

<h1 align="left"> Proceda a identificarse </h1><br><br><br><hr>
<form method="post" action="logueo.php">
<table align="left">
<tr><td><b>Nombre de Usuario:</b></td><td>
<input type="text" name="nombre"></td></tr>
<tr><td><b>Contrase~
na:</b></td><td><input type="password" name="clave">
</td></tr>
<tr><td><b>tipo de usuario:</b></td>
<td><select name="usrcls"><option value="1">usuario</option>
<option value="2">administrador</option></td></tr>
<tr><td><input type="submit" value="iniciar sesion"></td></tr>
</table></form><br><br><br><br><br><hr></body></html>
El formulario recién expuesto pide 3 datos: el nombre, la contraseña y el tipo de usuario

que está intentando ’loguearse’. El script que procesa esta información debe crear una sesión,
pues recuérdese que esto debe ser lo primero que aparezca en el script. Luego debe chequear
que la clave ingresada corresponda a un usuario existente, sin embargo, también debe realizar
diferentes acciones si se trata de un usuario común o del administrador, por lo anterior, este
script funcionará en base al condicional if. No debe sorprender la cantidad de código, pues,
la idea es una sola, cambiando los nombres de las variables:
• Archivo logueo.php
<?php session_start();
$nombre=$_POST[’nombre’];
$clave=$_POST[’clave’];
$tipo=$_POST[’usrcls’];
$conexion=mysql_connect(’localhost’,’lamp’, ’bd’)or
die(’No es posible conectar’.mysql_error());
mysql_select_db(’ramo’)or die (’error al conectar a la base’);
if($tipo==1)
{$p="select Nombre,clave from alumnos where Nombre=’$nombre’ and
clave=PASSWORD(’$clave’)";
$q=mysql_query($p) or die(’no se pudo hacer el pedido’);
$b=mysql_fetch_row($q);
if($b==false)
{echo "usted no es reconocido por el sistema";
?> <a href="log.html"><font color="red"> Volver</font></a>
<?php}
else
{$_SESSION[’estado’]="conectado"; require(’notas.php’);}}
else if($tipo==2)
{$p="select Nombre,clave from administrador where Nombre=’$nombre’
and clave=PASSWORD(’$clave’)";
$q=mysql_query($p) or die(’no se pudo hacer el pedido’);
$b=mysql_fetch_row($q);
if($b==false)
{echo "usted no es reconocido por el sistema";
?> <a href="log.html"><font color="red"> Volver</font></a><?php}
else{$_SESSION[’estado’]="conectado"; require(’acciones.php’);}}
else{require("log.html");}?>
La función del script es la siguiente: primero recupera las variables introducidas en el
formulario y se conecta a la base de datos ramo; después, en función del valor de la variable
’usrcls’, decide dónde buscar la información del nombre de usuario y claves respectivas. Fi-
nalmente, la última lı́nea contempla la posibilidad de que se haya intentado acceder a esta
página sin haber pasado por el formulario, requiriéndoló. A partir de este script, el árbol de
páginas se bifurca en 2 : la “rama del usuario” y la “rama del administrador”. Los nom-
bres de las páginas ya fueron nombrados en el último script. Se lista a continuación el script
acciones.php, el cual permite al administrador ingresar información de manera intuitiva.
Archivo • acciones.php
<?php session_start();if ( $_SESSION[’estado’] != ’conectado’ )
{die( "Ud no esta logueado!.Click aqui para <a href=’log.html’>volver</a>");}?>
<html><title> Administrando las notas</title>
<body bgcolor="#000000" text="#66FF00" link="#CC0033" alink="#66FF66">
<font color="red"><u><a href="salir.php"><h4 align="right"> Cerrar sesión.</h4>
<h1 align="center"><font color="blue"> acciones.</h1>
<table><tr><td><?php require(’nuser.php’);?></td><td>
<?php require(’nnota.php’);?>
</td></tr></table></body></html>
Las primeras lı́neas chequean que el usuario se haya “logueado” y especifica el estilo de la
página. Luego, se utiliza la función require para solicitar los 2 formularios que corresponden a
las acciones que pueden ser realizadas por el administrador: crear nuevos usuarios y agregar
notas a cada usuario. Ambos formularios son del tipo caja de texto y la información de éstos
es enviada a un archivo del mismo nombre con una “p” final (de procesar). Los archivos
que procesan la información solo escriben directamente en la base de datos la información
obtenida de los formularios. Finalmente, cabe destacar el link “cerrar sesión”, el cual conduce
a un script que cual destruye todas las variables de sesión y devuelve a la página de “logueo”
log.html, lo que se presenta a continuación:
Archivo • salir.php

{die( "Ud no esta logueado!.Click aqui para <a href=’log.html’>volver</a>");}
session_unset();header("Location:log.html");echo"<html></html>";exit;?>
A continuación se presentan los scripts que permiten poner notas, crear nuevos usuarios
y sus respectivos archivos de proceso: Archivo • nnota.php.

<html><body bgcolor="#000000" text="#66FF00" link="#CC0033" alink="#66FF66">
<br><br><form method="post" action="nnotap.php"><table align="center">
<tr><td><h2>Nueva nota</h2></td></tr>
<tr><td>Nombre:</td><td><input type="text" name="nombre"></td></tr>
<tr><td>Nota No :</td><td><input type="text" name="nnota"></td></tr>
<tr><td>La Nota es:</td><td><input type="text" name="nota"></td></tr>
<tr><td></td><td><input type="submit" value="ingresar nota">
</table></form></body></html>
El archivo que procesa las variables:

• nnotap.php

$alumno=$_POST[’nombre’]; $nnota=$_POST[’nnota’];$nota=$_POST[’nota’];
if($nnota>8){echo "el sistema aguanta máximo 8 evaluaciones";
require("acciones.php");}
else{$conexion=mysql_connect(’localhost’,’lamp’,’bd’)
or die (’No conecta’.mysql_error());
mysql_select_db(’ramo’);
$escribe="update notas set nota$nnota=’$nota’ where nombre=’$alumno’";
$haz=mysql_query($escribe);
echo "<b>".$alumno. " saco un ".$nota." en la evaluacion no ".$nnota."</b>";
require("acciones.php");}?>
Debiera quedar completamente claro lo que ejecuta este script: recupera las variables y revisa
que no se haya sobrepasado la cota máxima de las 8 notas por alumno. De ser ası́, procede
a escribir la nueva información en la base de datos. Cabe notar que la información no esta
escrita con la sentencia INSERT, sino UPDATE, por lo cual las notas pueden ser cambiadas. La
segunda acción habilitada por el administrador es la de agregar nuevos usuarios, lo cual se
hace de una manera totalmente análoga a los scripts anteriores:
Archivo • nuser.php

<html><body bgcolor="#000000" text="#66FF00" link="#CC0033" alink="#66FF66">
<br><br>
<form method="post" action="nuserp.php"><table align="left">
<tr><td align="center"> <h2>Nuevo registro</h2><br></td></tr>
<tr><td>Nombre:</td><td><input type="text" name="nombre"></td></tr>
<tr><td>Contrase~
na:</td><td><input type="password" name="clave"></td></tr>
<tr><td></td><td><input type="submit" value="ingresar usuario"></td></tr>
</table></form></body></html>
El archivo que procesa las variables.

Archivo • nuserp.php

$conexion=mysql_connect(’localhost’,’lamp’,’bd’)
or die (’No conecta’.mysql_error());
mysql_select_db(’ramo’);
$alumno=$_POST[’nombre’];
$clave=$_POST[’clave’];
$nusuario="insert into alumnos(Nombre,clave)
values (’$alumno’,PASSWORD(’$clave’))";
$nusuariob="insert into notas (nombre) values (’$alumno’)";
$escribe=mysql_query($nusuario)or die(’no se pudo escribir’);
$escribeb=mysql_query($nusuariob) or die(’no se pudo escribir’);
echo "<b> alumno ".$alumno. " ingresado con exito</b>";
require("acciones.php");?>
Con esto se da por finalizado el proceso de introducir información al sistema. Ahora solo
resta generar un script que muestre la información correspondiente a cada usuario.
Archivo • notas.php
<?php session_start(); $nombre=$_POST[’nombre’]; $clave=$_POST[’clave’];

$conexion=mysql_connect(’localhost’,’lamp’, ’bd’)
or die(’No es posible conectar’.mysql_error());
mysql_select_db(’ramo’)or die (’error al contactar base’);
$pedir="select nota1, nota2, nota3, nota4, nota5, nota6, nota7, nota8
from notas where nombre=’$nombre’";
$pedido=mysql_query($pedir);
$notas=mysql_fetch_row($pedido);
?>
<html>
<title> Notas: </title>
<body bgcolor="#333300" text="#3300FF" link="33FF33" alink="#669900">
<h2 align="right"> <a href="salir.php" >
<font color="red" <u> Cerrar sesion.</u>
</a> </h2>
<h3 align="left"> <font color="green"> Alumno <?php echo $nombre;?></h3>
<table align="left"><tr><td><b> Sus notas son</b></td></tr>
<tr><td>Eval.No :</td><td>Nota</td><tr>
<?php
$i=1;
$g=0;
$cont=0;
while($i<=8)
{ $k=$i-1;
echo "<tr><td>". $i . "</td><td>" .$notas[$k]. "</td></tr>";
$i++;
if($notas[$k]>=1){$cont++;}
$g=$g+$notas[$k];
}
if($g==0){echo "usted no tiene notas";}
else{$t=$g/$cont;}?>
<br><br>
<tr><td>Su promedio final es:</td><td><b><?php echo $t; ?> </b> </td></tr>
</table>
</body></html>
Sobre el último ejemplo cabe destacar: se piden todas las notas del alumno en cuestión; la
base de datos devuelve para esto la información que es convertida en fila (mysql_fetch_row());
luego la fila comienza a ser recorrida utilizando un control de flujo while, el cual va generando
a tiempo de ejecución una tabla en html ; las variables auxiliares $i, $g y $cont son utilizadas
para calcular el promedio del número de notas que existan.
G.10. Conclusiones.
El ejemplo ha sido chequeado siguiendo los pasos dados en este apéndice y funciona de
manera básica (pudiendo ser mejorado),pues su fin no es ser operativo, sino explicativo.
Podrı́a parecer que se trata de una gran cantidad de código, sin embargo, la mayor parte
del tiempo se está repitiendo lo mismo con variaciones obvias. Esperando haber logrado
una comprensión aceptable por parte del lector, A partir de las herramientas entregadas, es
posible realizar proyectos bastante más ambiciosos tales como:
Sistema de votaciones en lı́nea.
G.10. CONCLUSIONES. 425
Comunicación mediante mensajes entre usuarios (un rudimentario chat).
Sistema de encuestas en lı́nea.
En general, cualquier problema de administración que involucre diferentes usuarios a

distancia se torna en algo solucionable mediante las herramientas aquı́ desarrolladas. Por
último, se deja como ejercicio al lector un par de puntos que restan por mejorar del ejemplo
final.
G.10.1. Mejoras al Ejemplo final.

Faltó lograr:
No se repitan usuarios.
Solo existan notas entre 1 y 7.
Comunique al administrador cuando éste intente ingresar notas a un usuario inexistente.
Sobra decir para el lector con algo de experiencia en programación que todas estos pro-
blemas serán fácilmente solucionables utilizando el condicional if, de manera de cubrir todas
las posibilidades. Esto no se ha hecho, pues volvı́a el ejemplo demasiado redundante y por lo
tanto se ha priorizado su funcionalidad.
G.11. Tabla de Colores en html.
Figura G.2: Los 256 colores posibles de desplegar en una página en html, con su respectivo
código.
Colección
Libros de Matemática
en PDF
Esta colección no es más que una

recopilación, sin ánimo de lucro y
distribuida solo con fines educativos,
de diferentes obras autoeditadas y
apuntes docentes elaborados por
Universidades, Institutos y Escuelas
Técnicas, que generalmente ponen al
alcance de sus estudiantes, sobre
diferentes temas de matemáticas,
física, ingeniería y ciencias afines,
ahora reunidas bajo el sello del grupo
"Libros de Matemática en PDF".
Libros de Matemática en PDF
Todos los derechos pertenecen a sus respectivos autores.

Solo con fines educativos

Apuntes

Cargado por

Copyright:

Formatos disponibles

Apuntes

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Apuntes

Cargado por

Copyright:

Formatos disponibles

Apuntes de un

Solo con fines educativos

1.11. Uso del ratón. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36

3. Una breve introducción a Python. 51

3.3.5. La palabra clave pass. . . . . . . . . . . . . . . . . . . . . . . . . . . . 59

3.13.1. Funciones del módulo os. . . . . . . . . . . . . . . . . . . . . . . . . . . 79

4. Una breve introducción a C++. 99

4.1.3. Nombres de variables. . . . . . . . . . . . . . . . . . . . . . . . . . . . 102

4.8.8. Arreglos de clases. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149

6. El sistema de preparación de documentos TEX . 163

6.4.7. Sı́mbolos matemáticos. . . . . . . . . . . . . . . . . . . . . . . . . . . . 176

II Métodos Numéricos. 217

8. EDO: Métodos básicos. 235

8.1.4. Métodos de Euler-Cromer y de Punto Medio. . . . . . . . . . . . . . . 239

9. EDO II: Métodos Avanzados. 261

10.Resolviendo sistemas de ecuaciones. 293

10.2.3. Osciladores armónicos acoplados. . . . . . . . . . . . . . . . . . . . . . 303

11.Análisis de datos. 321

12.Integración numérica básica 329

III Apéndices. 345

B. Las shells csh y tcsh. 349

C. Editores tipo emacs. 353

D. Una breve introducción a Octave/Matlab 361

E. Asignación dinámica. 385

F. make y Makefile. 387

G. Herramientas básicas en el uso de L.A.M.P. 399

G.6. Páginas Básicas en html. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 401

6.1. Un sujeto caminando. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 196

7.1. Salida gráﬁca del programa interp. . . . . . . . . . . . . . . . . . . . . . . . . 226

8.1. Trayectoria para un paso de tiempo con Euler. . . . . . . . . . . . . . . . . . . 239

9.1. Órbita elı́ptica alrededor del Sol. . . . . . . . . . . . . . . . . . . . . . . . . . . 262

11.1. Dióxido de carbono medido en Hawai. . . . . . . . . . . . . . . . . . . . . . . . 322

12.1. Subintervalos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 329

D.1. Gráﬁco simple. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 376

Elementos del sistema operativo unix.

Multitarea (Multitasking): Cada programa tiene asignado su propio “espacio” de me-

Por su naturaleza de multiusuario, nunca se deberı́a apagar impulsivamente una máquina

1.2. Ingresando al sistema.

Debian GNU/Linux 4.0 hostname tty2

También pueden ocurrir un par de cosas:

La pantalla no muestra nada.

• Comprobar que la pantalla esté encendida.

• Las mayúsculas y minúsculas no son equivalentes, sin embargo se recomienda que

El password debe ser cambiado con regularidad.

La instrucción para cambiar el password en unix es passwd. A menudo, cuando existen

1.3. El Proyecto Debian.

1.4. Archivos y directorios.

/home - Espacio reservado para las cuentas de los usuarios.

/bin, /usr/bin - Binarios (ejecutables) básicos de unix.

/proc, es un sistema de archivos virtuales. Contiene archivos que residen en memoria

/usr/share/doc aquı́ se puede encontrar información relacionada con aplicaciones (en

1.5. Órdenes básicas.

1.5.1. Órdenes relacionadas con archivos.

Path Absoluto, aquél que empieza con /

Por ejemplo : /etc/printcap

Path Relativo, aquél que no empieza con /

Por ejemplo : ../examples/rc.dir.01

1.5.2. Órdenes relacionadas con directorios.

-a (list All) lista también los archivos ocultos.