Erste Schritte Potenzmethode per double

[ocsme]

Hallo,

ich möchte gerne eine Potenzmethode schreiben die auch Funktioniert wenn man zwei double werte eingibt. Das Problem liegt eigentlich nur an k dem Exponenten denn ist dieser ja ein Bruch so habe ich ja eine Wurzel.

Ich habe so angefangen das klappt aber nur wenn k = int ist!

public static double pow(double x, double k) {
        double sum=1.0;
        while(k>0) {
            sum*=x;
            k--;
        }
        return sum;
    }

Ich müsste ja im ersten schritt mir erst mal k anschauen und es kleiner machen als 1 danach dann die gesagte Wurzel ziehen mit diesem Exponenten!
Doch ich weiß nicht so recht wie ich das machen soll.
Die Quadratwurzel und Kubikwurzel folgen noch der Code ist fast fertig. Muss ich dann für jeden Fall die passende Wurzel berechnen?

Hat jemand so etwas schon mal gemacht? Ich mach es nur aus Spaß also falls nichts gescheides dabei raus kommt wäre es nicht so schlimm doch Interessieren tut mich eben schon

LG

 

[MoxxiManagarm]

Deinen bestehenden Code so umschreiben:

public static double pow(double x, double k) {
  double result = 1.0; // bitte verwende Sum nicht für etwas was keine Summe ist
  for(int exp = 1; exp <= k; exp++) { // for-Schleife anstatt solcher while-Konstruktionen
    result *= x;
  }
  
  // für Wurzel
  double w = k - (int)k;
  // hier Wurzel

  return result;
}

 

[mihe7]

Ich würde mal vermuten, dass so etwas intern durch exp(k*ln(x)) berechnet wird. Für die numerische Berechnung der Exponentialfunktion und den Logarithmus gibt es effiziente Algorithmen. Zum Spaß kann man das aber mal über Reihenentwicklungen realisieren.

 

[ocsme]

Okay soweit habe ich das alles verstanden und es läuft mein Problem ist jetzt nur noch der Rest.
Denn wir Potenzieren ja bei k=2.33 Basis ^2. Aber was ist mit dem Rest von .33? Ich würde den jetzt erst in einen Bruch versuchen umzuwandeln was aber auch wieder keine Gute Idee ist da es ja auch zahlen gibt wie .33 die Periodisch im Binären sind.
Wie kann ich den mit Log oder exp eine Wurzel umschreiben das verstehe ich grade nicht?

Denn die können ja in einer Pow Methode nicht jede Primzahl-Wurzel Implementiert haben. Denn jede Ungerade Wurzel -1 gibt gerade das kann man ja über das Potenzgesetz ((Basis)^1/2)^1/2 = 4te Wurzel von Basis ... und so weiter rechnen doch wenn man bei der 7ten Wurzel ist wie dann?

    public static double sqrt(double x) {
        double q=1.0;
        int step=0;
       
        while(Math.abs(x-q*q)>1e-8) {
            q=(q+x/q)/2;
            step++;
        }
        return q;
    }

    public static double exp(double x) {
    int n=0;
    double an=1;
    double sn=1;
    while(Math.abs(an)>EPSILON*Math.abs(sn)) {
        an *= x/(n+1);
        sn += an;
        n++;
        }
    return sn;
    }

 

[mihe7]

Denn die können ja in einer Pow Methode nicht jede Primzahl-Wurzel Implementiert haben.

Lesen:

Ich würde mal vermuten, dass so etwas intern durch exp(k*ln(x)) berechnet wird.

pow(x, k) = exp(k*ln(x))

 

[ocsme]

achso hast du es gemeint. Hier hab ich noch einen Link für die herleitung der nten Wurzel so könnte man es sicher auch irgendwie hin bekommen. Da ich noch mehr zu tun habe lasse ich das erst einmal und versuche sowas wieder später
https://www.math.uni-sb.de/ag/wittstock/lehre/WS00/analysis1/Vorlesung/node38.html

