Fibonacci recursivo - Mala idea

Algoritmos Computacionales 

Ya sabemos que hacer Fibonacci en lenguaje C esta muy repetitivo, pero ahora vengo a intentar mostrarles el porque es muy mala idea querer hacer la serie en forma recursiva.

En la siguiente imagen muestro el código para la serie de Fibonacci en forma recursiva. Lo que he agregado es un contador dentro de la función "fibo" para conocer al final cuantas veces se manda a llamar y así tener un punto de comparación con la forma iterativa.

También en la forma iterativa agregue un contador, que en realidad no se necesitaba por el hecho de ser iterativo, pero lo pongo al igual que en recursivo para conocer las veces que se repite el proceso.

Los resultados son los siguientes:

Tenemos que Fibonacci recursivo con una instancia de 40, el contador nos da como resultado 331160281, esto quiere decir que se hace tal cantidad de llamadas.

En cambio con forma iterativa:

Tenemos que solamente se repite el proceso 39 veces para una instancia de 40.

Para esta demostración tomamos la instancia como la cantidad de números de la serie de Fibonacci que se desean obtener.

En cuanto a tiempo de ejecución también nos da en la forma recursiva, un tiempo mayor, esto se podría verificar colocando un contador de tiempo.

Conclusión:
Es muy mala idea hacer la serie de Fibonacci con fines prácticos.

Análisis asintótico

Algoritmos Computacionales 

Suponiendo que las siguientes funciones indican la complejidad asintótica de algunos algoritmos para resolver un problema, se tienen que ordenar en orden del peor algoritmo al mejor, donde el mejor sería aquél que tarde menos en resolver el problema.

En la imagen se muestran las ocho funciones a ordenar:

Tenemos que:

I. La función que implica mayor comlejidad es f2, porque al elevar una variable a una potencia igual a sí misma, incrementará rápidamente.

II. Parecido al caso anterior pero con la diferencia de que en la base tenemos una constante, tenemos que f1 es la que sigue a esta lista.

III. Ahora tenemos una base a la n elevada a la siete, esto nos daría en una gráfica que se encuentra más abajo de las dos anteriores esta es f3.

IV. Ahora tenemos una logarítmica un tanto engañosa f4, que sabemos de antemano que es mayor a f6 por el hecho de tener una n multiplicando al logaritmo.

V. Si aplicamos propiedades de los logaritmos y simplificamos, tenemos que f7 es la siguiente en nuestra escala.

VI. Una variable multiplicada a una constante grande f8, es menor a la constante elevada al logaritmo.

VII. Ya casi por terminar tenemos f5, porque una raíz es de los mejores casos que se puede tener.

VIII. Por regla vimos que f6, una función logarítmica es mejor a una polinomial.

Este orden lo obtuvimos en colaboración con todos los alumnos de la clase.

Gráfica aplicando escala logarítmica

Algoritmos Computacionales 

En una de nuestras primeras sesiones vimos lo que pasa cuando tenemos diferentes funciones y como se ven graficadas.

Esta es la tabla con datos y cada columna una función diferente.

Al graficar tenemos que aplicar la escala logaritmica para lograr observar como se disparan las líneas de la función exponencial.

Lista enlazada simple

Algoritmos Computacionales 
Tarea 4 

Vídeo incrustado hablando de listas enlazadas simples y muestra de un ejemplo desde terminal.





El vídeo original dura aproximadamente 4 minutos, por más que intente Mencoder no convertía como debería.

Problema de las 8 reinas

Algoritmos Computacionales 
Tarea 3 

Esta tarea corresponde al tema de algoritmos recursivos. El trabajo a entregar es una presentación en diapositivas.

Problema de las 8 reinas

Ver más presentaciones de Esteban González.

Esta animación muestra todos los cambios que se hacen al resolver por recursión el problema de las ocho reinas. Lo pongo aquí porque en la presentación no se pueden ver los cambios.





Obtenido de Wikipedia.

Problema de Clique

Algoritmos Computacionales 
Tarea 2 

