Anterior

Procedimientos numéricos

Raíces de una ecuación

Resolver la ecuación trascendente

|gsinθ-ω2Rsinθcosθ|=μ(gcosθ+ω2Rsin2θ)

aplicando el procedimiento del punto medio para raíces múltiples . 

public class Applet1 extends Applet {
  double w=2.0;
  double mu=0.4;
//raíces de la ecuación
    static final double CERO=1e-10;
    static final double ERROR=0.001;
    final int MAXITER=200;
    final int MAXRAICES=3;
    int iRaiz;
    double[] raices=new double[MAXRAICES];

   void explorar(double xIni, double xFin, double dx){
        double y1, y2;
	    iRaiz=0;
        y1=f(xIni);
        for(double x=xIni; x<xFin; x+=dx){
            y2=f(x+dx);
//uno de los extremos del intervalo es raíz
            if(Math.abs(y1)<CERO && iRaiz<MAXRAICES){
                raices[iRaiz++]=x;
                y1=y2;
                continue;
            }
//no hay raíz en este intervalo
            if(y1*y2>=0.0){
                y1=y2;
                continue;
            }
//hay una raíz en este intervalo
            if(iRaiz<MAXRAICES){
                raices[iRaiz]=puntoMedio(x, x+dx);
                iRaiz++;
            }
            y1=y2;
        }
    }

   public double puntoMedio(double a, double b){
        double m, ym;
        int iter=0;
        do{
            m=(a+b)/2;
            ym=f(m);
            if(Math.abs(ym)<CERO)           break;
            if(Math.abs((a-b)/m)<ERROR)     break;

            if((f(a)*ym)<0)     b=m;
            else                a=m;
            iter++;
        }while(iter<MAXITER);
        return m;
    }
 double f(double x){
    double y=Math.abs(g(x))-mu;
    return y;
 }
 void calcular()
     explorar(0, 150*Math.PI/180, Math.PI/180);
     for(int i=0; i<MAXRAICES; i++){
        System.out.println(raices[i]*180/Math.PI);
    }
 }
}

Ecuación diferencial

Resolver la ecuación diferencial de segundo orden por el procedimiento de Runge-Kutta

d 2 θ d t 2 =( ω 2 cos⁡θ− g R )sin⁡θ−μ( ω 2 sin⁡ 2 θ+ g R cos⁡θ )

con las siguientes condiciones iniciales, en el instante t=0, θ=θ0, dθ/dt=0.

public class Sistema extends RungeKutta{
    double w;  //velocidad angular
    final double radio=1.0;
    double mu;  //coef. rozamiento
    public Sistema(double w, double mu, double h){
      super(h);
      this.w=w;
      this.mu=mu;
    }
    void cambiaSigno(){
      this.mu=-mu;
    }
    public double f(double x, double v, double t){
         double y=w*w*Math.sin(x)*Math.cos(x)-9.8*Math.sin(x)
/radio-mu*(w*w*Math.sin(x)*Math.sin(x)+9.8*Math.cos(x)/radio);
         return y;
    }
    double cociente(double x){
      double y=(w*w*Math.sin(x)*Math.cos(x)-9.8*Math.sin(x)/radio)
/(w*w*Math.sin(x)*Math.sin(x)+9.8*Math.cos(x)/radio);
      return Math.abs(y);
    }
}
public class MiCanvas extends Canvas {
   Sistema sistema=null;
   Estado estado=new Estado(0.0, Math.PI/6, 0.0);
//...
 void setNuevo(double vAngular, double ang, double roza){
    estado=new Estado(0.0, ang, 0.0);
    sistema=new Sistema(vAngular, roza, 0.01);
    if(vAngular>Math.sqrt(9.8/radio)){
      angulo=Math.acos(9.8/(radio*vAngular*vAngular));
    }else{
    angulo=0.0;
  }
  if(sistema.cociente(estado.x)<mu){  //se para
      sistema=null;
      return;
   }

  if(ang<angulo) {
      bIda=true;
      bVuelta=false;
  }else{
      bIda=false;
      bVuelta=true;
      sistema.cambiaSigno();       //mu negativo
  }
 }
  void mover(){
     if(sistema!=null) sistema.resolver(estado);
    if(estado.v<0 && bIda){
       sistema.cambiaSigno();
        bIda=false;
        bVuelta=true;
        if(sistema.cociente(estado.x)<mu){  //se para
            sistema=null;
            return;
        }
    }
    if(estado.v>0 && bVuelta){
        sistema.cambiaSigno();
        bVuelta=false;
        bIda=true;
        if(sistema.cociente(estado.x)<mu){  //se para
            sistema=null;
            return;
        }
    }
  }
Anterior