Mostrando entradas con la etiqueta operaciones matematicas. Mostrar todas las entradas
Mostrando entradas con la etiqueta operaciones matematicas. Mostrar todas las entradas

domingo, 19 de enero de 2014

Raíz cuadrada de un numero Math.sqrt y raíces de diferentes índices Math.pow en java – Law Firm – Domains – Automovil



Para aplicarle la raíz cuadrada a un número enjava usaremos el métodoMath.sqrt

Lo único que debemos hacer es declarar una variable preferiblemente de tipo float y almacenar en ésta el resultado del métodoMath.sqrt(numero). Ejemplo si tenemos Math.sqrt(16) el resultado sería 4.

Ejemplo raíz cuadrada:
1
2
3
4
5
int numero;
System.out.println("Ingrese el radicando: ");
numero = tec.nextInt();
float resultado1 = (float) Math.sqrt(numero);
System.out.println("La raiz cuadrada de "+ numero + " es: " + resultado1);

La salida sería la siguiente:
Ingrese el radicando:
9
La raiz cuadrada de 9 es: 3.0
También si queremos podemos operar raíces cúbicas, y con cualquier índice n. Haremos algo parecido a lo mostrado en la entradaElevar un número a una potencia en java Math.pow

Ejemplo de raíz de índice n:
1
2
3
4
5
6
7
double indice, radicando;
System.out.println("Ingrese el radicando ");
radicando = tec.nextInt();
System.out.println("Ingrese el indice");
indice = tec.nextInt();
float resultado2 = (float) Math.pow(radicando, 1/indice);
System.out.println("La raíz " + indice+ " de "+ radicando+ " es "+ resultado2);

Si lo ven almacenamos el valor del radicando y del índice de la raíz en sus respectivas variables, luego el métodoMath.pow se encargará de realizar la operación.Recordemos que si tenemos la raíz cuadrada de 4 ésto sería igual a decir 4 elevado a la 1/2, por ello la operación 1/índice en el segundo parámetro del método Math.pow.

En consola vamos a ver algo parecido a lo siguiente:
Ingrese el radicando
64
Ingrese el indice
3
La raíz 3.0 de 64.0 es 4.0

Elevar un número a una potencia en java Math.pow – Hard drive – Automovil – Phone – Hipotecario



Para elevar un número a una potencia n enjava usaremos el métodoMath.pow.

Math.pow(a, b) dondea es la base yb el exponente. Es decir, sí tenemosMath.pow(2, 3) el resultado sería 8 dado que 2^3 = 8 o lo que sería lo mismo 2*2*2.

Ejemplo Potencia:
1
2
3
4
5
6
7
int n, base;
System.out.println("Ingrese la base: ");
base = tec.nextInt();
System.out.println("Ingrese el exponente");
n = tec.nextInt();
int resultado = (int) Math.pow(base, n);
System.out.println(base + " elevado a la " + n + " es igual a " + resultado);

Declaramos 2 variables de tipo entero llamadasbase yn. Pedimos al usuario que ingrese la base y el exponente y los almacenamos en las respectivas variables, luego realizamos la operación y finalmente imprimimos el resultado.

Lo que veríamos en la consola sería algo parecido a lo siguiente:
Ingrese la base:
2
Ingrese el exponente
3
2 elevado a la 3 es igual a 8

También te podría interesar:
Elevar un número a una potencia en C++
60+ Manuales y libros sobre programación para descargar
Generar número aleatorio en Java Math.random()
3 libros sobre programacion orientada a objetos
Curso Online Programacion Orientada a Objetos (JAVA, MVC)
Curso online de Programacion de Aplicaciones Android de la UPV


sábado, 7 de diciembre de 2013

Mini Calculadora en Java [Swing Biblioteca Gráfica] – cancer – Credit – Miami

En Java existe una biblioteca gráfica (Componentes Swing) la cual incluye widgets para la interfaz gráfica de usuario (cajas de texto, botones, menús entre muchos otros...).

Haciendo uso de ésta biblioteca vamos a crear una "MiniCalculadora" con las operaciones básicas como lo son: suma, resta, multiplicación y división.

Para ésta "MiniCalculadora" haremos uso de 3JTextField (campos de texto) dos para los operando y uno para mostrar el resultado , 5JButtons (botones) 4 para las operaciones 1 para salir de la aplicación y 1 para mostrar el about, a su vez 4JLabels para mostrar ciertos textos en la ventana.

Operar.java //Calculadora
  1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
import javax.swing.*;

import java.awt.event.*; // agregamos esto tambien para el boton.