En complejidad computacional, el problema de la Clique o Problema de la liga de amigos, es un problema NP-completo según la Teoría de la complejidad computacional.

Problema

EL problema de clique es el siguiente:
Dado un grafo no dirigido G, y un número natural k, determinar si G posee un clique de tamaño k.

De nuevo:
Dado un grafo no dirigido cualquiera G= (V,E), en el cual V={1,2,…,n} es el conjunto
de los vértices del grafo y E es el conjunto de aristas. Un clique es un conjunto C de
vértices donde todo par de vértices de C esta conectado con una arista en G, es decir C
es un subgrafo completo.

Este problema se puede enunciar como un problema de decisión si la pregunta que se hace es saber si existe una clique de tamaño k en el grafo.

El correspondiente problema de optimización, consiste en encontrar una clique de tamaño máximo en un grafo.

Una vez que tenemos k o más vertices que forman una clique, es trivial verificar que lo son, por eso es un problema NP.

¿Qué es un clique?

El término proviene de la palabra inglesa clique, que define a un grupo de personas que comparten intereses en común.

En esta analogía, las personas serían los vértices y los intereses en común, las aristas. Cuando todas compartan un mismo interés, forman un grafo completo, es decir, forman un clique.

Un clique en un grafo no dirigido G es un conjunto de vértices V, tal que para todo par de vértices de V, existe una arista que las conecta, donde el tamaño de un clique es el número de vértices que contiene.

Ejemplo

El grafo G:
Tiene cliques {1,2,5} y {1,4,5} de tamaño 3.
Tiene cliques {2,3} y {3,4} de tamaño 2.

Aplicaciones al mundo real

Link Farm
Una granja de enlaces es un grupo de sitios web que enlazan a todos los sitios de un grupo entre sí. Esto es una forma de spamming para los indices de un motor de búsqueda.

Los motores de búsqueda necesitan una forma para encontrar la relevancia de una página. Un método para encontrarla es examinando todos los enlaces provenientes de páginas relevantes.

En otras palabras, crear una granja de enlaces tenía el propósito de incrementar la relevancia de un sitio web para aparecer en los primeros lugares de búsqueda. Para ello se creaban páginas que enlazaran unas a otras conteniendo los enlaces hacia aquellos sitios a los que se les deseaba dar popularidad.

Segmentación de imágenes y reconocimiento de patrones
Un problema muy común en computación gráfica es el de encontrar patrones dentro de una imagen. Hay una gran cantidad de problemas que entran dentro de esta categoría desde reconocimiento de bordes hasta búsqueda de figuras geométricas.

Un problema particular que se puede resolver utilizando una variación de Clique Máxima es la de reconocimiento de segmentos o regiones. Una región en una imagen es un conjunto de pixeles que comparten alguna característica.

Cálculo de probabilidades condicionales
El algoritmo general más común en redes bayesianas es el de agrupamiento "árbol cliques". El método de agrupamiento consiste en transformar la estructura de la red para obtener un árbol, mediante agrupación de nodos. Para ello, se hace una transformación de la red a un árbol de cliques máximas.

Biología
En el desarrollo evolutivo, una de las maneras de reconocer muchos de los procesos es mirar la expresión de genes en términos de las redes de la expresión de genes, que son los grafos. Los sistemas de regulación a menudo se revela como cliques en la red de expresión.

Al estudiar las estructuras de proteínas, una de las técnicas más importantes es analizar las proteínas similares, y encontrar cliques en común para las redes estructurales basados ​​en grafos de las proteínas.

Algoritmos para resolver este problema

Algoritmo de fuerza bruta
Un ejemplo de algoritmo de fuerza bruta para encontrar una clique en un grafo consiste en listar todos los subconjuntos de vértices V y verificar para cada uno de ellos si forma una clique.

Ese algoritmo es polinómico si k es una constante, pero como no lo es para este caso, tenemos un exponencial de n^k.

