SUBPROGRAMAS

LOS SUBPROGRAMAS

Mediante el uso de los subprogramas, es posible diseñar sistemas modulares en los cuales ya no existe un solo algoritmo que se encarga de todo, sino que tenemos diferentes algoritmos especializados por temas y que en conjunto forman el gran programa. 

Nuestro propio organismo esta dividido en subprogramas en los cuales cada parte tiene un fin específico e interactúan para mantener todo el sistema en pleno funcionamiento. 

Los sub-programas también se conocen con el nombre de subrutinas, módulos, operaciones o métodos. 

Debemos ver a los subprogramas como una estrategia para dividir un problema mayor en partes más pequeñas, de forma que al interactuar entre ellos el sistema se comporte tal y como se diseñó.

Cada subprograma es en realidad un algoritmo más pequeño que aporta parte de la solución al problema principal. En estos subprogramas podemos definir variables, realizar asignaciones, realizar lectura de datos, imprimir expresiones, variables y literales, usar ciclos, vectores, decisiones, incluso invocar o llamar  a otros subprogramas.

MODELO GRAFICO DE UN PROGRAMA QUE ESTA CONSTRUIDO CON UN :

SUB-PROGRAMA

A Pesar de usar todos los subprogramas que se deseen siempre habrá de existir uno denominado principal, el cual es el encargado de organizar el uso de los elementos y subprogramas disponibles. Un programa siempre inicia en su parte principal y es desde allí de donde se articulan los elementos a ser usados.

COMO FUNCIONA UN PROGRAMA QUE ESTA ESTRUCTURADO POR SUBPROGRAMAS?

El programa inicia en su parte principal, es desde allí donde se ejecuta linea a linea, cuando el programa desea utilizar un subprograma, realiza un llamado,al cual se le conoce con el nombre de invocación. 

En este llamado,es vital conocer el nombre del subprograma que se desea invocar y los elementos que se deben enviar para que éste funcione adecuadamente, el programa ejecuta cada instrucción del subprograma que fue llamado, y cuando termina, regresa retornando el resultado y permitiendo que el programa siga la ejecución en la parte donde había sido llamado. 

LOS SUBPROGRAMAS TIENEN DOS ASPECTOS CLAVES

1. Un subprograma se crea una sola vez.

Esto implica hacer el algoritmo que se encuentra en el interior del subprograma de forma que cumpla un fin específico.

2. Un subprograma se usa n veces en un subprograma

Desde cualquier parte del programa se puede llamar a un subprograma creado con el fín de ser usado, solo se necesita enviar los parámetros necesarios para su correcto funcionamiento.

Forma general para definir un subprograma en el lenguaje python.

Para utilizar un subprograma se aplica la misma técnica que trabajamos para las funciones definidas por el sistema.

Para construir un subprograma se necesita:

1. Asignarle un nombre que sea acorde a lo que se espera realice el subprograma

2. Definir el número de parámetros que se necesitarán para su funcionamiento. En este punto la idea es que en un comienzo desde el enunciado se sugiera el número de parámetros que necesitará el subprograma y que más adelante se desarrolle esa habilidad.

3. Crear el algoritmo que se encuentra en el interior del subprograma. Utilizando los parámetros como datos de entrada y aplicando cualquiera de las instrucciones que se venían  aplicando en los algoritmos realizados hasta ahora.

4. Si el programa debe retornar un resultado, este se logra mediante el uso de la instrucción return seguida de lo que se desea retornar. 

Forma general de un programa construido con subprogramas.

1. ¿Para crear un programa con subprogramas siempre hay que importar las bibliotecas?

No. Eso solo depende si se necesitan funciones definidas por el sistema en lo que deseamos construir.

2. ¿Dos subprogramas pueden llamarse igual?

No. Cada subprograma debe tener un único nombre que lo identifique de los demás.

3. ¿Los parámetros pueden llamarse igual?

En un mismo subprograma cada parámetro debe ser diferente de los otros, cada parámetro se separa de los demás por el uso de comas. Pero dos subprogramas si pueden tener el mismo nombre de los parámetros, dado que cada uno es independiente de los demás.

4. ¿Qué instrucciones pueden ir dentro de un subprograma?

Todas las que se han trabajo.

- Definición de variables

- Realización de operaciones lógicas, matemáticas...

- Toma de decisiones if, else, elif ...

- Realización de ciclos, simples y anidados.

