Ankündigung

Einklappen
Keine Ankündigung bisher.

Taschenrechner Umgekehrte Polnische Notation, Wurzel ziehen

Einklappen
X
  • Filter
  • Zeit
  • Anzeigen
Alles löschen
neue Beiträge

  • Taschenrechner Umgekehrte Polnische Notation, Wurzel ziehen

    Hallo,
    ich habe einen Tachenrechner gecodet der mit Umgekehrter Notation rechnet, in diesem kann man auch die Nachkommastellen in den Properties einstellen.

    Nun meine Frage, ich habe die Standardabweichung schon gecoded, aber ich steh auf den schlauch wie die alleinige Wurzel berechnung geht.

    Code:
    import java.math.BigDecimal;
    import java.math.BigInteger;
    import java.math.MathContext;
    
    public class StdAw {
    
    	private static BigDecimal ZERO = new BigDecimal("0");
    
    	private static BigDecimal ONE = new BigDecimal("1");
    
    	private static BigDecimal TWO = new BigDecimal("2");
    
    	public static final int DEFAULT_MAX_ITERATIONS = 50;
    
    	private BigDecimal error;
    
    	private int iterations;
    
    	public int getIterations() {
    		return iterations;
    	}
    
    	private int maxIterations = DEFAULT_MAX_ITERATIONS;
    
    	public void setMaxIterations(final int maxIterations) {
    		this.maxIterations = maxIterations;
    	}
    
    	static BigDecimal getInitialApproximation(final BigDecimal n) {
    		final BigInteger integerPart = n.toBigInteger();
    		int length = integerPart.toString().length();
    		if (length % 2 == 0)
    			length--;
    		length /= 2;
    		final BigDecimal guess = ONE.movePointRight(length);
    		return guess;
    	}
    
    	public BigDecimal get(final BigDecimal n, final int scale) {
    
    		if (n.compareTo(ZERO) == 0)
    			return n;
    
    		if (n.compareTo(ZERO) < 0)
    			throw new IllegalArgumentException();
    
    		final BigDecimal initialGuess = getInitialApproximation(n);
    		BigDecimal lastGuess = ZERO;
    		BigDecimal guess = new BigDecimal(initialGuess.toString());
    
    		iterations = 0;
    		boolean more = true;
    		while (more) {
    			lastGuess = guess;
    			guess = n.divide(guess, scale, BigDecimal.ROUND_HALF_UP);
    			guess = guess.add(lastGuess);
    			guess = guess.divide(TWO, scale, BigDecimal.ROUND_HALF_UP);
    			error = n.subtract(guess.multiply(guess));
    			if (++iterations >= maxIterations)
    				more = false;
    			else if (lastGuess.equals(guess))
    				more = error.abs().compareTo(ONE) >= 0;
    		}
    		return guess.round(new MathContext(scale));
    	}
    }
    So Sieht der Code für die Standardabweichung aus, ich möchte jetzt aber eine extra Funktion die nur die Wurzel rechnet, könnte mir da wer behilflich sein?


    Danke

    Royalbunker

  • #2
    Und wo ist das problem bei der berechnung der Wurzel.

    Dafü gibt es Math.sqrt.

    Kommentar


    • #3
      Hallo,

      beim Rechnen mit der Klasse BigDecimal muss man natürlich anders vorgehen.

      Hier ist ein Beispiel für eine Wurzelfunktion.

      PHP-Code:
      //----------------------------------------------------------
      // Compute square root of large numbers using Heron's method
      //----------------------------------------------------------

      import java.math.*;

      public class 
      BigSquareRoot {

        private static 
      BigDecimal ZERO = new BigDecimal ("0");
        private static 
      BigDecimal ONE = new BigDecimal ("1");
        private static 
      BigDecimal TWO = new BigDecimal ("2");
        public static final 
      int DEFAULT_MAX_ITERATIONS 50;
        public static final 
      int DEFAULT_SCALE 10;

        private 
      BigDecimal error;
        private 
      int iterations;
        private 
      boolean traceFlag;
        private 
      int scale DEFAULT_SCALE;
        private 
      int maxIterations DEFAULT_MAX_ITERATIONS;

        
      //---------------------------------------
        // The error is the original number minus
        // (sqrt * sqrt). If the original number
        // was a perfect square, the error is 0.
        //---------------------------------------

        
      public BigDecimal getError () {
          return 
      error;
        }

        
      //-------------------------------------------------------------
        // Number of iterations performed when square root was computed
        //-------------------------------------------------------------

        
      public int getIterations () {
          return 
      iterations;
        }

        
      //-----------
        // Trace flag
        //-----------

        
      public boolean getTraceFlag () {
          return 
      traceFlag;
        }

        public 
      void setTraceFlag (boolean flag) {
          
      traceFlag flag;
        }

        
      //------
        // Scale
        //------

        
      public int getScale () {
          return 
      scale;
        }

        public 
      void setScale (int scale) {
          
      this.scale scale;
        }

        
      //-------------------
        // Maximum iterations
        //-------------------

        
      public int getMaxIterations () {
          return 
      maxIterations;
        }

        public 
      void setMaxIterations (int maxIterations) {
          
      this.maxIterations maxIterations;
        }

        
      //--------------------------
        // Get initial approximation
        //--------------------------

        
      private static BigDecimal getInitialApproximation (BigDecimal n) {
          
      BigInteger integerPart n.toBigInteger ();
          
      int length integerPart.toString ().length ();
          if ((
      length 2) == 0) {
            
      length--;
          }
          
      length /= 2;
          
      BigDecimal guess ONE.movePointRight (length);
          return 
      guess;
        }

        
      //----------------
        // Get square root
        //----------------

        
      public BigDecimal get (BigInteger n) {
          return 
      get (new BigDecimal (n));
        }

        public 
      BigDecimal get (BigDecimal n) {

          
      // Make sure n is a positive number

          
      if (n.compareTo (ZERO) <= 0) {
            throw new 
      IllegalArgumentException ();
          }

          
      BigDecimal initialGuess getInitialApproximation (n);
          
      trace ("Initial guess " initialGuess.toString ());
          
      BigDecimal lastGuess ZERO;
          
      BigDecimal guess = new BigDecimal (initialGuess.toString ());

          
      // Iterate

          
      iterations 0;
          
      boolean more true;
          while (
      more) {
            
      lastGuess guess;
            
      guess n.divide(guessscaleBigDecimal.ROUND_HALF_UP);
            
      guess guess.add(lastGuess);
            
      guess guess.divide (TWOscaleBigDecimal.ROUND_HALF_UP);
            
      trace ("Next guess " guess.toString ());
            
      error n.subtract (guess.multiply (guess));
            if (++
      iterations >= maxIterations) {
              
      more false;
            }
            else if (
      lastGuess.equals (guess)) {
              
      more error.abs ().compareTo (ONE) >= 0;
            }
          }
          return 
      guess;

        }

        
      //------
        // Trace
        //------

        
      private void trace (String s) {
          if (
      traceFlag) {
            
      System.out.println (s);
          }
        }

        
      //----------------------
        // Get random BigInteger
        //----------------------

        
      public static BigInteger getRandomBigInteger (int nDigits) {
          
      StringBuffer sb = new StringBuffer ();
          
      java.util.Random r = new java.util.Random ();
          for (
      int i 0nDigitsi++) {
            
      sb.append (r.nextInt (10));
          }
          return new 
      BigInteger (sb.toString ());
        }

        
      //-----
        // Test
        //-----

        
      public static void main (String[] args) {

          
      BigInteger n;
          
      BigDecimal sqrt;
          
      BigSquareRoot app = new BigSquareRoot ();
          
      app.setTraceFlag (true);

          
      // Generate a random big integer with a hundred digits

          
      BigSquareRoot.getRandomBigInteger (100);

          
      // Build an array of test numbers

          
      String testNums[] = {"9""30""720""1024"n.toString ()};

          for (
      int i 0testNums.lengthi++) {
            
      = new BigInteger (testNums[i]);
            if (
      0) {
              
      System.out.println ("----------------------------");
            }
            
      System.out.println ("Computing the square root of");
            
      System.out.println (n.toString ());
            
      int length n.toString ().length ();
            if (
      length 20) {
              
      app.setScale (length 2);
            }
            
      sqrt app.get (n);
            
      System.out.println ("Iterations " app.getIterations ());
            
      System.out.println ("Sqrt " sqrt.toString ());
            
      System.out.println (sqrt.multiply (sqrt).toString ());
            
      System.out.println (n.toString ());
            
      System.out.println ("Error " app.getError ().toString ());
          }

        }


      Kommentar


      • #4
        Zitat von Unregistriert Beitrag anzeigen
        Und wo ist das problem bei der berechnung der Wurzel.

        Dafü gibt es Math.sqrt.
        Das Problem ist das bei Math.sqrt nicht die Xte kommastelle noch genau ist.


        Mike, vielen Dank ich werds gleich ausprobieren.

        Kommentar

        Lädt...
        X