Introducción Importaciones Declaración de variables Declaración de constantes Tipos de datos INTEGER CARDINAL REAL BOOLEAN CHAR BITSET String Otras

Transcripción

1 Introducción Importaciones Declaración de variables Declaración de constantes Tipos de datos INTEGER CARDINAL REAL BOOLEAN CHAR BITSET String Otras funciones y procedimientos estándar Declaración de tipos ARRAY RECORD SET Sub Rango Enumerados Redefinición de tipos Estructuras de control IF CASE REPEAT WHILE FOR LOOP WITH Procedimientos Procedimientos Parámetros de array abierto Funciones Modularización Método de Ordenación Quick Sort Búsqueda Dicotomica o Binaria Punteros

2 INTRODUCCION Todo programa en Modula 2 consta de uno o mas módulos, hay cuatro tipos de módulos, cada uno con su función especifica, pero por el momento nos ocuparemos de la sintaxis del modulo cuya cabecera es "MODULE Nombre;", este es el que una vez compilado genera un programa ejecutable. La sintaxis de este modulo es: MODULE nombre; (* Importaciones de funciones y procedimientos *) FROM NombreLibreria1 IMPORT NombreFuncion1,.., NombreProcedimiento1, NombreTipo1, NombreConstante2; FROM NombreLibreria2 IMPORT NombreFuncion2,.., NombreProcedimiento2, NombreTipo1, NombreConstante2; CONST (* declaración de constantes *) TYPE (* declaración de tipos *) (* Declaración de variables *) (* Declaración de procedimientos *) (* Sentencias *) END nombre. Una de las diferencias que tiene modula 2 con pascal es que reconoce mayúsculas y minúsculas, en Modula 2 todas las palabras reservadas se escriben en mayúscula. Los códigos de Modula 2 se guardan con extension.mod (*******************************************************************) (* Primer programa: *) MODULE PrimerP; FROM STextIO IMPORT WriteString, WriteString('Hola!!!'); WriteLn END PrimerP. (*******************************************************************)

3 IMPORTACIONES Pascal utiliza por defecto en todos sus programas las funciones, tipos, constantes y los procedimientos de la librería system, (una librería es un archivo que contiene "trozos" de código pre compilado), así es que desde un programa en pascal se puede utilizar por ejemplo el procedimiento writeln, también se pueden usar otras librerías con el uso de la sentencia: uses NombreLibreria, en Modula 2 solo se utiliza lo que se le indique al compilador, este no "carga" ninguna librería por defecto, para utilizar un procedimiento como WriteString hay que indicarselo al compilador. Modula 2 hace referencia al nombre que esta en el texto del archivo y no al nombre del archivo. (* pp.def *) DEFINITION MODULE Pp; TYPE cosa = RECORD p, q: CHAR; END; (* cosa *) PROCEDURE Algo (ent: INTEGER; sal INTEGER); END Pp. (* pp.def *) quiere decir que desde el modulo Pp y no pp (Modula 2 reconoce mayúsculas y minúsculas) se puede importar el procedimiento Algo y el tipo de datos cosa Sintaxis: FROM NombreLibreria IMPORT funciones, procedimientos, constantes, tipos; siendo: NombreLibreria = el nombre de alguna de las librerías que se encuentran en la carpeta LIB donde fue instalado el compilador o el nombre de alguna librería propia del programador funciones = NombreFunc1,.., NombreFuncN procedimientos = NombreProc1,.., NombreProcM tipos = NombreTipo1,.., NombreTipoK constantes = NombreConst1,.., NombreConstH;

4 Ejemplos: FROM STextIO IMPORT WriteString, (* desde la librería STextIO importar los procedimientos WriteString y writeln *) FROM SRealIO IMPORT WriteReal, ReadReal; FROM WholeStr IMPORT StrToCard, CardToStr; FROM RealMath IMPORT sqrt, exp, arctan; ident11,.., identn1: Tipo1; ident1m,.., identlm: TipoM; DECLARACIONES DE IABLES Los identificadores constan de letras y números, debiendo comenzar por una letra y sin espacios en blanco, Tipo es el nombre de uno de los tipos estándar de Modula 2 o el nombre de algún tipo definido por el programador. CONST ident1 = valor1; identn = valorn; DECLARACION DE CONSTANTES No hace falta especificar el tipo de cada constante, esto lo determina el compilador. Es también interesante el comportamiento de las contantes de tipo CARDINAL que también las considera como INTEGER a la misma vez.

