hfloat.java

j2me is based on j2mepolish, client & server for mobile application. menu sample

    HFloat zuGross = new HFloat("1.5");
    int addMe = 0;
    while(arg.cmp(zuKlein).intValue() == -1){
      --addMe;
      arg = arg.mlt(EUL);
    }
    while(arg.cmp(zuGross).intValue() == 1){
      ++addMe;
      arg = arg.div(EUL);
    }
    arg = arg.sbt(1);
    return arg.taylor(new HFloatHTaylor(LN_HTAYLOR)).mlt(arg).add(addMe);
  }

  public HFloat sin(){
    if(!this.valid) return NaN;
    HFloat arg = mod(PI.mlt(2));
    if(arg.cmp(PI       ).intValue() > 0) return arg.sbt(PI).sin().neg();
    if(arg.cmp(PI.div(2)).intValue() > 0) return PI.sbt(arg).sin();
    return arg.quad().taylor(new HFloatHTaylor(SIN_HTAYLOR)).mlt(arg);
  }
  
  public HFloat cos(){
    if(!this.valid) return NaN;
    HFloat arg = mod(PI.mlt(2));
    if(arg.cmp(PI       ).intValue() > 0) return arg.sbt(PI).cos().neg();
    if(arg.cmp(PI.div(2)).intValue() > 0) return PI.sbt(arg).cos().neg();
    return arg.quad().taylor(new HFloatHTaylor(COS_HTAYLOR));
  }
  
  public HFloat tan(){return sin().div(cos());}
  
  public HFloat cot(){return cos().div(sin());}
  
  public HFloat asin(){
    if(!this.valid                              ) return NaN;
    if(softCmp(0, 1, false).intValue() != 0) return NaN;
    if(cmp(               ).intValue() <  0) return neg().asin().neg();
    if(cmp("0.71"         ).intValue() >  0) return (new HFloat(1)).sbt(quad()).sqrt().acos();
    return mlt(quad().taylor(new HFloatHTaylor(ASIN_HTAYLOR)));
  }
  
  public HFloat acos(){return PI.div(2).sbt(asin());}
  
  public HFloat atan(){
    if(!this.valid) return NaN;
    if(cmp(     ).intValue() < 0) return neg().atan().neg();
    if(cmp(1    ).intValue() > 0) return PI.div(2).sbt(acot());
    if(cmp("0.5").intValue() > 0) return sbt(1).div(add(1)).atan().add(PI.div(4));
    return mlt(quad().taylor(new HFloatHTaylor(ATAN_HTAYLOR)));
  }
  
  public HFloat acot(){return inv().atan();}

  public HFloat sinh(){return exp().sbt(neg().exp()).div(2);}
  
  public HFloat cosh(){return exp().add(neg().exp()).div(2);}
  
  public HFloat tanh(){return sinh().div(cosh());}
  
  public HFloat coth(){return cosh().div(sinh());}

  public HFloat asinh(){return add(quad().add(1).sqrt()).ln();}
  
  public HFloat acosh(){return add(quad().sbt(1).sqrt()).ln();}
  
  public HFloat atanh(){return (add(1).div(sbt(1))).ln().div(2);}
  
  public HFloat acoth(){return (add(1).div(sbt(1))).ln().div(2);}

  //Hilf (protected)
  
  protected void HFloatInit(int wertA, int expoA, boolean validA){
	  this.mant  = wertA;
	  this.expo  = expoA;
	  this.valid = validA;
	  norm();
  }

  protected int[] format(long arg){
    int[] retval = new int[2];
    int   expoR  = 0;
    long  wertR  = arg;
    for(; abs(wertR) > iMax; wertR /= 10) expoR++;
    retval[0] = (int) wertR;
    retval[1] = expoR;
    return retval;
  }
  
  protected int integerParseInt(String text){
    int retval = 0;
    for(int n = 0; n < text.length(); ++n) retval = 10 * retval + "0123456789".indexOf(text.charAt(n)); 
    return retval;
  }

  protected String[] fuehrende(String text, char zch0, boolean auch){
    String[]       ret    = new String[2];
    StringBuffer[] retBuf = new StringBuffer[2];
    boolean        habe   = false;
    retBuf[0]             = new StringBuffer();
    retBuf[1]             = new StringBuffer();
    for(int wo = 0; wo < text.length(); ++wo){
      char zch1 = text.charAt(wo);
      if(zch0 == zch1){
        if(habe){
          if(auch) retBuf[0].append(zch1);
        }else{
          retBuf[1].append(zch1);
        }
      }else{
        habe = true;
        retBuf[0].append(zch1);
      }
    }
    ret[0] = retBuf[0].toString();
    ret[1] = retBuf[1].toString();
    return ret;
  }

  protected String[] stringSplit2(String text, char pat){
    String[]       ret    = new String[2];
    StringBuffer[] retBuf = new StringBuffer[2];
    int            habe   = 0;
    retBuf[0]             = new StringBuffer();
    retBuf[1]             = new StringBuffer();
    for(int wo = 0; wo < text.length(); ++wo){
      char zch = text.charAt(wo);
      if(zch == pat){
        ++habe;
      }else{
        if(habe < 2) retBuf[habe].append(zch);
      }
    }
    ret[0] = retBuf[0].toString();
    ret[1] = retBuf[1].toString();
    return ret;
  }

  protected int[] format(String text){
    int[]        retval  = new int[2];
    String[]     vorNach = new String[2];
    StringBuffer sb      = new StringBuffer();
    for(int wo = 0; wo < text.length(); ++wo){
      char zch = text.charAt(wo);
      if("0123456789e.-".indexOf(zch) == -1){
        if(zch == 'E') sb.append('e');
        if(zch == ',') sb.append('.');
      }else{
        sb.append(zch);
      }   
    }
    text                    = sb.toString();
    vorNach                 = stringSplit2(text, 'e');
    String strVorE          = vorNach[0];           
    String strNachE         = vorNach[1];           
    vorNach                 = fuehrende(strVorE, '-', false);
    String strMant          = fuehrende(vorNach[0], '0', true)[0];
    int    sgnMant          = 1 - 2 * (vorNach[1].length() % 2);
    vorNach                 = stringSplit2(strMant, '.');
    String strMantVorKomma  = vorNach[0];
    String strMantNachKomma = vorNach[1];
    vorNach                 = fuehrende(strNachE, '-', false);
    String strExpo          = fuehrende(vorNach[0], '0', true)[0];
    int    sgnExpo          = 1 - 2 * (vorNach[1].length() % 2);
    String strExpoVorKomma  = stringSplit2(strExpo, '.')[0];
    String mantStr;
    int    mantExpo;
    if("".equals(strMantVorKomma)){
      vorNach  =  fuehrende(strMantNachKomma, '0', true);
      mantStr  =  vorNach[0];
      mantExpo = -vorNach[1].length();
    }else{
      mantStr  = strMantVorKomma + strMantNachKomma;
      mantExpo = strMantVorKomma.length();
    }
    for(int n = 0; n < eInt; ++n) mantStr = mantStr + '0';
    mantStr  = mantStr.substring(0, eInt);
    int localMant = sgnMant * integerParseInt(mantStr);
    int localExpo = sgnExpo * integerParseInt(strExpoVorKomma) + mantExpo - eInt;
    retval[0] = localMant;
    retval[1] = localExpo;
    return retval;      
  } 
  
  protected void norm(){
    if(this.mant == 0){
    	this.expo = 0;
    }else{
      while(abs(this.mant) < iMin){
    	  this.expo--;
    	  this.mant *= 10;
      }
    }
  }
  
  protected int abs(int i){
    if(i < 0) return -i;
    else      return  i;
  }
  
  protected long abs(long i){
    if(i < 0) return -i;
    else      return  i;
  }