Algoritmo Bron-Kerbosch
Este algoritmo consiste en arrancar con cliques de un solo elemento e intentar mezclar cliques para obtener otras más grandes, hasta que no queden más mezclas por intentarse. Dos cliques pueden ser mezcladas si cada nodo de la primera es adyacente a cada nodo de la segunda.

Es eficiente en el peor de los casos por un resultado de Moon and Moser, donde un grafo de n vértices tiene a lo sumo 3^(n/3) cliques máximos, y el tiempo de ejecución del peor caso del algoritmo Bron-Kerbosch, con una estrategia dinámica que reduce al mínimo el número de llamadas recursivas realizadas en cada paso, es O(3^(n/3)), que coincidan con este límite.

Para estos dos algoritmos es fácil saber cuál es mejor que el otro. Tenemos que:
- El mejor es Bron-Kerbosch.
- El peor es Fuerza bruta.

En el siguiente pdf encontramos la reducción SAT para el problema de clique:
Time reduction

Bibliografía:
Problema de Clique Máximo
Clasificación de problemas
Clique problem - Wikipedia
Problema de la clique - Wikipedia
Complejidad computacional
Cliques and a bit of biology

Algoritmo de Prim

Algoritmos Computacionales 
Tarea 1 

El Algoritmo de Prim es de los más conocidos en la teoría de grafos cuyo principal objetivo consiste en encontrar el árbol de expansión mínima en un cierto grafo, que debe ser conexo, no dirigido y cuyas aristas están etiquetadas.

Pero para entender esto, veamos que son estos conceptos:

Grafo - Se define como un conjunto de objetos llamados vértices o nodos y la unión de pares de vértices por líneas llamadas aristas, que pueden ser orientadas o no. Orientadas quiere decir si se indica la dirección en que se puede mover de vértice a vértice.

Conexo - Quiere decir que todos los pares de vértices deben de estar unidos por un camino o arista.

No dirigido - Es decir, que no se indica hacia dónde se mueve.

Aristas etiquetadas - Que nos indiquen un peso, cuota o distancia entre vértices.

Sin embargo este no es el único algoritmo que existe para encontrar el árbol de expansión mínima, ya que existe otro como lo es el:

• Algoritmo de Kruskal

Ejemplo de grafo conexo, no dirigido y con aristas etiquetadas

Cada punto negro es un vértice o nodo, y se le suele asignar una letra para hacer referencia a cada uno. También es posible encontrar grafos donde sus vértices se indican con números, esto no afecta en nada.

"Sea V el conjunto de nodos de un grafo pesado no dirigido. El algoritmo de Prim comienza cuando se asigna a un conjunto U de nodos un nodo inicial perteneciente a V, en el cual crece un árbol de expansión, arista por arista. En cada paso se localiza la arista más corta (u,v) que conecta a U con V-U, y después se agrega v, el vértice en V-U, a U. Este paso se repite hasta que V=U. El algoritmo de Prim es de O(N^2), donde |V| = N."

En otras palabras:

"Este algoritmo construye un árbol agregando aristas de manera iterativa hasta que se obtiene un árbol de expansión mínima. El algoritmo comienza con un solo vértice. Después, en cada iteración, agrega al árbol actual una arista de peso mínimo que no completa un ciclo."

Aplicaciones en la vida real

Este algoritmo puede ser utilizado en muchos campos como lo son las carreteras, vías férreas, aéreas o marítimas. También en redes eléctricas o de telefonía.

Actualmente empresas con servicios de cable e internet que necesitan expandirse lo más posible por toda una ciudad, hacen uso de estos algoritmos para seleccionar las rutas cuyos caminos sean los mas cortos y que generen un ahorro en el uso de cable como la fibra óptica.

En este caso el resultado de encontrar el camino de mínima expansión sería el siguiente:

Un ejemplo simple imaginable sería el querer viajar en auto por carretera a ciertas ciudades y buscar los caminos que generan distancias más cortas entre ciudades, en el menor tiempo posible o viajando la mínima cantidad de horas.

Ejemplo de ejecución

Obtenido de Wikipedia, al final se encuentra el enlace.