- Aplicación de vectores 

- Utilización de funciones definidas por el sistema

- Utilización de subprogramas.

5.¿Puede ejecutarse un subprograma solo?

No. Todo subprograma debe ser llamado desde otra parte del programa y ningún subprograma se ejecutará sin que exista un programa principal que desencadene su utilización.

6. ¿Cuántas veces puedo utilizar un subprograma?

Un subprograma puede ser utilizado las veces que se desee, no hay limites. Pero si se aplica una llamada recursiva, es decir, un programa que se llama a si mismo n veces puede saturar la memoria del computador y bloquear el programa que se esta ejecutando.

7. ¿Que pasa cuando en dos subprogramas se definen variables con el mismo nombre?

Al estar en subprogramas diferentes, no les sucede nada, dado que cada subprograma genera una capsula que la convierte en independiente de los demás e incluso independiente del programa principal.

Ejemplo 1Construir un subprograma que genera una información y es invocado desde el programa principal. 

Ejemplo 2 Construir un subprograma que dados dos catetos, calcule el valor de la hipotenusa a la cual pertenecen. Utilizar dicho subprograma para calcular la hipotenusa de unos catetos leídos por el teclado. 

Ejemplo 3 Crear un sistema que realiza las operaciones básicas entre dos valores decimales aplicando el concepto de subprograma para cada una de las operaciones y del menú principal. 

ARREGLOS BIDIMENCIONALES Y UNIDIMENCIONALES

BIDIMENCIONALES

Son estructuras de datos que agrupan muchos datos del mismo tipo, en donde cada elemento se puede trabajar individualmente y se puede referenciar con un mismo nombre. Se usan para representar datos que pueden verse como una tabla con filas y columnas.

ü Declaración:

Tipo_dato nombre_matriz [índice fila] [índice columna]

ü Uso:

Nombre_matriz [subíndice1] [subíndice2]

int matriz [2][2]

char mapa [100][100]

int certamen [60][4]

Declara una matriz de 3 filas por 4 columnas:

int matriz [3][4];

ü Declaración e iniciación:

int matriz [2][2]={1,2,3,4}

1

2

Para referenciar un elemento de la matriz, debe darse un nombre de la matriz y el índice de la fila y de la columna que el elemento ocupa en dicha matriz. Es importante que los índices de las matrices tanto de las filas como de las columnas empiezan en 0 y terminan en tamaño fila-1 y tamaño columna-1 respectivamente.

A las matrices se le asignan automáticamente valores iniciales predeterminados a cada uno de sus elementos, de acuerdo a los siguientes criterios:

• Si el tipo del arreglo es numérico, a sus elementos se les asigna el valor cero.
• Si el tipo del arreglo es char, a sus elementos se les asigna el valor ‘\u0000′.
• Si el tipo del arreglo es bool, a sus elementos se les asigna el valor false.
• Si el tipo del arreglo es una clase, a sus elementos se les asigna el valor null.

Ejemplo:

#include <stdio.h>

int main()

{

int fila, columna;

int matriz[2][2];

for(fila=0; fila<2; fila++)

for(columna=0; columna<2; columna++)

printf(“%d”, matriz[fila][columna]);

return 0;

}

Es un tipo de dato estructurado, finito ordenado y homogéneo.
El acceso a ellos también es en forma directa por medio de un par de índices.
Los arreglos bidimensionales se usan para representar datos que pueden verse como una tabla con filas y columnas.
La primera dimensión del arreglo representa las columnas, cada elemento contiene un valor y cada dimensión representa una relación.
La representación en memoria se realiza de dos formas: 
 1.-Almacenamiento por columnas
 2.-Almacenamiento por renglones
Para determinar el número total de elementos en un arreglo bidimensional usaremos las siguientes fórmulas:
 Rango de renglones (r1) = ls1 - (li1+1)
 Rango de columnas (r2) = ls2 - (li2+1)
 No. Total de componentes = r1 * r2
Representación en memoria por columnas
[pic]
 x : array [1..5,1..7] of integer

Para calcular la dirección de memoria de un elemento se usan la siguiente formula:
 A[i,j] = base (A) + [((j - li2) R1 + (i + li1))*w]

Representación en memoria por renglones
[pic]
 x : array [1..5,1..7] of integer

Para calcular la dirección de memoria de un elemento se usan la siguiente formula:
 A[i,j] = base (A) + [((i - li1) R2 + (j + li2))*w]
