jueves, 23 de junio de 2016

Instalación de MathType en Windows Versión completa

En esta ocasión les traigo los paso para la instalación del editor de formulas MathType que el cual es una versión muy completa, esta herramienta que se adhiere a Word es muy funcional a la hora de la insertar de formulas ya sea para un trabajo formal o ya sea un trabajo para la escuela, pues este cuenta con muchas herramientas y expresiones matemáticas útiles que en el editor de formulas de Word no tiene, ademas de darle un toque mas profesional a los trabajos, sin mas que decir de ello los pasos para la instalación son los siguientes:

Paso 1:

Ir a la pagina oficial de Mathtype que es la siguiente    http://www.dessci.com/en/products/mathtype/
la página es como se muestra en la imagen



Paso 2:

Descargar dando click en el boton que se muestra en la imagen con el circulo rojo de arriba.


Paso 3:

Instalar MathType dando click sobre el Archivo descargado como se muestra en la siguiente imagen:



Paso 4:

Aceptar términos y condiciones y pulsamos siguiente:



Paso 5:

Una vez finalizada la instalación se debe validar con licencia a Mathtype como se muestra en la imagen de abajo:



¨Paso 6:

Damos Clock a next y luego a OK


Paso 7:

Esparamos a que  la instalación finalice y listo.


Podemos ya utilizar MathType en Word


Si no quedo muy claro de como hacer la instalación pueden checar el siguiente video donde hago la instalación paso a paso:
Video Tutorial


Bueno Muchas Gracias por Visitarme Espero que la información haya sido útil  Hasta la próxima. 



lunes, 20 de junio de 2016

Sistema de Administración de Procesos Método SJF (Shortest-Job-First) en Java

El método SJF o Trabajo mas  Corto ese tipo de administración de procesos se basa en ejecutar los procesos mas cortos sin importar cuantos llegues o cuales procesos lleguen primero, el principal objetivo es la reducción del tiempo de espera ya que al ejecutarse primero los procesos con menos pero se hará de la manera mas rápida, aunque también tiene sus contra partes ya que al ejecutarse siempre los procesos mas pequeños siempre será así eso conlleva a  que si hay un proceso tal vez mas grande pero existen demasiados procesos pequeños se atenderán esto siendo que tal vez el procesos "grande" sea mas rápido de atender ya que es solo uno. 

Un ejemplo de lo que se describe en el texto anterior:

Sean los Procesos A = 10, B = 3, C = 1, D = 12, E = 2, F = 3.

Primero Proceso en Entrar C = 1 el tiempo de espera es 0.

C = 0
Segundo Proceso es E = 2  el tiempo de espera es 1.

E = 0

Tercer Proceso es F = 3 el tiempo de espera es 3.

F = 0

Cuarto Proceso es B = 3 el tiempo de espera es 6.

B = 0

Quinto Proceso es A = 10 el tiempo de espera es 9.

A = 0

Sexto Proceso es D = 12 el  tiempo de espera es 18.

D = 12

Con ese pequeño ejemplo se muestra como funciona el este algoritmo. Pasamos a la parte del condigo en Java:





// Creación del Método
public void sjf(){
    // Se Define el número de Porcesos a ejecutar
         tamar=Integer.parseInt(nprocesos.getText());
    // Inicialización de Variables
      int p[] = new int[tamar];
        int co[] = new int[tamar];
        int es[] = new int[tamar];
        int vuelta[] = new int[tamar];
        int procesos_originales[] = new int[tamar];
    // Recibe el Tamaño de los procesos
        for (int i = 0; i < tamar; i++) {
            procesos_originales[i] = co[i] = p[i] = Integer.parseInt(JOptionPane.showInputDialog("introduza el tamanio "
                    + "del proceso [" + (i + 1) + "]"));
        }
    //  Se hace el proceso para elegir el proceso con menos peso
        for (int i = 0; i < tamar - 1; i++) {
            for (int j = i + 1; j < tamar; j++) {
                if (p[i] > p[j]) {
                    temp = p[i];
                    p[i] = p[j];
                    p[j] = temp;
                }
            }
        }
        
        for (int i = 0; i < p.length; i++) {
                       txtoriginales.append("\nP[" + (i + 1) + "] : " + p[i] + "\t");
        }

        for (int i = 0; i < tamar - 1; i++) {
            for (int j = i + 1; j < tamar; j++) {
                if (co[i] > co[j]) {
                    temp = co[i];
                    co[i] = co[j];
                    co[j] = temp;
                }
            }
        }
        vuelta[0] = 0;
    // Se calcula la espera de los Procesos
        for (int i = 1; i < tamar; i++) {
            vuelta[i] = vuelta[i - 1] + co[i - 1];
            total = total + vuelta[i];
            
        }
    // Se calculan las estadisticas de los procesos
        for (int i = 0; i < p.length; i++) {
            es[i] = vuelta[i] + co[i];
            tiempo_espera += vuelta[i];
            tiempo_ida += es[i];
            txtordenados.append("\nP[" + (i + 1) + "] : " + procesos_originales[i] + "\t");

        }
    // Se muestran los resultados
        txtesta.append("\nProceso\ttamanio\tespera\tida");
        for (int i = 0; i < p.length; i++) {
            txtesta.append("\np[" + (i + 1) + "] \t   " + co[i] + "\t   " + vuelta[i] + "\t" + es[i]);
        }
        promedioespera.setText(""+(tiempo_espera / tamar));
        promedioida.setText("" + (tiempo_ida / tamar));
     }

Espero le haya servido la Información Gracias por Visitarme les dejo el Código.

Aquí esta el Código el Un proyecto de NetBeans:


Algoritmo SJF

miércoles, 15 de junio de 2016

Sistema de Administración de Procesos FCFS (Firts-Come, First-Served) en Java

La administración de procesos mediante este método ejecuta los procesos según llegues en cola, lo que significa que el primer proceso que llegue será el primero en ser atendido y el primero en salir por eso mismo también se le conoce como el método FIFO (Firts Intput, Firts Output), loa cual significa que cada procesos tarde dependiendo del numero de procesos que se encuentran en cola, entonces tomando en principio del método se plantea el siguiente ejemplo:
Llegan tres procesos sean los cuales A = 23 , B = 12 y C = 1

Tiempo de espera de A es 0 ya que es el primero en llegar

A = 0

Tiempo de espera de B es 23  ya que espero a la ejecución del A

B = 0

Tiempo de espera de C es de 35 por la espera de  los procesos A y B

C=0

Ahora seguimos a la parte del código el cual esta realizado en el lenguaje Java.

Este es el método que hace todos los cálculos


public void fcfs(){
    //Se define el número de procesos       
    tamar=Integer.parseInt(nprocesos.getText()); 
    //Inicialización de Variables para el almacenamiento de los datos    
      int p[] = new int[tamar];
        int co[] = new int[tamar];
        int es[] = new int[tamar];
        int vuelta[] = new int[tamar];
    //Entrada de los valores de Cada procesos    
        for (int i = 0; i < tamar; i++) {
            co[i] = p[i] = Integer.parseInt(JOptionPane.showInputDialog("introduza el tamanio "
                    + "del proceso [" + (i + 1) + "]"));
        }
        //se imprime el valor de cada uno de los procesos
        for (int i = 0; i < p.length; i++) {
        
            txtoriginales.append("\nP[" + (i + 1) + "] : " + p[i] + "\t");
        
        }
        vuelta[0] = 0;
        //Se calcula el total de rondas que tadan los procesos
        for (int i = 1; i < tamar; i++) {
            vuelta[i] = vuelta[i - 1] + co[i - 1];
            total = total + vuelta[i];
        }
        //se calcula el tiempo de espera de cada una de los procesos
        for (int i = 0; i < p.length; i++) {
            es[i] = vuelta[i] + co[i];
            tiempo_espera += vuelta[i];
            tiempo_ida += es[i];

        }
        //Impresion de los datos Calculados
txtesta.append("\nProceso\ttamanio\tespera\tida" );
        for (int i = 0; i < p.length; i++) {
            txtesta.append("\np[" + (i + 1) + "] \t   " + co[i] + "\t   " + vuelta[i] + "\t" + es[i]);
        }
        //Se Calcula el promedio de las rondas y de las esperas de los procesos
        promedioespera.setText(""+ (tiempo_espera / tamar));
        promedioida.setText(""+ (tiempo_ida / tamar));
     }

