Suscribirse a
Entradas
Comentarios
domingo, 15 de abril de 2018
domingo, 30 de septiembre de 2012
Letra Vocal Consonante
/* Letra Vocal Consonante con Switch
*
* Fuente: .....------ Conocimientos adquiridos e investigacion en distintas fuentes ------.....
*********************************************
* InGeNiErIa En SiStEmAs CoMpUtAcIoNaLeS *
* InStItUtO tEcNoLoGiCo SuPeRiOr De JeReZ *
* ErNeStO rOsAlEs CaRlOs *
* ernestorosales@live.com *
*********************************************
Problema 7.- Elaborar un programa que lea una letra y determine si es vocal, o
constante.
*/
import java.io.*;
class Siete_LetraVocalConstante
{
public static void main (String args[]) throws IOException
{
BufferedReader LVC=new BufferedReader (new InputStreamReader (System.in));
System.out.println("Ingresa una letra en minuscula ");
String CV1=LVC.readLine();
char ConstanteVocal=CV1.charAt(0);
switch(ConstanteVocal)
{
case 'a':
System.out.println("Vocal");
break;
case 'b':
System.out.println("Constante");
break;
case 'c':
System.out.println("Constante");
break;
case 'd':
System.out.println("Constante");
break;
case 'e':
System.out.println("Vocal");
break;
case 'f':
System.out.println("Constante");
break;
case 'g':
System.out.println("Constante");
break;
case 'h':
System.out.println("Constante");
break;
case 'i':
System.out.println("Vocal");
break;
case 'j':
System.out.println("Constante");
break;
case 'k':
System.out.println("Constante");
break;
case 'l':
System.out.println("Constante");
break;
case 'm':
System.out.println("Constante");
break;
case 'n':
System.out.println("Constante");
break;
case 'o':
System.out.println("Vocal");
break;
case 'p':
System.out.println("Constante");
break;
case 'q':
System.out.println("Constante");
break;
case 'r':
System.out.println("Constante");
break;
case 's':
System.out.println("Constante");
break;
case 't':
System.out.println("Constante");
break;
case 'u':
System.out.println("Vocal");
break;
case 'v':
System.out.println("Constante");
break;
case 'w':
System.out.println("Constante");
break;
case 'x':
System.out.println("Constante");
break;
case 'y':
System.out.println("Constante");
break;
case 'z':
System.out.println("Constante");
break;
default:
System.out.println("Ingresaste dato incorrecto");
break;
}
}
}
Área Triangulo, Rectángulo, Circulo, Cuadrado con Switch
/* Área Triangulo, Rectángulo, Circulo, Cuadrado con Switch
*
* Fuente: .....------ Conocimientos adquiridos e investigacion en distintas fuentes ------.....
*********************************************
* InGeNiErIa En SiStEmAs CoMpUtAcIoNaLeS *
* InStItUtO tEcNoLoGiCo SuPeRiOr De JeReZ *
* ErNeStO rOsAlEs CaRlOs *
* ernestorosales@live.com *
*********************************************
*/
import java.io.*;
class SwitchAreaTCRC
{
public static void main (String args []) throws IOException
{
BufferedReader Option=new BufferedReader (new InputStreamReader (System.in));
System.out.println("1.- Area del triangulo: ");
System.out.println("2.- Area del rectangulo: ");
System.out.println("3.- Area del circulo: ");
System.out.println("4.- Area del cuadrado: ");
System.out.println("Escribe el numero de la opcion deseada: ");
String Opcion1=Option.readLine();
int O1=Integer.parseInt(Opcion1);
switch(O1)
{
case 1:
System.out.println("Ingresa la base: ");
String base=Option.readLine();
int B1=Integer.parseInt(base);
System.out.println("Ingresa la altura: ");
String altura=Option.readLine();
int H1=Integer.parseInt(altura);
System.out.println("El area del triangulo es igual a: " + ((H1*B1)/2));
break;
case 2:
System.out.println("Ingresa la base: ");
String bas=Option.readLine();
int RB=Integer.parseInt(bas);
System.out.println("Ingresa la altura: ");
String altur=Option.readLine();
int RH=Integer.parseInt(altur);
System.out.println("El area del rectangulo es igual a: " + (RB*RH));
break;
case 3:
System.out.println("Ingresa el radio: ");
String radio=Option.readLine();
int R1=Integer.parseInt(radio);
System.out.println("El area del circulo es igual a: " + (3.14*R1*R1));
break;
case 4:
System.out.println("Ingresa la medida de un lado: ");
String lado=Option.readLine();
int L1=Integer.parseInt(lado);
System.out.println("El area del cuadrado es igual a: " + (L1*L1));
break;
default:
System.out.println("OpCiOn InCoRrEcTa");
break;
}
}
}
Conversión Número Letra con Switch
/* Conversion Numero Letra con Switch
*
* Fuente: .....------ Conocimientos adquiridos e investigacion en distintas fuentes ------.....
*********************************************
* InGeNiErIa En SiStEmAs CoMpUtAcIoNaLeS *
* InStItUtO tEcNoLoGiCo SuPeRiOr De JeReZ *
* ErNeStO rOsAlEs CaRlOs *
* ernestorosales@live.com *
*********************************************
*/
import java.io.*;
class SwitchConversionNumeroLetra
{
public static void main (String args []) throws IOException
{
BufferedReader Numbers=new BufferedReader (new InputStreamReader (System.in));
System.out.println("Ingresa un numero del 1 al 10: ");
String nn1=Numbers.readLine();
int Number=Integer.parseInt(nn1);
switch(Number)
{
case 1:
System.out.println("UnO");
break;
case 2:
System.out.println("DoS");
break;
case 3:
System.out.println("TrEs");
break;
case 4:
System.out.println("CuAtRo");
break;
case 5:
System.out.println("CiNcO");
break;
case 6:
System.out.println("SeIs");
break;
case 7:
System.out.println("SiEtE");
break;
case 8:
System.out.println("OcHo");
break;
case 9:
System.out.println("NuEvE");
break;
case 10:
System.out.println("DiEz");
break;
default:
System.out.println("OpCiOn InCoRrEcTa");
break;
}
}
}
Vocales Minuscula Mayuscula con Switch
/* Vocales Minuscula Mayuscula con Switch
*
* Fuente: .....------ Conocimientos adquiridos e investigacion en distintas fuentes ------.....
*********************************************
* InGeNiErIa En SiStEmAs CoMpUtAcIoNaLeS *
* InStItUtO tEcNoLoGiCo SuPeRiOr De JeReZ *
* ErNeStO rOsAlEs CaRlOs *
* ernestorosales@live.com *
*********************************************
*/
import java.io.*;
class SwitchVocalMinusculaMayuscula
{
public static void main (String args []) throws IOException
{
BufferedReader Vocal=new BufferedReader (new InputStreamReader (System.in));
System.out.println("Ingresa una vocal en minuscula: ");
String vO=Vocal.readLine();
char V1=vO.charAt(0);
switch(V1)
{
case 'a':
System.out.println("Vocal: A");
break;
case 'e':
System.out.println("Vocal: E");
break;
case 'i':
System.out.println("Vocal: I");
break;
case 'o':
System.out.println("Vocal: O");
break;
case 'u':
System.out.println("Vocal: U");
break;
default:
System.out.println("OpCiOn InCoRrEcTa");
break;
}
}
}
Dias de Semana con Switch
/* Dias de Semana con Switch
*
* Fuente: .....------ Conocimientos adquiridos e investigacion en distintas fuentes ------.....
*********************************************
* InGeNiErIa En SiStEmAs CoMpUtAcIoNaLeS *
* InStItUtO tEcNoLoGiCo SuPeRiOr De JeReZ *
* ErNeStO rOsAlEs CaRlOs *
* ernestorosales@live.com *
*********************************************
*/
import java.io.*;
class SwitchDiasSemana
{
public static void main (String args []) throws IOException
{
BufferedReader TheDays=new BufferedReader (new InputStreamReader (System.in));
System.out.println("Ingresa un numero del 1 al 7: ");
String nn1=TheDays.readLine();
int Day=Integer.parseInt(nn1);
switch(Day)
{
case 1:
System.out.println("LuNeS");
break;
case 2:
System.out.println("MaRtEs");
break;
case 3:
System.out.println("MiErCoLeS");
break;
case 4:
System.out.println("JuEvEs");
break;
case 5:
System.out.println("ViErNeS");
break;
case 6:
System.out.println("SaBaDo");
break;
case 7:
System.out.println("DoMiNgO");
break;
default:
System.out.println("OpCiOn InCoRrEcTa");
break;
}
}
}
Intercalacion Directa Ernesto Rosales
/* Metodo de Intercalacion Directa.
*
* Fuente: .....------ Conocimientos adquiridos e investigacion en distintas fuentes ------.....
*********************************************
* InGeNiErIa En SiStEmAs CoMpUtAcIoNaLeS *
* InStItUtO tEcNoLoGiCo SuPeRiOr De JeReZ *
* EsTrUcTuRa De DaToS *
* ErNeStO rOsAlEs CaRlOs *
* ernestorosales@live.com *
*********************************************
*/
import java.io.*;
import java.awt.*;
public class IntercalacionDirectaErnestoRosales
{
private static void Inter(int[] Arreglo1, int[] Arreglo2, int[] Arreglo3) // Metodo Inter con tres arreglos.
{
int Indice1=0; // Declaracion de posiciones de arreglo.
int Indice2=0;
int Indice3=0;
while(Indice1<Arreglo1.length && Indice2<Arreglo2.length) // Mientras la variable Indice1 y 2 sean de menor longitud
{ // que el tamano del arreglo 1 y 2.
if(Arreglo1[Indice1]<Arreglo2[Indice2]) // Si el arreglo en posicion 0 es menor que el arreglo 2 en posicion 0
{
Arreglo3[Indice3]=Arreglo1[Indice1] ; // Almacena el dato del arreglo1 en el arreglo3.
Indice1++;
}
else
{
Arreglo3[Indice3]=Arreglo2[Indice2]; // Si no almacena el dato de arreglo2 en arreglo3.
Indice2++;
}
Indice3++;
}
if(Indice1<Arreglo1.length) // Si valor de Indice1 es menor al tamano del arreglo1.
System.arraycopy(Arreglo1,Indice1,Arreglo3,Indice3,Arreglo1.length-Indice1);
/*
*Copiar dos arrays en uno con Java (arraycopy).
*
Los parámetros que recibe el método Java .arrayCopy son:
* Array origen
* Posición inicial del array origen
* Array destino
* Posición incial en el array de destino
* Numero de elementos a copiar del array origen al array destino
*/
else
System.arraycopy(Arreglo2,Indice2,Arreglo3,Indice3,Arreglo2.length-Indice2);
}
public static void erc(int arre[]) // Metodo erc, con el argumento arre[](un arreglo).
{
if(arre.length<=1) // Si el tamano del arreglo es igual o mayor a 1.
return;
int tamano1=arre.length/2; // Divide el arreglo en dos partes.
int tamano2=arre.length-tamano1;
int PrimeraMitad[]=new int[tamano1]; // Declara dos arreglos con el tamano antes dividido.
int SegundaMitad[]=new int[tamano2];
System.arraycopy(arre,0,PrimeraMitad,0,tamano1); // Inserto primera mitad de datos en arreglo PrimeraMitad
System.arraycopy(arre,tamano1,SegundaMitad,0,tamano2); // Inserto segunda mitad de datos en arreglo SegundaMitad.
erc(PrimeraMitad);
erc(SegundaMitad);
IntercalacionDirectaErnestoRosales.Inter(PrimeraMitad,SegundaMitad,arre); // Relacion de metodo IDER e Inter. con
} // atributos PM,SM y arre.
public static void main(String args[])throws IOException
{
BufferedReader erc=new BufferedReader(new InputStreamReader(System.in));
System.out.println("Tamano de vector"); // Pido tamano de vector desde teclado.
int t=Integer.parseInt(erc.readLine());
int[] v=new int[t];
System.out.println("\nIngresa datos\n"); // Solicito que usuario ingrese datos.
for(int i=0;i<t;i++)
{
try{
System.out.println("Dato "+(i+1)+ ":");
v[i]=Integer.parseInt(erc.readLine());
}
catch(Exception e) // Exepcion en caso de que no ingrese numero.
{
System.out.println("Numero");
}
}
IntercalacionDirectaErnestoRosales.erc(v);
System.out.println("Vector ordenado: "); // Imprimo datos ordenados.
for(int i=0;i<t;i++)
{
System.out.println(" " + v[i]);
}
}
}
Intercalacion Directa Swing
/* Proyecto Final de las materias Topicos Selectos de Programacion y Estructura de Datos/
* Programa de intercalacion directa en swing.
* Fuente: .....------ Conocimientos adquiridos e investigacion en distintas fuentes ------.....
*********************************************
* InGeNiErIa En SiStEmAs CoMpUtAcIoNaLeS *
* InStItUtO tEcNoLoGiCo SuPeRiOr De JeReZ *
* EsTrUcTuRa De DaToS *
* ErNeStO rOsAlEs CaRlOs *
* ernestorosales@live.com *
*********************************************
*/
import javax.swing.*;
import java.awt.event.*;
import java.awt.*;
class IntercalacionDirectaSwing extends JFrame
{
JLabel l1,l2;
JTextField t1;
JButton b1;
public IntercalacionDirectaSwing()
{
setSize(300,350);
setTitle("Intercalacion Directa");
setVisible(true);
setDefaultCloseOperation(HIDE_ON_CLOSE);
setLocationRelativeTo(null);
Container contenedor=getContentPane();
contenedor.setLayout(new FlowLayout());
l1=new JLabel("Programa de Intercalacion Directa");
contenedor.add(l1);
l2=new JLabel("Tamano de vector");
contenedor.add(l2);
t1=new JTextField(10);
contenedor.add(t1);
b1=new JButton("HaCeR");
contenedor.add(b1);
ManejadorCamposTexto m=new ManejadorCamposTexto();
b1.addActionListener(m);
}
private static void Inter(int[] Arreglo1, int[] Arreglo2, int[] Arreglo3)
{
int Indice1=0;
int Indice2=0;
int Indice3=0;
while(Indice1<Arreglo1.length && Indice2<Arreglo2.length)
{
if(Arreglo1[Indice1]<Arreglo2[Indice2])
{
Arreglo3[Indice3]=Arreglo1[Indice1] ;
Indice1++;
}
else
{
Arreglo3[Indice3]=Arreglo2[Indice2];
Indice2++;
}
Indice3++;
}
if(Indice1<Arreglo1.length)
System.arraycopy(Arreglo1,Indice1,Arreglo3,Indice3,Arreglo1.length-Indice1);
else
System.arraycopy(Arreglo2,Indice2,Arreglo3,Indice3,Arreglo2.length-Indice2);
}
public static void erc(int arre[])
{
if(arre.length<=1)
return;
int tamano1=arre.length/2;
int tamano2=arre.length-tamano1;
int PrimeraMitad[]=new int[tamano1];
int SegundaMitad[]=new int[tamano2];
System.arraycopy(arre,0,PrimeraMitad,0,tamano1);
System.arraycopy(arre,tamano1,SegundaMitad,0,tamano2);
erc(PrimeraMitad);
erc(SegundaMitad);
IntercalacionDirectaSwing.Inter(PrimeraMitad,SegundaMitad,arre);
}
public static void main (String args[])
{
new IntercalacionDirectaSwing();
}
private class ManejadorCamposTexto implements ActionListener
{
public void actionPerformed(ActionEvent evento)
{
if(evento.getSource()==b1)
{
if(t1.getText().equals(""))
{
JOptionPane.showMessageDialog(null,"Ingresa Dato");
}
else
{
String nt=t1.getText();
int t=Integer.parseInt(nt);
int[] v=new int[t];
for(int i=0;i<t;i++)
{
v[i]=Integer.parseInt(JOptionPane.showInputDialog("Ingresa dato "+(i+1)+" : "));
}
t1.setText("");
IntercalacionDirectaSwing.erc(v);
//<<<<<<<<<<<<<<<<<<<<<<<<<<<<< Codigo obtenido de la pag:
//***************************** http://www.daniweb.com/forums/thread14841.html
//***************************** Permite imprimir el arreglo en un Mensaje de dialogo.
StringBuilder builder = new StringBuilder(v.length);
for (int i=0;i<v.length;builder.append(v[i++])) builder.append(" ");
JOptionPane.showMessageDialog(null, builder.toString(), "Datos en Orden", JOptionPane.INFORMATION_MESSAGE);
}
}
}
}
}
lunes, 21 de marzo de 2011
ALGORITMO CONGRUENCIAL ADITIVO
/* Algoritmo Congruencial Aditivo
*
* Este algoritmo requiere una secuencia previa de numeros enteros, X1, X2, X3,...,Xn. para generar una secuencia nueva
* de numeros enteros que emieza en Xn+1, Xn+2,...
* Su ecuacion recursiva es:
* Xi=(Xi-1 + Xi-n) mod (M)
*
* i=n+1, n+2, n+3, ..., N.
*
* Los primeros ri pueden ser generados mediante la ecuacion:
* ri=Xi/(M-1)
*
*
* Fuente: .....------ Conocimientos adquiridos e investigacion en distintas fuentes ------.....
*********************************************
* InStItUtO tEcNoLoGiCo SuPeRiOr De JeReZ *
* InGeNiErIa En SiStEmAs CoMpUtAcIoNaLeS *
* SiMuLaCiOn *
* ErNeStO rOsAlEs CaRlOs *
* ernestorosales@live.com *
*********************************************
*/
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.border.*;
import java.util.*;
class AlgoritmoCongruencialAditivo extends JFrame
{
private Container contenedor;
private GridBagLayout esquema;
private GridBagConstraints restricciones;
JLabel l1, l2, l3, l4, l5, l6;
JButton b1,b2;
JTextField t1,t2, t3, t4, t5, t6;
JTextArea a1, a2, a3;
int numero=0, valor1=0, veces=0;
String valor, ccuadrado="", sale="", cua="", erre="", algo="", lfinal="", rtot="";
LinkedList lista=new LinkedList();
int n, num1, num2, ta1=0, ta2=0, ta3=0;
double y;
public AlgoritmoCongruencialAditivo()
{
setSize(350,350);
setTitle("Algoritmo Congruencial Aditivo");
setVisible(true);
setLocationRelativeTo(null);
setDefaultCloseOperation(HIDE_ON_CLOSE);
contenedor=getContentPane();
esquema=new GridBagLayout();
contenedor.setLayout(esquema);
//**********************************************************
//- Permite ingresar imagen de fondo. -
//----------------------------------------------------------
((JPanel)getContentPane()).setOpaque(false);
ImageIcon img = new ImageIcon("16.jpg");
JLabel fondo = new JLabel(img);
fondo.setBounds(0,0,img.getIconWidth(),img.getIconHeight());
getLayeredPane().add(fondo,JLayeredPane.FRAME_CONTENT_LAYER);
//----------------------------------------------------------
restricciones=new GridBagConstraints();
restricciones.insets=new Insets(5,5,5,5);
restricciones.fill=GridBagConstraints.BOTH;
l1=new JLabel("Algoritmo Congruencial Aditivo");
l1.setFont (new Font ("Arial", Font.BOLD, 25));
l1.setForeground (Color.BLACK);
establecerValores(0,0,4,1);
restricciones.fill=GridBagConstraints.BOTH;
esquema.setConstraints(l1,restricciones);
contenedor.add(l1);
//----- Cantidad de datos a ingresar -----
l2=new JLabel("Cantidad de datos a ingresar:");
l2.setFont(new Font("Bell MT",Font.PLAIN,14));
l2.setForeground(Color.BLUE);
establecerValores(0,2,2,1);
restricciones.fill=GridBagConstraints.CENTER;
esquema.setConstraints(l2,restricciones);
contenedor.add(l2);
t1=new JTextField(10);
t1.setToolTipText("Escribe Numero");
t1.setBorder(BorderFactory.createMatteBorder(1, 3, 1, 3, Color.BLACK));
establecerValores(2,2,2,1);
restricciones.fill=GridBagConstraints.CENTER;
esquema.setConstraints(t1,restricciones);
contenedor.add(t1);
//----- Valor del modulo -----
l3=new JLabel("Valor del modulo:");
l3.setFont(new Font("Bell MT",Font.PLAIN,14));
l3.setForeground(Color.BLUE);
establecerValores(0,3,2,1);
restricciones.fill=GridBagConstraints.CENTER;
esquema.setConstraints(l3,restricciones);
contenedor.add(l3);
t2=new JTextField(10);
t2.setToolTipText("Escribe Numero");
t2.setBorder(BorderFactory.createMatteBorder(1, 3, 1, 3, Color.BLACK));
establecerValores(2,3,2,1);
restricciones.fill=GridBagConstraints.CENTER;
esquema.setConstraints(t2,restricciones);
contenedor.add(t2);
//----- Cantidad de numeros a generar -----
l4=new JLabel("Cantidad de numeros a generar:");
l4.setFont(new Font("Bell MT",Font.PLAIN,14));
l4.setForeground(Color.BLUE);
establecerValores(0,5,2,1);
restricciones.fill=GridBagConstraints.CENTER;
esquema.setConstraints(l4,restricciones);
contenedor.add(l4);
t3=new JTextField(10);
t3.setToolTipText("Escribe Numero");
t3.setBorder(BorderFactory.createMatteBorder(1, 3, 1, 3, Color.BLACK));
establecerValores(2,5,2,1);
restricciones.fill=GridBagConstraints.CENTER;
esquema.setConstraints(t3,restricciones);
contenedor.add(t3);
b1=new JButton("HaCeR");
b1.setToolTipText("Clic Para Convertir");
b1.setBorder(new EmptyBorder(10,15,10,15));
b1.setMnemonic(KeyEvent.VK_H);
b1.setFont(new Font("Bell MT",Font.PLAIN,14));
b1.setForeground(Color.RED);
establecerValores(1,7,2,1);
restricciones.fill=GridBagConstraints.CENTER;
esquema.setConstraints(b1,restricciones);
contenedor.add(b1);
b2=new JButton("LiMpIaR");
b2.setToolTipText("Clic Para Limpiar Datos");
b2.setBorder(new EmptyBorder(10,15,10,15));
b2.setMnemonic(KeyEvent.VK_L);
b2.setFont(new Font("Bell MT",Font.PLAIN,14));
b2.setForeground(Color.RED);
establecerValores(3,7,2,1);
restricciones.fill=GridBagConstraints.CENTER;
esquema.setConstraints(b2,restricciones);
contenedor.add(b2);
l4=new JLabel("Numeros Enteros");
l4.setFont(new Font("Bell MT",Font.PLAIN,14));
l4.setForeground(Color.BLUE);
establecerValores(1,8,1,1);
restricciones.fill=GridBagConstraints.CENTER;
esquema.setConstraints(l4,restricciones);
contenedor.add(l4);
a1=new JTextArea(2,15);
a1.setEditable(false);
a1.setBorder(BorderFactory.createMatteBorder(1, 2, 1, 1, Color.BLACK));
establecerValores(1,9,3,1);
restricciones.fill=GridBagConstraints.CENTER;
esquema.setConstraints(a1,restricciones);
contenedor.add(a1);
l5=new JLabel("Xi");
l5.setFont(new Font("Bell MT",Font.PLAIN,14));
l5.setForeground(Color.BLUE);
establecerValores(2,10,1,1);
restricciones.fill=GridBagConstraints.CENTER;
esquema.setConstraints(l5,restricciones);
contenedor.add(l5);
a2=new JTextArea(10,6);
a2.setEditable(false);
a2.setBorder(BorderFactory.createMatteBorder(1, 2, 1, 1, Color.BLACK));
establecerValores(2,11,1,1);
restricciones.fill=GridBagConstraints.CENTER;
esquema.setConstraints(a2,restricciones);
contenedor.add(a2);
l6=new JLabel("Ri");
l6.setFont(new Font("Bell MT",Font.PLAIN,14));
l6.setForeground(Color.BLUE);
establecerValores(3,10,1,1);
restricciones.fill=GridBagConstraints.CENTER;
esquema.setConstraints(l6,restricciones);
contenedor.add(l6);
a3=new JTextArea(10,6);
a3.setEditable(false);
a3.setBorder(BorderFactory.createMatteBorder(1, 2, 1, 1, Color.BLACK));
establecerValores(3,11,1,1);
restricciones.fill=GridBagConstraints.CENTER;
esquema.setConstraints(a3,restricciones);
contenedor.add(a3);
ManejadorCamposTexto m=new ManejadorCamposTexto();
b1.addActionListener(m);
b2.addActionListener(m);
pack();
}
//********************************************************************************************
public void establecerValores(int columna,int fila, int anchura, int altura)
{
restricciones.gridx=columna;
restricciones.gridy=fila;
restricciones.gridwidth=anchura;
restricciones.gridheight=altura;
}
//*******************************************************************************************
public static void main(String args[])
{
new AlgoritmoCongruencialAditivo();
}
private class ManejadorCamposTexto implements ActionListener
{
public void actionPerformed(ActionEvent evento)
{
if (evento.getSource()==b1)
{
if(t1.getText().equals(""))
{
JOptionPane.showMessageDialog(null,"Ingresa numero de datos deseados");
}
if(t2.getText().equals(""))
{
JOptionPane.showMessageDialog(null,"Ingresa modulo");
}
if(t3.getText().equals(""))
{
JOptionPane.showMessageDialog(null,"Ingresa cantidad de datos a generar");
}
else
{
try
{
int datos=Integer.parseInt(t1.getText());
int modulo=Integer.parseInt(t2.getText());
int cantidad=Integer.parseInt(t3.getText());
if(datos<=0)
{
JOptionPane.showMessageDialog(null,"El numero de datos debe ser \nmayorr a 0","error",JOptionPane.ERROR_MESSAGE);
t1.setText("");
}
else
{
if(modulo<=0)
{
JOptionPane.showMessageDialog(null,"El numero modulo debe ser \nmayor a 0","error",JOptionPane.ERROR_MESSAGE);
t2.setText("");
}
else
{
if(cantidad<=0)
{
JOptionPane.showMessageDialog(null,"El numero de datos debe ser \nmayor a 0","error",JOptionPane.ERROR_MESSAGE);
t3.setText("");
}
else
{
for(int i=0; i<datos; i++)
{
n=Integer.parseInt(JOptionPane.showInputDialog("Ingresa dato "+(i+1)+" : "));
lista.addLast(n);
sale+=n+" ";
ta1++;
}
for(int i=0; i<cantidad; i++)
{
String dat1=String.valueOf(lista.get(datos-1+i));
int da1=Integer.parseInt(dat1);
String dat2=String.valueOf(lista.get(i));
int da2=Integer.parseInt(dat2);
ta2++;
ta3=ta1+ta2;
n=(da1+da2)% modulo;
lista.addLast(n);
lfinal+="x"+ta3+": "+n+"\n";
y=n*1.0/(modulo-1);
String yt=String.format("%.5f",y);
rtot+="r"+i+": "+yt+"\n";
}
a1.setText(sale);
a2.setText(lfinal);
a3.setText(rtot);
}
}
}
}
catch(java.lang.NumberFormatException e)
{
JOptionPane.showMessageDialog(null,"Dato invalido");
t1.setText("");
t2.setText("");
t3.setText("");
t4.setText("");
}
}
}
if(evento.getSource()==b2)
{
t1.setText("");
t2.setText("");
t3.setText("");
a1.setText("");
a2.setText("");
a3.setText("");
//----- Permite vaciar el arreglo -----
if(sale != null && lfinal != null && rtot != null)
{
sale="";
lfinal="";
rtot="";
}
lista.clear();
}
}
}
}
Suscribirse a:
Entradas (Atom)