# Potenzieren ohne pow



## Jats (5. Okt 2010)

Hey, ich habe jetzt nach einer Stunde google und 20 Minuten Forensuche immernoch nicht herausfinden können, wie man ohne Math.pow oder ohne pow potenzieren kann.
Unser Lehrer sagt, wir sollen die Datei zur Berechnung von Zweierpotenzen OHNE pow schreiben.
Ich denke mal, ich bin einfach schlicht und ergreifend zu dumm dafür.
Ich probier hier rum und niemals kommt was ordentliches raus.
Ich hab via Forensuche das hier gefunden, aber das verstehe ich erstens nicht und zweitens ist ja auch pow drin.

Jetzt meine einfache Frage .. wie geht das mit dem Potenzieren ohne pow und für extra Dumme ???:L
Danke schonmal 

EDIT: 

Hier ist mal meine aktuelle Datei mit Math.pow .. 


```
public class ZweierPotenzenUnendlich            //23:09Uhr, 29.09.2010 by Jats - (UN)ENDLICH oO

{

public static void main(String [] args)

{

System.out.println("Hallo Benutzer (:");


    long a = (long) 2;
    long b = (long) 0;

for (long i = (long) a; i >=b; i++)

{

    long c = (long) Math.pow(a,i);

System.out.println(a + "^" + i + "=" + c);

}


}

}
```


----------



## Gast2 (5. Okt 2010)

Math.pow(2, 7) = 2 ^ 7 = 2 * 2 * 2 * 2 * 2 * 2 * 2

Du musst dir also einfach nur eine Rekursive Methode (oder Schleife) schreiben, die dir eine Zahl y x-mal miteinander multipliziert.


----------



## ARadauer (5. Okt 2010)

naja wie EikeB schon gezeigt hat... was ist den 2 hoch 7? 

faetzminator  hat in dem von dir gepostet link sogar schon die lösung gepostet...


----------



## Michael... (5. Okt 2010)

Ich weiss ja nicht, wie man heute das Potenzieren lernt, ich hab das damals in der Schule gelernt, nicht durch google --> brain --> on, google --> off ;-)
Potenzieren ist ja nichts anderes nichts anderes als wiederholtes Multiplizieren - zumindest bei ganzzahligen Exponenten.
Rekursion ist dafür ganz schön, für Anfänger sollten aber auch einfache Schleifen ausreichen.


----------



## Jats (5. Okt 2010)

Ich kenne den Begriff "Rekursion" jetzt halt nur von ein paar Suchergebnissen und deshalb kann ich damit nicht viel anfangen.
Ich probier das mal .. und @ Michael... jaa, ich weiß zwar, wie man potenziert, aber wenn ich das hier bei Java in einer Schleife probiere kommt nur Scheiß raus -.-


----------



## SlaterB (5. Okt 2010)

ne normale Schleife geht auch, Schleife bis 7 und auf ein Ergebnis einen Faktor so oft multiplizieren


----------



## Der Müde Joe (5. Okt 2010)

>aber wenn ich das hier bei Java in einer Schleife probiere kommt nur Scheiß raus -.- 

2^3

multiplizier 3 mal die 2 oder 2*2*2

```
int result = //...
for(/* 3 mal */) { result = result*2;}
```


----------



## Michael... (5. Okt 2010)

für ganzzahlige, positive Exponenten

```
int base = 2;
int exponent = ... //was auch immer gewünscht ist
int result = 1;
for (int i=0; i<exponent; i++) {
   // Hier die Variablen multiplizieren und das Ergebnis in der richtigen Variable zwischenspeichern
}
```


----------



## M4D-M4X (5. Okt 2010)

Nur mal so rein aus Interesse:

Wie würde das ganze dann mit rekursivität aussehen?


----------



## Der Müde Joe (5. Okt 2010)

ca so

```
private static double power(double x, double y) {
    if (y == 0) {
        return 1;
    }
    if (y % 2 == 0) {
        return power(x * x, y / 2);
    } 
    return x * power(x, y - 1);
}
```


----------



## Runtime (5. Okt 2010)

Ich würde die rekursive Methode nehmen, weil man dort auch 2^2.86... rechnen kann.


----------



## SlaterB (5. Okt 2010)

welche rekursive denn, die von Der Müde Joe?
das würde ich nicht empfehlen -> StackOverflowError

schon mit Ganzzahlen sind die double-Parameter und das Rechnen /2 usw. gefährlich, 
wenn da irgendwann mal x.99999968 rauskommt wird der Vergleich == 0 nie erfüllt sein


----------



## Landei (5. Okt 2010)

Runtime hat gesagt.:


> Ich würde die rekursive Methode nehmen, weil man dort auch 2^2.86... rechnen kann.



Das funktioniert nicht. Dafür könnte man z.B. den natürlichen Logarithmus und die Exponentialfunktion (e^x) über Reihen definieren, und dann die Identität a^b = e^(b*ln(a)) verwenden.


----------



## Gast2 (5. Okt 2010)

```
Ich würde die rekursive Methode nehmen, weil man dort auch 2^2.86... rechnen kann.
```
Wie kommst du dadrauf?
Ich behaupte mal dass es bei power(2, 2.86...) nen überlauf gibt und kein ergebnis


----------



## Runtime (5. Okt 2010)

Wie macht es denn Math.pow? Da kann man doch auch sowas ausrechnen: Math.pow(10, 9.815);