Donde:
i = Indice del renglón a calcular
j = Indice de la columna a calcular
li1 = Límite inferior de renglones
li2 = Límite inferior de columnas
w = Número de bytes tipo componente

UNIDIMECIONALES

Un arreglo unidimensional es un tipo de datos estructurado que está formado por una colección finita y ordenada de datos del mismo tipo. Es la estructura natural para modelar listas de elementos iguales. Los datos que se guarden en los arreglos todos deben ser del mismo tipo.

El tipo de acceso a los arreglos unidimensionales es el acceso directo, es decir, podemos acceder a cualquier elemento del arreglo sin tener que consultar a elementos anteriores o posteriores, esto mediante el uso de un índice para cada elemento del arreglo que nos da su posición relativa.
Para implementar arreglos unidimensionales se debe reservar espacio en memoria.

Los arreglos nos permiten hacer un conjunto de operaciones para manipular los datos guardados en ellos, estas operaciones son: ordenar, buscar, insertar, eliminar, modificar entre otras.

REPRESENTACION EN MEMORIA: Los arreglos guardan en memoria la cantidad de espacios que se le indican en la declaración.

Ejemplo: sea el siguente arreglo unidimensional donde se va a guardar 5 datos de tipo entero (integer)

x : array[1..5] of integer

En memoria el computador guarda 5 espacios: esto quiere decir en el arreglo X en la posición 1 guarda 34, en el arreglo X en la posición 2 guarda 22, asi hasta la última posición del arreglo X posicion 5 guarda 72.

X [1]

34

X [2]

22

X [3]

39

X [4]

63

X [5]
72

Declaracion de los arreglos unidimensionales: Se declara el tipo del arreglo, con la palabra reservada TYPE, luego se declara la variable de tipo arreglo, esto se hace en el 

bloque de declaracion de variables palabra reservada VAR.

Type

nombre_arreglo= array[x..y]of tipo_dato;

Ejemplos:

salarios= array [1…x] of real;

nombre_trabajador=array[1..x] of string;

Nota: El tipo de dato del arreglo puede ser: integer,real, boolean, string etc.

Variables tipo array

Var

sueldo:salarios;

nombre:nombre_trabajador;

Una vez declarados los arreglos procedemos a cargar información en ellos, para esto usamos estructuras repetitivas la mas recomendable por su facilidad es el for, una vez cargada la información se puede hacer cualquier operación de calculo y por último mostramos la 

información de los arreglos usando de igual manera la estructura repetitiva for.carga de un arreglo, la letra i es el indice o subindice del arreglo e indica la posición del 

arreglo:

for i:=1 to num do

begin

readln(notas[i]);

end;

Mostrar la información de un arreglo, la letra i es el indice o subindice del arreglo e indica la posición del arreglo::

for i:=1 to num do

begin

writeln(notas[i]:3:1);

end;

Se han hechos programas que suman una cantidad de números usando dos variables, una para leer cada número y otra para acumular la suma. Este enfoque tiene la desventaja de que se pierden los valores de los sumandos. El uso de arreglos permite calcular la suma de los números con una cantidad mínima de código y a la vez conservar cada valor, como muestra el

 siguiente programa completo:

Program SumaN;

Uses

Crt;

Const

n = 5;

Var

nums: Array[1..n] Of Integer;

s, i: Integer;

Begin

For i:=1 To n Do

Begin

Write('Escriba el número: ');

ReadLn(nums[i]);

s := s + nums[i];

End;

WriteLn('La suma es: ', s);

End.

Nótese el uso de una constante para marcar el tamaño del arreglo; dicha constante, también sirve para controlar el For. De este modo, sólo se hace necesario cambiar un número para 

adecuar el programa a la escala apropiada

EJERCICIOS DE ARREGLOS UNIDIMENSIONALES:

* Dadas n cantidad de notas, calcular e imprimir el promedio de las notas y todas las notas que fueron mayor a la media calculada.

PROGRAM calificaciones;
USES CRT;
type
listacalificaciones=array[1..n]of real;
VAR
notas:listacalificaciones;
media,suma:real;
num,i:integer;

BEGIN
WRITELN('INTRODUZCA la cantidad de notas a procesar');
READLN(NUM);
suma:=0;

for i:=1 to num do

begin

readln(notas[i]);

suma:=suma+notas[i];

end;
media:=suma/num;
writeln('la media es:' , media:2:2);
writeln('la lista de calificaciones mayores a la media es:');
for i:=1 to num do
begin
if notas[i]>media then
writeln(notas[i]:3:1);
readln;
end;
END.

(*Escribir un programa en pascal que rellene un array con 11
numeros, luego dividirlos entre 3 y mostralos por pantalla *)
PROGRAM numeros;
USES CRT;
type
arreglonumeros=array[1..11]of real;
VAR
num:arreglonumeros;
i:integer;
numero:real;

BEGIN
for i:=1 to 11 do
begin
WRITELN('Introduzca el numero ' , i, ' a dividir');
readln(num[i]);
numero:=num[i]/3;
write('los numero resultantes de la division son:' ,numero:2:2);
readln;
end;
end.

CICLOS ALGORITMICOS

LOS CICLOS

Un algoritmo se comporta de una manera secuencial, cada instrucción se lee desde inicio hasta fin. Esto nos da pie a pensar que para lograr repetir algo, será necesario copiarlo muchas veces. En el mundo de los algoritmos encontramos la forma de repetir las veces que deseamos una instrucción o un bloque de ellas, a este elemento lo denominamos ciclo. En la naturaleza y en el mundo real la mayoría de cosas son cíclicas, comer, dormir, respirar, trabajar, estudiar, descansar.... son cosas que se repiten con diferente periodicidad.

¿QUÉ SON LOS CICLOS? 

Son estructuras que permiten hacer  n repeticiones de un bloque de instrucciones.

En los algoritmos los ciclos son diversos, para el caso de estudio del curso seleccionaremos el ciclo mientas, en inglés while y en DFD MQ. El ciclo funciona de modo que: mientras la expresión de control sea verdadera se ejecuta todo el bloque que contienen y cuando llega al final, se devuelve a la expresión de control y nuevamente pregunta, de ser verdad, sigue repitiendo este proceso mientras sea verdad dicha expresión y cuando no, termina saltando el bloque y continuando con las demás acciones programadas en el algoritmo.

EL CICLO MIENTRAS

Ya conocemos que la finalidad de un ciclo es hacer un número de repeticiones y en dichas repeticiones denominadas iteraciones realizar otras instrucciones que permitan dar respuesta al problema originalmente planteado.

El ciclo mientras se fundamenta en un expresión relacional o lógica al igual que lo hacen las decisiones.

El ciclo mientras funciona preguntado por una expresión lógica o relacional si es verdad ingresa al ciclo y cuando es falsa salta el bloque y continua en la siguiente instrucción después del bloque mientras.

En esta forma genérica, si la expresión es verdadera se ejecuta inst1, inst2, inst3, inst4 tantas veces como sea verdad la expresión, es decir se deja de repetir cuando la expresión sea falsa. Un dato muy importante es que de alguna forma la expresión  tenga elementos que cambien al interior del ciclo.Cuando los elementos no cambian, se puede generar un ciclo que nunca termina o denominado infinito.

Empezaremos por definir una forma general de usar el ciclo mientras, nos concentraremos en lograr que el ciclo realice n repeticiones. 

La forma general de hacer esto, es definir cuántas repeticiones se desean hacer, crear una expresión que sea verdadera mientras no se cumpla el total de las repeticiones y dentro del ciclo modificar la variable de control del ciclo.

EL CONCEPTO DE CONTADOR

¿Qué es un contador? 

Es una variable, cuya finalidad es la de permitir guardar un conteo sobre algo que se necesita. Desde el punto de vista de la programación es lo siguiente.

variable = variable + K

donde K es una constante numérica que puede ser entera o decimal.

Ejemplos realizados

Construir un programa que lea el nombre de un usuario y su edad. Validar que la edad sea correcta en un rango de 10 a 90. Imprimir el nombre tantas veces como años tiene la persona.

#Algoritmo construido en python 3.2
#Forma 1 de solucionar el planteamiento dado.
n=input("digite nombre")
e=int(input("edad"))
if e>=10 and e<=90:
    c=1
    while c<=e:
        print(n)
        c+=1
else:
     print("fuera del rango")

#Algoritmo construido en python 3.2

#Forma 2 de construir el problema planteado.

n=input("digite nombre")

e=int(input("edad"))

if e<10 or e>90:

    print("fuera del rango")

