Datentypen Wurzel auf n stellen nach dem Komma selber zeihen -> double zu schlecht

[Blackhole16]

Ich würde gerne die Wurzel auf n Stellen nach dem komma selber ziehen, der Zweck ist eigentlich eher zum Üben und aus eigenem Interesse/Spaß

Ich habe nun mit Näherungswerten gearbeitet, was auch gut funktioniert hat, bis darauf, dass ab der 16. (vielleicht auf 17., weiß grad nicht mehr so genau ;P) Stelle die Nachkommazahlen aufhören, und ich damit auch aufhören muss.

Nun habe ich überlegt, dass ich auch mehrere Doubles nehmen kann, immer wenn ich das Limit einer erreicht habe, nehme ich die nächste. Nur leider ist dabei das Problem gekommen, dass ich da bei der Multiplikation zum Herausfinden, ob ich schon größer als die eigentliche Zahl bin dasselbe Problem bekommen werde und es mir somit nichts nützt...

Auch habe ich mir BigDecimal angeschaut, was mir aber mehr Sorgen als Hilfe brachte und auch begrenzt ist.

Wie kann ich es also schaffen, z.B. auch auf die 1000. Nachkommastelle ein korrektes Ergebnis zu haben?

Hier mein Algo (bitte nicht über Form etc aufregen, da ist ncoh sehr viel durcheinander; Die System.out.println()s sind zur eigenen Kontrolle, eo Fehler auftreten eingebaut)

