Introducción.
Raíces de una ecuación de segundo grado
a
x
2
+bx+c=0
x
1,2
=
−b±
b
2
−4ac
2a
x
'
1,2
=
−2c
b±
b
2
−4ac
Calcular las raíces x1,2 y x’1,2 de la ecuación de segundo grado
x
2
+x+
10
−n
=0 n=1,2,3...
Solución
public class Raices {
public double r1,r2;
public Raices(double r1, double r2){
this.r1=r1;
this.r2=r2;
}
}
public class Ecuacion {
private double a,b,c;
public Ecuacion(double a,double b,double c){
this.a=a;
this.b=b;
this.c=c;
}
void set_c(double c){
this.c=c;
}
public Raices raices1(){
double r1=(-b+Math.sqrt(Math.pow(b,2)-4*a*c))/(2*a);
double r2=(-b-Math.sqrt(Math.pow(b,2)-4*a*c))/(2*a);
return new Raices(r1, r2);
}
public Raices raices2(){
double r1=(-2*c)/(b+Math.sqrt(Math.pow(b,2)-4*a*c));
double r2=(-2*c)/(b-Math.sqrt(Math.pow(b,2)-4*a*c));
return new Raices(r1, r2);
}
}
public class RaicesApp {
public static void main(String[] args){
int i=1;
Ecuacion ecuacion=new Ecuacion(1.0,1.0,0.1);
System.out.println("Las raíces de la ecuación x^2+x+10^-n");
do{
System.out.println("para n="+i+
"son: x12=("+ecuacion.raices1().r1+","+ecuacion.raices1().r2+")"
+" y x12'=("+ecuacion.raices2().r1+","+ecuacion.raices2().r2+")" );
ecuacion.set_c(Math.pow(10, -(++i)));
}while(i<15);
}
}
Series
Obtener la suma de los primeros 10 términos del desarrollo
en serie de
e
x
=1+x+
x
2
2!
+...+
x
n
n!
+...
sin(x)=
∑
0
∞
(−1)
n
x
2n+1
(2n+1)!
cuando se proporciona el dato de x.
Comparar:
- e2 obtenido mediante desarrollo en serie y Math.exp(2)
- sin(π/6) obtenido mediante desarrollo en serie con Math.sin(Math.PI/6).
Solución
public class Series {
public static long factorial(int x){
long resultado=1;
for(int i=1;i<=x;i++) resultado*=i;
return resultado;
}
public static double potencia(double base, int exp){
double resultado=1.0;
for(int i=1; i<=exp; i++){
resultado*=base;
}
return resultado;
}
public static void main (String args[]){
System.out.println(" e^x es:" + exponencial(2.0));
System.out.println("Math.exp(2) es:" + Math.exp(2));
System.out.println("sin(x) es:" + seno(Math.PI/6));
System.out.println("Math.sin(Math.PI/6) es:" +Math.sin(Math.PI/6));
}
public static double exponencial(double x){
double suma = 1.0 + x;
for (int i = 2; i < 10; i++) {
suma += potencia(x, i)/factorial(i);
}
return suma;
}
public static double seno(double x){
double suma=0.0;
for(int i=0;i<10;i++){
int sgn=(i%2==0)?1:-1;
suma+=sgn*potencia(x,2*i+1)/factorial(2*i+1);
}
return suma;
}
Representación de una función
1.-Representar en un applet la parábola
y=x·tan60º−
x
2
80
Solución
Alcance:
y=0, x=80·tan60=138
Altura máxima
d
y
d
x
=
0
x
=
40
·
tan
60
y
=
20
·
tan
2
60
=
60
import java.awt.*;
import java.awt.event.*;
import java.applet.*;
public class Parabola extends Applet {
public void init(){
}
public void paint(Graphics g){
int wAlto=getSize().height;
int wAncho=getSize().width;
//dimensiones de los caracteres
int cAlto=g.getFontMetrics().getHeight();
int cAncho=g.getFontMetrics().stringWidth("0");
//origen
int orgX=5*cAncho;
int orgY=wAlto-cAncho-cAlto;
//escalas
double escalaY=(double)(orgY-cAncho)/70;
double escalaX=(double)(wAncho-orgX-cAncho)/200;
g.setColor(Color.black);
g.drawLine(orgX, orgY, wAncho, orgY);
String texto;
int x1, y1;
for(int i=0; i<=200; i+=25){
x1=orgX+(int)(i*escalaX);
g.drawLine(x1, orgY, x1, orgY+cAncho);
texto=String.valueOf(i);
g.drawString(texto, x1-g.getFontMetrics().stringWidth(texto)/2, orgY+cAlto+cAncho);
}
g.drawLine(orgX, 0, orgX, wAlto);
for(int i=0; i<=70; i+=10){
y1=orgY-(int)(i*escalaY);
g.drawLine(orgX, y1, orgX-cAncho, y1);
texto=String.valueOf(i);
g.drawString(texto, orgX-cAncho-g.getFontMetrics().stringWidth(texto), y1+cAlto/4);
}
int x2=orgX;
int y2=orgY;
g.setColor(Color.red);
for(double x=0.0; x<=200; x++){
x1=orgX+(int)(x*escalaX);
y1=orgY-(int)(f(x)*escalaY);
g.drawLine(x1, y1, x2, y2);
x2=x1; y2=y1;
}
}
double f(double x){
double y=x*Math.tan(Math.PI/3)-Math.pow(x,2)/80;
return y;
}
}
2.-Representar en un applet para cada n
Ψ
n
(x)=
H
n
(x)
2
n
π
n!
exp(
−
x
2
2
)
H
0
(x)=1
H
1
(x)=2x
.....
Relación de recurrencia
H
n
(x)=2x
H
n−1
(x)−2(n−1)
H
n−2
(x)
Hn(x) son los polinomios de Hermite
Véase el Oscilador armónico cuántico
Solución
public class ArmonicoApplet1 extends Applet {
Panel bevelPanel1 = new Panel();
Panel bevelPanel2 = new Panel();
Panel bevelPanel3 = new Panel();
Button btnDibuja = new Button();
Label label1 = new Label();
Choice chEstado = new Choice();
FlowLayout flowLayout1 = new FlowLayout();
FlowLayout flowLayout2 = new FlowLayout();
BorderLayout borderLayout1 = new BorderLayout();
BorderLayout borderLayout2 = new BorderLayout();
MiCanvas canvas;
public void init() {
int ancho = Integer.parseInt(this.getParameter("WIDTH"));
int alto = Integer.parseInt(this.getParameter("HEIGHT"));
this.setSize(new Dimension(ancho, alto));
canvas=new MiCanvas();
bevelPanel1.setBackground(Color.lightGray);
btnDibuja.setLabel("Dibuja");
btnDibuja.addActionListener(new Accion(this));
label1.setText("Estado");
flowLayout1.setAlignment(0);
flowLayout1.setVgap(1);
flowLayout2.setVgap(1);
for(int i=0; i<6; i++){
chEstado.addItem(String.valueOf(i));
}
bevelPanel1.setLayout(borderLayout1);
bevelPanel2.setBackground(Color.gray);
bevelPanel2.setLayout(flowLayout2);
bevelPanel3.setLayout(flowLayout1);
this.setLayout(borderLayout2);
this.add(bevelPanel1, BorderLayout.SOUTH);
this.add(canvas, BorderLayout.CENTER);
bevelPanel1.add(bevelPanel2, BorderLayout.EAST);
bevelPanel2.add(btnDibuja, null);
bevelPanel1.add(bevelPanel3, BorderLayout.CENTER);
bevelPanel3.add(label1, null);
bevelPanel3.add(chEstado, null);
}
void btnDibuja_actionPerformed(ActionEvent e) {
int nEstado=chEstado.getSelectedIndex();
canvas.setNuevo(nEstado);
}
//Get Applet information
public String getAppletInfo() {
return "(C) Angel Franco García. Universidad del País Vasco (España)";
}
}
class Accion implements ActionListener {
ArmonicoApplet1 adaptee;
Accion(ArmonicoApplet1 adaptee) {
this.adaptee = adaptee;
}
public void actionPerformed(ActionEvent e) {
adaptee.btnDibuja_actionPerformed(e);
}
}
public class MiCanvas extends Canvas {
//anchura y altura del canvas
int wAncho, wAlto;
//anchura y altura de un carácter
int cAlto, cAncho;
//orígenes
int orgX, orgY;
//escala
double escalaY, escalaX;
//estado
int n=0;
Polygon pol=new Polygon();
public MiCanvas() {
setBackground(Color.white);
}
void origenEscalas(Graphics g){
wAncho=getSize().width;
wAlto=getSize().height;
//dimensiones de los caracteres
cAlto=g.getFontMetrics().getHeight();
cAncho=g.getFontMetrics().stringWidth("0");
//escalas
escalaY=(double)(wAlto-3*cAlto)/7.0;
escalaX=(double)(wAncho-cAlto)/7.0;
//orígenes
orgX=wAncho/2;
orgY=wAlto-2*cAlto;
}
void setNuevo(int nEstado){
this.n=nEstado;
repaint();
}
//calcula la función de onda
double funcion(double x){
double y=(1.0/Math.sqrt(potencia2(n)*Math.sqrt(Math.PI)*factorial(n)))
*hermite(x, n)*Math.exp(-x*x/2);
return y;
}
//función recursiva polinomio de Hermite
private double hermite(double x, int n){
if(n==0) return 1.0;
if(n==1) return 2*x;
return (2*x*hermite(x, n-1)-2*(n-1)*hermite(x, n-2));
}
private long potencia2(int n){
long result=1;
for(int i=1; i<=n; i++){
result*=2;
}
return result;
}
private long factorial(int n){
if(n==0) return 1;
long result=1;
for(int i=1; i<=n; i++){
result*=i;
}
return result;
}
void graficaPotencial(Graphics g){
g.setColor(Color.black);
String texto;
int x1, y1;
//escala
g.drawLine(0, orgY, wAncho, orgY);
g.drawString("x", wAncho-2*cAncho, orgY-2);
for(int i=-4; i<=4; i++){
x1=orgX+(int)(escalaX*i);
g.drawLine(x1, orgY, x1, orgY+cAncho);
texto=String.valueOf(i);
g.drawString(texto, x1-g.getFontMetrics().stringWidth(texto)/2, orgY+cAncho+cAlto);
if(i==4) break;
for(int j=1; j<5; j++){
x1=orgX+(int)(escalaX*(i+(double)j/5));
g.drawLine(x1, orgY, x1, orgY+cAncho/2);
}
}
g.drawLine(orgX, orgY, orgX, 0);
g.drawString("Energía", orgX+cAncho, cAlto);
for(int i=0; i<=7; i++){
y1=orgY-(int)(escalaY*i);
g.drawLine(orgX, y1, orgX-cAncho, y1);
texto=String.valueOf(i);
g.drawString(texto, orgX-4*cAncho, y1+cAlto/2);
}
//energía potencial
pol.npoints=0;
double x=0.0;
do{
x1=orgX+(int)(x*escalaX);
y1=orgY-(int)(x*x*escalaY/2);
pol.addPoint(x1, y1);
x+=0.05;
}while(y1>0);
pol.addPoint(wAncho, 0);
pol.addPoint(wAncho, orgY);
g.setColor(Color.gray);
g.fillPolygon(pol);
for(int i=0; i<pol.npoints; i++){
pol.xpoints[i]=wAncho-pol.xpoints[i];
}
g.fillPolygon(pol);
}
void funcionOnda(Graphics g){
g.setColor(Color.blue);
int y1=orgY-(int)((n+0.5)*escalaY);
g.drawLine(0, y1, wAncho, y1);
int x1=orgX;
y1=orgY;
int x3=orgX;
int y3=orgY;
int x2, y2, x4, y4;
g.setColor(Color.red);
double x=0.0, y;
int signo=(n%2==0)?1:-1;
do{
x2=orgX+(int)(x*escalaX);
y=funcion(x);
y2=orgY-(int)((n+0.5+y)*escalaY);
g.drawLine(x1, y1, x2, y2);
x1=x2; y1=y2;
x4=orgX-(int)(x*escalaX);
y4=orgY-(int)((n+0.5+signo*y)*escalaY);
g.drawLine(x3, y3, x4, y4);
x3=x4; y3=y4;
x+=0.05;
}while(x2<wAncho);
}
public void paint(Graphics g){
origenEscalas(g);
graficaPotencial(g);
funcionOnda(g);
}
}
Errores
Considérese la suma
S
N
(1)
=
∑
n=1
2N
(−1)
n
n
n+1
La expresión equivalente
S
N
(2)
=−
∑
n=1
N
2n−1
2n
+
∑
n=1
N
2n
2n+1
La expresión más simplificada
S
N
(3)
=
∑
n=1
N
1
2n(2n+1)
Aunque las tres sumas son iguales matemáticamente, pueden
ser diferentes numéricamente.
Supongamos que S(3) es la respuesta
exacta. Representar gráficamente
log
10
|
S
N
(1)
−
S
N
(3)
S
N
(3)
|
en función de log10(N)
Comenzar con N=1 y terminar con N=1 000 000.
Recordar que
log
10
x=
lnx
ln10
Nota: utilizar en los cálculos float (precisión
simple) en vez de double.
Solución
import java.awt.*;
import java.awt.event.*;
import java.applet.*;
public class SumasApplet extends Applet {
public void init() {
}
public void paint(Graphics g){
int wAlto=getSize().height;
int wAncho=getSize().width;
//dimensiones de los caracteres
int cAlto=g.getFontMetrics().getHeight();
int cAncho=g.getFontMetrics().stringWidth("0");
//origen y ejes
int orgX=5*cAncho;
int orgY=wAlto-cAncho-cAlto;
double escalaY=(double)(orgY-cAncho)/10;
double escalaX=(double)(wAncho-orgX-cAncho)/6;
g.setColor(Color.black);
g.drawLine(orgX, orgY, wAncho, orgY);
String texto;
int x1, y1;
for(int i=0; i<=6; i++){
x1=orgX+(int)(i*escalaX);
g.drawLine(x1, orgY, x1, orgY+cAncho);
texto=String.valueOf(i);
g.drawString(texto, x1-g.getFontMetrics().stringWidth(texto)/2, orgY+cAlto+cAncho);
}
g.drawLine(orgX, 0, orgX, wAlto);
for(int i=0; i<=10; i++){
y1=orgY-(int)(i*escalaY);
g.drawLine(orgX, y1, orgX-cAncho, y1);
texto=String.valueOf(i);
g.drawString(texto, orgX-cAncho-g.getFontMetrics().stringWidth(texto), y1+cAlto/4);
}
int x2, y2;
g.setColor(Color.red);
x1=orgX;
y1=orgY+(int)(f(1)*escalaY);
for(double x=0; x<6; x+=0.06){
int n=(int)(Math.pow(10, x));
y2=orgY+(int)(f(n)*escalaY);
x2=orgX+(int)(Math.log(n)*escalaX/Math.log(10));
g.drawLine(x1, y1, x2, y2);
x1=x2; y1=y2;
}
}
double f(int x){
double y=Math.log(Math.abs((suma1(x)-suma3(x))/suma3(x)))/Math.log(10);
return y;
}
float suma1(int n){
float suma=0;
float signo;
for(int i=1;i<=2*n;i++){
signo=(i%2==0)?1:-1;
suma+=signo*i/(i+1);
}
return suma;
}
float suma3(int n){
float suma=0;
for(int i=1;i<=n;i++){
suma+=1F/(2*i*(2*i+1));
}
return suma;
}
}