✔ log() Function Programmieren
- Themenstarter melmager
- Beginndatum
Thomas Darimont
Erfahrenes Mitglied
Hallo!
Schau mal hier:
Die pow Methode kann man sich zur Not auch noch selbst stricken... aber welches "höhere" System bietet denn keine Logarithmus Funktion an? Kann ich mir ja gar nicht vorstellen...
Gruß Tom
Schau mal hier:
Code:
/*
* Created on 03.02.2005@10:06:51
*
* TODO Licence info
*/
package de.tutorials;
/**
* @author Darimont
*
* TODO Explain me
*/
public class LogTest {
public static void main(String[] args) {
System.out.println(ln(10)); // 2.3025850929940455;
/*
* Nach der Regel: Logarithmus der Zahl a zur Basis b ist gleich dem
* Logarithmus der Zahl a zur Basis e, geteilt durch den Logartihmus der
* Zahl b zur Basis e. Mit e ist die Eulersche Zahl gemeint.
*
* Beispiel logarithmus der Zahl 2 zur Basis 10:
*/
double lg = ln(2) / ln(10);
System.out.println(lg); //0.30102999566398114
}
public static double ln(double x) {
double log = 0.0D;
double t = (x - 1.0D) / (x + 1.0D);
for (int i = 0; i < 100; i++) {
log += Math.pow(t, (2.0D * i + 1.0D)) / (2.0D * i + 1.0D);
}
log *= 2.0D;
return log;
}
}Die pow Methode kann man sich zur Not auch noch selbst stricken... aber welches "höhere" System bietet denn keine Logarithmus Funktion an? Kann ich mir ja gar nicht vorstellen...
Gruß Tom
Zuletzt bearbeitet:
Servus,
Also den Logarithmus kannst du dir über die Taylorreihe berechen, das bringt aber auch nur richtig was mit Fließkomma zahlen .. bei Integern würde ich dies über Shift Operationen machen, da ja jedes Bit fuer eine 2er Potenz steht kann man log2(X) berechnen, dabei entfällt jedoch der Teil hinterm Komma weg .. oder du machst dir ne Tabelle und benutzt zusätzlich ln(a*b) = ln(a) + ln(b)
usw .. ausserdem ist es wichtig ob die Zahlen als Integer angesehen werden oder als Fractional (festkomma zahlen)
Es gibt kein Computer und den wirds wohl auch nie nicht geben der reelle Zahlen darstellen kann, aber das ist ne andere geschichte.... du meinst wohl fließkomma Zahlen
Also den Logarithmus kannst du dir über die Taylorreihe berechen, das bringt aber auch nur richtig was mit Fließkomma zahlen .. bei Integern würde ich dies über Shift Operationen machen, da ja jedes Bit fuer eine 2er Potenz steht kann man log2(X) berechnen, dabei entfällt jedoch der Teil hinterm Komma weg .. oder du machst dir ne Tabelle und benutzt zusätzlich ln(a*b) = ln(a) + ln(b)
usw .. ausserdem ist es wichtig ob die Zahlen als Integer angesehen werden oder als Fractional (festkomma zahlen)
SilentWarrior
Erfahrenes Mitglied
Ähm... ich glaube schon, dass ihm das klar war. Aber es heisst halt nunmal Real und Integer. Daran kannst du auch nix ändern.
Obwohl ich ja immer noch nicht peile, worin der Unterschied zwischen real, double und float liegt, aber nunja, das gehört nicht hierher.
SilentWarrior
Erfahrenes Mitglied
Hm das kann ich so nicht stehen lassen. Es gibt drei Zahlentypen (ok vier, aber integer ist bissle was anderes):
Also ich hoffe mal, dass das so stimmt und ich nicht nachher einen aufs Maul kriege, weil ich hier (mal wieder) Müll verzapft habe.
- Real - Single-Precision-Zahlen (Speicherplatz: 16bit)
- Double - Double-Precision-Zahlen (Speicherplatz :32bit)
- Floating-Point-Zahlen (Fliesskomma) - dazu gehören einfach beide Datentypen, da kann man also was beliebiges reinnehmen
Also ich hoffe mal, dass das so stimmt und ich nicht nachher einen aufs Maul kriege, weil ich hier (mal wieder) Müll verzapft habe.
melmager was ist eigentlich mit deinem Logarithmus.
SilenWarrior fängt sich gleich eine ;-) LOL
na is net bös gemeint
Also ich kenne FloatingPoint und integer;
FixedPoint ist auch nur ein kodierter Integer (eine festkomma zahl ); ein Integer hat sein komma nach dem niederwertigsten Bit, also nur ganze Zahlen
Single Precission ist auf 32 Bit Systemen 32 Bit/ 4 Byte lang (unser bekannter float IEEE 754 siehe auch http://en.wikipedia.org/wiki/IEEE_754 )
Double Precission ist dort 64 Bit / 8 Byte
Das kann je nach prozessor und compiler variieren.
SilenWarrior fängt sich gleich eine ;-) LOL
na is net bös gemeint
Also ich kenne FloatingPoint und integer;
FixedPoint ist auch nur ein kodierter Integer (eine festkomma zahl ); ein Integer hat sein komma nach dem niederwertigsten Bit, also nur ganze Zahlen
Single Precission ist auf 32 Bit Systemen 32 Bit/ 4 Byte lang (unser bekannter float IEEE 754 siehe auch http://en.wikipedia.org/wiki/IEEE_754 )
Double Precission ist dort 64 Bit / 8 Byte
Das kann je nach prozessor und compiler variieren.
melmager
Erfahrenes Mitglied
der liegt im Moment etwas auf Halde - sprich steht noch auf meiner to do Liste
im Moment ärgere ich mich mit J2ME rum
Erstmal muss ich es schaffen 2 Messwerte zu ermitteln dann kann ich die miteinander verwuschteln
um den dritten wert zu berechnen
Um auch noch mein Senf zum Thema Real vs Fiesskomma abzugeben:
in einigen Prorammiersprachen wird halt eine Fliesskommazahl als real definiert
Ich hoffe ich habe nicht zuviel Verwirrung gestiftet
Zuletzt bearbeitet:
melmager
Erfahrenes Mitglied
So mal den Thread aufwärm ....
ich habe eine Formel zur Berechnung des naturlichen Logarithmus gefunden:
ln x = 2 ( (x-1)/(x + 1) + ( (x-1)^3/3(x+1)^3) + ( (x-1)^5/5(x+1)^5))
ok die Formel ist gekürzt aber die Genauigkeit reicht mir - ich brauche 3 stellen hinter dem komma maximum
als Eingangswerte für x kann 1 - 100 vorkommen
da mein Kleinrechner nur Integer kann muss um Kommawerte zu bekommen mit dem 100 bzw mit dem 1000 fachen Werden intern gerechnet werden
xin = Eingangswert von 1 bis 100
zuerst ermittle ich x-1 und dabei den 100 fachen wert für 2 Nachkomma stellen
xm = (xin - 1) * 100;
dann x+1
xp = (xin + 1) * 100;
Zuerst innerhalb der Klammer rechnen
da = xm / xp ; 100 facher wert von (x-1)/(x + 1)
Jezt kommt mein Problem:
(x-1)^3/3(x+1)^3
wie drösel ich das Jetzt auf ohne den erlaubten Wertebereich von Integer zu sprengen?
xh3m = xm * xm * xm ; da könnte es schon Platzen der Integer beim Eingangs-Wert von 100
ich hatte so gedacht
(x-1)^3 sollte ja xm * xm * xm sein
(x+1)^3 solle dann xp * xp * xp sein
und dann alles mal 3
xp * xp * xp * 3
dann ist
(xm * xm * xm) / (3 * xp * xp * xp)
da ja die rechenreihenfolge bei Multiplikation und Division egal ist sollte man das doch bunt mischen können
xm / xp * xm / xp * xm / xp * 3
um für die einzelnen Rechenschritte immer Im grünen Bereich zu sein
Aber ich habe das Gefühl ich habe da ein Denkfehler drin - einfach ein ungutes Gefühl - sprich ne Milchmädchen Rechnug wurde gebaut
Hilf mir doch mal einer auf die Sprünge bitte
edit ------
sieht einer ein fehler?
ich habe eine Formel zur Berechnung des naturlichen Logarithmus gefunden:
ln x = 2 ( (x-1)/(x + 1) + ( (x-1)^3/3(x+1)^3) + ( (x-1)^5/5(x+1)^5))
ok die Formel ist gekürzt aber die Genauigkeit reicht mir - ich brauche 3 stellen hinter dem komma maximum
als Eingangswerte für x kann 1 - 100 vorkommen
da mein Kleinrechner nur Integer kann muss um Kommawerte zu bekommen mit dem 100 bzw mit dem 1000 fachen Werden intern gerechnet werden
xin = Eingangswert von 1 bis 100
zuerst ermittle ich x-1 und dabei den 100 fachen wert für 2 Nachkomma stellen
xm = (xin - 1) * 100;
dann x+1
xp = (xin + 1) * 100;
Zuerst innerhalb der Klammer rechnen
da = xm / xp ; 100 facher wert von (x-1)/(x + 1)
Jezt kommt mein Problem:
(x-1)^3/3(x+1)^3
wie drösel ich das Jetzt auf ohne den erlaubten Wertebereich von Integer zu sprengen?
xh3m = xm * xm * xm ; da könnte es schon Platzen der Integer beim Eingangs-Wert von 100
ich hatte so gedacht
(x-1)^3 sollte ja xm * xm * xm sein
(x+1)^3 solle dann xp * xp * xp sein
und dann alles mal 3
xp * xp * xp * 3
dann ist
(xm * xm * xm) / (3 * xp * xp * xp)
da ja die rechenreihenfolge bei Multiplikation und Division egal ist sollte man das doch bunt mischen können
xm / xp * xm / xp * xm / xp * 3
um für die einzelnen Rechenschritte immer Im grünen Bereich zu sein
Aber ich habe das Gefühl ich habe da ein Denkfehler drin - einfach ein ungutes Gefühl - sprich ne Milchmädchen Rechnug wurde gebaut
Hilf mir doch mal einer auf die Sprünge bitte
edit ------
Code:
public int log_nat(int wert) {
// formel : ln x = 2 ( (x-1) / (x+1) + (x-1)^3 / 3(x+1)^3 + (x-1)^5 / 5(x+1)^5)
// intern alle werte mal 100 für 2 stellen hinter dem komma
int xm , xp, ya, yb, yc, q ;
xm = (wert - 1) * 100;
xp = (wert + 1) * 100;
ya = xm / xp;
yb = ya * xm / xp * xm / xp;
yc = yb * xm / xp * xm / xp;
q = ya + yb / 3 + yc / 5;
q = q * 2;
return q;
}sieht einer ein fehler?
Zuletzt bearbeitet:
