- Objetivo
General - Marco
Teórico - Principios de Resolución
de Problemas - Problemas
- Diseño de la
Aplicación - Ventana
portada - Ventana
evaluar - Ventana ayuda
- Ventana
salida - Conclusión
- Bibliografía
En este trabajo se da
a conocer de forma detallada y paso a paso el funcionamiento,
estructura,
código
fuente, utilidad y muchas
otras características y funcionalidades del proyecto
desarrollado en esta materia.
A pesar que el desarrollo y
diseño
de esta aplicación nos llevó muchas horas de
trabajo, en este reporte se presenta la explicación
detallada de lo que se ha hecho de tal manera que el lector
podrá comprender fácilmente el funcionamiento y
estructura de este programa.
También aparecerán los diferentes gráficos de cada una de las ventanas que
tiene nuestra aplicación para que el lector visualice e
identifique rápidamente de lo que se está hablando
en la explicación teórica.
Aparte de mostrar el código fuente de cada
botón de nuestra aplicación, encontraremos en las
páginas de este trabajo una explicación del
código en nuestro propio lenguaje
cotidiano, es decir que traduciremos el código programado
en Visual Basic a
nuestro lenguaje natural y cotidiano.
Hemos centralizado al máximo nuestro esfuerzo no
solamente en crear una aplicación de calidad sino que
también en hacer este reporte o trabajo lo mejor posible,
ya que es la documentación de nuestro programa o
aplicación.
A pesar de nuestro gran esfuerzo por explicar todo
claramente en este trabajo, podrían surgir otras dudas
respecto al funcionamiento de nuestro programa, por lo cual
también lo defenderemos o daremos una explicación
verbal para dar a conocer todos los detalles de esta
aplicación.
Desarrollar una aplicación o
programa en Visual Basic 6.0 que muestre los números
primos, la suma de los números primos y los números
primos gemelos comprendidos en un intervalo definido por el
usuario.
OBJETIVOS
ESPECÍFICOS
1. Crear códigos en Visual Basic que nos permitan
mostrar los números primos, la suma de los números
primos y los números primos gemelos comprendidos en un
intervalo definido por el usuario.
2. Explicar con toda claridad en el lenguaje
natural, los códigos desarrollados en el lenguaje de
programación Visual Basic 6.0.
3. Dar a conocer paso a paso el funcionamiento nuestra
aplicación.
4. Ser capaces de prevenir e identificar errores en
nuestra aplicación.
5. Desarrollar un programa de gran calidad en el
lenguaje de programación Visual Basic 6.0.
Antes de comenzar hablar de nuestra aplicación,
daremos una introducción necesario respecto a la
resolución de problemas, ya
que en la programación nos enfrentamos a cada momento con
problemas que debemos resolver. De igual forma, la
aplicación que hemos creado presentó una serie de
problemas que tuvimos que ir resolviendo hasta lograr una
aplicación que no presente errores y que funcione de
acuerdo a nuestras necesidades.
PRINCIPIOS DE RESOLUCIÓN DE
PROBLEMAS
No existen reglas sencillas que garanticen el éxito
en la resolución de problemas. Sin embargo es posible
establecer algunas pautas generales en el proceso de la
resolución de problemas, y algunos principios que
pueden ser útiles en la solución de problemas
específicos; estas pautas y principios son sentido
común planteado explícitamente.
1. COMPRENDER EL PROBLEMA
El primer paso es leer el problema y asegurarse de
comprenderlo con toda claridad. Debemos hacernos a nosotros
mismos las siguientes preguntas:
¿Cuál es la
incógnita?
¿Cuáles son las
cantidades dadas?
¿Cuáles son las
condiciones dadas?
Para muchos problemas resulta útil
Dibujar un diagrama
e identificar las cantidades dadas y las requeridas en
el diagrama.
Por lo general es necesario
Introducir una notación
adecuada.
Al seleccionar símbolos para las cantidades desconocidas,
a menudo utilizamos letras como a, b, c, m, n, x y
y, pero en algunos casos ayuda usar iniciales como
símbolos sugerentes, por ejemplo V para volumen, o bien
t para el tiempo.
2. PENSAR EN UN PLAN
Determinar una relación entre la información dada y la incógnita que
nos permita calcular ésta. A menudo es bueno preguntarnos
a nosotros mismos: "¿de qué manera podemos se
pueden relacionar los datos con la
incógnita?". Si de manera inmediata no se percibe una
relación, las siguientes ideas pueden ser de utilidad para
diseñar un plan:
- Tratar de reconocer algo
familiar
Relacionar la situación dada con alguna
experiencia anterior. Debemos observar las incógnitas y
recordar un problema más familiar que tenga
incógnitas semejantes.
- Tratar de reconocer algún
patrón
Algunos problemas se resuelven reconociendo que un
cierto patrón está ocurriendo; éste
podría ser geométrico, numérico o
algebraico. Si se puede detectar en un problema alguna
regularidad, entonces imaginemos cuál es el patrón
y después debemos comprobarlo.
- Utilizar la analogía
Tratar de pensar en algún problema
análogo, esto es, uno similar o relacionado, pero
más sencillo que el original. Si podemos resolver
éste, quizá nos dé la clave que necesitamos
para resolver el original. Por ejemplo, si un problema involucra
números muy grandes, podríamos primero intentar uno
semejante con números más pequeños. O bien
si el problema es de geometría en tres dimensiones, que un caso
similar en dos dimensiones. O si el problema con el cual
empezamos es general, podríamos intentar con un caso
especial.
- Introducir algo adicional
A veces es posible que necesitemos introducir algo nuevo
–una ayuda- que nos permita establecer la relación
entre la información dada y las incógnitas. Por
ejemplo, en un problema para el cual es útil un diagrama,
una estrategia
auxiliar podría ser una nueva recta dibujada en el
diagrama. En un problema algebraico la ayuda podría ser
una nueva incógnita relacionada con la
original.
- Dividir en casos
A veces tendremos que dividir un problema en varios
casos dando un argumento diferente para cada uno de ellos. Por
ejemplo, a menudo tenemos que utilizar esta estrategia al tratar
con el valor
absoluto.
- Trabajar hacia atrás
A veces resulta útil imaginar que el problema
está resuelto y trabajar hacia atrás, paso a paso
hasta que se llegue a los datos dados. Entonces podremos regresar
sobre nuestros pasos y, a partir de ahí, construir una
solución para el problema original. Este procedimiento es
de uso común en la resolución de ecuaciones.
Por ejemplo, para resolver la ecuación 3x – 5 = 7
suponemos que x es un número que satisface a 3x – 5
= 7 y trabajamos hacia atrás. Sumamos 5 a cada lado de la
ecuación y después dividimos entre 3 para obtener x
= 4. En vista que cada uno de estos pasos puede invertirse, hemos
resuelto el problema.
- Establecer objetivos
parciales
En un problema complejo, a menudo resulta útil
establecer objetivos parciales (en los cuales la situación
deseada se satisface particularmente). Si primero alcanzamos
estos objetivos, quizá podamos laborar a partir de ellos
para alcanzar el objetivo
final.
- Razonamiento indirecto
Algunas veces es apropiado atacar un problema
indirectamente. Al utilizar la demostración por
contradicción para probar que P implica a Q, suponemos
que P es verdadera y Q es falsa y tratamos de ver por qué
no puede ocurrir. De alguna manera tenemos que utilizar esta
información y llegar a una contradicción de algo
que sabemos con absoluta certeza que es verdadero.
- Inducción
matemática
Al probar enunciados que involucren un entero positivo
n, a menudo es conveniente utilizar el principio de
inducción matemática.
3. EJECUTAR EL PLAN
En el paso 2 se elaboró un plan. Al ejecutar
dicho plan, debemos verificar cada etapa del mismo y escribir los
detalles que prueban que cada etapa es correcta.
4. VER HACIA ATRÁS (APLICAR LA "CORRIDA
MENTAL")
Después de completar nuestra solución es
conveniente ver hacia atrás, con el objetivo de detectar
si se han cometido errores en la solución y si podemos
descubrir una forma más sencilla de resolver el problema.
Otra razón para ver hacia atrás es que lo
familiarizaremos con el método de
la solución, lo cual es para la solución de
problemas futuros. Descartes
dijo, "Todo problema que he resuelto se convirtió en una
regla que posteriormente sirvió para resolver otros
problemas".
PROBLEMA: MOSTRAR LOS NÚMEROS PRIMOS
EXISTENTES EN UN INTERVALO DETERMINADO POR EL
USUARIO
Veamos a continuación método que
utilizaríamos para resolver este problema paso a paso
mediante variables el
uso de variables y a la manera que lo haríamos en un
diagrama de
flujo:
1. INICIO
2. ENTRADA: v_ini
3. ENTRADA: v_fin
4. DECISIÓN: SI v_ini > =
0
5. DECISIÓN: SI v_ini =
0
6. ASIGNACIÓN: v_ini = 1
7. CICLO PARA: n = v_ini , v_fin , 1
8. ASIGNACIÓN: contador = 0
9. ASIGNACIÓN: x = n
10. CICLO PARA: ciclo = x , 1 , ciclo
11. ASIGNACIÓN: residuo = x MOD
ciclo
12. CONDICIÓN: SI residuo = 0
13. ASIGNACIÓN: contador = contador +
1
14. CIERRE
15. CONDICIÓN: SI contador < =
2
16. SALIDA: x
17. CIERRE
18. FIN
PROBLEMA: SUMAR NÚMEROS LOS
PRIMOS EXISTENTES EN UN INTERVALO DETERMINADO POR EL
USUARIO
Este problema podemos resolverlo con la siguiente
secuencia:
1. INICIO
2. ENTRADA: v_ini
3. ENTRADA: v_fin
4. DECISIÓN: SI v_ini > = 0
5. ASIGNACIÓN: contadorsuma = 0
6. CICLO PARA: n = v_ini , v_fin , 1
7. ASIGNACIÓN: contador = 0
8. ASIGNACIÓN: x = n
9. CICLO PARA: ciclo = 1 , x , 1
10. ASIGNACIÓN: residuo = x MOD
ciclo
11. DECISIÓN: SI residuo = 0
12. ASIGNACIÓN: contador = contador +
1
13. CIERRE
14. CONDICIÓN: SI contador < =
2
15. ASIGNACIÓN: contadorsuma =
contadorsuma + x
16. CIERRE
17. SALIDA: "SUMA PRIMOS":
contadorsuma
PROBLEMA: MOSTRAR NÚMEROS
PRIMOS GEMELOS EXISTENTES EN UN INTERVALO DETERMINADO POR EL
USUARIO
El método de solución paso a paso para
este problema es bastante similar al problema de encontrar los
primos, pero tiene un mayor grado de complejidad porque no basta
con saber si un número es primo o no, sino que
además de eso se deben encontrar las parejas de primos
gemelos. Para ello determinamos primeramente si un número
es primo o no, y en caso que sea primo, sumamos dos unidades y si
el número que al sumarle dos unidades es primo
también, entonces tenemos una pareja. Pero se debe
controlar que no se tome una pareja donde uno de los
números de la pareja esté fuera del intervalo
especificado. Por ejemplo, si el usuario determina un intervalo
entre 0 y 11, la pareja de primos gemelos (11,13) no debe
aparecer porque el 13 se sale del intervalo. Por ello en el paso
25 de la secuencia que aparece a continuación, encontramos
la DECISIÓN: SI prueba < = v_fin. En el caso que
acabamos de plantear sobre la pareja (11,13), la variable
"prueba" sería el 13, y v_fin sería el valor final
del intervalo, que en este caso es 11. Significa que
deberá imprimir (11,13) como números primos gemelos
dentro del intervalo sólo si la variable "prueba" es menor
o igual que el valor final, que es 11 en este ejemplo. Entonces
como conclusión, la pareja (11,13) no aparecería,
lo cual es correcto porque el intervalo es de 0 a 11.
1. INICIO
2. ENTRADA: v_ini
3. ENTRADA: v_fin
4. DECISIÓN: SI v_ini > =
0
5. DECISIÓN: SI v_ini = 0
6. ASIGNACIÓN: v_ini = 1
7. CICLO PARA: n = v_ini , v_fin , 1
8. ASIGNACIÓN: contador = 0
9. ASIGNACIÓN: x = n
10. CICLO PARA: ciclo = 1 , x , 1
11. ASIGNACIÓN: residuo = x MOD
ciclo
12. DECISIÓN: SI residuo = 0
13. ASIGNACIÓN: contador = contador +
1
14. CIERRE
15. DECISIÓN: SI contador < =
2
16. ASIGNACIÓN: prueba = x + 2
17. ASIGNACIÓN: c = 0
18. CICLO PARA: n1 = 1 , prueba , 1
19. ASIGNACIÓN: residuo1 = prueba MOD
n1
20. DECISIÓN: SI residuo1 = 0
21. ASIGNACIÓN: c = c + 1
22. CIERRE
23. DECISIÓN: SI c < = 2
24. ASIGNACIÓN: anterior = prueba –
2
25. DECISIÓN: SI prueba < =
v_fin
26. SALIDA: anterior , " y " , prueba
27. CIERRE
28. FIN
Nuestra aplicación consta de cuatro ventanas o
formularios.
La más utilizada será la segunda ventana, pues es
en ella en la que trabajaremos evaluando los números
primos en el intervalo que deseemos. Podemos clasificar el
diseño de nuestra aplicación en cuatro ventanas de
esta manera:
1. Ventana o Formulario PORTADA.
2. Ventana o Formulario
EVALUACIÓN.
3. Ventana o Formulario AYUDA.
4. Ventana o Formulario SALIDA.
Es a través de las cuatro ventanas
mencionadas que trabajaremos con esta aplicación sobre los
números primos.
Conozcamos ahora el diseño de cada ventana a
través de imágenes
que nos permitirán visualizar la apariencia y
presentación de nuestro programa:
- VENTANA DE INICIO O PORTADA
2. VENTANA DE TRABAJO O DE
EVALUACIÓN DE NÚMEROS PRIMOS
3. VENTANA DE
AYUDA
4. VENTANA DE
SALIDA
Después de dos segundos aparecerá el
siguiente mensaje dentro de la misma ventana de
salida:
Después de dos segundos se cerrará
automáticamente el programa, sin hacer clic en
ningún botón, puesto que anteriormente se le ha
preguntado al usuario mediante un MsgBox si desea salir del
programa.
Esta es la parte más importante y fundamental de
este trabajo o reporte, pues aquí se explicará de
forma detallada el código fuente y toda la estructura del
programa que hemos desarrollado. Ahora conoceremos paso a paso el
funcionamiento y estructura de este programa, valiéndonos
también de imágenes que nos permitirán
ubicarnos mejor en la y de forma visual en el diseño de la
aplicación y llevar la secuencia de cada cosa que se
está hablando. Igualmente analizaremos el código
programado, que es obviamente lo más importante de
todo.
1.1. Propiedades de los objetos de la ventana
PORTADA
Para el diseño de este formulario se utilizaron
los siguientes objetos:
- Form
- Image
- Label
- CommandButton
El objeto inicial que utilizamos fue un Form o
formulario, que es indispensable y es el objeto en el cual se
ubicarán todos los demás controles. La propiedad que
se modificó en el formulario fue Caption, con lo
cual se escribió el título de la barra de
título.
El objeto Image fue utilizado para colocar una
imagen como
fondo del formulario. La propiedad que le modificamos a este
objeto fue Picture, con la cual insertamos una imagen
dentro del formulario.
Los Label se han utilizado para mostrar la
información de texto. La
propiedad Alignment se cambió en el primer
Label a 2 – Center para que ubique el
título centrado en la pantalla. A los Label se les
modificó la propiedad Caption para introducir
nuestro texto personalizado. Igualmente modificamos la propiedad
Font para cambiar el tamaño, estilo y tipo de
letra, así como para subrayar algunos textos. El tipo de
letra que usamos es Trebuchet MS, el tamaño 18 en los
primos dos Label y 16 en todos los demás, y el
estilo de la letra es Negrita. Otra propiedad que fue modificada
es ForeColor, con la cual cambiamos el color de la
fuente a blanco porque utilizamos un fondo oscuro en nuestro
formulario.
El objeto CommandButton sufrió
modificación en la propiedad Caption para ponerle
el texto "Iniciar". También le modificamos la propiedad
Font para personalizar la fuente del texto. Cambiamos la
propiedad Picture para poner una imagen como fondo del
botón y finalmente la propiedad Style a 1
– Graphical para que el botón muestre la imagen
de fondo.
1.2. Código de la ventana
PORTADA
En la ventana de código, el único objeto
que fue codificado es el Command1. El código es el
siguiente:
Private Sub
Command1_Click()
Form1.Show
Form2.Hide
End Sub
Explicación: Al hacer
clic sobre este botón, el Formulario 1, que es la
ventana principal en la cual se evaluarán los
números primos, será mostrada, y a la vez se
ocultará el Formulario 2. Eso lo hacemos con las
propiedades Show y Hide, tal como lo vemos en el
código.
2.1. Propiedades de los objetos de la ventana
EVALUAR
Para el diseño de este formulario se utilizaron
los siguientes objetos:
- Form
- Menu
- Image
- Label
- TextBox
- CommandButton
El primer objeto utilizamos fue un Form o
formulario, que es indispensable y es el objeto en el cual se
ubicarán todos los demás controles. La propiedad
que se modificó en el formulario fue Caption, con
lo cual se escribió el título de la barra de
título.
El objeto Menu se utilizcó para
proporcionar cuatro menús de acceso fácil. Estos
son:
- Menú Evaluar Primos.
- Menú Limpiar.
- Menú Ayuda.
- Menú Salir.
El objeto Image fue utilizado para colocar una
imagen como fondo del formulario. La propiedad que le modificamos
a este objeto fue Picture, con la cual insertamos una
imagen dentro del formulario.
Los Label se han utilizado para mostrar la
información de texto. A los Label se les
modificó la propiedad Caption para introducir
nuestro texto personalizado. Igualmente modificamos la propiedad
Font para cambiar el tamaño, estilo y tipo de
letra, así como para subrayar el primer Label o el
título. El tipo de letra que usamos es Trebuchet MS, el
tamaño 20 para el primer Label o el título y
16 para los otros dos, el estilo Negrita cursiva para el primer
Label y sólo Negrita para los otros dos. Otra
propiedad que fue modificada es ForeColor, con la cual
cambiamos el color de la fuente a blanco porque utilizamos un
fondo oscuro en nuestro formulario.
Hemos utilizado tres objetos TextBox. Los
primeros dos sirven para que el usuario introduzca el valor
inicial y el valor final que determine el intervalo a evaluar,
mientras que el tercer objeto TextBox muestra los
resultados de las evaluaciones y no puede ser modificado por el
usuario. Al TextBox número 3 le aplicamos la
propiedad ScrollBars a 2 – Vertical para que
cuando los valores
resultantes sobrepasen el tamaño del TextBox,
automáticamente aparezca una barra de desplazamiento. A
éste último TextBox también se le
aplicó la propiedad Locked y se le cambió a
True para el usuaria no pueda modificar los resultados que
aparecerán en este objeto.
El objeto CommandButton sufrió
modificación en la propiedad Caption para ponerle
el texto correspondiente según la acción
que se ejecutará al hacer clic sobre cada botón.
También le modificamos la propiedad Font para
personalizar la fuente del texto. Cambiamos la propiedad
Picture para poner una imagen como fondo del botón
y finalmente la propiedad Style a 1 –
Graphical para que el botón muestre la imagen de
fondo.
2.2. Código de la ventana
EVALUAR
2.2.1. Código para los objetos
Menu
El menú ha sido creado como una opción de
acceso fácil y rápido a todas las opciones que hay
en nuestra aplicación, pero el código es
exactamente el mismo que se le ha dado a los botones, por lo cual
lo explicaremos más adelante. La única
excepción es que en el menú Limpiar, se dan
las opciones extra de limpiar sólo el valor inicial,
sólo el valor final y sólo los resultados, a
diferencia del botón Limpiar, que limpia
automáticamente los tres TextBox.
2.2.2. Código para los objetos
TextBox
Primeramente encontramos el código del
objeto Text1, que tiene exáctamente el mismo
código que el objeto Text2. El código es el
siguiente:
Private Sub
Text1_KeyPress(KeyAscii As
Integer)
If KeyAscii < 48
Or KeyAscii > 57
Then
Beep
KeyAscii = 0
End If
End Sub
Explicación: El evento
que afectamos es el KeyPress, que se da cuando el usuario
presiona una tecla. El objetivo de este código es que en
el usuario no pueda introducir caracteres sino que solamente
números enteros entre el 0 y el 9. Para ello utilizamos el
Código ASCII, que es
el American Standard Code for Information Interchange o
Código Americano Estándar para Intercambio de
Información. En este código, los números de
0 a 255 representan letras, números, signos de
puntuación y otros caracteres. Los códigos en
ASCII para los números 0 a 9 en ASCII son
los siguientes:
El evento será que el usuario presionará
una tecla, y cuando eso suceda se tomará el el código
ASCII de la tecla que se ha presionado. Si el valor
numérico de dicho código es menor que 48 o mayor
que 57, significa que el caractar es diferente a 0, 1, 2, 3, 4,
5, 6, 7, 8 o 9. Eso correcpondería a una letra, un signo
de puntuación o algún otro caracter, pero como no
queremos que el TextBox permita dígitos diferentes
de valores
numéricos, decimos que si el valor numérico de
dicho código es menor que 48 o mayor que 57 entonces la
palabra Beep es el sonido que
indicará que no es un valor permitido y el código
ASCII de la tecla presionada por el usuario se
convertirá en cero, y el cero en KeyASCII es un
espacio en blanco.
2.2.3. Código para los objetos
CommandButton
2.2.3.1. Código para el botón
MOSTRAR PRIMOS (Command1)
Private Sub
Command1_Click()
If Text1.Text = ""
Then
MsgBox "Introduzca el valor inicial", 16, "Proyecto
Visual Basic"
Text1.SetFocus
Text3.Text = ""
Else
If Text2.Text = ""
Then
MsgBox "Introduzca el valor final"
Text2.SetFocus
Text3.Text = ""
Else
If Val(Text1.Text) >
Val(Text2.Text) Then
MsgBox "El valor final no puede ser menor que el valor
inicial", 16, "Proyecto Visual Basic"
Text2.SetFocus
Text2.Text = ""
Text3.Text = ""
Else
Text3.Text = ""
v_ini = Val(Text1.Text)
v_fin = Val(Text2.Text)
cad = ""
If v_ini = 0
Then 'Esta condición es para que no interprete el
0 como número
primo.
v_ini = 1
End If
For n1 = v_ini
To v_fin
contador1 = 0
primo1 = n1
For ciclo1 = 1
To primo1
residuo1 = primo1 Mod ciclo1
If residuo1 = 0
Then
contador1 = contador1 + 1
End If
Next ciclo1
If contador1 <= 2
Then
variable = primo1 'último primo del rango
End If
Next n1
v_fin = variable
For n = v_ini
To v_fin
contador = 0
primo = n
For ciclo = 1
To primo
residuo = primo Mod
ciclo
If residuo = 0
Then
contador = contador + 1
End If
Next ciclo
If contador <= 2
Then
If n = v_fin
Then
cad = cad & primo & "."
Else
cad = cad & primo & ", "
End If
End If
Next n
Text3.Text = cad
If Val(Text1.Text) <
0 Then
Text3.Text = ""
End If
If Val(Text2.Text) <=
0 Then
Text3.Text = ""
End If
If Val(Text3.Text) =
0 Then
Text3.Text = "No hay números primos en el
intervalo indicado."
End If
End If
End If
End If
End Sub
Explicación:
Primeramente si cuando el usuario haga clic sobre este
botón, solamente hay un espacio en blanco o no se ha
introducido ningún dato, se enviará un mensaje en
una ventana con el ícono de alerta, donde dirá
"Proyecto Visual Basic" en la barra de título y el mensaje
será: "Introduzca el valor inicial". El cursor
estará siempre en el primer TextBox. De lo contrario, si
el usuario introdujo el valor inicial, se irá a verificar
el mismo proceso con el valor final.
Si ya existe tanto el valor inicial como el valor final,
se procede a verificar que el valor inicial no sea mayor que el
valor final, de modo que si tenemos un valor inicial mayor que el
valor final aparecerá un mensaje que dirá: "El
valor final no puede ser menor que el valor inicial". El
cursór estará en el segundo TextBox y tanto el
segundo TextBox como el primero aparecerán en blanco.
Sólo se conservará el valor que se introdujo al
primer TextBox. De lo contrario, si el valor inicial y el valor
final tienen números válidos para determinar el
intervalo a evaluar, se procede a buscar los números
primos, lo cual se hará de esta forma:
El TextBox 3 estará totalmente en blanco al
inicio.
Se declaran las variables v_ini para el valor
inicial y v_fin para el valor final, que será el
intervalo a evaluar. Para presentar la respuesta utilizaremos una
concatenación, entonces lo que se mostrará al final
en el tercer TextBox será la variable cad, la cual
contendrá la suma todos los resultados que se vayan
obteniendo.
Ponemos la condición que si el valor inicial es
0, entonces que interprete ese cero como uno, porque de lo
contrario, con el proceso que se le dará para hayar
números primos, interpretaría el cero como un
número primo, lo cual no queremos que suceda.
Posteriormente haremos un ciclo que vaya desde el valor
inicial hasta el valor final, para que sólo evalúe
el intervalo dado por el usuario. Ese ciclo se almacenará
en una variable llamada n1. Ahora inicializamos una
variable que se llame contador1 con el valor de cero. Esa
variable la utilizaremos para que cuando se cumpla la
condición que daremos más adelante,
contador1 incremente en una unidad y al final de todo
determinaremos a partir del valor de contador1 si un
número es primo o no.
Luego inicializamos una variable que se llame
primo1 y que tenga el valor de n1, es decir del
ciclo previamente iniciado. La variable primo1 será
cada número que será evaluado para determinar si es
primo o no, e irá aumentando en uno hasta llegar al valor
final. Por ejemplo, si el intervalo es entre 7 y 11,
primo1 tomará el valor de 7, 8, 9, 10 y 11,
aumentando 1 en cada ciclo. Eso significa que cada número
del intervalo se examinará para saber si es o no un
número primo.
A continuación abriremos un ciclo anidado, es
decir un ciclo dentro de otro ciclo que ya había sido
abierto previamente. Este ciclo se asignará en la variable
ciclo1 e irá desde uno hasta primo1.
Recordemos que primo1 irá aumentando una unidad
cada final de ciclo hasta llegar al valor final.
Ahora abrimos dentro del ciclo interno (ciclo1)
una variable que se llame residuo1, la cual
contendrá el residuo de dividir la variable primo1
entre ciclo1. Recuérdese que primo1 es cada
número que se irá evaluando para determinar si es
un número primo o no, y ciclo1 es el divisor que
irá desde 1 hasta primo1, es decir que el
número que se evalúe será dividido por todos
los números enteros comprendidos desde uno hasta llegar a
él mismo.
Sabiendo que para determinar si un número es
primo la condición es que sea divisible únicamente
entre él mismo y la unidad, concluimos que sólo dos
residuos de cero debemos tener como máximo para que un
número sea primo. De lo contrario el número no
sería primo. Por tanto decirmos que si residuo1 = 0
entonces que contador1 = contador1 + 1. Si
contador1 llega a ser mayor que dos al final del ciclo, el
número no sería primo.
Cuando termina el ciclo para la variable ciclo1,
decimos que si contador1 es menor o igual a dos, entonces
una variable llamada variable tomará el valor de
primo1. Luego como se trata de un ciclo anidado, cuando
sale del ciclo más interno (es decir de ciclo1),
pasa al ciclo más externo (es decir n1).
Cuando llegue a la última iteración del
ciclo más externo, primo1 tendrá el valor
del último número primo existente en el rango
especificado. Entonces eso nos servirá para abrir otro
ciclo que haga exáctamente lo mismo con la
excepción que el valor final dejará de ser el valor
ingresado por el usuario y pasará a ser el valor de
primo1. Por ejemplo si el usuario determinó que el
intervalo fuera entre 7 y 12, al final primo1
tomará el valor de 11, que es el último
número primo que hay en el rango. Esto nos servirá
únicamente para que al concatenar en la variable
cad, podamos poner la condición que cuando el ciclo
esté en su último valor, que ya sería 11 en
este caso y no 12, que ponga un punto y no otra coma, porque si
no hiciéramos esto, con el valor inicial 7 y el valor
final 12 tendríamos lo siguiente:
7, 11,
Pero no queremos que después del 11 aparezca otra
coma, sino que queremos que aparezca un punto para indicar que el
11 es el último número primo que hay en el rango.
Es por ello que hacemos dos veces el proceso casi similar. La
primera vez es para encontrar el último número
primo existente el el rango y sabiendo eso, procedemos a hacer lo
mismo pero desde 7 a 11 y no desde 7 a 12, de manera que cuando
primo1 (osea el número que se está evaluando
para saber si es primo o no) sea 11, que aparezca la
condición que si primo1 = v_fin (y
v_fin estará valiendo lo que vale primo1),
entonces que en la concatenación le sume al final un punto
y no otra coma.
El código hubiera resultado mucho más
corto y más simple si no nos hubiera importado que
aparezca una coma después del último número
primo encontrado, pero para que la presentación sea la
mejor y para que no haya ninguna confusión de pensar que
la coma significa que hay más números pendientes,
se ha trabajado más pero se ha logrado lo que
deseamos.
Luego de eso, es decir sabiendo cuál es el
último número primo del intervalo, decimos que
v_fin va a ser igual a variable, y anteriormente
habíamos dicho que variable tomaría el valor
del último número primo del intervalo, es decir de
primo1.
Ahora comenzamos un ciclo en la variable n que
vaya desde el valor inicial o v_ini hasta el valor final o
v_fin, pero téngase en cuenta que v_fin o el
valor final ya no tiene el valor que el usuario le dio, sino que
tiene el valor del último número primo del
intervalo, lo cual como ya se explicó nos es útil
únicamente para que en el cuadro de resultados nos
aparezca al final un punto y no otra coma.
Luego de esto el código es exáctamente el
mismo que el que se hizo al principio para determinar los
números primos existentes en el intervalo, con la
diferencia que las variables ya no tendrán en 1 al
final, sino que tendrán el mismo nombre pero sin el
1 al final.
Esto es para que las variables comiencen con nuevos
valores y no conserven los valores de los ciclos anteriores, lo
cual arruinaría por completo el código. Otra de las
diferencias de esta última parte del código es que
cuando llegue al momento de determinar si un número es
primo o no, en caso que sea primo, no simplemente se
escribirá el número primo, porque de ser
así, cuando terminen todos los ciclos y llegue al final
del código, lo único que imprimiría en el
TextBox de los resultados sería el último valor que
tomó la variable que almacena el número primo, de
modo que en el intervalo de 7 a 12, sólo imprimiría
11, pues es el último valor que tuvo la variable que
almacena el número primo (primo1 en el proceso que
explicamos).
Entonces lo que se pretende es que imprima el 11 pero
que no pierda todos los primos que ha venido encontrando, para lo
cual usaremos la herramienta de la concatenación, de esta
forma: cuando el código encuentre un número primo,
la variable cad será igual a cad (que
inicialmente vale un espacio en blanco) más el primer
número primo encontrado (que sería la variable
donde se almacena dicho número) más una coma para
separar un primo del otro, o un punto si se trata del
último número primo del intervalo. Cuando llegue a
la segunda iteración, la variable cad ya no
valdrá un espacio en blanco sino que valdrá el
primer número primo y una coma, y así
sucesivamente. Ilustremos lo que sucedería para el ejemplo
de un intervalo entre 7 y 12:
Primera iteración:
cad = cad & primo & ",
"
Es decir:
cad = espacio en blanco + 7 + una coma
ortográfica y un espacio para que el siguiente
número primo no quede justo a la par de la coma, aunque
este último espacio es opcional y sólo por estética. Es decir que cad
valdría "7, "
Segunda iteración:
El ocho no es primo, pasaríamos a la siguiente
iteración.
Tercera iteración:
El nueve no es primo, pasaríamos a la siguiente
iteración.
Cuarta iteración:
El diez no es primo, pasaríamos a la siguiente
iteración.
Quinta iteración:
cad = cad & primo &
"."
Es decir:
cad = 7, " + 11 + un punto ortográfico.
Punto porque ya sería la última iteración,
osea que llegamos al último valor del ciclo. Es decir que
cad valdría "7, 11."
Ahora bien, puede darse un caso y es que no haya
ningún número primo en un intervalo indicado por el
usuario. Por ejemplo si el valor inicial fuera 8 y el valor final
fuera 10, no existe ningún número primo, entonces
cuando terminan los ciclos para encontrar números primos,
agregamos una parte de código que si el valor del tercer
TextBox es 0, es decir que no hay ningún número
primo, entonces que en ese TextBox muestre el siguiente mensaje:
"No hay número primos en el intervalo
indicado."
Es así como termina el código para este
botón.
2.2.3.2. Código para el botón SUMAR
PRIMOS (Command2)
Private Sub
Command2_Click()
If Text1.Text = ""
Then
MsgBox "Introduzca el valor inicial", 16, "Proyecto
Visual Basic"
Text1.SetFocus
Text3.Text = ""
Else
If Text2.Text = ""
Then
MsgBox "Introduzca el valor final"
Text2.SetFocus
Text3.Text = ""
Else
If Val(Text1.Text) >
Val(Text2.Text) Then
MsgBox "El valor final no puede ser menor que el valor
inicial", 16, "Proyecto Visual Basic"
Text2.SetFocus
Text2.Text = ""
Text3.Text = ""
Else
v_ini = Val(Text1.Text)
v_fin = Val(Text2.Text)
contadorsuma = 0
For n = v_ini
To v_fin
contador = 0
x = n
For ciclo = 1
To x
residuo = x Mod
ciclo
If residuo = 0
Then
contador = contador + 1
End If
Next ciclo
If contador <= 2
Then
contadorsuma = contadorsuma + x
End If
Next n
If contadorsuma = 0
Then
Text3.Text = "No hay números primos en el
intervalo indicado y por lo tanto no se puede realizar una
suma."
Else
Text3.Text = contadorsuma & "."
End If
End If
End If
End If
End Sub
Explicación: Si el usuario no
introduce un valor inicial, si no introduce un valor final o si
el valor inicial es mayor que el valor final, entonces
aparecerá una ventana indicando el error y ubicando el
cursor en el lugar correspondiente para que el usuario introduzca
un valor válido.
v_ini y v_fin serán el valor
inicial y el valor final determinados por el usuario desde el
teclado. Una
variable llamada contadorsuma será inicializada con
el valor de cero y nos servirá para sumar todos los primos
que hay en el intervalo en el que se está
trabajando.
Como en el caso de encontrar primos, trabajamos
nuevamente con ciclos anidados, es decir uno dentro de otro. El
ciclo más externo nos sirve para que evalúe todos
los números enteros que existen en el intervalo indicado,
y el ciclo más interno sirve para determinar si el
número que se está evaluando es primo o no. Por
ejemplo en en intervalo de 8 a 10 tendríamos:
El ciclo más externo sirve para que en la primera
iteración evalúe el 8, en la segunda
iteración el 9 y en la tercera iteración el 10. El
ciclo más interno sirve para que en determine si el 8, el
9 y el 10 son números primos.
Hay un detalle muy importante que hemos tomado en cuenta
en este código y es que en el ciclo más externo no
simplemente va ascendiendo un número para ir evaluando
todos los valores enteros del intervalo, sino que se hace algo
más, y es que partiendo si al evaluar un número con
el ciclo más interno determinamos que es primo, el ciclo
más externo no simplemente se quedará con eso sino
que hará algo que viene a ser la médula de todo en
este problema, pues lo que necesitamos es sumar los
números primos existentes en el intervalo dado.
Entonces lo que hacemos es que la variable
contadorsuma, que inicialmente valía cero, le
sumamos el valor de contadorsuma + x, y la variable
x será un número que con el código
hemos determinado que es primo. En cada iteración en la
que encuentre un número primo, el valor de
contadorsuma cambiará, pues se le habrá
sumado el número primo anterior y así sucesivamente
hasta llegar al último número primo del intervalo,
de modo que al finalizar, en la variable contadorsuma
tendremos la suma de todos los números primos que hay en
el intervalo que el usuario indicó.
Si al finalizar los ciclos contadorsuma es igual
a 0, significa que la variable x nunca fue un
número positivo o que no existe ningún
número positivo en el intervalo, y como
contadorsuma fue inicializado con el valor de 0, entonces
al final sigue valiendo 0. Por lo tanto si eso fuera así
mostraremos un mensaje en el tercer TextBox, el cual dirá:
"No hay números primos en el intervalo indicado y por lo
tanto no se puede realizar una suma." De lo contrario, si
contadorsuma no fuera cero, entonces el resultado
será contadorsuma + un punto
ortográfico.
2.2.3.3. Código para el botón
MOSTRAR PRIMOS GEMELOS (Command3)
Private Sub
Command3_Click()
If Text1.Text = ""
Then
MsgBox "Introduzca el valor inicial", 16, "Proyecto
Visual Basic"
Text1.SetFocus
Text3.Text = ""
Else
If Text2.Text = ""
Then
MsgBox "Introduzca el valor final", 16, "Proyecto Visual
Basic"
Text2.SetFocus
Text3.Text = ""
Else
If Val(Text1.Text) >
Val(Text2.Text) Then
MsgBox "El valor final no puede ser mayor que el valor
inicial", 32, "Proyecto Visual Basic"
Text2.SetFocus
Text2.Text = ""
Text3.Text = ""
Else
Text3.Text = ""
v_ini = Val(Text1.Text)
v_fin = Val(Text2.Text)
If v_ini = 0
Then 'Esta
condición es para que no interprete el 0 como
número primo.
v_ini = 1
End If
cad = ""
For n7 = v_ini
To v_fin
contador7 = 0
primo7 = n7
For ciclo7 = 1
To primo7
residuo7 = primo7 Mod ciclo7
If residuo7 = 0
Then
contador7 = contador7 + 1
End If
Next ciclo7
If contador7 <= 2
Then
prueba7 = primo7 + 2
c7 = 0
For n17 = 1
To prueba7
residuo17 = prueba7 Mod n17
If residuo17 = 0
Then
c7 = c7 + 1
End If
Next n17
If c7 <= 2
Then
If prueba7 <=
v_fin Then
variable = prueba7
End If
End If
End If
Next n7
v_fin = variable
For n = v_ini
To v_fin 'Teniendo el
último primo gemelo en la variable n7, el ciclo se hace
haste ese número ahora, todo para que aparezca punto al
final, y no coma.
contador = 0
primo = n
For ciclo = 1
To primo
residuo = primo Mod
ciclo
If residuo = 0
Then
contador = contador + 1
End If
Next ciclo
If contador <= 2
Then
prueba = primo + 2
c = 0
For n1 = 1
To prueba
residuo1 = prueba Mod n1
If residuo1 = 0
Then
c = c + 1
End If
Next n1
If c <= 2
Then
If prueba <=
v_fin Then
If prueba = v_fin
Then
cad = cad & "(" & primo & "," & prueba
& ")" & "."
Text3.Text = cad
Else
cad = cad & "(" & primo & "," & prueba
& ")" & ", " 'Entre 1 y 13,
primo sería el primo gemelo 11 y prueba sería el
primo gemelo 13.
Text3.Text = cad
End If
End If
End If
End If
Next n
If Text3.Text = ""
Then
Text3.Text = "No hay números primos gemelos en el
intervalo indicado."
End If
If Val(Text1.Text) <
0 Then
Text3.Text = ""
End If
If Val(Text2.Text) <=
0 Then
Text3.Text = ""
End If
If Val(Text1.Text) =
0 And Val(Text2.Text) =
0 Then
Text3.Text = "No hay números primos gemelos en el
intervalo indicado."
End If
End If
End If
End If
End Sub
Explicación: Este código es
muy similar al que utilizamos para encontrar los números
primos existentes en un intervalo pero presenta la
excepción que al encontrar un número primo, no lo
presenta inmediatamente como número primo sino que procede
a evaluar al número que está dos unidades adelante
del primo encontrado y en caso que ese también sea primo
entonces ya se tiene una pareja de primos gemelos.
Hay también un detalle muy importante que se debe
tomar en cuenta y que aunque ya se mencionó anteriormente
en este trabajo, vale la pena hacerlo ver nuevamente:
Se debe controlar que no se tome una pareja donde uno de
los números de la pareja esté fuera del intervalo
especificado. Por ejemplo, si el usuario determina un intervalo
entre 0 y 11, la pareja de primos gemelos (11,13) no debe
aparecer porque el 13 se sale del intervalo.
Por ello en el código encontramos la
condición que si la variable prueba es menor o
igual que v_fin, entonces que afecte la variable
cad de la respuesta, pues en la variable prueba se
almacenaría el número primo gemelo mayor. Para
comprenderlo mejor veamos un ejemplo claro:
La variable primo junto a la variable
prueba determinarán la pareja de primos gemelos. En
el caso de la pareja de primos gemelos (11,13), el 11 se
almacenará en la variable primo y el 13 en la
variable prueba. Lo único que faltará es que
antes de la variable primo aparezca un paréntesis
de inicio, que después de la variable primo
aparezca una coma, que después de la coma aparezca la
variable prueba, que después de la variable prueba
aparezca un paréntesis de cierre y que después del
paréntesis de cierre aparezca una coma en caso que haya
otra pareja de números primos gemelos en el intervalo o un
punto si se trata de la última pareja de primos gemelos
existente en el intervalo.
Eso se controlará mediante concatenación
con la variable cad y usando el proceso que ya se
explicó en el botón MOSTRAR PRIMOS.
Entonces el método utilizado en el código
para determinar los números primos es básicamente
encontrar un número primo y sumarle dos unidades, luego
ese nuevo valor que resulta de haber sumado dos unidades al
número primo que se había encontrado, tiene que
evaluarse individualmente para determinar si es primo
también. En caso de ser esto cierto, concluimos que se
trata de una pareja de números primos gemelos. Si no
existiera ningún número primo gemelo en el
intervalo indicado, en el cuadro de resultados se presenta el
mensaje: "NO hay números primos gemelos en el intervalo
indicado."
2.2.3.4. Código para el botón
LIMPIAR (Command4)
Private Sub
Command4_Click()
Text1.Text = ""
Text2.Text = ""
Text3.Text = ""
Text1.SetFocus
End Sub
Explicación: Al hacer
clic sobre este botón se borrarán todos los valores
que contenta el primero, segundo y tercer TextBox, y el cursor
aparecerá en el primer TextBox para que el usuario
comience a introducir nuevos valores.
2.2.3.5. Código para el botón AYUDA
(Command5)
Private Sub
Command5_Click()
Form1.Hide
Form4.Show
End Sub
Explicación: Al hacer
clic sobre este botón se ocultará la ventana de
evaluar números primos y aparecerá una ventana de
ayuda, que es por supuesto otro formulario. Como vemos el
código es de solamente dos líneas.
2.2.3.6. Código para el botón SALIR
(Command6)
Private Sub
Command6_Click()
mensaje = MsgBox("¿Desea salir del programa?",
vbYesNo, "Cerrando…")
If mensaje = 6
Then
Form3.Show
Form1.Hide
End If
End Sub
Explicación: en la
variable mensaje se almacena el MsgBox o el cuadro o
ventana de mensaje, que contendrá dos botones: SI y NO. Si
el usuario hace clic en el botón sí, la variable
mensaje tendrá el valor numérico de 6.
Entonces si la variable mensaje tiene el valor
numérico de 6, entonces se ocultará el formulario 1
o la ventana de evaluación y se mostrará el
formulario 3 o la ventana de salida.
3.1. Propiedades de los objetos de la ventana
AYUDA
Para el diseño de este formulario utilizamos los
siguientes objetos:
- Form
- Image
- Label
- CommandButton
El objeto inicial que utilizamos fue un Form o
formulario, en el cual ubicamos todos los controles de esta
ventana. La propiedad que se modificó para el formulario
fue Caption, con lo cual se escribió el
título de la barra de título.
El objeto Image fue utilizado para colocar una
imagen como fondo del formulario. La propiedad que le modificamos
a este objeto fue Picture, con la cual insertamos una
imagen dentro del formulario.
Los Label se han utilizado para mostrar la
información de texto. La propiedad Alignment fue
cambiada únicamente en el primer Label a 2
– Center para que ubique el título centrado en
la pantalla. Todos los demás permanecieron alineados a la
izquierda. A los Label se les modificó la propiedad
Caption para introducir nuestro texto personalizado.
Igualmente modificamos la propiedad Font para cambiar el
tamaño, estilo y tipo de letra, así como para
subrayar algunos textos. El tipo de letra que usamos es Trebuchet
MS, el tamaño 20 para el primer Label y 14 para
todos los demás y el estilo Negrita cursiva y subrayado
para el primer Label, subrayado para los Label de
título y Normal todos los demás Label que
tienen los conceptos o explicaciones. Otra propiedad que fue
modificada es ForeColor, con la cual cambiamos el color de
la fuente a blanco porque utilizamos un fondo oscuro en nuestro
formulario. El objeto CommandButton sufrió
modificación en la propiedad Caption para ponerle
el texto "Regresar". También le modificamos la propiedad
Font para personalizar la fuente del texto. Cambiamos la
propiedad Picture para poner una imagen como fondo del
botón y finalmente la propiedad Style a 1
– Graphical para que el botón muestre la imagen
de fondo.
3.2. Código de la ventana
AYUDA
En la ventana de código, el único objeto
que fue codificado es el Command1. El código es el
siguiente:
Private Sub
Command4_Click()
Form4.Hide
Form1.Show
End Sub
Explicación: Cuando el
usuario haga clic sobre esto botón, se ocultará el
Formulario 4, que es la ventana de ayuda o la ventana activa al
momento del evento clic y aparecerá o se mostrará
el Formulario 1, que es el formulario o ventana de
evaluación de números primos. Es decir que
regresará a la ventana de trabajo y ocultará la
ventana de ayuda.
4.1. Propiedades de los objetos de la ventana
SALIDA
Para el diseño de este formulario utilizamos los
siguientes objetos:
- Form
- Image
- Label
- Timer
El objeto inicial que utilizamos fue un Form o
formulario, en el cual ubicamos todos los controles de esta
ventana. La propiedad que se modificó para el formulario
fue Caption, con lo cual se escribió el
título de la barra de título.
El objeto Image fue utilizado para colocar una
imagen como fondo del formulario. La propiedad que le modificamos
a este objeto fue Picture, con la cual insertamos una
imagen dentro del formulario.
El Label se ha utilizado para mostrar la
información de texto. La propiedad Alignment fue
cambiada en Label a 2 – Center para que
ubique el título centrado en la pantalla. Al Label
se le modificó la propiedad Caption para introducir
nuestro texto personalizado. Igualmente modificamos la propiedad
Font para cambiar el tamaño, estilo y tipo de
letra. El tipo de letra que usamos es Trebuchet MS, el
tamaño 36 y el estilo Negrita cursiva.
Otra propiedad que fue modificada es ForeColor,
con la cual cambiamos el color de la fuente a blanco porque
utilizamos un fondo oscuro en nuestro formulario.
Finalmente insertamos dos Timer para crear unos
efectos con los Label y cerrar así nuestro programa
sin que el usuario haga clic ni ejecute ninguna acción,
pues previamente había sido consultado a través de
un mensaje (MsgBox) sobre si deseaba salir del programa, y si
hizo clic en sí, llegaremos a esta ventana de salida donde
el usuario no ejecutará ninguna acción. Esta
ventana no tiene una funcionalidad necesaria ni indispensable
para que el programa trabaje, pues bien podría ser omitida
y el programa simplemente se cerraría sin mostrar esta
última ventana.
El propósito y utilidad de esta ventana es para
darle una apariencia agradable y mayor estética o
vistosidad a nuestra aplicación, de modo que no
simplemente cierra el programa sino que manda dos mensajes que
indican que se está saliendo del programa y cerrando la
aplicación.
La única propiedad que se modificó en el
primer Timer fue Interval, a la cual se le dio un
valor de 2000, y al Timer número 2 también
se le cambió solamente esa propiedad y se le dio el valor
de 4000. Más adelante explicaremos por qué se les
dieron esos valores.
4.2. Código de la ventana
SALIDA
En la ventana de código, hemos codificado
únicamente dos objetos, y son precisamente los dos
Timer.
4.2.1. Código para el objeto
Timer1
El código para el primer Timer o
Timer1 es el siguiente:
Private Sub
Timer1_Timer()
Label1.Caption = "Cerrando…"
End Sub
Explicación: La propiedad
Interval de un un objeto Timer está dada en
milisegundos, es decir un segundo dividido entre mil o una
milésima de segundo. Esto significa que si a la propiedad
Interval le damos el valor de 500, significa la mitad de
un segundo, si le damos el valor de 1000, significa un segundo,
si le damos el valor de 2000, dos segundos, 4000 serían
cuatro segundos y así sucesivamente.
Ese tiempo comenzará a contarse desde que
aparezca la ventana SALIDA o desde que esta comience a ser la
ventana activa. Hemos programado para el primer Timer la
propiedad Interval con el valor de 2000, lo cual significa
dos segundos. Cuando se cumplan esos dos segundos,
ejecutará lo que le hemos programado: Label1.Caption =
"Cerrando…"
Sabemos que el texto inicial en el Label1 era
"Saliendo del programa…", pero al pasar dos segundos ese texto
será sustituido por el nuevo texto que será
"Cerrando…", y conservará las propiedades de color, tipo
de letra, estilo y tamaño del texto anterior, pues el
mensaje está siempre ubicado en el Label1, al cual
se le han asignado propiedades específicas de formato de
fuente.
El trabajo del Timer1 termina con sustituir el
mensaje "Saliendo del programa…" por el mensaje "Cerrando…"
cuando hayan pasado dos segundos.
4.2.2. Código para el objeto
Timer2
Private Sub
Timer2_Timer()
End
End Sub
Explicación: A
diferencia del Timer1, el Timer2 no
modificará el texto del Label1 ni hará nada
más que dar la orden para salir de la aplicación o
que se cierre completamente el programa. A la propiedad
Interval de este Timer se le ha dado el valor de
4000, es decir que el código se ejecutará cuando
hayan pasado cuatro segundos. Lo único que dice el
código es "End", que quiere decir Fin o que
finalice el programa. Significa entonces que cuando hayan pasado
4 segundos automáticamente se cerrará el programa
sin que el usuario ejecute ninguna acción.
Al poner en conjunto el la acción del
Timer1 con la acción del Timer2 tendremos el
efecto que al iniciar la ventana SALIDA, aparecerá el
mensaje "Saliendo del programa…", después de dos
segundos ese mensaje será sustituido por el mensaje
"Cerrando…", y cuando hayan pasado cuatro segundos desde el
momento en que la ventana salida llegó a estar activa, la
instrucción End hará que el programa se
cierre.
Hemos concluido de esta manera nuestro proyecto luego de
haber aprendido y adquirido nuevas experiencias en el manejo del
lenguaje de programación Visual Basic 6.0.
Como grupo pudimos
experimentar cada paso del proceso que toma crear una
aplicación completa en Visual Basic. Nos dimos cuenta que
esto requiere tiempo, mucho trabajo y análisis sobre lo que se está
haciendo, así como dedicación y mucha
concentración.
Hemos tratado de explicar todo paso a paso y de la forma
más clara posible de manera que el lector comprenda muy
fácilmente la estructura y forma en la que trabaja el
código.
De la misma forma el trabajo ha
sido ordenado de tal manera que los temas se encuentren en orden
de acuerdo a cada ventana y cada control u objeto
de la aplicación.
Como grupo de trabajo nos sentimos satisfechos ya que
creemos que hemos alcanzado los objetivos que nos trabamos, ya
que desarrollamos exitosamente el proyecto que inicialmente era
un plan o un problema que debíamos resolver o dar una
solución mediante la programación y las herramientas
que nos proporciona Visual Basic 6.0.
También aprendimos a identificar errores en
nuestro código, pues es totalmente cierto que las cosas no
nos salieron como queríamos al primer intento, sino que
por el contrario, al principio encontrábamos más
problemas que soluciones y
con paciencia y mucha dedicación logramos ir depurando y
quitando cada error hasta perfeccionar nuestro programa o
aplicación y presentar nuestro trabajo completo y
exitosamente terminado.
Esperamos que este proyecto sea de gran utilidad y que
ayude a otros a comprender mejor a través del
código y las explicaciones paso a paso que aquí se
presentan, sobre la forma de desarrollar programas en
Visual Basic. Creemos que a través de las explicaciones
detalladas de nuestro programa, este trabajo puede servir como un
modelo
útil para ver claramente todo el proceso desde el
principio hasta el fin para desarrollar una aplicación en
el lenguaje Visual Basic 6.0.
Igualmente si surgen más preguntas sobre nuestro
proyecto que no hayan sido descritas en este trabajo,
complementaremos este reporte con una explicación oral del
funcionamiento, diseño y estructura de nuestro
programa.
- Stewart, James. Redlin, Lothar. Watson, Saleem.
2001. Precálculo. Tercera Edición. Páginas 122-124.
International Thomson Editores. México. - García de Jalón, Javier.
Rodríguez, José Ignacio. Brazález,
Alfonso. 1999. Aprenda Visual Basic 6.0 como si estuviera en
primero. Escuela
Superior de Ingenieros Industriales de San Sebastián.
Universidad de Navarra. España. - Matta Gonzales, Danny A. Fundamentos de
Programación en Visual Basic. - Rodríguez Bucarelly, Carlos M.
Rodríguez Bucarelly, Pablo A. 2004. Visual Basic 6.0.
Programación Orientada a Objetos.
Desarrollando Grupo Experto Bucarelly. Twinsmaster Soft
Corporation ã
1998-2004. - MSDN Library Visual Studio 6.0. Microsoft
Corporation.
Jennifer Esmeralda Chacón
Carranza
Glenda Maritza España Canalez
Jaime Oswaldo Montoya Guzmán
UNIVERSIDAD CATÓLICA DE OCCIDENTE
FACULTAD DE INGENIERÍA Y ARQUITECTURA
PROGRAMACIÓN I
noviembre de 2005