- 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