Ejercicios, introducción

Introducción.

Raíces de una ecuación de segundo grado

$a x^{2} + b x + c = 0 x_{1,2} = \frac{- b \pm \sqrt{b^{2} - 4 a c}}{2 a} x'_{1,2} = \frac{- 2 c}{b \pm \sqrt{b^{2} - 4 a c}}$

Calcular las raíces x_1,2y 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

$\begin{array}{l} e^{x} = 1 + x + \frac{x^{2}}{2!} + ... + \frac{x^{n}}{n!} + ... \\ \sin (x) = \sum_{0}^{\infty} {(- 1)}^{n} \frac{x^{2 n + 1}}{(2 n + 1)!} \end{array}$

cuando se proporciona el dato de x.

Comparar:

e² 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 \cdot \tan 60 º - \frac{x^{2}}{80}$

Solución

Alcance:

y=0, x=80·tan60=138

Altura máxima

$\frac{d y}{d x} = 0 x = 40 \cdot \tan 60 y = 20 \cdot \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

$\begin{array}{l} Ψ_{n} (x) = \frac{H_{n} (x)}{\sqrt{2^{n} \sqrt{π} n!}} \exp (- \frac{x^{2}}{2}) \\ H_{0} (x) = 1 \\ H_{1} (x) = 2 x \\ ..... \\ Relación de recurrencia \\ H_{n} (x) = 2 x H_{n - 1} (x) - 2 (n - 1) H_{n - 2} (x) \end{array}$

H_n(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)} = \sum_{n = 1}^{2 N} {(- 1)}^{n} \frac{n}{n + 1}$

La expresión equivalente

$S_{N}^{(2)} = - \sum_{n = 1}^{N} \frac{2 n - 1}{2 n} + \sum_{n = 1}^{N} \frac{2 n}{2 n + 1}$

La expresión más simplificada

$S_{N}^{(3)} = \sum_{n = 1}^{N} \frac{1}{2 n (2 n + 1)}$

Aunque las tres sumas son iguales matemáticamente, pueden ser diferentes numéricamente.

Supongamos que S⁽³⁾ es la respuesta exacta. Representar gráficamente

$\log_{10} | \frac{S_{N}^{(1)} - S_{N}^{(3)}}{S_{N}^{(3)}} |$ en función de log₁₀(N)

Comenzar con N=1 y terminar con N=1 000 000.

Recordar que $\log_{10} x = \frac{\ln x}{\ln 10}$

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;
 }
}