Espero haya sido de ayuda.

Aquí te dejo el código:

FCFS



viernes, 11 de marzo de 2016

Sistema de Administración de Procesos Método Round Robin en Java

Administración de Procesos Round Robin

La administración de procesos mediante este método se trata de ir tomando un proceso turno por turno hasta que todos y cada uno de los procesos terminen, así con todos y cada uno de los procesos que vayan llegando, entra en juego el "Quantum" que es el numero de procesos simultáneos a tomar en cuanta por Round , un ejemplo de ello es lo siguiente:
llegan 3 Procesos A, B y C, donde A=2, B=3 y C=1, entonces tomando el método de Round Robin el proceso será el siguiente:

Quantum=1
1.- Primer Round

 Entran 
A=2-1 B=3-1 C=1-0 ----->A=1 B=2 C=0(PROCESO TERMINADO).

2.- Segundo Round

A=1-1 B=2-1  ------> A=0(PROCESO TERMINADO) B=1.

3.- Tercer Round

B=1-1 -----------> B=0(PROCESO TERMINADO)

Así es como se terminan  el total de procesos usando Round Robin 

Una vez Visto la Parte Teórica Implementaremos el algoritmo en Java

Se hace Uso de Una Sencilla Interfaz Gratifica para la obtención de Datos.



Aquí e Código:


// Declaración de Variables
    int p[];
    int co[];
    int vuelta[];
    int q;
    int nProceso;
    int c = 0;
    float tiempo_espera, tiempo_ida;
    
//Método Round Robin el cual se manda a llamar en el Boton Run en su evento actionPerformed
    public void RoundRobin(){
        // se Inicializan las Variables
    nProceso=Integer.parseInt(nProcesos.getText());// Obtención de numero y tamaño de procesos
    //Inicializacion de Variables
    int p[]=new int [nProceso];
    int co[]=new int [nProceso];
    int es[]=new int [nProceso];
    int vuelta[]=new int [nProceso];
    //Obtención de Valores para cada uno de los procesos
    for(int i=0;i< nProceso;i++){
    co[i]=p[i]=Integer.parseInt(JOptionPane.showInputDialog("Introduzca el Tamaño de Proceso"+"["+(i+1)+"]"));
    }
    //Obteción del  "Quantum"
    q=Integer.parseInt(Q.getText());
    
            for (int j = 0; j <nProceso; j++) {//Este Proceso se hará hasta terminar todos los procesos
                while (p[j] >= 0) {//mientras los valores de los procesos no sean sero no terminará
                for (int i = 0; i < p.length; i++) {// se hace el recorrido de cada proceso                    
                    if (p[i] >= 0) {//verificando que aun no termine
                        Originales.append("\nP[" + (i + 1) + "] : " + p[i] + "\t");
                        if (p[i] > 0) {//en caso de terminar se agrega una vuelta el en arreglo
                            vuelta[i]++;
                        }
                    }
                    p[i] -= q;//aqui se le resta el cuantum al proceso mientras sea mayor a 0
                }
                c++;
            }
        }
    for (int i = 0; i < p.length; i++) {//aqui se cuenta el tiempo de espera para cada uno de los proceso sumando el tiempo de los procesos anteriores
            es[i] = vuelta[i] + co[i];
            tiempo_espera += vuelta[i];
            tiempo_ida += es[i];
        }
        Estadisticas.append("\nProceso\ttamanio\tespera\tida");
        for (int i = 0; i < nProceso; i++) {
         Estadisticas.append("\np[" + (i + 1) + "] \t   " + co[i] + "\t   " + vuelta[i] + "\t" + es[i]);
        }
        PromedioEspera.setText(""+ (tiempo_espera / nProceso));
        PromedioIda.setText(""+ (tiempo_ida / nProceso));
    }

Espero  y Sirva este aporte subiré otros métodos de Administración de Procesos mas Adelante Saludos.

Aquí el Codigo:


Round Robin