Kennst du die Algorithmen für exp und ln z. B. die schneller (effizienter) sind als die Reihenentwicklung?
Denn mit der Reihenentwicklung habe ich jetzt einige Funktionen geschrieben das ist ja auch nicht wirklich weiter schwer

Hier mal noch ln(x) für -1<x<=1

    public static double ln1plusX(double x) {
        int n=1;
        double an=x;
        double sn=x;
        while(Math.abs(an)>EPSILON*Math.abs(sn)) {
            an *= -x*n/(n+1);
            sn += an;
            n++;
        }

EPSILON ist eine Konstante bei mir sieht so aus.

    public final static double EPSILON = 1E-16;

 

[mihe7]

Hier hab ich noch einen Link für die herleitung der nten Wurzel so könnte man es sicher auch irgendwie hin bekommen.

Dein n ist aber keine natürliche Zahl.

Kennst du die Algorithmen für exp und ln z. B. die schneller (effizienter) sind als die Reihenentwicklung?

z. B. https://de.wikipedia.org/wiki/BKM-Algorithmus - ansonsten findet man ein Uni-Skript, hab den Link aber nicht mehr - Google hilft.

 

[ocsme]

da hab ich gar nicht mehr dran gedacht ich habe ja dann eine Rationale Zahl! mhhh... misst dann weiß ich keine Annäherungsverfahren an eine N-te Wurzel
Ich könnte die Zahl mit String in einen Bruch umwandeln doch das Hilft ja alles nix! Komme ich auf eine Primzahl habe ich das Problem mit der doofen Wurzel
Denn ich kann ja nicht in meiner POW methode Math.Pow(x, k) = exp(k*ln(x)) benutzen das wäre ja doof außer ich nehme meine Reihen oder eben den BKM Algorithmus aber erstmal wichtigere Dinge machen das ist ja nur so just for fun =)

Danke für den Link

 

[ocsme]

Läuft danke ich konnte die Finger doch nicht davon lassen
Mit dem Trick von dir echt geiloooo verstehe es zwar nicht zu 100% aber es geht

Hier der Code:

public static double pow(double x, double k) {
        double tmp=1;
        for(int i=1;i<=k;i++) {
            tmp*=x;
        }
        double kk=k-(int)k;
        return tmp*exp(kk*lnxx(x));
    }

System.out.println(Undefined.pow(5, 4.1212));
System.out.println(Math.pow(5, 4.1212));

Ausgabe:
759.6178855890656
759.6178855890657

Nur für -exponenten läuft es nicht da mein log nur für positive x definiert ist und ich keine Ahnung habe wie ich eine negative Variante hin bekomme aber so läuft es ja erstmal =)
Ich denke das die Pow methode in java anders läuft es gibt sicher eine Methode die N-Te Wurzel irgendwie so zu berechnen!

LG

 

[mihe7]

m=ln(x) <=> e^m = x, also e^ln(x) = x
e^(k*ln(x)) = (e^ln(x))^k = x^k

Ich denke das die Pow methode in java anders läuft

Es ist eine native Methode. Die Implementierung fürs OpenJDK dürfte diese hier sein: https://github.com/frohoff/jdk8u-jdk/blob/master/src/share/native/java/lang/fdlibm/src/e_pow.c

 

[ocsme]

Nochmals Danke =)

Den Link verstehe ich nicht da wir noch kein c hatten vielleicht verstehe ich das ja auch dann später mal und verstehe wie es RICHTIG gemacht wird
Denn ich will es ja auch Ordentlich Lernen also viel ÜBEN

LG

 

[mihe7]

Der wichtige Punkt steht auch im Kommentar:

3. Return x**y = 2**n*exp(y'*log2)

Ohne das im Detail verstehen zu müssen, kann man erkennen, dass hier letztlich exp(y*log(x)) berechnet werden muss. Die etwas andere Darstellung dürfte sich ergeben, weil hier auf Bit-Ebene mit Gleitkommazahlen nach IEEE-754 gearbeitet wird. Das will ich jetzt aber echt nicht nachvollziehen