Image	Descripción	No visto	En el grafo	En el árbol
	Este es el grafo ponderado de partida. No es un árbol ya que requiere que no haya ciclos y en este grafo los hay. Los números cerca de las aristas indican el peso. Ninguna de las aristas está marcada, y el vértice D ha sido elegido arbitrariamente como el punto de partida.	C, G	A, B, E, F	D
	El segundo vértice es el más cercano a D: A está a 5 de distancia, B a 9, E a 15 y F a 6. De estos, 5 es el valor más pequeño, así que marcamos la arista DA.	C, G	B, E, F	A, D
	El próximo vértice a elegir es el más cercano a D o A. B está a 9 de distancia de D y a 7 de A, E está a 15, y F está a 6. 6 es el valor más pequeño, así que marcamos el vértice F y a la arista DF.	C	B, E, G	A, D, F
	El algoritmo continua. El vértice B, que está a una distancia de 7 de A, es el siguiente marcado. En este punto la arista DB es marcada en rojo porque sus dos extremos ya están en el árbol y por lo tanto no podrá ser utilizado.	null	C, E, G	A, D, F, B
	Aquí hay que elegir entre C, E y G. C está a 8 de distancia de B, E está a 7 de distancia de B, y G está a 11 de distancia de F. E está más cerca, entonces marcamos el vértice E y la arista EB. Otras dos aristas fueron marcadas en rojo porque ambos vértices que unen fueron agregados al árbol.	null	C, G	A, D, F, B, E
	Sólo quedan disponibles C y G. C está a 5 de distancia de E, y G a 9 de distancia de E. Se elige C, y se marca con el arco EC. El arco BC también se marca con rojo.	null	G	A, D, F, B, E, C
	G es el único vértice pendiente, y está más cerca de E que de F, así que se agrega EG al árbol. Todos los vértices están ya marcados, el árbol de expansión mínimo se muestra en verde. En este caso con un peso de 39.	null	null	A, D, F, B, E, C, G

Código y ejecución

El código primero abre desde un archivo de texto los pares de vértices y la distancia entre ellos, para luego acomodar los valores en un arreglo.

Las iteraciones las logré gracias al ejemplo en C++ del blog de Ankit.

Esta es la captura de los datos de entrada, guardados en un archivo.

El grafo se ve de esta manera:

Ejecución:

El resultado obtenido como distancia mínima fue de 12.

El resultado obtenido fue:

Esto fue todo por hoy, para dudas o correcciones, dejen su comentario.

Bibliografía:
Libro: Matemáticas Discretas - Richard Johnsonbaugh (págs.398-401)
Algoritmos básicos de Grafos
Teoría de Grafos
Algoritmo de Prim

Blogs consultados:
Jonathan De La Rosa
Ankit Agrawal

Crear archivos jar ejecutables

Entrada extra 

Cuando trabajamos en un proyecto en lenguaje java nos habremos de dar cuenta que hacemos uso de muchos archivos e inclusive directorios para almacenar nuestro trabajo, y sabemos que si deseamos que alguien más pueda ejecutar nuestro proyecto en su computadora tendríamos que enviarle todos estos archivos y directorios para que lo pueda compilar y ejecutar en su computadora.

Entonces surge el ideal de colocar todos estos archivos y directorios en un único fichero comprimido. Java nos ofrece el comando jar, que nos permite hacer esto. Este comando junta todo lo que le indiquemos, ya sean carpetas completas, clases, imágenes o archivos de datos, y todo lo coloca en un archivo nuevo con extensión .jar.

Este nuevo .jar es similar a ficheros que ya conocemos como los .zip, .rar o los .tar que ya hemos manejado antes. Inclusive descompresores winrar o winzip puedes abrir el contenido de nuestro nuevo fichero con extensión jar.

Además Java nos permite ejecutar el contenido del fichero .jar sin necesidad de desempaquetarlo.

El comando jar

$ jar

A este comando desde el terminal podemos incluirle las siguientes opciones:

c - Indica que vamos a crear un archivo, y si existe ya uno se eliminará.
f - Indicar el nombre del fichero, que va inmediatamente después.
v - Indica que queremos obtener información durante el proceso de creación del archivo.
m - Indica al programa que queremos personalizar el archivo de manifiesto para añadir información adicional.
M - Indica que no se cree el archivo de manifiesto.
0 - Indicamos que no queremos que se comprima el contenido del archivo.

Crear un fichero jar

Antes de la creación de nuestro fichero jar, debemos procurar que nuestros archivos estan compilados y funcionan correctamente.

Nota: Ya que el proceso de compilar y ejecutar archivos java ya es un tanto repetitivo a estas alturas, me salto este paso.

Cuando las clases del programa no pertenecen a paquetes

En este caso solo debemos meter las clases en el .jar, así que nos ubicamos en el directorio donde se encuentran contenidas nuestros archivos .class y ejecutamos el siguiente comando desde el terminal:

$ jar -cf Nuevo.jar fichero1.class fichero2.class fichero3.class

La opción "c" indica que queremos crear un fichero.jar nuevo.
La opción "f" sirve para indicar el nombre del fichero.

Finalmente se pone una lista de ficheros .class, o de cualquier otro tipo que queramos meter en nuestro jar.

También se pueden usar comodines, como *.class para meter todos los .class del directorio.

Cuando las clases del programa pertenecen a paquetes

Para esto debemos meter la estructura de directorios equivalente a los paquetes del proyecto completo.

Nos vamos al directorio padre de donde empiece nuestra estructura de paquetes.

$ jar -cf Nuevo.jar nombredelpaquete

Esto colocará el paquete dentro de nuestro jar.

También podemos incluir los .class indicando el camino relativo para llegar a ellos:

$ jar -cf Nuevo.jar nombredelpaquete/Hola.class

Ejecutar el jar

Tenemos que colocar nuestro fichero .jar en el CLASSPATH, para poder recurrir a él.

Para ejecutar el archivo escribiríamos lo siguiente en el terminal:

$ java -cp ./Nuevo.jar prueba.Hola

Ejecutar de esta manera no es lo mejor, ya que tenemos que ponerle opciones al ejecutar, además debemos conocer el nombre de la clase principal y en que paquete se encuentra.

Afortunadamente java nos ofrece otra posibilidad de forma que no ocupemos tanto rollo. Se trata de un fichero de texto donde metemos una línea en la que se ponga cual es la clase principal. Este fichero se conoce como fichero de manifiesto y su contenido es tan simple como este:

Main-Class: prueba.Hola

El archivo de manifiesto es un archivo de texto plano por lo que podrá ser creado con cualquier editor de textos convencional. El archivo podrá tener cualquier nombre y extensión, ya que lo que el programa jar hará, será mezclar el contenido de este archivo con el que se crea por defecto.

Crear jar agregando nuestro archivo manifiesto

Cuando construimos el jar, debemos incluir este fichero de la siguiente forma. Por ejemplo, si el fichero lo llamamos manifiesto.mf y lo ponemos en el directorio donde vamos a construir el jar, el comando para hacerlo sería este:

$ jar cmf manifiesto.mf Nuevo.jar prueba/Hola.class

Agregamos la opción "m" para indicar que vamos a añadir un fichero de manifiesto.
Importante el orden en que colocamos las cosas; como en las opciones colocamos mf, debemos indicar primero lo que requiere "m" en este caso el archivo manifiesto, y después "f" el nombre de nuestro jar.

Ejecutar nuestro jar

Una vez construido, se ejecuta de la siguiente manera:

$ java -jar Nuevo.jar

La opción "-jar" indica que se va a ejecutar el Nuevo.jar que se ponga a continuación haciendo caso de su fichero de manifiesto y como este fichero de manfiesto dice que la clase principal es prueba.Hola, será esta la que se ejecute.

Con esto podemos entregar directamente nuestro fichero jar a un amigo y listo, no tendrá problemas para ejecutarlo.

Ejemplos

Jar con archivo manifiesto