public class Operar extends JFrame implements ActionListener {
private JTextField operando1, operando2, resultado;
private JButton restar, sumar, multiplicar, dividir, cerrar, acerca;
private JLabel titulo, texto1, texto2, result;
public Operar(){
setLayout(null);
//text fields
operando1 = new JTextField();
operando1.setBounds(100, 100, 100, 20);
add(operando1);
operando2 = new JTextField();
operando2.setBounds(100, 130, 100, 20);
add(operando2);
resultado = new JTextField();
resultado.setBounds(100, 160, 100, 20);
add(resultado);
//buttons
restar = new JButton("Restar");
restar.setBounds(220, 100, 100, 50);
add(restar);
restar.addActionListener(this);

sumar = new JButton("Sumar");
sumar.setBounds(220, 160, 100, 50);
add(sumar);
sumar.addActionListener(this);

multiplicar = new JButton("Multiplicar");
multiplicar.setBounds(220, 220, 100, 50);
add(multiplicar);
multiplicar.addActionListener(this);

dividir = new JButton("Dividir");
dividir.setBounds(220, 280, 100, 50);
add(dividir);
dividir.addActionListener(this);

cerrar = new JButton("Salir");
cerrar.setBounds(100, 200, 100, 50);
add(cerrar);
cerrar.addActionListener(this);

acerca = new JButton("About");
acerca.setBounds(100, 260, 100, 50);
add(acerca);
acerca.addActionListener(this);
//labels
titulo = new JLabel("Calculadora francves v1.0");
titulo.setBounds(130, 40, 200, 30);
add(titulo);

texto1 = new JLabel("Primer Valor: ");
texto1.setBounds(10, 95, 200, 30);
add(texto1);

texto2 = new JLabel("Segundo Valor: ");
texto2.setBounds(10, 125, 200, 30);
add(texto2);

result = new JLabel("Resultado: ");
result.setBounds(10, 155, 200, 30);
add(result);
}



public void actionPerformed(ActionEvent e) {
if(e.getSource() == restar){
String oper1=operando1.getText();
String oper2=operando2.getText();
int num1=Integer.parseInt(oper1);
int num2=Integer.parseInt(oper2);
int resul=num1-num2;
String total=String.valueOf(resul);
resultado.setText(total);
}
if(e.getSource() == sumar){
String oper1=operando1.getText();
String oper2=operando2.getText();
int num1=Integer.parseInt(oper1);
int num2=Integer.parseInt(oper2);
int resul=num1+num2;
String total=String.valueOf(resul);
resultado.setText(total);
}
if(e.getSource() == multiplicar){
String oper1=operando1.getText();
String oper2=operando2.getText();
int num1=Integer.parseInt(oper1);
int num2=Integer.parseInt(oper2);
int resul=num1*num2;
String total=String.valueOf(resul);
resultado.setText(total);
}
if(e.getSource() == dividir){
String oper1=operando1.getText();
String oper2=operando2.getText();
int num1=Integer.parseInt(oper1);
int num2=Integer.parseInt(oper2);
int resul=num1/num2;
String total=String.valueOf(resul);
resultado.setText(total);
}

if(e.getSource() == cerrar){
System.exit(0);
}

if(e.getSource() == acerca){
JOptionPane.showMessageDialog(null, "Calculadora francves v1.0 \n Sigueme en twitter @francves");
}
}

public static void main(String[] ar){
Operar ope = new Operar();
ope.setBounds(10, 10, 400, 400);
ope.setResizable(false);
ope.setVisible(true);
}
}

Explicación:


importjavax.swing.*;


importjava.awt.event.*;


Debemos importar esos paquetes para poder manejar las componentes Swing que vamos a utilizar en la calculadora.

Declaramos cada componente y luego le empezamos a dar ciertas características como lo son el tamaño y la posición en la pantalla.

restar.setBounds(220, 100, 100, 50);

La linea anterior le está dando ciertas características al botón "restar.setBounds(x, y, width, height);" con el parámetro "X" indicamos que tan a la izquierda o derecha se encuentra el boton, con el parámetro "Y" indicamos que tan arriba o abajo está el botón. En el tercer parámetro "width" como allí lo indica en lo ancho del botón y "Height" lo alto del botón.

Luego, debemos definir la acción que ejecutará cada botón al hacer clic sobre el. Seguimos con el ejemplo del botón "restar".


if(e.getSource()== restar){


Stringoper1=operando1.getText();


String oper2=operando2.getText();


int num1=Integer.parseInt(oper1);


int num2=Integer.parseInt(oper2);


int resul=num1-num2;


String total=String.valueOf(resul);


resultado.setText(total);


}


Con el método .getText() obtenemos el valor ingresado dentro de los campos de texto. Luego, estos valores ingresan como un tipo de datoSTRING por ello hay que convertirlos a un tipo de dato con el cual podamos realizar operaciones matemáticas, en este caso lo convertimos a int(entero). Esa conversión de tipo de dato la realizamos con el métodoInteger.parseInt() pasándole como parámetro la variable que ha guardado el valor ingresado, en nuestro caso sería la variable oper1.
Después de realizar esa conversión, el dato lo debemos guardar en una nueva variable de tipo entero.
Realizamos las operaciones respectivas y al tener un resultado, ese valor lo debemos convertir en un dato STRINGpara luego mostrarlo en el campo de texto correspondiente al resultado. Esto lo hacemos con el métodoString.valueOf(resul)pasándole como parámetro la variable que almacena el resultado. Por último Asignamos el valor de la nueva variable de tipo string que contiene el resultado al campo de texto que lo mostrará en pantalla.


1 ope.setBounds(10,10,400,400);


2 ope.setResizable(false);


3 ope.setVisible(true);


Si desean cambiar el tamaño de la ventana modifiquen el valor 400 al que ustedes deseen. Recordar que el métodosetBounds(10, 10, 400, 400);definen la posición en pantalla (en éste caso de la ventana) y el tamaño de la misma. Si desean modificar el tamaño de la pantalla a su gusto en el momento que están ejecutando el programa camabien el parámetro del metodoope.setResizable(false); de false a true.
Por último el método setVisible(true); si cambiamos el parámetro de true a false haremos invisible la ventana.

ScreenShot del programa:


Consideraciones:
La calculadora realiza operaciones con datos enteros, si desean hacerlo con datos reales (float) deben hacer uso del métodoFloat.parseFloat(Variable que deseo convertir su valor en numero real); y luego de realizar las operaciones convierte el resultado a String de la misma manera como lo hicimos previamente.