Instalación de graphviz 2.36 en Ubuntu 13.10

“Sueña y serás libre en espíritu, lucha y serás libre en vida”
— Che Guevara

Un cordial saludo gente,    en este post  mostrare la instalación manual de graphviz en su versión 2.36 para Ubuntu 13.10.
Una forma instantánea de instalación puede ser descargado desde launchpad.net.
Para los que no desean una versión actual y poseen una conexión a Internet, pueden usar el siguiente comando desde su terminal:

sudo apt-get  update
sudo apt-get install graphviz

Las herramientas:

Graphviz para Ubuntu 13.10.

¿Qué es Graphviz?
Graphviz es de código abierto de software de visualización gráfica. Visualización gráfica es una forma de representar información estructural como diagramas de grafos y redes abstractas.
Características
Visualización gráfica es una forma de representar información estructural como diagramas de grafos y redes abstractas. Tiene importantes aplicaciones en la red, la bioinformática, la ingeniería de software, base de datos y diseño de páginas web, aprendizaje de máquina, y en las interfaces visuales para otros dominios técnicos.
Gráfico de Visualización
En la práctica, los gráficos suelen ser generados a partir de orígenes de datos externos, pero también pueden ser creados y editados manualmente, ya sea como archivos de texto sin procesar o dentro de un editor gráfico. (Graphviz no fue pensado para ser un reemplazo Visio, por lo que es probable que sea frustrante para tratar de usarlo de esa manera.)
Página oficial : http://www.graphviz.org/

Package: libgd2-xpm

Versión 2 de la biblioteca de gráficos GD
GD es una biblioteca de gráficos. Permite a un código dibujar rápidamente imágenes completas con líneas, arcos, textos, varios colores, cortar y pegar desde otras imágenes, rellenar, y guardar el resultado como un archivo PNG. Es particularmente útil en aplicaciones web, donde el PNG es una de los formatos que aceptan la mayoría de los navegadores para añadir imágenes en línea.
Este es el paquete ejecutable de la biblioteca, que permite usar XPM (mapa de píxeles de X) y fontconfig.
Pagina oficial: www.libgd.org

Pasos de  instalación

Para realizar la instalación en la versión 13.10 de Ubuntu. Es necesario descargar la versión adecuada de la misma.

• Ingresando a la página oficial : http://www.graphviz.org/
• Ir a la pestaña de descargas, aceptar los términos de descarga.

• Seleccionar  la versión con la arquitectura adecuada  para nuestro pc, siendo este como 32 o 64 bits.

• En cualquiera de los casos solamente necesitamos descargar  graphviz_2.36.0-1~saucy_.

• En cualquier parte de nuestro pc donde se encuentre ubicado nuestro archivo. Daremos clic derecho al archivo y elegir las opciones abrir con gestor de paquetes.

• Si en proceso de instalación existe error, ver el apartado de error de dependencia para dar solución.
• Si todo marcha bien permitimos que instale como un programa cualquiera y esperamos el tiempo necesario.

• Después de ello, ya es posible ser usado sin modificar entornos de variables.

Error de dependencia de librerías.

En algunos casos, suele pasar que hagan falta algún tipo de librerías.
Para dar solución al problema, basta con descargar la librería en : http://packages.ubuntu.com/search?keywords=libgd2-xpm
Package: libgd2-xpm-

• Según la versión de su sistema operativo:

• En cualquier parte de nuestro pc donde se encuentre nuestro archivo. Daremos clic derecho al archivo y elegir las opciones abrir con gestor de paquetes.

• Permitimos que instale como un programa cualquiera y esperamos el tiempo necesario.
• Nuevamente intentamos instalar graphviz_2.36.0-1~saucy.

NOTA: Si existieran mas problemas de dependencia es necesario actualizar nuestro sistema operativo o buscar las librerías necesarias.
Vídeo:

Datos alfabéticamente en un arreglo

Ejemplos prácticos alimentan la noción del emprendedor.

Saludos les comparto un nuevo ejemplo para ampliar aun mas el uso de estructuras de datos del tipo arreglo. En esta oportunidad le muestro como ingresar dato de manera ordenada en un arreglos de string, sin duplicidad. Particularmente siempre suelen pedirse en las practicas este tipo de métodos, puesto que es mas rápido acceder a los datos si tienen un orden especifico.

Cuando se trabaja con arreglos ordenados se debe evitar alterar el orden al insertar nuevos elementos o al modificar los existentes.
Metodología para Inserción:

• Para insertar un elemento X (cualquiera) en un arreglo unidimensional V ordenado, primero se debe verificar que exista espacio.
• Luego se encontrará la posición en la que debería estar el nuevo valor para no alterar el orden del arreglo. Cuando se detecte la posición, se procederá a recorrer todos los elementos desde ahí hasta la N-ésima posición. Finalmente se asignará el valor de X en la posición encontrada.
• Cabe destacar que el desplazamiento no se lleva a cabo cuando el valor a insertar es mayor que el último elemento del arreglo.
  Generalmente, cuando se quiere hacer una inserción se debe verificar que el elemento no se encuentre en el arreglo. En la mayoría de los casos prácticos no interesa tener información duplicada; por tanto, si el valor que se desea insertar ya estuviera en el arreglo, la operación no se llevará a cabo.

Ejemplo

 

Codigo fuente

public class ArregloOrdenado {
    
        //forma#1
  String [] Nombres;
  String [] Mensaje={"Disponible",
                    "Espacio no Disponible",
                    "Error de formato",
                    "Sistema iniciado",
                    "Dato repetido"
                    };
  String linea;
  InputStreamReader Flujo_bytes= new InputStreamReader (System.in);
  BufferedReader entrada= new BufferedReader (Flujo_bytes); 
  
   public void iniciarSistema(){
      System.out.println("Para Iniciar el sistema debe ingresar el numero de datos a registrar:");
      try {
          linea= entrada.readLine();
      
      } catch (IOException ex) {
          System.out.println(Mensaje[2]);
      } 
      
      try{
      int numPersona= Integer.parseInt(linea);
      Nombres= new String[numPersona];
      System.out.println(Mensaje[3]);
       linea=null;
      }catch(NumberFormatException e){
           System.out.println( Mensaje[2] +" debe ingrese numeros");
           iniciarSistema();
      }
       
 }
 
   
    public void registrarUsuario(){
 int tamaño= Nombres.length;
 int contador=0;
  while(contador<tamaño){
            System.out.println("Ingrese el nombre de usuario");  
                try {
                    linea= entrada.readLine();
                    listarOrdenado(linea);

                } catch (IOException ex) {
                    System.out.println(Mensaje[2]);
                }

                contador++;
  
        }
     
 
 }
    
    public void listarOrdenado(String nombre){

   int N=Nombres.length;
   int l = 0;
   int pos =busquedaSecuencial(nombre);
   
 
 
 
    if (pos<N&pos!=-1) {
     System.out.println(Mensaje[0]+" casilla " + pos); 
        switch(pos){//caso 1
            case 0:// este es el caso en que sea el primer elemento
                
                  Nombres[pos] = nombre;
                
                break;
            default: //caso 2
 //*************************** ordenado               
               char[] inicialNombres =  Nombres[pos-1].toCharArray();
               char[] inicialNuevo =  nombre.toCharArray(); 
               int ordenAnterior= (int)inicialNombres[0];
               int ordenNuevo= (int)inicialNuevo[0];
               
                if( ordenAnterior<ordenNuevo|ordenAnterior==ordenNuevo){//
                  System.out.println("Dato en orden");
                  Nombres[pos] = nombre;
                }else{
                //hacer un cambio
                  System.out.println("Se intercabia posiciones");

                  while(l<N&Nombres[l]!=null){
                       inicialNombres =  Nombres[l].toCharArray();
                       int actual= (int)inicialNombres[0];                    
                       if( ordenNuevo<actual|actual==ordenNuevo){               
                    break;
                    }

                  l++;
                  }
                  

                   System.out.println("Debe ir en la posicon: "+ l); 
                   if(l<N){
                       
                  String temp=  Nombres[l];
                  Nombres[l]=nombre;
                  String aux=null;
                  int contador=l+1;
                        while(contador<N){
                       aux=  Nombres[contador]; //toma el dato siguiente   
                       Nombres[contador]= temp;// en la posicion siguiente inserta el nuevo
                       temp=  aux;//asigna el dato anterio que no tiene casilla.
//                          
                            
                        contador++;
                        }
                       
                   
                   }
                    
                }
         
                
  //***************************Fin ordenado          
        
        }
        
      
        
    } else if(pos==-1) {
        
          System.out.println(Mensaje[4]);
    }else{
    System.out.println(Mensaje[1]);
    }


}
    
    private int busquedaSecuencial(String nombre) {
    int respueta=0;
    int N=Nombres.length;
    int l=0;   

            while(l<N&&Nombres[l]!=null){    

               if(Nombres[l].equals(nombre)){
                l=-1;
                break;
               }
               l++;

           }
 respueta=l;
  
    return respueta;
       
    }
    
    public void listarDatos(){
     System.out.println("************Incio de listar******************");
 for (int i = 0; i < Nombres.length; i++) {

               
                System.out.println("Usuario \t"+Nombres[i]);
               
         }
    System.out.println("************Fin de listar******************");

}
  
    
}

// metodo principal 

public static void main(String[] args) {
      ArregloOrdenado objeto= new ArregloOrdenado();
      objeto.iniciarSistema();
      objeto.registrarUsuario();
      objeto.listarDatos();
       
    }

Modelo Vista Controlador

Les dejo un pequeño instructivo el  cual es de mucha utilidad para incursionar en el desarrollo de software de calidad.

En el se describen conceptos que permiten entender sus orígenes e importancia del uso  de patrones de diseño, para dar soluciones a problemas comunes en el mismo desarrollo del software.

Investigacion Modelo Vista Controlador by José Alexander

Asignación de memoria y Punteros

Les comparto mi primer instructivo, el cual se desarrolla  temas de programación fundamentales para el desarrollo de estructuras de datos.

El cual hace énfasis en el proceso de asignatura de la memoria y  una comparación entre el lenguaje Java y C, en el manejo de punteros.  

Sugerencias son bienvenidas y espero que les sea de gran utilidad.

Asignacion de Memoria y Apuntadores 

Ejemplo: estructuras de datos del tipo arreglo

Ejemplos prácticos alimentan la noción del emprendedor.

Diagrama del clase del ejemplo 1

Les comparto la ultima parte del vídeo, en el cual dimos solución a un problema planteado, el cual requería la implementacion de los métodos elementales para la gestión de un registro de datos :
Registrar, buscar, remplazar y eliminar.

Utilizando  un arreglo de datos del tipo String.
El vídeo describe la realización del programa como también el uso de los métodos implementados, en la parte baja del vídeo encontraran el código fuente del mismo.

Temas sugeridos si aun no comprendes el uso de datos del tipo arreglo. Dejo los enlaces a continuación:

Fundamentos de Arreglos o Array
Apuntadores en java.

Ejemplo 1 parte 2

 

Código fuente

public class ArregloSimple {
    
      //Tipos Simples
  private  String mensaje;
  private  String linea;
  private boolean asignado;
  
     //forma#1
//  String [] Nombres;
//  String [] Clasificaciones={"Disponible","Espacio no Disponible","Error de formato","Sistema iniciado"};
  //forma#2
   private  String [] Nombres, Clasificacion={"Disponible","Espacio no Disponible","Error de formato","Sistema iniciado"};
   InputStreamReader Flujo_bytes= new InputStreamReader (System.in);
   BufferedReader entrada= new BufferedReader (Flujo_bytes); 
 public void iniciarSistema(){
      System.out.println("Para Iniciar el sistema debe ingresar el numero de datos a registrar:");
      try {
          linea= entrada.readLine();
      
      } catch (IOException ex) {
          Logger.getLogger(ArregloSimple.class.getName()).log(Level.SEVERE, null, ex);
      }
      
      
      try{
      int numPersona= Integer.parseInt(linea);
      Nombres= new String[numPersona];
      System.out.println( Clasificacion[3]);
      }catch(NumberFormatException e){
           System.out.println( Clasificacion[2] +" debe ingrese numeros");
           iniciarSistema();
      }
       
 }
 