Como ven en la secuencia de comando de la captura de ventana hago lo siguiente:
-Ver los archivos contenidos de la carpeta "hola".
-Visualizar el contenido del archivo "manifiesto.mf".
-Compilar el archivo "Hola.java".
-Ejecutar "Hola" para verificar que funciona.
-Crear el fichero jar.
-Ver nuevamente el contenido de la carpeta.
-Ejecutar el contenido del fichero jar.

Así se ven los archivos finales:

Jar con archivo manifiesto y clases contenidas en un paquete

Ahora una prueba con otro ejemplo, en este caso lo realizado fue:
-Primero compilo los archivos .java contenidos en el paquete "graficador".
-Ejecuto la clase principal del paquete para corroborar que funciona.
-Vemos los archivos contenidos en el directorio actual.
-Creamos el fichero jar.
-Volvemos a ver los archivos contenidos, y vemos que se creo nuestro jar.
.Por último ejecutamos el jar para probar.

Esta es una imagen de como resulta después de la ejecución del jar:

Espero les haya servido para que ustedes hagan sus propios jar y puedan compartir sus proyectos. Cabe mencionar que es posible crear estos jar sin necesidad de incluir los archivos .java para evitar que alguien nos copie, y al solo incluir los .class solo podrán ejecutar y ver como va nuestro proyecto.

Les dejo los .jar de los ejemplos para que prueben verlos.

Descargar ejemplos desde MediaFire:
HolaMundo.jar
Graficador.jar

Referencias:
Ficheros JAR
Jar ejecutable

Demostración final

Taller de Programación Orientada a Objetos 
Semana 14 

Diapositivas en persona o video en YouTube.

Demostración final

Ver más presentaciones de Esteban González.

En esta demostración:
- En que lenguaje.
- Porqué.
- Con que herramientas.
- Como obtenerlas.
- Como instalarlas.
- Highlights de código.
- Documentación del código.
- Como compilar/ejecutar (el software y las pruebas).
- Qué hace el programa, qué falta.
- Qué fue difícil, tardado, etc.

Presentación final

Programación Orientada a Objetos 
Semana 14 

Diapositivas en persona o video en YouTube.

Presentación final

Ver más presentaciones de Esteban Gonzalez.

Para esta presentación:
- Para qué sirve tu proyecto.
- Para quién es tu proyecto.
- Porqué.
- Diseño de clases (UML clases).
- Diseño de función (UML secuencia).
- Diseño de pruebas.
- Diseño de pantallas.
- Opcional (Base de datos, serializacion, distribuidos).

Guardar archivos en la nube - Ubuntu One

Entrada extra 

Al finalizar nuestros trabajos de Taller de Programación, comúnmente nos olvidamos de los archivos y dónde quedaron guardados, por lo que es bueno tener algún tipo de respaldo que este accesible en Internet. Con esto evitaremos tal y como nos menciono la Dra. Elisa, si un día se nos cae la Laptop al río y nuestro proyecto estaba guardado solamente ahí sería una pérdida muy grande. Afortunadamente existen muchas páginas y aplicaciones que nos permiten guardar archivos en la nube.

Algunos de los servicios que en lo personal yo he usado y recomiendo son:

1. Google Docs: Servicio que nos proporciona Google con una capacidad de almacenaje de 1GB y que además nos permite crear documentos en línea.
2. Sky Drive: Es proporcionado por Microsoft dentro se sus servicios de Windows Live y que nos brinda una aplicación para escritorio llamada Mesh. Tenemos una capacidad de 25GB en la web y 5GB extras para la sincronización con Mesh.
3. Ubuntu One: Precisamente este servicio es de Ubuntu y nos regala 2GB gratis y opciones para expandir a más capacidad con precios accesibles.

Estos servicios antes mencionados no tienen ningún consto pero si requieren tener una cuenta creada previamente, o sino la opción de crear una cuenta nueva.

Ubuntu One

Ya que recién cree esta cuenta les hablaré un poquito de ella y los pasos que seguí para hacerlo.

>> Ir a Ubuntu One

Una vez que estemos en la página nos vamos a la opción Join de la barra de menú.