----------



## Michael... (5. Okt 2010)

Runtime hat gesagt.:


> Wie macht es denn Math.pow?


Die Methode verwendet native Funktionen.

Das Berechnen von Potenzen mit rationalem Exponenten ist nicht ganz trivial.
Aber wenn hier jemand eine reine Java Lösung ohne Verwendung von Math.* und StrictMath.* präsentiert, wäre ich sehr interessiert. Ob per Schleife oder Rekursion bleibt dabei freigestellt ;-)


----------



## SlaterB (5. Okt 2010)

Creating a Java ME Math.pow() Method | Java.net
vielleicht,

Source-Link unten geht nicht, aber etwas Quellcode ist über die Seite verteilt, wenn auch alles immer in einer Zeile formatiert..

edit:
Suche auf der Seite führt zumindest zu Forumeintrag
java.net Forums : J2ME Math exp ...
mit Link auf
java.net Forums : IEEE Math on Java ME / J2ME - the real ...
da steht ne Menge Code


----------



## M4D-M4X (5. Okt 2010)

Entweder hab ich jetzt ein Verständnisproblem oder schlecht überlegt, aber:

Wenn man 4^5,5 rechnet, dann ists doch nichts anderes wie:

4*4*4*4*4*4*0,5

bekomme das selbe auch mit Math.pow...

Okay ne vergesst es... war reiner Zufall, dass es funktioniert hat


----------



## SlaterB (5. Okt 2010)

genau, der Zufall ist dass 4^0.5 = Wurzel(4) == 2 == 4 * 0.5 ist


----------



## Michael... (5. Okt 2010)

Wohl eher:
4^5,5 = (Wurzel(4))^11
In Deinem Fall kommt zwar das selbe raus liegt, aber daran, dass: Wurzel aus 4 = 4 * 0,5


----------



## Der Müde Joe (5. Okt 2010)

>Die Methode verwendet native Funktionen.

Stells jetzt hier nicht rein. Aber

Java Platform, Standard Edition 6u23 Source Snapshot Releases

Source laden
Code befindet sich unter:
j2se/src/share/native/java/lang/fdlibm/src/e_pow.c


----------



## bubka (5. Okt 2010)

also, zu Mathe: 
5.5 = 0.5 * 11  => 
4 * 5.5  ~  4 * (11 * 0.5)
Schau vielleicht Potenzen mit rationalen Exponenten an.

Darf man eigentlich die Wurzel mit *sqrt *ziehen, oder ist es auch untersagt? 
Wenn es aber auch ein Tabu ist, dann Heron-Verfahren anwenden. 

Also mit den zwei Verfahren ist dann sowas möglich:
zahl ^5,5 = zahl ^(55/10)   =>
Man kann die Zahl mit sich selbst 55 mal multiplizieren und dann durch "Heron-Verfahren" eine Wurzel ziehen.

P.S.- vielleicht geht es auch einfacher, davon habe ich aber keine Ahnung.
P.P.S.- vielleicht müsst ihr gar nicht mit rationalen Exponenten arbeiten. Dann wird ja alles viel einfacher:

```
public class Potenz {
    public static double potenz(int number, int potenz)
    {
        double n = 1; //double: IN- Potenzen, IR-Zahlen
        for (int start = 1; start <= potenz; potenz--)
            n *= number;
            return n;
    }
public static void main(String arg[])
    {
    System.out.println(potenz(3,3));
    }
}
```


----------



## mol (16. Nov 2013)

Habe folgende Aufgabe:

Aufgabe 2

*Potenzieren der Zahl2 mit ganzzahligen Werten.*

I. integer Exponent grösser gleich Null.
II. Exponent kleiner gleich Null.
powerOf2

I. _// Diesen Teil mit ganzzahligen positiven Exponenten habe ich aber Teil II. mit negativen ist schwer.._

Schreiben Sie eine Klasse Power mit einer Methode powerOf2, die einen ganzzahligen Parameter e entgegen nimmt. Falls e < 0 ist, geben Sie “FEHLER” auf der Konsole aus, sonst berechnen Sie 2e mit Hilfe eines geeigneten Schleifenkonstrukts und geben das Ergebnis ebenfalls auf der Konsole aus.

II. _// Dieser Teil ist mein Problem. Möchte es wie in Teil I machen nur mit negativen ganzzahligen Exponenten._

Ändern Sie Ihr Programm so, dass es auch für e <= 0 sinnvolle Ergebnisse
ausgibt. _// Also negative ganze Zahlen  als Exponent
_


```
public class Power { 
    int potenz = 1 ;
    int e ;
    int i ;
    
  public void setE (int getE)
    {
        
        e = getE; // Usereingabe getE wird an e übergeben. e ist unser Exponent zur Basis 2.
    }
     
    
    public void powerOf2 () 
   
    {
        if (e > 0 ) // 2er Potenz für positive ganzzahlige Exponenten I. Teilaufgabe
        
            for (i=1; i<=e; i++)
           {
             potenz = potenz *2; 
           }
           
           
          else // 2er Potenz für e ganzzahlige negative Exponenten. II. Teilaufgabe
         
           for (i=-1; i>=e; i++)
            { 
            potenz = potenz * (1/2);
            }
            
            
          System.out.println ("2 hoch " + e + " beträgt: " + potenz);
          
    }
    
    

}
```


----------