5 TIPOS DE DATOS INTEGER El tipo INTEGER son los enteros con signo que están en el rango , a diferencia de Pascal no existe la constante maxint, el máximo y el mínimo valor que pueden alcanzar los valores de un tipo ordinal se pueden averiguar mediante el uso de las funciones MAX y MIN, en este caso: MAX(INTEGER) y MIN(INTEGER) Los limites del rango se deben a que cada compilador utiliza un numero diferente de bits para representar un INTEGER, es decir, si el compilador usa n bits, uno es para el signo entonces quedan n 1 para el numero. Nros negativos: desde el 1 hasta el 2^(n 1) Nros positivos: desde el 0 hasta 2^(n 1) Windows es un sistema de 32 bits, es decir, n = 32, los INTEGER posibles están entre y (El compilador es para Windows y por lo tanto trabaja con 32 bits) Las operaciones aplicables a este tipo son las definidas por los operadores: + (suma) (resta) * (multiplicación) DIV (division) MOD (resto de la division) este operador es definido solo para argumentos positivos. Los negativos se indican con el signo, también existen las funciones ABS(x) que retorna el valor absoluto de x y ODD(x) que retorna FALSE si x es par y TRUE si es impar Nota: bit las computadoras almacenan información a mediante zonas por las que pasa corriente eléctrica y zonas por las que no, representadas por 0 y 1, un 0 o un 1 es un bit, 8 bits son un byte, como debe ser múltiplo de 8: 1024 bytes son un KiloByte 1024 KiloBytes son un MegaByte 1024 MegaBytes son un GigaByte 1024 GigaBytes son un TeraByte

6 CARDINAL El tipo CARDINAL son los naturales que se encuentran en el rango , las operaciones definidas para este tipo son las mismas que para el tipo INTEGER. Los limites del rango en este caso son: 0 hasta 2^n debido a que no hay que utilizar ningún bit para el signo. Modula 2 no permite el uso de operadores de tipo INTEGER y CARDINAL en la misma expresión La razón es que las instrucciones aritméticas son diferentes para los dos tipos. Esto se soluciona mediante el uso de las funciones de transferencia, si i es del tipo INTEGER y c es del tipo CARDINAL, la expresión i + c no esta permitida, pero i + INTEGER(c) es del tipo INTEGER, y CARDINAL(i) + c es del tipo CARDINAL REAL Los valores del tipo REAL son números reales. Los operadores disponibles otra vez son los básicos y la función ABS. La division se denota por / en lugar de DIV. Las constantes de tipo REAL son caracterizadas por tener una parte decimal o un factor escalar, ejemplos son: E2 2.34E El factor escalar consiste en la letra E (mayúscula) seguida de un entero y representa la notación científica del numero real. Otra vez por razones de representación interna de los tipos no se permiten expresiones que contengan factores reales y factores enteros, para solucionar esto están las funciones de transferencia FLOAT(c) y TRUNC(x) FLOAT(c) es de tipo REAL y representa el valor del CARDINAL c, TRUNC(x) representa la parte entera del valor x y es de tipo CARDINAL BOOLEAN El valor de un BOOLEAN es uno de los dos valores de verdad lógicos denotados por los identificadores estándar TRUE y FALSE, un conjunto de operadores lógicos esta disponible, que junto con las variables booleanas forman expresiones booleanas. Estos operadores son AND (también denotado por &), OR, y NOT (también denotado por ~). Sus resultados son explicados como sigue: p AND q = "ambos p y q son TRUE" p OR q = "p es TRUE, o q es TRUE o ambos son TRUE" NOT p = "FALSE si p es TRUE y TRUE si p es FALSE" A veces es posible simplificar las expresiones booleanas aplicando las leyes de Morgan: (NOT p) AND (NOT q) = NOT (p OR q) (NOT p) OR (NOT q) = NOT (p AND q) Las relaciones producen valores booleanos, TRUE si se cumple y FALSE si no se

7 cumple, por ejemplo: 7 = 12 FALSE 7 < 12 TRUE 1.5 >= 1.6 FALSE Los operadores para las relaciones son: < > >= <= <> o # (diferencia) Los valores booleanos pueden compararse, especialmente FALSE < TRUE CHAR Todo sistema de computadoras se comunica con su entorno via algún dispositivo de entrada y otro de salida. Estos leen, escriben o imprimen elementos tomados de un conjunto de caracteres. Este conjunto define el rango de valores del tipo CHAR. Desafortunadamente, diferentes tipos de computadoras pueden usar un conjunto diferente de caracteres, los cuales hacen la comunicación entre ellos difícil y tediosa. Sin embargo existe un conjunto estandarizado internacional, llamado el conjunto ISO. El ISO estándar define un conjunto de 128 caracteres, 33 de los cuales son los llamados caracteres de control. Las restantes 95 elementos son los caracteres imprimibles mostrados en la siguiente tabla nul dle P î p 1 soh dc1! 1 A Q a q 2 stx dc2 " 2 B R b r 3 etx dc3 # 3 C S c s 4 eot dc4 $ 4 D T d t 5 enq nak % 5 E U e u 6 ack syn & 6 F V f v 7 bel etb ' 7 G W g w 10 bs can ( 8 H X h x 11 ht em ) 9 I Y i y 12 lf sub * : J Z j z 13 vt esc + ; K [ k { 14 ff fs < L \ l 15 cr gs = M ] m } 16 so rs. > N ê n ~ 17 si us /? O ë o del Constantes de tipo CHAR son denotadas entre comillas dobles o comillas simples y estos valores no pueden ser utilizados en operaciones aritméticas Los operadores