O directamente en el siguiente enlace: Join

Nos desplegará las siguientes opciones de planes, yo por supuesto seleccione la que es Gratis.

Todo es muy simple, ahora solo basta crearnos una cuenta nueva.

Nos nos piden tantos datos, así que no hay que preocuparse porque quieran secuestrarnos o algo parecido.

Cuando tengamos la cuenta creada ya podemos ingresar y empezar a hacer uso de este servicio.

Ya podemos crear carpetas dentro de la opción Files.

Ahora ya tenemos un lugar más donde podemos salvar archivos tan importantes como lo son los de nuestro proyecto y ya no habrá escusas como "Chuck Norris destruyo mi Lap" o "Olvide la USB en casa".

Otra cosa buena es que Ubuntu One tiene una aplicación de escritorio y que nos permite manejar la cuenta desde la misma aplicación así como subir archivos más fácilmente. Lo malo es que al parecer estando dentro de la universidad no se nos permite el acceso por algún motivo.

He probado desde la conexión de mi casa y aquí no me ha dado problemas con la aplicación Ubuntu One. Al abrir por primera vez este programa en la computadora nos pedirá que creemos una cuenta nueva, pero en nuestro caso que ya habíamos creado una anteriormente solo será necesario ingresar nuestros datos y la sincronización con el servidor será automática.

También podemos manejar los sitios donde existe la sincronización de nuestros archivos, con la posibilidad de eliminar un sitio que podría ser una intrusión.

Nos podemos dar cuenta entre nuestras carpetas que después de utilizar esta aplicación, tenemos una nueva con el nombre de Ubuntu One, al abrirla podemos encontrar las carpetas y archivos sincronizados con el servidor que se identifican con un indicador verde.

La finalidad de esta carpeta es la facilidad de respaldo de archivos en la nube, ya que solo arrastrando una carpeta a este lugar, o creando una carpeta nueva y copiando archivos existentes, esta es subida directamente al servidor, y cuando estemos en otro ordenador nuestras carpetas también estarán ahí siempre y cuando se haya configurado la sincronización de archivos.

Por si no lo sabían, espero les sirva.

NOTA: Me gustaría que los puntos obtenidos aquí vayan al Taller, ya que es dónde más me hace falta.

Implementación de interfaces gráficas

Taller de Programación Orientada a Objetos 
Semana 13 

Códigos documentados que implementan pantallas gráficas con la funcionalidad correcta de los componentes ya incorporada.

Tal y como había creado mi diseño en papel, lo intente reproducir en Java lo más parecido posible y lo siguiente fue el resultado.

Como ya mencione antes esta es la ventana principal de mi programa, y sus opciones están en la barra lateral izquierda.

El código de esta parte. Es donde están acomodados los paneles, y el uso de acomodo mediante paneles adentro de paneles...

Esta es la segunda ventana que había propuesto. Es donde tenemos las opciones de ver los archivos de datos que tenemos hasta el momento y que se mostrarán a un lado en el panel blanco cuanod se haya seleccionado alguno.

Aquí es la ventana de opciones que se tendrán al tener una gráfica. Como ven le falta meterle más contenido aquí y es porque me falta implementar bien esta parte ya que solo he logrado crear pequeños ejemplos de gráficas pero desde Netbeans.

El código que genera el acomodo de los paneles. Para el cambio de paneles en la ventana sin necesidad de crear una ventana nueva, utilizo un repaint() para actualizar los paneles.

Lo de mostrar la información de un archivo aun no logro acomodarlo en el panel blanco, que más bien sería un JTextArea, y solo me sale en terminal. Espero corregirlo bien para la demostración del jueves.

Ejemplos de gráficas generadas con JFreeChart.

Estas imágenes son ejemplo del uso de la librería JFreeChart en Java para la creación de imágenes.

En la anterior me hace idea a lo que quiero llegar... un botón al final para guardar la gráfica.

Aquí los otros dos tipos de gráficas que tengo pensado incluir:

Lineal:

Pastel:

Poco a poco va tomando forma.