 public void registrarUsuario(){
  boolean respuesta= true;
  while(respuesta){
  System.out.println("Ingrese el nombre de usuario");  
      try {
          linea= entrada.readLine();
          listarSimple(linea);
          
      } catch (IOException ex) {
          Logger.getLogger(ArregloSimple.class.getName()).log(Level.SEVERE, null, ex);
      }
      
      try{
      System.out.println("Desea registrar otro usuario? SI o NO");   
      linea= entrada.readLine();
     
      
       if( linea.equalsIgnoreCase("si")){
              continue;
              }else if( linea.equalsIgnoreCase("no")){
              break;
              }
      
      }catch (IOException ex) {
              Logger.getLogger(ArregloSimple.class.getName()).log(Level.SEVERE, null, ex);
          }
  
  }
     
 
 }
  
public void listarSimple (String nombre){
asignado= false;
if(Nombres!=null){//analizar si existe
        
                for (int i = 0; i < Nombres.length; i++) {

                if(Nombres[i]== null){
                System.out.println("Casilla \t"+i+Clasificacion[0]);
                Nombres[i]=nombre;
                
                asignado=true;
                break;
                }
                    
                
            }
            
        }



if(asignado){
            mensaje="Asignado Exitosamente";
            System.out.println(mensaje); 
        }else{
              mensaje="No existe Espacio suficiente";
            System.out.println(mensaje); 
        }


}

public void listarDatos(){
     System.out.println("************Incio de listar******************");
 for (int i = 0; i < Nombres.length; i++) {

               
                System.out.println("Usuario \t"+Nombres[i]);
               
         }
    System.out.println("************Fin de listar******************");

}

public boolean buscar(String Usuario){
    boolean respueta = false;
    
    for (int i = 0; i < Nombres.length; i++){
       String buscado=  Nombres[i];
    if (buscado.equalsIgnoreCase(Usuario)){
        respueta= true;
        break;
        }
    
    }
    
    
    
    
return respueta;
}


public void reemplazar(String Usuario, String buscado){



    for (int i = 0; i < Nombres.length; i++){
       String existe=  Nombres[i];
    if (buscado.equalsIgnoreCase(existe)){
        String anterior= Nombres[i];
        Nombres[i]=Usuario;
        System.out.println("Fue sustituido" +anterior+" por: "+Usuario);
        break;
        }
    
    }

}

public void reemplazar(String Usuario, int buscado){


 int datos=  Nombres.length;
   
      
    if (buscado < datos){
        String anterior= Nombres[buscado];
        Nombres[buscado]=Usuario;
        System.out.println("Fue sustituido " +anterior+" por: "+Usuario);
       
        }
    
    

}



public void Eliminar(String Usuario){
 
    
    for (int i = 0; i < Nombres.length; i++){
       String buscado=  Nombres[i];
    if (buscado.equalsIgnoreCase(Usuario)){
       Nombres[i]=null;
        break;
        }
    
    }
    
}
public void Eliminar(int index){
 
    
   int datos=  Nombres.length;
   
        
    if (index < datos){ 
       Nombres[index]=null;
    }
    
}
}

//clase principal 

public static void main(String[] args) {
      ArregloSimple objeto= new ArregloSimple();
      objeto.iniciarSistema();
      objeto.registrarUsuario();
      objeto.listarDatos();
      
//        boolean buscar = objeto.buscar("ana");
//        if(buscar){
//        System.out.println("Si existe el dato buscado" );
//        }else{
//        System.out.println("el dato buscado no existe");
//        }
//      objeto.reemplazar("ana", "alex");
//      objeto.reemplazar("ana", 2);
//      objeto.Eliminar("alex");
      objeto.Eliminar(3);
     objeto.listarDatos();
      
      
    }