else:

    c=0

    while c<e:

        print(n)

        c+=1

Construir un programa que realice un conteo descendente desde m hasta 0. Si m es negativo volverlo positivo.

#Algoritmo construido en Python 3.2 Forma 1 de resolver el planteamiento dado.
m=int(input("Digite m"))
if m<0:
    m=-m
c=0
while c<=m:
    print(m-c)
    c+=1

#Algoritmo construido en Python 3.2 Forma 2 de resolver el planteamiento dado

m=int(input("Digite m"))

if m<0:

    m=-m

while m>0:

    print(m)

    m-=1

Imprimir n números pares desde 0 en adelante.

#Algoritmo construido con Python 3.2
#Forma 1 de solucionar el planteamiento dado
m=int(input("numero pares"))
c=1
while c<=m:
    print(c*2)
    c+=1

#Algoritmo construido con Python 3.2
#Forma 2 de solucionar el planteamiento dado
m=int(input("numero pares"))
c=1
p=2
while c<0:
    print (p)
    p+=2
    c+=1

#Algoritmo construido con Python 3.2

#Forma 3 de solucionar el planteamiento dado

m=int(input("numero pares"))
c=1
while c<=m*2:
    if c%2==0:
        print(c)
        c+=1

Leer la edad de n personas, determinando cuántas de las edades están en el intervalo 18 a 90.

#Algoritmo desarrollado en Python 3.2
n=int(input("numero personas"))
p=0
while n>0:
    e=int(input("digite edad"))
    if e>17 and e<91:
        p+=1
        n-=1
        print(p,"personas en el rango")




CONDICIONALES

Las estructuras condicionales comparan una variable contra otro(s)valor (es), para que en base al resultado de esta comparación, se siga un curso de acción dentro del programa. Cabe mencionar que la comparación se puede hacer contra otra variable o contra una constante, según se necesite. Existen tres tipos básicos, las simples, las dobles y las múltiples.

SIMPLES:

Las estructuras condicionales simples se les conoce como “Tomas de decisión”. Estas tomas de decisión tienen la siguiente forma:

Pseudocódigo:	Diagrama de flujo:

DOBLES:
Las estructuras condicionales dobles permiten elegir entre dos opciones o alternativas posibles en función del cumplimiento o no de una determinada condición. Se representa de la siguiente forma:

Pseudocódigo:	Diagrama de flujo:

Donde:
Si:Indica el comando de comparación
Condición : Indica la condición a evaluar
Entonces : Precede a las acciones a realizar cuando se cumple la condición
Instrucción(es):Son las acciones a realizar cuando se cumple o no la condición
si no :Precede a las acciones a realizar cuando no se cumple la condición
Dependiendo de si la comparación es cierta o falsa, se pueden realizar una o más acciones.

MÚLTIPLES:

Las estructuras de comparación múltiples, son tomas de decisión especializadas que permiten comparar una variable contra distintos posibles resultados, ejecutando para cada caso una serie de instrucciones especificas. La forma común es la siguiente:

Pseudocódigo:	Diagrama de flujo:

MÚLTIPLES (EN CASO DE )
Las estructuras de comparación múltiples, es una toma de decisión especializada que permiten evaluar una variable con distintos posibles resultados, ejecutando para cada caso una serie de instrucciones especificas. La forma es la siguiente:

Pseudocódigo:	Diagrama de flujo:

Veamos algunos ejemplos donde se aplique todo lo anterior:

Realizar un algoritmo en donde se pide la edad del usuario; si es mayor de edad debe aparecer un mensaje indicándolo. Expresarlo en Pseudocódigo y Diagrama de flujos.

Pseudocódigo:	Diagrama de flujo:

Se pide leer tres notas del alumno, calcular su definitiva en un rango de 0-5 y enviar un mensaje donde diga si el alumno aprobó o reprobó el curso. Exprese el algoritmo usando Pseudocódigo y diagrama de flujos.

Pseudocódigo:

INICIO
   Not1, Not2, Not 3 :REAL
   Def: REAL
   LEA Nota1, Nota2, Nota3
   Def ß (Not1 + Not2 + Not3) /3
   Si Def < 3 entonces
      Escriba “Reprobó el curso”
   Sino
      Escriba “Aprobó el curso”
   Fin-Si
FIN

Diagrama de flujo:

Se desea escribir un algoritmo que pida la altura de una persona, si la altura es menor o igual a 150 cm envíe el mensaje: “Persona de altura baja”; si la altura está entre 151 y 170 escriba el mensaje: “Persona de altura media” y si la altura es mayor al 171 escriba el mensaje: “Persona alta”. Exprese el algoritmo usando Pseudocódigo y diagrama de flujos.

Pseudocódigo:

INICIO
   Altura: ENTERO
   ESCRIBA “Cuál es tu altura? ”
   LEA Altura
   Si Altura <=150 entonces
      ESCRIBA “persona de altura baja”
   Sino
      Si Altura <=170 entonces
         ESCRIBA “persona de altura media”
      Sino
         Si Altura>170 ENTONCES
            ESCRIBA “persona alta”
         Fin-Si
      Fin-Si
   Fin-Si
FIN

¡Es importante ser ordenado en el código que se escribe!

Diagrama de flujo:

Dado un numero entre 1 y 7 escriba su correspondiente día de la semana así:
1- Lunes 2- Martes 3- Miércoles 4- Jueves 5- Viernes 6- Sábado 7- Domingo
Exprese el algoritmo usando Pseudocódigo y diagrama de flujos.

Pseudocódigo: Pseudocódigo:

INICIO
   Dia: ENTERO
   ESCRIBA “Diga un número para escribir su día”
   LEA Dia
   En-caso-de Dia haga
      Caso 1: ESCRIBA “Lunes”
      Caso 2: ESCRIBA “Martes”
      Caso 3: ESCRIBA “Miércoles”
      Caso 4: ESCRIBA “Jueves”
      Caso 5: ESCRIBA “Viernes”
      Caso 6: ESCRIBA “Sábado”
      Caso 7: ESCRIBA “Domingo”
     SINO: ESCRIBA “Escribió un numero fuera del rango 1-7”
   Fin-Caso
FIN

Diagrama de flujo:

ORDEN DE PRECEDENCIA

Las reglas de precedencia de las expresiones del lenguaje C nos dicen el orden en que el computador evalúa una expresión cuando hay más de un operador. Para expresiones aritméticas se siguen, lógicamente, las reglas de precedencia aritmética. Es decir, primero se aplica el operador de cambio de signo (-) , a continuación se calculan multiplicaciones y divisiones, y por último sumas y restas. Cuando hay dos operadores con la misma precedencia, se calcula primero la operación que está a la izquierda. Veamos algunos ejemplos:

IVA=PVP-PVP/1.16;

Tenemos una suma y una división. Siguiendo las reglas de precedencia aritmética, primero se calcula la división y después la suma. Si tenemos:

Z=-X+Z*2+N+Y/X-7;

El computador primero cambia de signo el valor de X. Después calcula la multiplicación (los operadores * y / tienen la misma precedencia, pero * está a la izquierda en esta expresión). Sigue con la división y por último hace las operaciones de suma y resta empezando por la izquierda de la expresión.

Se pueden utilizar paréntesis para cambiar la precedencia. Una expresión entre paréntesis tiene siguiente formato general:

(Expresión)

esto hace que el computador evalúe en primer lugar el contenido de los paréntesis. Los paréntesis se pueden anidar, esto es, se pueden colocar paréntesis dentro de expresiones entre paréntesis. En tal caso, se calcula en primer lugar el contenido de los paréntesis más internos. En

B=(K-Z*(n-1))*K;

El computador calcula primero la expresión n-1, sigue con el paréntesis más externo, y lo último que hace es multiplicar su contenido por K. Cuando tenemos varios paréntesis al mismo nivel de anidamiento, se evalúan empezando la izquierda. El computador calcula la expresión

Z=-(X+Z)*(2+N)+Y/(X-7);

Evaluando primero el contenido de los paréntesis antes de hacer las operaciones que hay fuera de ellos.

Esto es un resumen de la prioridad de las operaciones aritméticas, de mayor prioridad a menor prioridad:

Aritmético	Comparación	Lógico
Negación (-)	Igualdad (=)	Not
Exponenciación (^)	Desigualdad (<>)	And
Multiplicación y división (*, /)	Menor que (<)	Or
División de número entero (\)	Mayor que (>)	Xor
Modelo aritmético (Mod)	Menor o igual que (<=)	Eqv
Suma y resta (+, -)	Mayor o igual que (>=)	Imp
Concatenación de cadenas (&)	Is	&