8 aritméticos pueden sen aplicados sin embargo a sus números ordinales obtenidos desde la función de transferencia ORD(ch), inversamente el carácter con el numero ordinal n es obtenido con la función de transferencia CHR(n) Esas dos funciones complementarias están relacionadas por las ecuaciones: CHR(ORD(ch)) = ch y ORD(CHR(n)) = n Para denotar a los caracteres no imprimibles Modula 2 usa su numero ordinal octal seguido de la letra mayúscula C. Por ejemplo, 14C es un valor de tipo CHAR denotando el carácter de control ff (form feed) con numero ordinal 14B. La función CAP es usada para obtener la mayúscula de un carácter en minúscula para los que tienen dicha equivalencia. BITSET conjunto de enteros entre 0 y N 1, donde N es una constante definida por el PC, generalmente 16 Las constantes de este tipo se utilizan bajo la notación de conjuntos Ejemplo: {5, 7, 11} {0} {8.. 15} {0.. 3, 11, 15} {} Operadores: + union diferencia * intersección / diferencia simétrica IN pertenece Si i un elemento y u, v denotan conjuntos esas operaciones son definidas de la siguiente manera: i IN (u + v) = (i IN u) OR (i IN v) i IN (u v) = (i IN u) AND NOT (i IN v) i IN (u * v) = (i IN u) AND (i IN v) i IN (u / v) = ((i IN u) # (i IN v)) Expresiones con el operador IN devuelven resultado booleanos i IN v es true si el elemento i esta en el conjunto v STRING: El tipo string no es un tipo predefinido de Modula 2 como lo es en Turbo Pascal o Free Pascal Un string es una lista de caracteres, como por ejemplo 'abcde', un string se reconoce también como un arreglo por lo que si A = 'abcde' entonces A[2] = 'b' Al igual que con el tipo CHAR también se pueden utilizar comillas dobles para definir un string, es importante notar que en el caso que el string contenga una comilla simple debe ir entre comillas dobles y si contiene comillas dobles debe ir

9 entre comillas simples LENGTH La función LENGTH es usada para obtener el largo de un string.

10 Otras funciones y procedimientos estándar MAX La función MAX es usada para obtener el valor máximo de un tipo escalar Ejemplo: MAX(INTEGER); MIN La función MIN es usada para obtener el valor mínimo de un tipo escalar ABS La función ABS es usada para obtener el valor absoluto. DEC El procedimiento DEC es usado para decrementar el valor de una variable de tipo ordinal. INC El procedimiento INC es usado para incrementar el valor de una variable de tipo ordinal. ODD Retorna FALSE si el argumento es par

11 DECLARACION DE TIPOS TYPE ident1 = definicion1; identn = definicionn; En una declaración pueden utilizarse las anteriores, en el único caso en que esta permitido usar un tipo que todavía no fue declarado es en la declaración de un tipo puntero. ARRAY: Nombre = ARRAY [subrango] OF Tipo; Matriz = ARRAY [subrango],[subrango] OF Tipo Si el subrango fue definido antes no hay que ponerlo entre [], es decir: TYPE Rango = [1.. N]; vector = ARRAY Rango OF Tipo; HIGH La función HIGH es usada para obtener el máximo indice de un ARRAY Ejemplo: MODULE Array; FROM STextIO IMPORT WriteString, FROM SWholeIO IMPORT WriteCard; CONST M = 10; TYPE Rango = [1.. 3]; Vector1 = ARRAY [0.. M] OF CARDINAL; Vector2 = ARRAY Rango OF CARDINAL; v : Vector1; u : Vector2; tmp, aux: CARDINAL; aux := 0; FOR tmp := 1 TO 3 DO aux := aux + u[tmp]; END; (* FOR *) FOR tmp := 1 TO M DO

12 v[tmp] := v[tmp] + aux; END; (* FOR *) WriteString( Resultado: ( ); FOR tmp := 1 TO M DO WriteCard(v[tmp], 0); WriteString( ); END; (* FOR *) WriteString( ) ); WriteLn END Array.

13 RECORD: Una variable de tipo ARRAY contiene N variables de otro tipo, pero con la restricción de que tienen que ser del mismo tipo, hay casos en lo que puede ser necesario que sean de distinto tipo, una variable de tipo RECORD permite almacenar varios valores de distinto tipo. Sintaxis de la declaración: nombre = RECORD campos estáticos; campos variables; END (* nombre *) La sintaxis de la parte estática es: ident1_1,.., ident1_n: Tipo1; identm_1,.., identm_n: TipoM; La sintaxis de la parte variable es: CASE identificador: Tipo OF valor1: Declaración estática; valorn: Declaración estática END; (* CASE *) Dependiendo del valor de la variable identificador es que campos son los visibles. Para acceder a un campo se hace referencia a el mediante el nombre de la variable de tipo RECORD seguido de un punto y el nombre del campo. Ejemplo: TYPE TipoBicho = (Mortal, Angel, Vacio); TipoCelda = RECORD CASE bicho: TipoBicho OF Mortal: Edad : TipoVida; espvida : TipoVida; ReNacido: BOOLEAN; mmovido : BOOLEAN Angel : amovido: BOOLEAN Vacio : null: BOOLEAN END; (* CASE *) END; (* TipoCelda *)

14 Celda: TipoCelda; Celda.bicho := Mortal; Celda.Edad := 15; Celda.espvida := 75; Celda.ReNacido := FALSE; Celda.mmovido := TRUE;

15 SET: Sintaxis de la declaración: nombre = SET OF tipo_numerable Las constantes del tipo nombre se representan como nombre{elemento1,.., elementon} Teniendo en cuenta esa representación el tipo SET se trata igual que un conjunto matemático Operadores: IN pertenece + union * intersección diferencia / diferencia simétrica (i IN (u / v) = ((i IN u) # (i IN v))) < incluido en (estricta) > incluye a (estricta) >= incluido en <= incluye a El procedimiento INCL(S, x) agrega x al conjunto S El procedimiento EXCL(S, x) quita x del conjunto S SUB RANGO nombre = [primer_valor.. ultimo_valor] Si primer_valor < 0 entonces el compilador asume que es un subrango de INTEGER, sino lo asume como CARDINAL para definir un subrango de INTEGER con ambos limites positivos debe hacerse de la siguiente manera: TYPE sub = INTEGER[ ] ; ENUMERADO nombre = (identficador1,.., identificadorn); El tipo enumerado define un orden entre los identificadores que lo componen, así que de la definición anterior sale que identificadori <= identificadorj para todo I <= J. También se puede utilizar la función ORD para pasar de un enumerado a un INTEGER y es posible el uso de los procedimientos INC y DEC sobre un enumerado

16 Ejemplo: TYPE command = (delete, dir, shutdown, print); ent: command; ent := dir; WriteInt(ORD(ent), 0); (* Imprimirá 2 *) INC(ent); (* Ahora ent vale shutdown *) DEC(ent); (* Ahora ent vale dir *)

17 REDEFINICION DE TIPOS Cualquier tipo de los existentes puede redefinirse con otro nombre. TYPE NuevoNombre = TipoAntiguo Ejemplos: TYPE Indice = CARDINAL; Porcentaje = REAL; IndiceBucle = Indice;(* Puede redefinirse un tipo ya redefinido *)

18 ESTRUCTURAS DE CONTROL Sentencia IF: La sintaxis general de la sentencia IF es la siguiente: IF expresión_booleana1 THEN SentenciaTrue1_1; SentenciaTrue1_N; ELSIF expresión_booleana2 THEN SentenciaTrue2_1; SentenciaTrue2_M; ELSE SentenciaFalse_1; SentenciaFalse_M; END (* IF *) La palabra reservada ELSIF es una abreviación de ELSE IF, por lo que puede usarse cualquiera de las dos formas. También existen variantes en las que se puede omitir alguna de las partes, como por ejemplo la del ELSE, estas son: Una forma sin ELSE: IF expresión_booleana1 THEN SentenciaTrue1_1; SentenciaTrue1_N; ELSIF expresión_booleana2 THEN SentenciaTrue2_1; SentenciaTrue2_M; END (* IF *) Una forma sin ELSIF: IF expresión_booleana1 THEN SentenciaTrue1_1; SentenciaTrue1_N; ELSE SentenciaFalse_1;

19 SentenciaFalse_M; END (* IF *) La mas simple de todas: IF expresión_booleana1 THEN SentenciaTrue1_1; SentenciaTrue1_N; END (* IF *) Ejemplo: MODULE If; FROM STextIO IMPORT WriteString, WriteLn, ReadCard; FROM SWholeIO IMPORT ReadCard; ent: CARDINAL; WriteString( Ingrese un natural ); ReadCard(ent); IF (ent # 10) (* # es igual a <> *) THEN WriteString( Fue distinto de 10 ); ELSIF (ent = 30) THEN WriteString( Es 30 ); ELSE WriteString( Es 10 ); END; (* IF *) WriteLn END If.

20 Sentencia CASE: La sentencia CASE permite optar que camino tomar dependiendo del valor de una cierta variable de control. Su sintaxis es: CASE variable OF valor1: sentencia_valor1_1; sentencia_valor1_k; valor2: sentencias_valor2_1; sentencias_valor2_j; ELSE sentencia_else END (* CASE *) Puede omitirse la parte del ELSE, en caso de que no se cumpla ninguna de las condiciones establecidas no hace nada. Las sentencias no van entre y END, comienzan después de los dos puntos y todas terminan en la barra vertical menos la ultima.

21 Sentencia REPEAT: En este ciclo se ejecutan todas las sentencias entre las palabras reservadas REPEAT y UNTIL y luego se verifica el valor booleano de la expresión, en caso de ser falso se vuelve a la primer sentencia. Este ciclo siempre se ejecuta como mínimo una vez. Su sintaxis es: REPEAT sentencia1; sentencian; UNTIL expresión_booleana; Hay que tener especial cuidado en que alguna de las sentencias modifique el valor de la expresión booleana que tenga como condición de salida de manera que se cumpla en algún momento, de lo contrario el ciclo nunca terminara. Ejemplo: MODULE Repeat; FROM STextIO IMPORT WriteCard, FROM SWholeIO IMPORT WriteCard; cont: CARDINAL; cont := 0; REPEAT WriteCard(cont, 0); INC(cont) (* cont := cont + 1 *) UNTIL (cont = 12) END Repeat.

22 Sentencia WHILE: Este ciclo es casi igual al REPEAT con la diferencia de que la condición se verifica al inicio, y por lo tanto el ciclo puede no ejecutarse ni una vez si esta es falsa. Su sintaxis: WHILE expresión_booleana DO Sentencia1; SentenciaN; END (* WHILE *) Hay que tener los mismos cuidados que con un ciclo REPEAT Ejemplo: MODULE While; FROM SWholeIO IMPORT WriteCard; FROM STextIO IMPORT cont: CARDINAL; cont := 24; WHILE cont > 12 DO WriteCard(cont, 0); DEC(cont); (* cont := cont 1 *) END (* WHILE *) END While.

23 Sentencia FOR: El ciclo FOR se utiliza cuando se conoce la cantidad exacta de veces que se repetirá el ciclo, este se ejecuta valor_final valor_inicial veces Su sintaxis: FOR contador := valor_inicial TO valor_final DO Sentencia1; SentenciaN END (* FOR *) La variable contador debe ser de un tipo numerable. valor_inicial debe ser menor que valor_final, de lo contrario no entra en el ciclo, también se puede especificar el incremento del contador de la siguiente manera: FOR contador := valor_inicial TO valor_final BY inc DO Sentencia1; SentenciaN END (* FOR *) Si inc es negativo, valor_inicial debe ser mayor que valor_final Ejemplo: MODULE For; FROM STextIO IMPORT WriteString, FROM SWholeIO IMPORT WriteCard; cont: CARDINAL; WriteString( Del 1 al 10 de uno en uno ); FOR cont := 1 TO 10 DO WriteCard(cont, 0); (* escribe cont de tipo CARDINAL utilizando 0 espacios o mas *) WriteString( ); END; (* FOR *) (* Fin de linea y retorno de carro *) WriteString( Del 1 al 10 de dos en dos ); FOR cont := 1 TO 10 BY 2 DO WriteCard(cont, 0); WriteString( ); END; (* FOR *)

24 WriteString( Del 10 al 1 de uno en uno ); FOR cont := 10 TO 1 BY 1 DO WriteCard(cont, 0); WriteString( ); END; (* FOR *) END For. Sentencia LOOP (* Solo informativo, generalmente no dejan usar procedimientos como EXIT o HALT *) El cuarto y ultimo ciclo es un ciclo infinito: nunca termina por si mismo. Es claro que alguna forma de terminación esta disponible, la mas usual es a través del uso de la sentencia EXIT. En cualquier lugar del ciclo se puede poner alguna condición de salida. Ejecutar el procedimiento EXIT produce que el control del programa deje el ciclo y comience a ejecutar la sentencia siguiente al ciclo. LOOP sentencias1; sentencian END; (* LOOP *) Ejemplo: LOOP WriteString("In the EXIT loop "); WriteInt(Index,5); IF Index = 5 THEN EXIT; END; (* IF *) WriteString("We are still in the loop."); INC(Index) END; (* LOOP *)

25 Sentencia WITH: La sentencia WITH permite accesar directamente a los campos de una variable de tipo RECORD. Su sintaxis es: WITH nombre DO Sentencia1; SentenciaN END (* WITH *) Ejemplo: TYPE complex = RECORD re, im: INTEGER; END; (* complex *) z1: complex; WITH z1 DO INC(re); (* re := re + 1 *) DEC(im); (* im := im 1 *) END; (* WITH *)

26 PROCEDIMIENTOS Modula 2 utiliza procedimientos de dos tipos, los que retornan un valor a través de la sentencia RETURN y los que no, los que utilizan la sentencia RETURN son los llamados funciones. Procedimientos: PROCEDURE nombre (parámetros); CONST (* igual que en el modulo principal *) TYPE (* igual que en el modulo principal *) (* igual que en el modulo principal *) Proc (* igual que en el modulo principal *) sentencias; END nombre; Ejemplo: TYPE rango = [0.. 2]; matriz = ARRAY rango, rango OF CARDINAL; PROCEDURE Proc (ent: CARDINAL; M: matriz); i, j: CARDINAL; FOR i := 0 TO 2 DO FOR j := 0 TO 2 DO M[i][j] := ent * M[i][j] END (* FOR *) END (* FOR *) END Proc;

27 (* Traducción del libro *) Parámetros de array abierto (open vector): Si un tipo formal de parámetro denota una estructura array, su correspondiente parámetro debe ser un array de idéntico tipo. Esto implica que debe tener elementos de idéntico tipo y el mismo tamaño en el rango del indice. Frecuentemente esta restricción es un poco severa, y mas flexibilidad es altamente deseable. Esto es proveído por las facilidades del llamado array abierto el cual requiere que los tipos de los elementos de los array normal y actual sea el mismo, pero deja el rango del indice del array abierto. En este caso, arrays de cualquier tamaño (numero de elementos) pueda ser sustituido como un parámetro actual. Un array abierto es especificado por el tipo del elemento precedido por "ARRAY OF". Por ejemplo, un procedimiento declarado como PROCEDURE P(s: ARRAY OF CHAR) permite llamadas con array de caracteres de indice de contenido arbitrario. El valor mas pequeño del rango del indice del array normal es siempre tomado como 0. El valor mas alto es obtenido llamando a la función estándar HIGH(s). Este valor es igual al numero de elementos menos 1. De aquí, si un array a declarado como a: ARRAY[m.. n] OF CHAR es sustituido por s, entonces s[i] denota a[m + i] para i = 0.. HIGH(s), donde HIGH(s) = n m Ejemplo: MODULE OpenArray; FROM STextIO IMPORT WriteString, FROM SWholeIO IMPORT WriteCard; p : CARDINAL; vect1: ARRAY [1.. 5] OF CARDINAL; vect2: ARRAY [0.. 10] OF CARDINAL; (*****************************************************************) PROCEDURE Sum (ent: ARRAY OF CARDINAL; sal: CARDINAL); i: CARDINAL; sal := 0; FOR i := 0 TO HIGH(ent) DO sal := sal + ent[i] END (* FOR *) END Sum; (*****************************************************************) Sum(vect1, p);

28 Sum(vect2, p); END OpenArray. Funciones: PROCEDURE nombre (parámetros): Tipo; CONST (* igual que en el modulo principal *) TYPE (* igual que en el modulo principal *) (* igual que en el modulo principal *) Proc (* igual que en el modulo principal *) sentencias; RETURN valor; END nombre; Puede haber mas de una sentencia RETURN en un procedimiento, pero debe ejecutarse una sola por vez que se llama el procedimiento. Ejemplo: PROCEDURE Fact (ent: CARDINAL): CARDINAL; IF (ent = 0) THEN RETURN 1 ELSE RETURN ent * Fact(ent 1) END (* IF *) END Fact;

29 MODULARIZACION Módulos: Hay cuatro tipos de módulos, cada uno con propiedades distintas, estos son: Modulo principal: aquel que compilado se transforma en un programa ejecutable (como los vistos en los ejemplos hasta ahora). Su cabecera es del tipo: MODULE nombre; Modulo de definición: Contiene las cabeceras de los procedimientos y funciones que se podrán importar desde otro modulo, también puede contener constantes y tipos de datos. Su cabecera es del tipo: DEFINITION MODULE NombreM; Modulo de implementación: Contiene la implementación de los procedimientos y funciones declarados en un modulo de definición Su cabecera es del tipo: IMPLEMENTATION MODULE NombreM; Modulo interno: este modulo tiene la misma sintaxis que el principal a no ser por que termina en punto y coma y solo puede importar desde el modulo en el que esta. Módulos de definición: Archivos cuya extension es def. DEFINITION MODULE nombre; CONST TYPE (* Cabecera de Funciones y procedimientos *) END nombre. Módulos de implementación: Archivos cuya extension es mod. IMPLEMENTATION MODULE nombre; (* debe ser igual al del modulo de definición *) (* Importaciones *) CONST TYPE (* Cabecera de Funciones y procedimientos con su respectivo cuerpo *) END nombre.

30 Ejemplo: Archivo uno.def (* *) DEFINITION MODULE uno; PROCEDURE Fact (ent: CARDINAL): CARDINAL; END uno. (* *) Archivo uno.mod (* *) IMPLEMENTATION MODULE uno; PROCEDURE Fact (ent: CARDINAL): CARDINAL; IF (ent = 0) THEN RETURN 1 ELSE RETURN ent * Fact(ent 1) END (* IF *) END Fact; END uno. (* *) Archivo main.mod (* *) MODULE main; FROM STextIO IMPORT WriteString, FROM SWholeIO IMPORT ReadCard, WriteCard; FROM uno IMPORT Fact; ent: CARDINAL; WriteString( Ingrese un natural ); ReadCard(ent);

31 WriteCard(ent, 0); ent := Fact(ent); WriteString(! = ); WriteCard(ent, 0); WriteLn END main. (* *) Ejemplo de un modulo interno: MODULE Externo; FROM STextIO IMPORT WriteString, FROM SWholeIO IMPORT ReadCard, WriteCard; (* *) MODULE Interno; (* No puede importar de STextIO, solo del externo, por eso no hace falta especificar desde donde esta importando *) IMPORT WriteString, WriteLn, WriteCard; EXPORT Acumulador, Suma; (* Esta sentencia le permite a Externo utilizar Acumulador y Suma *) Acumulador: CARDINAL; (* Variable estática *) (* *) PROCEDURE Suma (Incremento: CARDINAL); INC(Acumulador, Incremento); WriteString("La suma parcial es: "); WriteCard(Acumulador, 3); END Suma; (* *) (* Esta sentencia inicializa el modulo interno. Se ejecuta una sola vez, al hacer la importación *) Acumulador := 1; END Interno; (* Este modulo termina en punto y coma *) (* *)

32 c: CARDINAL; (* Variable global *) REPEAT WriteString(" Deme un incremento "); ReadCard(c); Suma(c); (* Al hacer esta llamada, Acumulador conserva su valor anterior *) UNTIL c = 0; WriteString("La suma final es: "); WriteCard(Acumulador, 5); END Externo.

33 Método de Ordenación Quick Sort Se toma el elemento del centro de la lista, y se busca en la lista completa desde el extremo izquierdo hasta el centro un elemento mayor que el, y desde el centro hasta el extremo derecho uno menor. Luego se intercambian. Este proceso continua hasta que se llega al elemento central de la lista. En ese momento hay dos sublistas, una con valores mayores y otra con valores menores. El elemento que estaba en el centro ahora ya esta en su puesto definitivo. Después se procede de igual forma con cada sublista, y así sucesivamente hasta que las sublistas constan de un solo elemento, lo que implica que ya están todos los elementos ordenados. (* *) MODULE MetodoQuickSort; FROM STextIO IMPORT WriteString, WriteLine, FROM InOut IMPORT Read; FROM SWholeIO IMPORT WriteInt, ReadInt; CONST Max = 5; Numeros: ARRAY [0.. Max] OF INTEGER; c : CHAR; (* *) PROCEDURE Intercambia ( x: INTEGER; y: INTEGER); aux: INTEGER; aux := x; x := y; y := aux; END Intercambia; (* *) PROCEDURE LeeNumeros(); i: INTEGER; WriteLine("Deme los números "); FOR i := 0 TO Max DO

34 WriteInt(i + 1, 2); WriteString(" º "); ReadInt(Numeros[i]); END; (* FOR *) END LeeNumeros; (* *) PROCEDURE EscribeNumeros(); i: INTEGER; WriteLine("Estos son los números "); FOR i := 0 TO Max DO WriteInt(Numeros[i], 3); END; (* FOR *) END EscribeNumeros; (* *) PROCEDURE QuickSort ( Lista: ARRAY OF INTEGER; Izq, Der: INTEGER); HaciaDerecha, HaciaIzquierda, PuntoMedio: INTEGER; HaciaDerecha := Izq; HaciaIzquierda := Der; PuntoMedio := (Izq + Der) DIV 2 + 1; REPEAT WHILE Lista[HaciaDerecha] < Lista[PuntoMedio] DO INC(HaciaDerecha); END; (* WHILE *) WHILE Lista[HaciaIzquierda] > Lista[PuntoMedio] DO DEC(HaciaIzquierda); END; (* WHILE *) IF HaciaDerecha <= HaciaIzquierda THEN Intercambia(Lista[HaciaDerecha], Lista[HaciaIzquierda]); INC(HaciaDerecha); DEC(HaciaIzquierda); END; (* IF *) UNTIL HaciaDerecha > HaciaIzquierda; IF Izq < HaciaIzquierda THEN QuickSort(Lista, Izq, HaciaIzquierda);

35 END; (* IF *) IF HaciaDerecha < Der THEN QuickSort(Lista, HaciaDerecha, Der); END; (* IF *) END QuickSort; (* *) LeeNumeros; QuickSort(Numeros, 0, Max); WriteLine("Estado Final "); EscribeNumeros; END MetodoQuickSort. (* *)

36 Búsqueda Dicotomica o Binaria Si todos los datos están ordenados se puede aprovechar esta circunstancia para hacer una búsqueda mas rápida Supongamos que esta ordenada en orden creciente. El algoritmo es: Mientras no se haya encontrado, y la lista considerada tenga mas de un elemento: Se comprueba el elemento que hay en el centro de la lista. Si es el buscado, se acaba la búsqueda Si es menor, se considera la lista que hay en la mitad derecha. Si es mayor, se considera la lista que hay en la mitad izquierda. Posicion := 0; Izquierda := 1; Derecha := Ultimo; WHILE (Posicion = 0) AND (Izquierda <= Derecha) DO Mitad := (Izquierda + Derecha) DIV 2; IF DatoBuscado = Lista[Mitad] THEN Posicion := Mitad; ELSIF DatoBuscado < Lista[Mitad] THEN Derecha := Mitad 1; ELSE Izquierda := Mitad + 1; END; (* IF *) END; (* WHILE *) Si el orden es decreciente, las mitades que hay que considerar en cada caso son las contrarias.

37 PUNTEROS Un puntero es un tipo de datos cuyo contenido es una dirección de memoria, en esta dirección de memoria puede estar cualquier tipo de datos incluso otro puntero. Una variable de cualquiera de los tipos ya vistos ocupa un espacio en la memoria desde principio a fin de la ejecución del programa, se uso o no la variable, estas variables se llaman estáticas, los punteros no existen al inicio de la ejecución del programa y pueden crearse o destruirse en cualquier momento de la ejecución, los punteros es lo que se llama un tipo de datos dinámico Un ejemplo: MODULE Pointers; FROM STextIO IMPORT WriteString, FROM SWholeIO IMPORT WriteInt; > FROM Storage IMPORT ALLOCATE, DEALLOCATE; TYPE Name = ARRAY[0.. 20] OF CHAR; > MyName: POINTER TO Name; (* MyName apunta a un string *) MyAge : POINTER TO INTEGER; (* MyAge apunta a un INTEGER *) > NEW(MyAge); NEW(MyName); > MyAge^ := 21; MyName^ := "Javier"; WriteString("Mi nombre es "); WriteString(MyName^); WriteString(" y tengo "); WriteInt(MyAge^,2); WriteString(" años."); > DISPOSE(MyAge); DISPOSE(MyName); END Pointers. Los punteros se declaran como nombre: POINTER TO Tipo, esto quiere decir que la variable nombre es un puntero que apunta a un espacio de memoria lo suficientemente grande como para contener un valor de tipo Tipo. NEW y DISPOSE: Los procedimientos NEW y DISPOSE se utilizan para crear o destruir variables del tipo POINTER TO NEW obtiene un espacio de memoria para el valor del tipo especificado y crea un nuevo puntero apuntando a ese espacio de memoria. DISPOSE elimina el puntero sin alterar el espacio de memoria, si este espacio esta

38 apuntado por otro puntero puede seguir siendo utilizado, sino se pierde. Para utilizar NEW y DISPOSE es necesario importar ALLOCATE y DEALLOCATE desde el modulo Storage. En un puntero hay que distinguir 2 cosas, una es el puntero mismo y la otra es aquello a lo que apunta. Al puntero se hace referencia solo con su nombre y a lo que apunta se hace referencia mediante el nombre del puntero seguido del símbolo ^, de acá sale que teniendo la siguiente declaración: p, q: POINTER TO INTEGER; no es lo mismo hacer p := q que hacer p^ := q^ la primera hace que p pase a apuntar al espacio de memoria apuntado por q y la segunda hace que el espacio de memoria apuntado por p pase a tener el mismo valor que el apuntado por q, también es claro que punteros a tipos distintos son incompatibles. Cuando un puntero no apunta a nada se escribe p^ = NIL, NIL es "el vacío" Ejemplo: MODULE Lista; FROM STextIO IMPORT WriteString, FROM InOut IMPORT Read, EOL; (* EOL es el carácter de final de linea *) FROM Storage IMPORT ALLOCATE, DEALLOCATE; TYPE list = POINTER TO node; (* Si bien node todavía no fue definido, esta permitido apuntar hacia algo que aun no existe *) node = RECORD dato: CHAR; (* este campo contendrá la información *) sig : list; (* este contendrá un apuntador al próximo *) END; (* node *) p, base: list; tmp : CHAR; (*************************************) p := NIL; (* no apunta a nada *) base := NIL; (* no apunta a nada *) (****** lectura de la lista ********) WHILE (tmp # EOL) DO (* mientras la entrada sea distinta de un ENTER *) Read(tmp); (* Lee tmp *) WriteString(tmp); (* Produce el eco *) WriteString(' ');

39 NEW(p); (* crea un nuevo p *) p^.dato := tmp; (* le asigno tmp como dato *) p^.sig := base; (* hago que apunte a base *) base := p; (* base se convierte en p + lo que era base antes por la sentencia anterior *) END; (* WHILE *) (****** escritura de la lista en orden inverso *********) WHILE (p # NIL) DO (* mientras p sea # NIL *) WriteString(p^.dato);(* escribe los datos de p *) WriteString(' '); p := p^.sig (* p se convierte en su campo sig *) END; (* WHILE *) (* esto va a parar dado que el ultimo elemento de la lista era la primer base que era igual a NIL *) END Lista. (******************************************************************) La lista que en orden inverso porque al leerla se va insertando los elementos al principio, y para escribirla se escribe primero el elemento que se encuentra en el principio de la lista