int zahl = 0;
		int stellen = 0;
		int aktStellen = 0;
		int aktTest = 0;
		double ergebnis = 0;
		boolean komma = false;
		Scanner scan = new Scanner(System.in);
		
		System.out.printf("Bitte Zahl eigeben: ");
		zahl = scan.nextInt();
		System.out.printf("\nBitte Anzahl der Stellen nach dem Komma eingeben: ");
		stellen = scan.nextInt();
		System.out.printf("Die Wurzel aus %d gerundet auf %d Stellen nach dem Komma ist:\n\n", zahl, stellen);
		
		while(aktStellen <= stellen) {
			while(ergebnis*ergebnis < zahl) {
				aktTest++;
				ergebnis+=1.0/(double)Math.pow(10, aktStellen);
					System.out.println("     + " + ergebnis);
			}
			
			if(ergebnis*ergebnis > zahl){
				ergebnis-=1.0/(double)Math.pow(10, aktStellen);
				System.out.println("     - " + ergebnis);
				aktTest--;
			}
			System.out.println(aktTest + "     " + ergebnis);
			if(!komma){
				System.out.print(",");
				komma=true;
			}
			aktStellen++;
			aktTest=0;

mfg
BH16

 

[Spacerat]

Wieso verwendest du denn nicht BigDecimal? Da hab' ich das schon für bis zu 1000 Nachkommastellen implementiert. Dann folgte PI, Euler, Logarhitmen, Potenzen, SIN, COS und TAN. BigDecimal geht aber noch sehr viel weiter als nur bis 1000 Stellen, aber das dauert irgendwann ewig. Alles unter Anleitung und Inspiration von diesem hier.

 

[jnetdev]

BigDecimal begrenzt ? Dafür hätte ich dann aber bitte mal gerne ein Beispiel. Oder meinst du das es irgendwann ab der 20ten Nachkommastelle auch ungenau wird ? Das könnte ich mir dann wirklich noch vorstellen, aber wenns auf 1000 Nachkommastellen genau sein soll musst du schon mit BigDecimal arbeiten (BigInteger ist ja nur für "Integer", also GANZE Zahlen).

 

[Blackhole16]

So, mit dem runden von BigDecimal funktioniert es jetzt. Vielleicht werde ich noch eine Funktion hinzufügen, mit der man auch die n-te wurzel ziehen kann.

Hier der Code:

import java.math.BigDecimal;
import java.util.Scanner;


public class Wurzel {
	public static void main(String args[]) throws InterruptedException {
		BigDecimal zahl;
		int stellen = 0;
		int aktStellen = 0;
		int aktTest = 0;
		BigDecimal ergebnis = new BigDecimal(0.0);
		boolean komma = false;
		Scanner scan = new Scanner(System.in);
		
		System.out.println("With this program you can calculate the square root of a number to 'n' decimal places.");
		System.out.print("Please insert your number (decimal ones with '.'): ");
		zahl = new BigDecimal(scan.nextLine());
		System.out.print("Please insert the position after decimal point: ");
		stellen = scan.nextInt();
		System.out.println("The root out of " + zahl + " with " + stellen + " decimal places is:");
		
		long startTime = System.currentTimeMillis();
		
		while(aktStellen <= stellen) {
			ergebnis = ergebnis.setScale(aktStellen, BigDecimal.ROUND_DOWN);
			while(ergebnis.multiply(ergebnis).compareTo(zahl) == -1) {
				aktTest++;
				ergebnis = ergebnis.add(new BigDecimal(1.0).divide(new BigDecimal(10).pow(aktStellen)).setScale(aktStellen, BigDecimal.ROUND_DOWN));
				ergebnis = ergebnis.setScale(aktStellen, BigDecimal.ROUND_DOWN);
			}
			
			if(ergebnis.multiply(ergebnis).compareTo(zahl) == 1){
				aktTest--;
				ergebnis = ergebnis.subtract(new BigDecimal(1.0).divide(new BigDecimal(10).pow(aktStellen)).setScale(aktStellen, BigDecimal.ROUND_DOWN));
				ergebnis = ergebnis.setScale(aktStellen, BigDecimal.ROUND_DOWN);
			}
			System.out.print(aktTest);
			if(!komma){
				System.out.print(",");
				komma=true;
			}
			aktStellen++;
			aktTest=0;
		}
		
		System.out.println("\n Your computer needed " + (System.currentTimeMillis()-startTime) + " milliseconds for that operation.");
	}
}

Mal so eine Frage, wie lange braucht euer Computer, um die 2. Wurzel auf 1000 Stellen nach dem komma auszurechnen? Ich habe 27sec gebraucht. Und für die Wurzel aus 3 habe ich 29sec gebraucht.

Ich werde hier auch wieder die n-te Wurzel reinposten, einfach, damit es mal da ist (ich habe sonst bisher noch nichts dergleichen im inet gefunden...). Oder sollte ich lieber im Codeschnipselabteil einen neuen Thread aufmachen?

Wer Lust hat, kann ja mal meinen code betrachten und mich auf Fehler, Verbesserung oder Conventionsverletzungen hinweisen.

Danke an eure Posts, sie haben mir jetzt diesen Algo gebracht

mfg
BH16

 

[Spacerat]

Also für die 2. Wurzel benötigt mein Algo 1 bis 2ms (Newtons Method). Für die 3. Wurzel ca. 3s. Meine Hardware: AMD PhenomII X4 * 3.2GHz und 8GB Speicher. Daraus schliesse ich, das bei deinem Algo irgend etwas nicht wirklich performant ist, bei deiner Hardware. Bei einem Thread wird glaub' ich ohnehin nur ein CPU-Kern verwendet.

 

[Landei]

Ich würde für Wurzeln mit hoher Genauigkeit einen Bruch zweier BigIntegers verwenden, und erst bei der benötigten Genauigkeit dividieren. Wenn man die Kettenbruchentwicklung der Wurzel kennt, dürfte das sehr schnell gehen.

Das Schema zur Berechnung findet sich hier: Continued fraction - Wikipedia, the free encyclopedia

Hier ein wenig Code für Wurzel aus 2:

public interface ContFrac {
    public int getIndex(int n);
}

import java.math.BigDecimal;
import java.math.BigInteger;
import java.math.RoundingMode;

public class ContFracCalc {

    public static BigInteger[] calc(ContFrac cf, int steps) {
        BigInteger h_2 = BigInteger.ZERO;
        BigInteger h_1 = BigInteger.ONE;
        BigInteger k_2 = BigInteger.ONE;
        BigInteger k_1 = BigInteger.ZERO;
        for(int i = 0; i < steps; i++) {
            BigInteger a = BigInteger.valueOf(cf.getIndex(i));
            BigInteger h = h_2.add(h_1.multiply(a));
            BigInteger k = k_2.add(k_1.multiply(a));
            h_2 = h_1;
            h_1 = h;
            k_2 = k_1;
            k_1 = k;
        }
        return new BigInteger[]{h_1, k_1};
    }

    public static void main(String[] args) {
        ContFrac sqrt_two = new ContFrac() {
            @Override
            public int getIndex(int n) {
                return n == 0 ? 1 : 2;
            }
        };
        BigInteger[] result = calc(sqrt_two, 100);
        System.out.println(result[0]);
        System.out.println(result[1]);
        System.out.println(new BigDecimal(result[0],100).divide(new BigDecimal(result[1],100), RoundingMode.HALF_EVEN));
    }
}

Das liefert die Ausgabe

94741125149636933417873079920900017937
66992092050551637663438906713182313772
1.4142135623730950488016887242096980785696718753769480731766797379907324784621858173900502314551910537

Wenn ich mich nicht verzählt habe, ist das immerhin auf 76 Stellen korrekt, und das bei nur hundert Schritten. Da können irgendwelche Newton-Verfahren kaum mithalten, allerdings braucht man jeweils die Kettenbruchentwicklung, die nicht immer so einfach zu ermitteln ist. Die Eulersche Zahl e ließe sich übrigens mit minimaler Änderung ebenfalls berechnen.

 

[Spacerat]

Wie Newton kann da nicht mithalten? Ist 1 bis 2ms etwa nicht schnell genug? BTW.: Bei solch geringen Zeiten wären Nanosekunden wohl angebrachter.

 

[Blackhole16]

Ich wollte erst einmal einen algo schreiben, der Stelle für Stelle exakt ausrechnet, ohne näherungswerte. Er ist leider sehr rechenintensiv, was ich selber auch schon feststellen musste. Wie könnte ich bei meinem Algo die Geschwindigkeit erhöhen? Mit Threads weiß ich nicht genau, wie ich dann sicher gehe, dass die einzelnen stellen nicht vertaudscht werden, weswegen ich halt noch nicht auf Multithreading gegangen bin. Insgesammt habe ich mit wait und notify und so noch keine Erfahrungen...
Aber kann ich bei meinem Algo die Rechnungen verringern und somit schneller machen?

Als nächstes wollte ich das Heron-Verfahren proggen und damit vergleichen (Genauigkeit, Geschwindigkeit).

@Spacerat: Und danach werde ich mir mal das Newtonsche Verfahren anschauen. Dein Algo funzt soweit erst einmal, da werde ic hacuh mal untersuchen, ob die Genauigkeit bei 100% liegt.

@Landei: Auf den ersten Blick verstehe ich ddein Programm nicht, werde i ch mir aber bei Zeiten auch anschauen.

Vielleicht bringe ich auch noch das schriftliche Rechnen ein und mache aus all den Algos ein gemeinsames Programm, mit dem man die Geschwindigkeiten und Genaukigkeiten vergleichen kann.

Sobald ich den nächsten Algo fertig habe, werde ich ihn hier auch wieder posten, bis ich beim vollständigen Programm angekommen binm, weshalb ich bitte, den Thread in dei Codeschnipüsel zu verschieben und den Namen zu ändern (wenn keiner etwas dagegen hat).

Was haltet ihr generell von der Idee?

mfg
BH16

 

[Landei]

Wie Newton kann da nicht mithalten? Ist 1 bis 2ms etwa nicht schnell genug? BTW.: Bei solch geringen Zeiten wären Nanosekunden wohl angebrachter.

Wenn sich solche Aufgaben mit Ganzzahl-Arithmetik lösen lassen, lässt sich das normalerweise kaum mit Fließkomma-Arithmetik toppen. Aber am Ende entscheidet natürlich der Benchmark...

@Landei: Auf den ersten Blick verstehe ich ddein Programm nicht, werde i ch mir aber bei Zeiten auch anschauen.

Wurzeln haben keine periodische Dezimalbruchentwicklung, aber dafür eine periodische Kettenbruchentwicklung. Die Wurzel aus 2 ist etwa [c]1 + 1/(2 + 1/(2 + 1/(2 + ...)))[/c], (was auch als [c][1;2,2,2...][/c] geschrieben wird). Das lässt sich leicht nachrechnen:

sqrt(2) = 1 + 1/(2 + x)
sqrt(2) - 1 = 1/(2 + x)   | (*)
2 + x = 1/(sqrt(2) - 1)   | rechte Seite mit (sqrt(2) + 1) erweitern
2 + x = sqrt(2) + 1
x = sqrt(2) - 1           | Gleichung (*)  einsetzen
x = 1/(2 + x)

Jetzt kann man diese Gleichung schrittweise in die erste Gleichung einsetzen:

sqrt(2) = 1 + 1/(2 + x)
sqrt(2) = 1 + 1/(2 + 1/(2 + x))
sqrt(2) = 1 + 1/(2 + 1/(2 + 1/(2 + x)))
...

Das obige Schema kann Zähler und Nenner solcher Kettenbrüche schrittweise ausrechnen, wenn man die Kettenbruchdarstellung (bei mir durch die Klasse [c]ContFrac[/c] gegeben) kennt.

 

[Spacerat]

Sieht Ok aus.

Aber woher weisst du, wie viele Kettenbruch-Elemente du benötigst um auf 1000 Stellen hinterm Komma genau zu sein? Dazu müsstest du die Zwischenergebnisse also eh' in Dezimalbrüche bringen und wärst damit wieder genau so schnell.

 

[Landei]

Ganze einfach: Wenn du eine Nährung x/y hast, ist diese garantiert näher am echten Wert als (x-1)/y oder (x+1)/y, also ist die Genauigkeit mindestens 1/y. Hat y tausend Stellen, ist man ohne kompliziertere Berechnungen auf der ganz sicheren Seite. In meinem Beispiel hat y 38 Stellen, und das Ergebnis ist auf 76 Stellen genau.

Übrigens lässt sich die ungefähre Differenz zwischen zwei Nährungsbrüchen auch ohne Bigdecimal abschätzen:

x1/y1 - x2/y2 = (x1*y2 - x2*y1)/(y1*y2)

Wenn man die Bitlänge des Zählers und des Nenners kennt (der ja etwa dem Zweierlogarithmus entspricht), kann man die ungefähre Abweichung ermitteln, und für eine Abschätzung sollte das ausreichen.

Das Problem bei der Methode ist eher, die Kettenbruchentwicklung einer beliebigen Wurzel zu ermitteln, was nicht ganz trivial ist. Mit generalisierten Kettenbrüchen geht das wohl einfacher.

 

[Spacerat]

Jetzt escalierts :lol:
Ich blicke da grad' auf meine Methode für xTe Wurzel aus y. Das mache ich so:

root(y, x) {
  return pow(y, 1/x)
}

pow(x, y) {
  if(x == 2) {
    return twoPow(y);
  }
  return pow(2, lb(x) * y);
}

"lb()" ist dabei der binäre Logarithmus einer Zahl und "twoPow()" halt das Gegenteil davon. "twoPow()" hat bereits einen integralen und einen fraktalen Part, wobei letzterer wiederum die "sqrt()"-Methode benötigt (damit benötige ich für 1000 Stellen 3sec. ). Ich denke mal da lässt sich noch jede Menge Performance rauskitzeln, aber das muss erst mal warten.

 

[Landei]

 

[Blackhole16]

@Landei: Ich habe mithilfe von google herausgefunden, dass dein Weg über den Satz des Eulers geht, und dann mit deiner Beschreibung zumindest ansatzweise die Funktionsweise verstanden. Aber wie genau müsste ich de nAlgo jetzt umschreiben, sodass er bei einer zahl x funktioniert? Oder geht das mit der Variante nicht? Denn du hast ja auch geschrieben, dass dies nicht so einfach ist. Denn mir geht es ja besonders darum aus einer Zahl x die Wurzel auf n stellen zu berechnen und nicht nur mit fixzahlen.
Und dein letzter Post (das Bild) ist irgendwie nicht richtig dargestellt, zumindest sehe ich nur einen lehren Post... Aber nice das Bild!
Kannst du mir dein Prog bitte so umschreiben, dass ich direkt die Stellenanzahl als Param übergeben kann?

@Spacerat: Ich glaube, das wird mir langsam zu hoch... Ich bin doch erst 11. Klasse und wollte einfach das Hauptproblem lösen (was inzwischen auch schon viel Neues für mcih gebracht aht, und das nicht nur Programmiertechnisch) ;D Ich meine Bitweises logarithmieren?!?
Naja egla, wenn du es fertig hast, werde ich es mit einbauen.

Übrigens: warum hat mir keiner gesagt, dass das Heron und das Newtonsche Verfahren genau dasselbe ist, nur mit anderem Namen? Als ich es dann fertig geproggt hatte, fiel mir auf, dass mein Code Spacerats ziehmlich ähnlich sah ;P

Ich werde erst einmal meinen Startalgo von der Geschwindigkeit her verbessern und jeden algo, der hier gepostet wird, mit einbinden. Am schönsten wäre es natürlich, wenn die Algos mit jeder beliebigen Zahl funktionieren, aber ich werde deinen, Landei, wegen des geschwindigkeitsvergleiches mit hineinbringen.

Und zwar soll das fertige Programm erst eine Übersicht aller algos zeigen, wo man auswählen kann mit welchem Algorithmus man arbeiten möchte und dann wird dieser gestartet. Des Weiteren soll man acuh noch einen Geschwindigkeitsvergleich machen können mit einer beliebigen Zahl auf beliebig viele Stellen entweder mit ms oder ns.

Danach verscuhe ich mal das schriftliche Wurzelziehen als algo hinzubekommen und mal sehen, was es noch so für varianten gibt

Danke für eure Hilfe und postet immer fleißig schön weiter eure codes, ich werde jeden witestgehend versucehn ins Programm einzubinden.

mfg
BH16

[EDIT]Jetzt sehe ich dein Bild doch Komisch manchmal...[/EDIT]

 

[Spacerat]

Übrigens: warum hat mir keiner gesagt, dass das Heron und das Newtonsche Verfahren genau dasselbe ist, nur mit anderem Namen? Als ich es dann fertig geproggt hatte, fiel mir auf, dass mein Code Spacerats ziehmlich ähnlich sah ;P

Dann bau den babylonischen Algo doch auch gleich mit ein (Geht am schnellsten, mit 'ner Gutenberg-Tastatur und Heron oder Newton als Vorlage). XD Mit anderen Worten: Heron, Newton und der babylonische Algo sind ein und der selbe.
Im übrigen war ich damals nur Realschüler und wir hatten Logarithmen bereits in der 10 Klasse. Ist aber schon länger her. Bischen was ist hängen geblieben, der Rest steht in Tabellenbüchern.

 

[Blackhole16]

Das mit dem babylonischen habe ich auch auf wikipedia gelesen, fiel mir beim antworten nur nicht mehr ein und ich war zu faul, um nochmal nachzugoogeln
Und logs hatten wir auch in der 10. (mal kurz angeschnitten, ich glaub 3 wochen). Aber bitweise??? Da ist doch einiges mehr an Computertechnischem Vorwissen nötig, denke ich

mfg
BH16

PS: Kennst du noch weite algos? Also außer die, die ich schon genannt habe (Aufmultiplizieren, Heron(usw), schriftlich, das von Landei (welches halt noch kein richtiger algo ist wegen der nciht vorhandenen Lösung mehrerer Zahlen. EDIT: Ich kann auch noch mithilfe von Quadratzahlen und dann der Halbierung arbeiten, mal sehen, wie das wird...

btw habe ich bei meinem algo die geschwindigkeit schon auf 1/5 verringert und schaffe es vielleicht nochmal um 50%, wobei ich noch nicht weiß, ob dass dann wirklich schneller sein wird... Werde ich sehen. Ich denke, das ich in 1-2 Tagen das Verlgeichprog fertig habe.

[EDIT]Und nochmal um 50% schneller gemacht. Und das war noch etwas anderes [/EDIT]

 

[Spacerat]

Weitere Algos kenne ich nicht. Ich kann dir ja mal die angesprochenen Teile so präsentieren, wie sie grad' sind. Ich bin mir relativ sicher, das Landei dazu schon was einfällt, wie's schneller geht aber so funktionieren jedenfalls schon mal der binäre Logarhitmus, Pozenzieren und Wurzeln aus zwei BigDecimals sowie auch die Quadratwurzel eines BigDecimals. Denkbar wäre auch noch eine Kubikwurzel.

import java.math.BigDecimal;
import java.math.BigInteger;
import java.math.RoundingMode;

public class BigDecimalMath {
	public final static BigDecimal ZERO = BigDecimal.valueOf(0);
	public final static BigDecimal ONE = BigDecimal.valueOf(1);
	public final static BigDecimal TWO = BigDecimal.valueOf(2);

	/**
	 * Binaerer Logarhitmus (Basis 2) von a
	 * Hier gibt's mit Sicherheit auch was ala Landeis Methode
	 * @param a
	 * @param scale
	 * @return
	 */
	public static BigDecimal lb(BigDecimal a, int scale) {
		if (a.compareTo(ZERO) <= 0) {
			throw new ArithmeticException("invalid argument " + a.toString());
		} else if (a.compareTo(TWO) == 0) {
			return ONE;
		} else {
			BigDecimal ip = ZERO;
			while (a.compareTo(ONE) < 0) {
				ip = ip.subtract(ONE);
				a = a.multiply(TWO);
			}
			while (a.compareTo(TWO) >= 0) {
				ip = ip.add(ONE);
				a = a.divide(TWO, scale + 2, RoundingMode.HALF_UP);
			}
			BigDecimal fp = ONE;
			BigDecimal rc = ZERO;
			while (fp.compareTo(ZERO) != 0) {
				while (a.compareTo(TWO) < 0) {
					fp = fp.divide(TWO, scale, RoundingMode.HALF_DOWN);
					a = a.multiply(a).setScale(scale + 2, RoundingMode.HALF_UP);
				}
				rc = rc.add(fp);
				a = a.divide(TWO, scale + 2, RoundingMode.HALF_UP);
			}
			return rc.add(ip).setScale(scale, RoundingMode.HALF_UP).stripTrailingZeros();
		}
	}

	/**
	 * Potenzieren zweier BigDecimals
	 * @param a
	 * @param b
	 * @param scale
	 * @return
	 */
	public static BigDecimal pow(BigDecimal a, BigDecimal b, int scale) {
		if (b.compareTo(ZERO) == 0) {
			return ONE;
		}
		if (a.compareTo(ZERO) == 0) {
			return ZERO;
		}
		if (a.compareTo(TWO) == 0) {
			return twoPow(b, scale);
		}
		return pow(TWO, lb(a, scale).multiply(b), scale);
	}

	/**
	 * Berechnet die Quadratwurzel nach Newton
	 * @param val
	 * @param scale
	 * @return
	 */
	public static BigDecimal sqrt(BigDecimal val, int scale) {
		BigDecimal x0 = ZERO;
		BigDecimal x1 = new BigDecimal(Math.sqrt(val.doubleValue()));
		while (!x0.equals(x1)) {
			x0 = x1;
			x1 = val.divide(x0, scale + 2, RoundingMode.HALF_UP);
			x1 = x1.add(x0);
			x1 = x1.divide(TWO, scale + 2, RoundingMode.HALF_UP);
		}
		val = x1;
		return val.setScale(scale, RoundingMode.HALF_UP).stripTrailingZeros();
	}

	/**
	 * Berechnet Wurzel n aus x
	 * @param x
	 * @param n
	 * @param scale
	 * @return
	 */
	public static BigDecimal root(BigDecimal x, BigDecimal n, int scale) {
		return pow(x, ONE.divide(n, scale + 2, RoundingMode.HALF_UP), scale);
	}

	/**
	 * Potenziert 2 mit X
	 * Hier gibt's mit Sicherheit auch was ala Landeis Methode
	 * @param x
	 * @param scale
	 * @return
	 */
	private static BigDecimal twoPow(BigDecimal x, int scale) {
		if (x.compareTo(ZERO) < 0) {
			return ONE.divide(twoPow(x.negate(), scale), scale, RoundingMode.HALF_UP);
		} else if (x.compareTo(ZERO) == 0) {
			return ONE;
		}
		// rein Integer
		BigInteger ix = x.toBigInteger();
		// Integer Part
		BigDecimal result = ONE;
		BigDecimal z = TWO;
		int b = ix.bitLength();
		for (int n = 0; n < b; n++) {
			if (ix.testBit(n)) {
				result = result.multiply(z).setScale(scale, RoundingMode.HALF_UP);
			}
			z = z.multiply(z);
		}
		// Fraktaler Part
		z = TWO;
		x = x.subtract(new BigDecimal(ix));
		while (x.compareTo(ZERO) == 0 || z.compareTo(ONE) != 0) {
			while (x.compareTo(ONE) < 0) {
				z = sqrt(z, scale + 2).setScale(scale, RoundingMode.HALF_DOWN);
				x = x.multiply(TWO).setScale(scale + 2, RoundingMode.HALF_DOWN);
			}
			result = result.multiply(z).setScale(scale, RoundingMode.HALF_UP);
			x = x.subtract(ONE);
		}
		return result.stripTrailingZeros();
	}
}

 

[Blackhole16]

So, das Programm steht jetzt. Man kann halt mit beiden methoden (Eulersche noch nicht, weil man halt nur die 2 machen kann) einzeln rechnen, aber auch beide in der geschwindigkeit vergleichen.

Meinen habe ich soweit modifiziert, dass ich für die Wurzel von 2 auf 1k Stellen statt der zuerst 30sec nur noch 3 brauche, worauf ich schon recht stolz bin ;P

Ich werde jetzt noch versuchen, miein Verfahren, aber auch das Heron-Verfahren (Kubikwurzeln - Mathematik - ChemieOnline Forum) hinzubekommen mit der n-ten wurzel aus m.
Dann werde ich auch noch zum Vergleich die normalen BigDecimal-Methoden reinbringen, was mir auch mal recht interessant scheint (das werde ich wohl als erstes machen).

Und dann noch all die anderen Varianten (die ich oben schon aufgezählt habe). Da weiß ich allerding noch nicht, inwiefern man iermit auch die n-te wurzel berechnen kann. Muss ich dann auch mal googeln.

@Spacerat: Ich verstehe dein Prog zwar noch nicht so ganz, werde es aber dennoch mit deiner Zustimmung hinzufügen. Du müsstest mir dann mal den Namen des Algos verraten, damit ich den gleich bei der Auswahl angeben kann. Aber ich denke, da warte ich dann acuh nochmal, bis Landei deins nochml performanter gemacht hat.

Soll ich meine jetzige Verasion schon einmal reinstellen? oder noch nicht? wenn ich sie reingestellt habe, könnt ihr ja noch performencevorschläge oder Verbesserungen machen. Dann ist das alles in Allem eine Teamarbeit (wenn es mal fertgig wird ;D ).
ich habe es consolenbasiert, da es hier schwerer ist eine GUI drumzubauen, die wirklich alles so schön macht und ich mag die console für solche mathematischen sachen auch mehr ;P
Wenn ihr wollt, könnt ihr ja trotzdem eine bauen.

Also 1.: Soll ich den Code bisher schon einmal veröffentlichen?
2. Sollte dies in den Projekte-Ordner, Codeschnipsel oder einfach hier bleiben?
3. worin sollte die Überschrift abgeändert werden?

mfg
BH16

[EDIT]Mir ist gerade aufgefallen, dass BigDecimal.pow() nur int-werte akzeptiert, womit das Java-Onboardberechnen schon einmal nicht funktioniert. Schade eigneltich. Aber vielleicht kommt da ja mal ein Update (was ich wohl eher bezweifle...)[/EDIT]

 

[Spacerat]

Also der "sqrt()"-Algo ist jener bereits Erwähnte nach Newton. Ob es für die anderen "Algos" überhaupt Namen gibt, weiss ich nicht, weil es sich halt (aus meiner Sicht) um normale Arithmetik handelt. Zum weiterverwenden bräuchtest du da nicht mal meine Zustimmung, da liegen keinerlei Rechte drauf.
Wenn sich dein Projekt öfters ändert, eignet sich wohl ein Konto bei Google-Code. Da kann man seinen Quellcode mit gängigen SVN-Tools hochladen, uptodate halten und hier verlinken. Das spart jede Menge Update-Beiträge und sowieso unnötige Doppelposts.

 

[Blackhole16]

Das mit dem sqrt ist mir schon aufgefallen, ich überlege halt nur auch noch die n-te wurzel reinzubringen.
Das mit den Rechten ist mir auch schon klar, ist halt open source, und dann auch noch in einem Forum

Ich habe mal ein Projekt bei google code erstellt. Ich komme damit zwar iwie noch nicht ganz klar, aber hier einfach mal der Link

Ich werde aber erst einmal all die anderen algos noch schreiben, dazu muss ich aber erstmal noch einen performanten quadratzahltest finden Wenn jemand einen guten hat, kann er ja mal posten, ich werde auf jeden fall auch suchen.

Möchte sonst noch jemand einen Algo übernehmen? Und wie sieht es mit den obigen Fragen aus?

mfg
BH16