//Taylor

  public HFloat taylor(HTaylor hTaylor){
    if(!this.valid) return NaN;
    HFloat summe      = new HFloat(0);
    HFloat xN         = new HFloat(1);
    HFloat altSumme;
    for(int index = 0;; ++index){
      altSumme = summe;
      summe    = summe.add(xN.mlt(hTaylor.coeff(index)));
      xN       = xN.mlt(this);
      if(summe.cmp(altSumme).intValue() == 0) return summe;
    }
  }  
  
//Kreis- und Kugelkoordinaten
  
  public static HFloat[] polByCrt(HFloat xP, HFloat yP){
    HFloat[] retval = new HFloat[2];
    HFloat phi      = new HFloat();
    HFloat radi     = new HFloat();
    if(xP.valid && yP.valid){
      radi = xP.quad().add(yP.quad()).sqrt();
      int xCmp = xP.cmp().intValue();
      int yCmp = yP.cmp().intValue();
      switch(xCmp){
        case 1: 
          phi = yP.div(xP).atan();
          break;
        case 0: 
          phi = PI.div(2).mlt(yCmp);
          break;
        case -1: 
          phi = yP.div(xP).atan();
          phi = phi.add(HFloat.PI.mlt(-phi.cmp().intValue()));
          break;
      }
    }
    retval[0] = phi;
    retval[1] = radi;
    return retval;
  }

  public static HFloat[] crtByPol(HFloat phi, HFloat radi){
    HFloat[] retval = new HFloat[2];
    HFloat xP       = new HFloat();
    HFloat yP       = new HFloat();
    if(phi.valid && radi.valid){
      xP = radi.mlt(phi.cos());
      yP = radi.mlt(phi.sin());
    }
    retval[0] = xP;
    retval[1] = yP;
    return retval;
  }

  public static HFloat[] sphByCrt(HFloat xP, HFloat yP, HFloat zP){
    HFloat[] retval = new HFloat[3];
    HFloat bet      = new HFloat();
    HFloat lam      = new HFloat();
    HFloat radi     = new HFloat();
    if(xP.valid && yP.valid && zP.valid){
      HFloat[] pbcXY    = polByCrt(xP      , yP);
      HFloat[] pbcXYZ   = polByCrt(pbcXY[1], zP);
      lam               = pbcXY[0];
      bet               = pbcXYZ[0];
      radi              = pbcXYZ[1];
    }
    retval[0] = bet;
    retval[1] = lam;
    retval[2] = radi;
    return retval;
  }

  public static HFloat[] crtBySph(HFloat bet, HFloat lam, HFloat radi){
    HFloat[] retval = new HFloat[3];
    HFloat xP       = new HFloat();
    HFloat yP       = new HFloat();
    HFloat zP       = new HFloat();
    if(bet.valid && lam.valid && radi.valid){
      HFloat radiCosBet = radi.mlt(bet.cos());
      xP                = radiCosBet.mlt(lam.cos());
      yP                = radiCosBet.mlt(lam.sin());
      zP                = radi.mlt(bet.sin());
    }
    retval[0] = xP;
    retval[1] = yP;
    retval[2] = zP;
    return retval;
  }

//Const

  protected static final long    lMax  =             1000000000000000000L;
  protected static final int     iMax  =                      1000000000 ;
  protected static final int     iMin  =                       100000001 ;
  protected static final int     eInt  =                               9 ;
  protected static final int     eLong =                              18 ;
  public    static final HFloat  PI    = new HFloat("3.1415926535897931");
  public    static final HFloat  EUL   = new HFloat("2.7182818284590451");
  public    static final HFloat  NaN   = new HFloat("NaN"               );

//Member

  public int     mant ;
  public int     expo ;
  public boolean valid;
  
  
//Enum

  protected static final int ASIN_HTAYLOR = 0;
  protected static final int ATAN_HTAYLOR = 1;
  protected static final int COS_HTAYLOR  = 2;
  protected static final int EXP_HTAYLOR  = 3;
  protected static final int LN_HTAYLOR   = 4;
  protected static final int SIN_HTAYLOR  = 5;

}