Eine allererste Einführung
0.1
Normales LLM
Antwortet direkt: Eingabe → Ausgabe
Schnell, ausreichend für einfache Aufgaben
Risiko: unvollständiger oder fehlerhafter Code bei komplexeren Problemen
Beispiel: „Schreibe eine Python-Funktion für Fibonacci-Zahlen“ → sofortiger Code
Thinking-LLM
Führt interne „Denk“-Schritte vor der Antwort aus
Reflektiert, prüft und verbessert den Code, bevor er ausgegeben wird
Langsamer, aber zuverlässiger bei komplexen Aufgaben
Beispiel: Überlegt Algorithmus-Varianten, Edge-Cases und Tests, bevor Code zurückkommt
Programmiersprache und gewünschte Bibliotheken benennen.
Erwünschte Signatur oder Interfaces spezifizieren und dabei möglichst präzise sein.
Erst Algorithmus erklären lassen, dann den Code generieren.
Hilft bei komplexen Problemen (Divide & Conquer im Prompt).
„Few-Shot Prompting“ mit kleinen Code-Snippets als Vorlage.
Fördert Einhaltung von Stil, Syntax und Konventionen.
Auf Testfälle im Prompt hinweisen: „Der Code muss diese Tests bestehen …“
Erst groben Entwurf generieren, dann gezielt Verbesserungen anfordern
Keine Programmiersprache/Technologien angegeben → Modell wählt zufällig.
Lösung: Sprache und Version im Prompt festlegen
Ohne Funktionssignatur oder Interfaces generiert LLM „freie“ Lösungen
Lösung: Signaturen, Klassen oder API-Vorgaben angeben
Prompt enthält Code + Prosa → Antwort enthält unnötige Erklärungen
Lösung: explizit nur Codeblock anfordern
Lange Prompts mit vielen Bedingungen führen zu Fehlern
Lösung: Problem in mehrere Teilaufgaben aufsplitten, dabei jedoch alle für einen Schritt relevanten Anforderungen benennen, um sich (viel) Nacharbeit zu sparen.
Modernere LLMs können immer besser mit komplexen Prommpts umgehen und hier sind auch weitere Verbesserungen zu erwarten.
Modell weiß nicht, wann Lösung „korrekt“ ist
Lösung: Testfälle im Prompt beilegen oder explizit anfordern
Generierter Code wird ohne Überprüfung übernommen!
Lösung: Immer Review, Linting und Tests durchführen. Insbesondere Versionen von externen Bibliotheken überprüfen, diese sind häufig nicht aktuell oder veraltet.
[...] Hoher Komplexitätsgrad als Stolperstein
Viele KI-Tools sind mittlerweile so leistungsstark geworden, dass sie Developern einen echten Mehrwert bringen. Komplexe Coding-Aufgaben können sich für Kollege KI jedoch laut der Studie als Stolperstein herausstellen. Darunter fallen etwa Aspekte wie das Kontextverständnis für sehr umfangreiche Codebasen, höhere logische Komplexitätsgrade sowie die Fähigkeit, Codestrukturen so zu planen und umzusetzen, dass ihre Qualität auch langfristig auf dem gleichen Niveau bleibt. [...]
—2.9.2025 - Heise Online - Das machen Menschen besser: Studie zeigt Grenzen von Coding-Agenten
Es ist davon auszugehen, dass sich diese Situation zeitnahe noch stärker verschieben wird, dadurch, dass die Modelle bei Unsicherheit nachfragen werden.
Das Ziel ist die Generierung einer Kommandozeilenanwendung zur Berechnung der Quadratwurzel einer Zahl mit vorgegebener, aber beliebiger Genauigkeit.
1. Schritt: Grundlegende Methode implementieren lassen.
Bitte schreibe mir eine Methode in Java, die die Newton-Raphson-Methode anwendet zur Berechnung der Quadratwurzel.
Hier ist eine Java-Methode, die mit Newtons Verfahren die Quadratwurzel einer Zahl berechnet:
1class NewtonSqrt {2/**3* Berechnet die Quadratwurzel einer Zahl mit Newtons Verfahren.4* @param n Die Zahl, deren Quadratwurzel berechnet werden soll (n >= 0)5* @param tolerance Die gewünschte Genauigkeit (z.B. 1e-10)6* @return Die berechnete Quadratwurzel von n */7public static double sqrt(double n, double tolerance) {8if (n < 0) { throw new IllegalArgumentException("n muss >= 0 sein"); }9if (n == 0) return 0;10double x = n;11while (Math.abs(x * x - n) > tolerance) {12x = 0.5 * (x + n / x);13}14return x;15}16}
Verwendung:
1public class ExampleUsage {2public static void main(String[] args) {3double wurzel = NewtonSqrt.sqrt(25, 1e-10);4System.out.println("Quadratwurzel von 25: " + wurzel);5}6}
2. Schritt: Ermöglichen einer konfigurierbaren Anzahl Stellen.
Die Methode soll in der Lage sein eine - ggf. sehr große - Anzahl an Nachkommastellen zu liefern.
Um eine sehr große Anzahl an Nachkommastellen zu berechnen, solltest du statt double die Klasse BigDecimal verwenden. Damit kannst du beliebige Genauigkeit erreichen, solange der Speicher reicht. Newtons Verfahren lässt sich auch mit BigDecimal umsetzen.
Hier ist eine Methode, die die Quadratwurzel einer Zahl mit Newtons Verfahren und beliebiger Genauigkeit berechnet:
1import java.math.BigDecimal;2import java.math.MathContext;3import java.math.RoundingMode;45public class BigDecimalNewtonSqrt {6/**7* Berechnet die Quadratwurzel einer Zahl mit Newtons Verfahren und hoher Genauigkeit.8* @param n Die Zahl, deren Quadratwurzel berechnet werden soll (n >= 0)9* @param scale Anzahl der gewünschten Nachkommastellen10* @return Die berechnete Quadratwurzel von n als BigDecimal11*/12public static BigDecimal sqrt(BigDecimal n, int scale) {13if (n.compareTo(BigDecimal.ZERO) < 0) {14throw new IllegalArgumentException("n muss >= 0 sein");15}16if (n.compareTo(BigDecimal.ZERO) == 0) return BigDecimal.ZERO;1718BigDecimal two = BigDecimal.valueOf(2);19MathContext mc = new MathContext(scale + 5, RoundingMode.HALF_UP); // Extra Stellen für Genauigkeit20BigDecimal x = n;21BigDecimal lastX;22int maxIterations = 1000;23int count = 0;2425do {26lastX = x;27x = n.divide(x, mc).add(x).divide(two, mc);28count++;29} while (x.subtract(lastX).abs().compareTo(BigDecimal.ONE.scaleByPowerOfTen(-scale)) > 0 && count < maxIterations);3031return x.setScale(scale, RoundingMode.HALF_UP);32}33}
Beispiel für die Verwendung:
1import java.math.BigDecimal;23public class BigDecimalNewtonSqrtTest {4public static void main(String[] args) {5BigDecimal n = new BigDecimal("2");6int scale = 50; // 50 Nachkommastellen7BigDecimal wurzel = BigDecimalNewtonSqrt.sqrt(n, scale);8System.out.println("Quadratwurzel von 2 mit 50 Nachkommastellen:");9System.out.println(wurzel.toPlainString());10}11}
Mit dieser Methode kannst du die Quadratwurzel mit beliebig vielen Nachkommastellen berechnen. Passe einfach den Wert von scale an deine Anforderungen an.
3. Schritt: Umwandlung in ein Kommandozeilenprogramm
Bitte stecke alle Methoden in eine Klasse und erweitere die Main Methode so, dass ich die Parameter auf der Kommandozeile eingeben kann. Erzeuge auch eine entsprechende Datei.
Hier ist die vollständige Java-Klasse BigDecimalNewtonSqrt mit Newtons Verfahren für die Quadratwurzel und einem Kommandozeilen-Interface. Die Datei wurde unter ...src/BigDecimalNewtonSqrt.java erstellt.
1import java.math.BigDecimal;2import java.math.MathContext;3import java.math.RoundingMode;45public class BigDecimalNewtonSqrt {67/**8* Berechnet die Quadratwurzel einer Zahl mit Newtons Verfahren und hoher Genauigkeit.9* @param n Die Zahl, deren Quadratwurzel berechnet werden soll (n >= 0)10* @param scale Anzahl der gewünschten Nachkommastellen11* @return Die berechnete Quadratwurzel von n als BigDecimal12*/13public static BigDecimal sqrt(BigDecimal n, int scale) {14if (n.compareTo(BigDecimal.ZERO) < 0) {15throw new IllegalArgumentException("n muss >= 0 sein");16}17if (n.compareTo(BigDecimal.ZERO) == 0) return BigDecimal.ZERO;1819BigDecimal two = BigDecimal.valueOf(2);20MathContext mc = new MathContext(scale + 5, RoundingMode.HALF_UP); // Extra Stellen für Genauigkeit21BigDecimal x = n;22BigDecimal lastX;23int maxIterations = 1000;24int count = 0;2526do {27lastX = x;28x = n.divide(x, mc).add(x).divide(two, mc);29count++;30} while (x.subtract(lastX).abs().compareTo(BigDecimal.ONE.scaleByPowerOfTen(-scale)) > 0 && count < maxIterations);3132return x.setScale(scale, RoundingMode.HALF_UP);33}3435/**36* Kommandozeilen-Interface:37* Parameter:38* args[0] - Zahl (z.B. "2")39* args[1] - Anzahl der Nachkommastellen (z.B. "50")40*/41public static void main(String[] args) {42if (args.length < 2) {43System.out.println("Verwendung: java BigDecimalNewtonSqrt <Zahl> <Nachkommastellen>");44System.out.println("Beispiel: java BigDecimalNewtonSqrt 2 50");45return;46}47try {48BigDecimal n = new BigDecimal(args[0]);49int scale = Integer.parseInt(args[1]);50BigDecimal wurzel = sqrt(n, scale);51System.out.println("Quadratwurzel von " + n.toPlainString() + " mit " + scale + " Nachkommastellen:");52System.out.println(wurzel.toPlainString());53} catch (Exception e) {54System.out.println("Fehler: " + e.getMessage());55}56}57}
Du kannst die Klasse wie folgt kompilieren und ausführen:
javac src/BigDecimalNewtonSqrt.java
java -cp src BigDecimalNewtonSqrt 2 50Das berechnet die Quadratwurzel von 2 mit 50 Nachkommastellen. Passe die Parameter nach Bedarf an.
4. Schritt: Kritisches Hinterfragen des Codes
In der Methode sqrt ist die Anzahl an Iterationen auf Max 1000 gesetzt. Sollte dies nicht abhängig sein von der Anzahl der geforderten Nachkommastellen. Wenn ich zum Beispiel 10000 Nachkommastellen anfordere, dann erwarte ich auch, dass diese Präzise sind und dies dürfte bei 1000 Iterationen nicht der Fall sein, oder?
Das ist ein sehr guter und berechtigter Hinweis! Die maximale Anzahl der Iterationen sollte tatsächlich von der gewünschten Genauigkeit (scale) abhängen. Je mehr Nachkommastellen du verlangst, desto mehr Iterationen sind in der Regel nötig, damit Newtons Verfahren konvergiert und die gewünschte Präzision erreicht wird.
Warum?
Newtons Verfahren verdoppelt grob die Anzahl der korrekten Stellen pro Iteration, aber bei sehr hoher Präzision kann es passieren, dass die Differenz zwischen zwei Iterationen so klein wird, dass sie erst nach sehr vielen Durchläufen unter die gewünschte Schwelle fällt.
Empfehlung:
Setze maxIterations proportional zur gewünschten Nachkommastellenzahl, z.B. maxIterations = Math.max(100, scale * 2) oder sogar scale * 5 für sehr hohe Sicherheit.
Hier ist die angepasste Methode:
1public static BigDecimal sqrt(BigDecimal n, int scale) {2if (n.compareTo(BigDecimal.ZERO) < 0) {3throw new IllegalArgumentException("n muss >= 0 sein");4}5if (n.compareTo(BigDecimal.ZERO) == 0) return BigDecimal.ZERO;67BigDecimal two = BigDecimal.valueOf(2);8MathContext mc = new MathContext(scale + 5, RoundingMode.HALF_UP); // Extra Stellen für Genauigkeit9BigDecimal x = n;10BigDecimal lastX;11int maxIterations = Math.max(100, scale * 5); // Dynamisch abhängig von scale12int count = 0;1314do {15lastX = x;16x = n.divide(x, mc).add(x).divide(two, mc);17count++;18} while (x.subtract(lastX).abs().compareTo(BigDecimal.ONE.scaleByPowerOfTen(-scale)) > 0 && count < maxIterations);1920if (count >= maxIterations) {21throw new ArithmeticException("Maximale Iterationszahl (" + maxIterations + ") erreicht, Ergebnis möglicherweise ungenau.");22}2324return x.setScale(scale, RoundingMode.HALF_UP);25}
Was ist neu? - maxIterations ist jetzt abhängig von scale. - Es wird eine Exception geworfen, falls die Iterationszahl überschritten wird (damit du weißt, dass das Ergebnis evtl. nicht präzise genug ist).
Mit dieser Anpassung kannst du auch sehr viele Nachkommastellen zuverlässig berechnen. Bei extrem hohen Anforderungen kann es trotzdem sinnvoll sein, die Konvergenz zu überwachen und ggf. die Startwerte oder die MathContext-Präzision weiter zu erhöhen.
5. Schritt: Dokumentation verbessern lassen
Bitte aktualisiere die Dokumentation der Methode in Hinblick darauf, dass eine ArithmeticException geworfen werden kann.
Die Dokumentation der Methode sqrt wurde aktualisiert und enthält jetzt den Hinweis, dass eine ArithmeticException geworfen werden kann, falls die maximale Iterationszahl überschritten wird und das Ergebnis möglicherweise ungenau ist.
Hier ist der relevante Ausschnitt:
1/**2* Berechnet die Quadratwurzel einer Zahl mit Newtons Verfahren und hoher Genauigkeit.3* @param n Die Zahl, deren Quadratwurzel berechnet werden soll (n >= 0)4* @param scale Anzahl der gewünschten Nachkommastellen5* @return Die berechnete Quadratwurzel von n als BigDecimal6* @throws ArithmeticException falls die maximale Iterationszahl überschritten wird und das Ergebnis möglicherweise ungenau ist7*/8public static BigDecimal sqrt(BigDecimal n, int scale) {9...10}
Damit ist die Methode und ihre Dokumentation jetzt korrekt und robust für sehr hohe Präzision.
6. Schritt: Dokumentation weiter verbessern lassen
Bitte dokumentiere bis zu wieviel Stellen die Methode aufgrund der Beschränkung des Counters auf den Datentyp Int maximal präzise sein kann.
Sehr gerne!
Da der Iterationszähler count vom Typ int ist, kann die Methode maximal Integer.MAX_VALUE Iterationen durchführen. Da die maximale Iterationszahl als maxIterations = Math.max(100, scale * 5) gesetzt wird, ist die maximale Anzahl an Nachkommastellen, die du zuverlässig berechnen kannst, durch die Größe des int-Datentyps begrenzt.
Berechnung:
Integer.MAX_VALUE = 2 147 483 647
Die Formel für die Iterationen: scale * 5 ≤ Integer.MAX_VALUE
Daraus folgt: scale ≤ Integer.MAX_VALUE / 5 ≈ 429 496 729
Dokumentationsvorschlag für die Methode:
1/**2* Berechnet die Quadratwurzel einer Zahl mit Newtons Verfahren und hoher Genauigkeit.3* <p>4* Hinweis: Die maximale Anzahl an Nachkommastellen ist durch den Datentyp {@code int} für den Iterationszähler begrenzt.5* Bei der aktuellen Implementierung mit {@code maxIterations = Math.max(100, scale * 5)} können maximal ca. 429.496.729 Nachkommastellen6* zuverlässig berechnet werden. Wird ein höherer Wert für {@code scale} angegeben, kann eine {@link ArithmeticException} auftreten.7* </p>8* @param n Die Zahl, deren Quadratwurzel berechnet werden soll (n >= 0)9* @param scale Anzahl der gewünschten Nachkommastellen (maximal ca. 429.496.729)10* @return Die berechnete Quadratwurzel von n als BigDecimal11* @throws ArithmeticException falls die maximale Iterationszahl überschritten wird und das Ergebnis möglicherweise ungenau ist12*/
Fazit:
Die Methode ist für bis zu ca. 429 Millionen Nachkommastellen präzise, sofern genügend Speicher und Rechenzeit vorhanden sind. Für noch höhere Präzision müsste der Iterationszähler auf long oder einen größeren Datentyp umgestellt werden.
7. Schritt: Kritisches Hinterfragen des Codes
Wenn ich in die Methode Int.MAX_VALUE reingebe, dann ist die Anzahl der Iterationen nicht wie erwartet. Passe den Code so an, dass bei einem zu großen Wert von scale eine Exception geworfen wird und passe auch die Dokumentation entsprechend an.
Die Methode wurde angepasst, sodass bei einem zu großen Wert für scale eine IllegalArgumentException geworfen wird. Die Dokumentation wurde ebenfalls entsprechend erweitert.
Hier ist der aktualisierte Ausschnitt:
1/**2* Berechnet die Quadratwurzel einer Zahl mit Newtons Verfahren und hoher Genauigkeit.3* <p>4* Hinweis: Die maximale Anzahl an Nachkommastellen ist durch den Datentyp {@code int} für den Iterationszähler begrenzt.5* Bei der aktuellen Implementierung mit {@code maxIterations = Math.max(100, scale * 5)} können maximal ca. 429496729 Nachkommastellen6* zuverlässig berechnet werden. Wird ein höherer Wert für {@code scale} angegeben, wird eine {@link IllegalArgumentException} geworfen.7* </p>8* @param n Die Zahl, deren Quadratwurzel berechnet werden soll (n >= 0)9* @param scale Anzahl der gewünschten Nachkommastellen (maximal ca. 429496729)10* @return Die berechnete Quadratwurzel von n als BigDecimal11* @throws IllegalArgumentException falls {@code scale} zu groß ist oder {@code n} negativ ist12* @throws ArithmeticException falls die maximale Iterationszahl überschritten wird und das Ergebnis möglicherweise ungenau ist13*/14public static BigDecimal sqrt(BigDecimal n, int scale) {15if (n.compareTo(BigDecimal.ZERO) < 0) {16throw new IllegalArgumentException("n muss >= 0 sein");17}18if (n.compareTo(BigDecimal.ZERO) == 0) return BigDecimal.ZERO;1920// Begrenzung für scale, damit maxIterations nicht über Integer.MAX_VALUE hinausgeht21int maxScale = Integer.MAX_VALUE / 5;22if (scale > maxScale) {23throw new IllegalArgumentException(24"scale ist zu groß. Maximal erlaubt: " + maxScale25);26}2728BigDecimal two = BigDecimal.valueOf(2);29MathContext mc = new MathContext(scale + 5, RoundingMode.HALF_UP); // Extra Stellen für Genauigkeit30BigDecimal x = n;31BigDecimal lastX;32int maxIterations = Math.max(100, scale * 5); // Dynamisch abhängig von scale33int count = 0;3435do {36lastX = x;37x = n.divide(x, mc).add(x).divide(two, mc);38count++;39} while (40x.subtract(lastX).abs().compareTo(BigDecimal.ONE.scaleByPowerOfTen(-scale)) >410 &&42count < maxIterations43);4445if (count >= maxIterations) {46throw new ArithmeticException(47"Maximale Iterationszahl (" +48maxIterations +49") erreicht, Ergebnis möglicherweise ungenau."50);51}5253return x.setScale(scale, RoundingMode.HALF_UP);54}
Damit ist die Methode jetzt robust gegen zu große Werte für scale und die Dokumentation informiert klar über die Begrenzung.
8. Schritt: Etwas Fordern, dass nicht bzw. nur begrenzt sinnvoll ist
Erzeuge mir ein einfaches npm Build-Script, dass Prettier verwendet, um den Code zu formatieren. Der Code soll eine maximale Breite von 70 Zeichen haben.
Hier ist ein einfaches npm Build-Script, das Prettier verwendet, um den Code zu formatieren. Die maximale Zeilenbreite ist auf 70 Zeichen gesetzt.
1. package.json
Das Format-Script und die Prettier-Dependency sind enthalten:
{
"name": "sqrt-jshell-vibecoded",
"version": "1.0.0",
"description": "Build-Script für Prettier-Codeformatierung mit max. 70 Zeichen Breite",
"scripts": {
"format": "prettier --write ."
},
"devDependencies": {
"prettier": "^3.0.0"
},
"prettier": {
"printWidth": 70
}
}2. Prettier-Konfiguration (.prettierrc)
Die maximale Breite ist explizit gesetzt:
{
"printWidth": 70
}Verwendung:
Installiere die Dependencies: sh npm install
Formatiere den Code: sh npm run format
Damit wird dein Code mit Prettier und einer Zeilenbreite von 70 Zeichen formatiert.
9. Schritt: Tests generieren lassen
Bitte generiere mir Tests für sqrt Methode.
Hier findest du eine vollständige JUnit-Testklasse für die``sqrt``-Methode. Die Datei liegt unter ./test/BigDecimalNewtonSqrtTest.java.
Die Tests prüfen:
Standardfälle (0, 1, 4, 9, 2 mit hoher Präzision)
Negative Eingabe
Zu große Präzision (scale)
Sehr große und sehr kleine Zahlen
1import org.junit.jupiter.api.Test;2import org.junit.jupiter.api.DisplayName;3import org.junit.jupiter.api.function.Executable;45import java.math.BigDecimal;67import static org.junit.jupiter.api.Assertions.*;89class BigDecimalNewtonSqrtTest {1011@Test12@DisplayName("Quadratwurzel von 0 ist 0")13void testSqrtZero() {14BigDecimal result = BigDecimalNewtonSqrt.sqrt(BigDecimal.ZERO, 10);15assertEquals(BigDecimal.ZERO.setScale(10), result);16}1718@Test19@DisplayName("Quadratwurzel von 1 ist 1")20void testSqrtOne() {21BigDecimal result = BigDecimalNewtonSqrt.sqrt(BigDecimal.ONE, 10);22assertEquals(BigDecimal.ONE.setScale(10), result);23}2425@Test26@DisplayName("Quadratwurzel von 4 ist 2")27void testSqrtFour() {28BigDecimal result = BigDecimalNewtonSqrt.sqrt(new BigDecimal("4"), 10);29assertEquals(new BigDecimal("2.0000000000"), result);30}3132@Test33@DisplayName("Quadratwurzel von 2 mit 20 Nachkommastellen")34void testSqrtTwoHighPrecision() {35BigDecimal expected = new BigDecimal("1.41421356237309504880");36BigDecimal result = BigDecimalNewtonSqrt.sqrt(new BigDecimal("2"), 20);37// Vergleiche die ersten 20 Nachkommastellen38assertEquals(expected, result);39}4041@Test42@DisplayName("Quadratwurzel von 9 ist 3")43void testSqrtNine() {44BigDecimal result = BigDecimalNewtonSqrt.sqrt(new BigDecimal("9"), 8);45assertEquals(new BigDecimal("3.00000000"), result);46}4748@Test49@DisplayName("Negative Eingabe wirft IllegalArgumentException")50void testNegativeInputThrows() {51assertThrows(IllegalArgumentException.class, () ->52BigDecimalNewtonSqrt.sqrt(new BigDecimal("-1"), 10)53);54}5556@Test57@DisplayName("Zu großer scale wirft IllegalArgumentException")58void testTooLargeScaleThrows() {59int tooLargeScale = Integer.MAX_VALUE / 5 + 1;60assertThrows(IllegalArgumentException.class, () ->61BigDecimalNewtonSqrt.sqrt(BigDecimal.ONE, tooLargeScale)62);63}6465@Test66@DisplayName("Quadratwurzel von sehr großer Zahl")67void testSqrtLargeNumber() {68BigDecimal large = new BigDecimal("1000000000000");69BigDecimal result = BigDecimalNewtonSqrt.sqrt(large, 5);70assertEquals(new BigDecimal("1000000.00000"), result);71}7273@Test74@DisplayName("Quadratwurzel von kleiner Zahl")75void testSqrtSmallNumber() {76BigDecimal small = new BigDecimal("0.0004");77BigDecimal result = BigDecimalNewtonSqrt.sqrt(small, 6);78assertEquals(new BigDecimal("0.020000"), result);79}80}
Du kannst die Tests mit JUnit 5 ausführen. Falls du Unterstützung für das Test-Setup brauchst, sag einfach Bescheid!
10. Schritt: Umstieg auf Maven als Build-Tool
Bitte erstelle mir eine Maven Konfiguration. Wenn möglich soll die Maven Konfiguration auch die Code Formatierung übernehmen und auf ein Plug-in setzten, dass auch die Dokumentation formatieren kann.
Hier ist eine Maven-Konfiguration (pom.xml), die folgende Features bietet:
JUnit 5 für Tests
Spotless Maven Plugin für die automatische Formatierung von Java-Code und JavaDoc-Kommentaren
Zeilenlänge und JavaDoc-Umbruch auf 70 Zeichen
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>de.michael.sqrt</groupId>
<artifactId>sqrt-jshell-vibecoded</artifactId>
<version>1.0.0</version>
<packaging>jar</packaging>
<name>SQRT-JShell-VibeCoded</name>
<description>Berechnung der Quadratwurzel mit Newtons Verfahren und Formatierung/Tests</description>
<properties>
<maven.compiler.source>17</maven.compiler.source>
<maven.compiler.target>17</maven.compiler.target>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<junit.version>5.10.2</junit.version>
<formatter.version>2.23.0</formatter.version>
</properties>
<dependencies>
<!-- JUnit 5 Jupiter API & Engine -->
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter</artifactId>
<version>${junit.version}</version>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<plugins>
<!-- Maven Compiler Plugin -->
<plugin>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.11.0</version>
<configuration>
<source>${maven.compiler.source}</source>
<target>${maven.compiler.target}</target>
</configuration>
</plugin>
<!-- Maven Surefire Plugin for running tests -->
<plugin>
<artifactId>maven-surefire-plugin</artifactId>
<version>3.2.5</version>
<configuration>
<useSystemClassLoader>false</useSystemClassLoader>
</configuration>
</plugin>
<!-- Spotless Plugin for code and JavaDoc formatting -->
<plugin>
<groupId>com.diffplug.spotless</groupId>
<artifactId>spotless-maven-plugin</artifactId>
<version>2.23.0</version>
<executions>
<execution>
<goals>
<goal>apply</goal>
</goals>
</execution>
</executions>
<configuration>
<java>
<googleJavaFormat>
<version>1.17.0</version>
<style>AOSP</style>
</googleJavaFormat>
<target>src/**/*.java</target>
<removeUnusedImports />
<formatAnnotations />
<importOrder>
<order>java,javax,org,com</order>
</importOrder>
<licenseHeader>
<!-- Optional: Add a license header if desired -->
</licenseHeader>
<endWithNewline>true</endWithNewline>
<indent>
<spaces>4</spaces>
</indent>
<trimTrailingWhitespace>true</trimTrailingWhitespace>
<maxLineLength>70</maxLineLength>
<javadocFormatter>
<enabled>true</enabled>
<wrapLength>70</wrapLength>
</javadocFormatter>
</java>
</configuration>
</plugin>
</plugins>
</build>
</project>Wichtige Hinweise:
Die Formatierung und das JavaDoc-Wrapping übernimmt das Spotless-Plugin mit Google Java Format und aktiviertem JavaDoc-Formatter.
Du kannst formatieren mit:
sh mvn spotless:apply
Tests laufen wie gewohnt mit:
sh mvn test
Falls du weitere Anpassungen oder eine andere Formatierungsstrategie möchtest, gib einfach Bescheid!
10. Schritt: Verwendung aktueller Tools einfordern
Bitte aktualisiere die Versionen der Plug-ins auf die neuesten Versionen.
Alle Versionen in deiner pom.xml wurden auf die neuesten stabilen Versionen aktualisiert und als Properties hinterlegt, damit du sie zentral pflegen kannst. Hier sind die wichtigsten Änderungen:
Java-Version: 21
Spotless Maven Plugin: 2.45.0
Google Java Format: 1.17.0
Maven Compiler Plugin: 3.11.0
Maven Surefire Plugin: 3.2.5
JUnit Jupiter: 5.10.2
11. Schritt: Build-Skript korrigieren
Wenn ich mvn test ausführe, dann bekomme ich: “No tests to run.” Bitte behebe das Problem.
Das Problem lag daran, dass sich deine Testklasse nicht im Standard-Maven-Testverzeichnis (src/test/java) befand. Ich habe die Datei jetzt nach src/test/java/BigDecimalNewtonSqrtTest.java verschoben.
Jetzt erkennt Maven die Tests automatisch.
Du kannst die Tests wie gewohnt mit
mvn testausführen.
Falls du weitere Testklassen hast, sollten diese ebenfalls im Verzeichnis src/test/java liegen und das Package-Statement (falls verwendet) korrekt gesetzt sein. Wenn du noch ein Package hinzufügen möchtest, kann ich das gerne für dich erledigen!
12. Schritt: Fehler korrigieren
Ein Test schlägt fehl: [ERROR] BigDecimalNewtonSqrtTest.testSqrtZero – Time elapsed: 0.003 s <<< FAILURE! org.opentest4j.AssertionFailedError: expected: <0E-10> but was: <0>
Das Problem entsteht, weil BigDecimal.ZERO.setScale(10) ergibt 0E-10, während das Ergebnis der Methode sqrt einfach 0 ist (Skalierung 0). Obwohl beide Werte mathematisch gleich sind, unterscheidet BigDecimal.equals() zwischen der Skala.
...
13. Schritt: Code verbessern
Bitte ergänze den Code so, dass negative scale Werte sinnvoll behandelt werden.
Die Methode behandelt jetzt negative Werte für scale sinnvoll:
1if (scale < 0) {2throw new IllegalArgumentException("scale muss >= 0 sein");3}
Das bedeutet:
Wenn ein negativer Wert für scale übergeben wird, wird eine aussagekräftige IllegalArgumentException geworfen. Damit ist die Eingabeprüfung für die Präzision jetzt vollständig und robust.
14. Schritt: Tests nachziehen
Bitte ergänze auch die Tests.
Die Tests wurden ergänzt:
Es gibt jetzt einen Test, der prüft, dass ein negativer Wert für scale eine IllegalArgumentException auslöst:
1@Test2@DisplayName("Negative scale wirft IllegalArgumentException")3void testNegativeScaleThrows() {4assertThrows(IllegalArgumentException.class, () ->5BigDecimalNewtonSqrt.sqrt(BigDecimal.ONE, -1)6);7}
Damit ist die Eingabeprüfung für negative scale-Werte auch durch die Tests abgedeckt.
15. Schritt: Build-Skript vervollständigen
Bitte ergänze das Build-Skript so, dass die Testabdeckung berechnet wird.
Um die Testabdeckung in einem Maven-Projekt zu berechnen, wird üblicherweise das Plugin JaCoCo verwendet. Dieses Plugin erstellt Berichte über die Testabdeckung (Coverage) und lässt sich einfach in die pom.xml integrieren.
Hier ist die Ergänzung für dein Build-Skript:
<plugin>
<groupId>org.jacoco</groupId>
<artifactId>jacoco-maven-plugin</artifactId>
<version>0.8.11</version>
<executions>
<execution>
<goals>
<goal>prepare-agent</goal>
</goals>
</execution>
<execution>
<id>report</id>
<phase>test</phase>
<goals>
<goal>report</goal>
</goals>
</execution>
</executions>
</plugin>16. Schritt: Basierend auf Codeabdeckung weitere Tests fordern
Die Testabeckung sagt, dass die Zeile 62 noch nicht getestet wird. Kannst Du dafür einen Testfall generieren?
Die Zeile 62 ist:
1if (count >= maxIterations) {2throw new ArithmeticException(3"Maximale Iterationszahl (" +4maxIterations +5") erreicht, Ergebnis möglicherweise ungenau."6);7}
Das bedeutet:
Du brauchst einen Test, der absichtlich dafür sorgt, dass die maximale Iterationszahl überschritten wird.
Wie erreichst du das?
Wähle einen Wert für n, der schwer konvergiert (z.B. eine sehr große Zahl mit sehr hoher Präzision).
Setze scale auf einen Wert > 0, aber so hoch, dass die Konvergenz nicht innerhalb von maxIterations erreicht wird.
Oder: Manipuliere die Methode für den Test, sodass sie nie konvergiert (das ist aber unsauber).
Praktischer Testfall:
Setze scale auf einen sehr hohen Wert (z.B. Integer.MAX_VALUE / 5), aber das wirft schon vorher eine IllegalArgumentException. Deshalb: Wähle einen Wert, bei dem die Methode zwar startet, aber nicht konvergiert. Ein Ansatz ist, eine Zahl zu wählen, die sehr klein ist und eine sehr hohe Präzision verlangt.
Zusammenfassung
Gesamtaufwand ca. 2 Stunden
An mehreren Stellen war manuelles Eingreifen erforderlich
Man kann Dinge einfordern, die wenig Sinn machen, ohne dass man (unmittelbar) darauf aufmerksam gemacht wird (z. B. Verwendung von npm)
An vielen Stellen war das einfache Kopieren von Fehlermeldungen in den Chat ausreichend, um die Fehler korrigiert zu bekommen.
Wenn der Prompt nicht präzise genug ist, dann muss man (ggf. mehrfach) prompten.
Kritisches Hinterfragen des Codes ist dringend notwendig. Nur dann erhält man Code, der auch höhere Qualitätsstandards erreicht.
Häufig wird die nicht die Codebasis als Ganzes betrachtet. Zum Beispiel brauchen ggf. Anpassungen von Dokumenten, Skripts und Tests nachfolgende Prompts.
Das Ziel ist (auch hier) die Generierung einer Kommandozeilenanwendung zur Berechnung der Quadratwurzel einer Zahl mit vorgegebener, aber beliebiger Genauigkeit.
Der Unterschied ist jedoch, dass wir versuchen das ganze Projekt in einem Zug generieren zu lassen, in dem wir einen Prompt erstellen, der „alle“ Anforderungen des Projekts beschreibt.
Initialer Prompt
Bitte generiere mir ein Java-Kommandozeilenprogramm zur Berechung der Quadratwurzel unter Verwendung der Newtown-Raphson-Methode. Die Anforderungen sind:
Es soll möglich sein die gewünschte Anzahl an Nachkommastellen anzugeben.
Die Methode zur Berechnung der Quadratwurzel soll auch aus anderem Code heraus aufrufbar sein.
Die Methode soll robust sein bei fehlerhaften Eingaben und ggf. aussagekräftige Ausnahmen werfen.
Die Methode zur Berechnung der Quadratwurzel soll über eine umfassende Dokumentation verfügen, die auch alle Sonderfälle und Ausnahmen dokumentiert.
Es soll nach Möglichkeit nur eine Datei generiert werden, um eine optionale Verwendung als Skript einfach zu ermöglichen.
Das Programm soll die neueste Version von Java verwenden.
Alle verwendeten Bibliotheken und Tools sollen auf dem neuesten Stand sein.
Es soll ein Build-Skript geben, dass den Code formatiert und testet. Bei der Codeformatierung soll insbesondere eine maximale Zeilenlänge von 70 Zeichen eingehalten werden. Die Tests sollen die Methode, die die Berechnung durchführt, umfassend testen; inkl. Sonderfälle. Es soll auch eine Codeabdeckung berechnet werden und nach Möglichkeit 100% Branch-Coverage erreicht werden.
(Thought Process)
<think>
Das ist eine umfassende Anforderung für ein Java-Kommandozeilenprogramm. Lass mich die Anforderungen durchgehen:
Java-Kommandozeilenprogramm zur Berechnung der Quadratwurzel mit Newton-Raphson-Methode
Anzahl der Nachkommastellen soll konfigurierbar sein
Methode soll aus anderem Code aufrufbar sein
Robust bei fehlerhaften Eingaben mit aussagekräftigen Ausnahmen
Umfassende Dokumentation inkl. Sonderfälle
Nur eine Datei wenn möglich (für Skript-Verwendung)
Neueste Java-Version
Neueste Bibliotheken
Build-Skript mit Formatierung (max 70 Zeichen Zeilenlänge) und Tests
Umfassende Tests inkl. Sonderfälle
100% Branch-Coverage angestrebt
Ich sollte zuerst schauen, was im aktuellen Projektverzeichnis ist, und dann eine Struktur aufbauen.
Newton-Raphson für Quadratwurzel: \(x_{n+1} = (x_n + a/x_n) / 2\) wobei a die Zahl ist, deren Quadratwurzel gesucht wird.
Ich werde:
Eine Java-Klasse erstellen mit der Newton-Raphson Implementierung
Kommandozeilenhandling hinzufügen
Robuste Fehlerbehandlung
Umfassende Dokumentation
Ein Build-Skript (build.gradle oder Maven) für Formatierung und Tests
JUnit-Tests mit hoher Abdeckung
Für maximale Flexibilität werde ich eine einzelne Java-Datei entwickeln, die sowohl als Skript als auch als importierbare Bibliothek funktioniert. Das bedeutet, ich integriere Kommandozeilen-Logik direkt in die Hauptklasse, sodass sie sowohl standalone als auch als Komponente in anderen Projekten nutzbar ist.
</think>
Generierter Code
1import java.math.BigDecimal;2import java.math.MathContext;3import java.math.RoundingMode;4import java.util.Scanner;56/**7* Ein hochpräziser Quadratwurzel-Rechner basierend auf der8* Newton-Raphson-Methode.9*10* Diese Klasse bietet sowohl eine Kommandozeilenschnittstelle als auch11* eine programmierbare API zur Berechnung von Quadratwurzeln mit12* beliebiger Genauigkeit.13*14* @author Generated Code15* @version 1.016* @since Java 2117*/18public class SquareRootCalculator {1920/**21* Standard-Präzision für Berechnungen (50 Dezimalstellen).22*/23private static final int DEFAULT_PRECISION = 50;2425/**26* Maximale erlaubte Präzision zur Vermeidung von27* Performance-Problemen.28*/29private static final int MAX_PRECISION = 1000;3031/**32* Maximale Anzahl von Iterationen für die Newton-Raphson-Methode.33*/34private static final int MAX_ITERATIONS = 10000;3536/**37* Custom Exception für ungültige Eingaben.38*/39public static class InvalidInputException extends Exception {40public InvalidInputException(String message) {41super(message);42}43}4445/**46* Custom Exception für Berechnungsfehler.47*/48public static class CalculationException extends Exception {49public CalculationException(String message) {50super(message);51}52}5354/**55* Berechnet die Quadratwurzel einer Zahl mit der56* Newton-Raphson-Methode.57*58* Die Newton-Raphson-Methode für Quadratwurzeln verwendet die59* Iterationsformel:60* x_{n+1} = (x_n + a/x_n) / 261*62* wobei 'a' die Eingabezahl und x_0 ein Startwert ist.63*64* @param number Die Zahl, deren Quadratwurzel berechnet werden soll.65* Muss größer oder gleich 0 sein.66* @param decimalPlaces Die Anzahl der gewünschten Nachkommastellen.67* Muss zwischen 0 und 1000 liegen.68* @return Die Quadratwurzel als BigDecimal mit der gewünschten69* Präzision.70*71* @throws InvalidInputException wenn die Eingabe ungültig ist:72* - number ist null73* - number ist negativ74* - decimalPlaces ist negativ oder größer als 100075* @throws CalculationException wenn die Berechnung fehlschlägt:76* - Konvergenz nicht erreicht nach MAX_ITERATIONS77* - Numerischer Overflow/Underflow78*79* Sonderfälle:80* - sqrt(0) = 081* - sqrt(1) = 182* - Für sehr kleine Zahlen (< 1e-100) wird eine spezielle83* Behandlung angewendet84* - Für sehr große Zahlen wird die Berechnung in Segmente85* aufgeteilt86*87* Beispiele:88* <pre>89* {@code90* // Einfache Berechnung91* BigDecimal result = calculateSquareRoot(92* new BigDecimal("2"), 5);93* // Ergebnis: 1.4142194*95* // Hochpräzise Berechnung96* BigDecimal precise = calculateSquareRoot(97* new BigDecimal("2"), 50);98*99* // Große Zahlen100* BigDecimal large = calculateSquareRoot(101* new BigDecimal("1234567890123456789"), 10);102* }103* </pre>104*/105public static BigDecimal calculateSquareRoot(BigDecimal number,106int decimalPlaces)107throws InvalidInputException, CalculationException {108109// Eingabevalidierung110if (number == null) {111throw new InvalidInputException(112"Die Eingabezahl darf nicht null sein.");113}114115if (number.compareTo(BigDecimal.ZERO) < 0) {116throw new InvalidInputException(117"Die Quadratwurzel aus negativen Zahlen ist nicht " +118"im Bereich der reellen Zahlen definiert. " +119"Eingabe: " + number);120}121122if (decimalPlaces < 0) {123throw new InvalidInputException(124"Die Anzahl der Nachkommastellen muss nicht-negativ " +125"sein. Eingabe: " + decimalPlaces);126}127128if (decimalPlaces > MAX_PRECISION) {129throw new InvalidInputException(130"Die maximale Anzahl von Nachkommastellen beträgt " +131MAX_PRECISION + ". Eingabe: " + decimalPlaces);132}133134// Sonderfall: sqrt(0) = 0135if (number.compareTo(BigDecimal.ZERO) == 0) {136return BigDecimal.ZERO.setScale(decimalPlaces,137RoundingMode.HALF_UP);138}139140// Sonderfall: sqrt(1) = 1141if (number.compareTo(BigDecimal.ONE) == 0) {142return BigDecimal.ONE.setScale(decimalPlaces,143RoundingMode.HALF_UP);144}145146// Präzision für interne Berechnungen (höher als gewünscht)147int internalPrecision = Math.max(decimalPlaces + 10,148DEFAULT_PRECISION);149MathContext mc = new MathContext(internalPrecision,150RoundingMode.HALF_UP);151152try {153// Startwert bestimmen (heuristische Schätzung)154BigDecimal x = getInitialGuess(number, mc);155BigDecimal previousX;156157// Newton-Raphson-Iteration158for (int i = 0; i < MAX_ITERATIONS; i++) {159previousX = x;160161// x_{n+1} = (x_n + number/x_n) / 2162BigDecimal quotient = number.divide(x, mc);163x = x.add(quotient).divide(BigDecimal.valueOf(2), mc);164165// Konvergenzprüfung166if (hasConverged(x, previousX, decimalPlaces + 5)) {167return x.setScale(decimalPlaces,168RoundingMode.HALF_UP);169}170}171172throw new CalculationException(173"Die Newton-Raphson-Methode konvergierte nicht nach " +174MAX_ITERATIONS + " Iterationen. Möglicherweise ist " +175"die gewünschte Präzision zu hoch oder die Eingabe " +176"numerisch instabil.");177178} catch (ArithmeticException e) {179throw new CalculationException(180"Numerischer Fehler während der Berechnung: " +181e.getMessage() + ". Dies kann bei sehr großen oder " +182"sehr kleinen Zahlen auftreten.");183}184}185186/**187* Bestimmt einen geeigneten Startwert für die Newton-Raphson-Iteration.188*189* @param number Die Zahl, deren Quadratwurzel berechnet werden soll190* @param mc Der MathContext für die Berechnung191* @return Ein geeigneter Startwert192*/193private static BigDecimal getInitialGuess(BigDecimal number,194MathContext mc) {195// Für Zahlen nahe 1: verwende die Zahl selbst196if (number.compareTo(BigDecimal.valueOf(0.1)) >= 0 &&197number.compareTo(BigDecimal.valueOf(10)) <= 0) {198return number;199}200201// Für sehr kleine Zahlen: verwende 1202if (number.compareTo(BigDecimal.valueOf(0.1)) < 0) {203return BigDecimal.ONE;204}205206// Für große Zahlen: verwende number/2207return number.divide(BigDecimal.valueOf(2), mc);208}209210/**211* Prüft, ob die Newton-Raphson-Iteration konvergiert ist.212*213* @param current Der aktuelle Wert214* @param previous Der vorherige Wert215* @param requiredPrecision Die erforderliche Präzision216* @return true, wenn konvergiert217*/218private static boolean hasConverged(BigDecimal current,219BigDecimal previous,220int requiredPrecision) {221if (current.equals(previous)) {222return true;223}224225BigDecimal difference = current.subtract(previous).abs();226BigDecimal tolerance = BigDecimal.ONE.divide(227BigDecimal.TEN.pow(requiredPrecision),228new MathContext(requiredPrecision + 10));229230return difference.compareTo(tolerance) <= 0;231}232233/**234* Überladene Methode mit Standard-Präzision von 10 Nachkommastellen.235*236* @param number Die Zahl, deren Quadratwurzel berechnet werden soll237* @return Die Quadratwurzel mit 10 Nachkommastellen238* @throws InvalidInputException bei ungültiger Eingabe239* @throws CalculationException bei Berechnungsfehlern240*/241public static BigDecimal calculateSquareRoot(BigDecimal number)242throws InvalidInputException, CalculationException {243return calculateSquareRoot(number, 10);244}245246/**247* Convenience-Methode für double-Werte.248*249* @param number Die Zahl als double250* @param decimalPlaces Anzahl Nachkommastellen251* @return Die Quadratwurzel252* @throws InvalidInputException bei ungültiger Eingabe253* @throws CalculationException bei Berechnungsfehlern254*/255public static BigDecimal calculateSquareRoot(double number,256int decimalPlaces)257throws InvalidInputException, CalculationException {258if (Double.isNaN(number) || Double.isInfinite(number)) {259throw new InvalidInputException(260"Die Eingabe darf nicht NaN oder unendlich sein.");261}262return calculateSquareRoot(BigDecimal.valueOf(number),263decimalPlaces);264}265266/**267* Hauptmethode für die Kommandozeilenschnittstelle.268*269* Verwendung:270* - Ohne Argumente: Interaktiver Modus271* - Mit einem Argument: Berechnet sqrt(arg) mit 10 Nachkommastellen272* - Mit zwei Argumenten: Berechnet sqrt(arg1) mit arg2273* Nachkommastellen274*275* @param args Kommandozeilenargumente276*/277public static void main(String[] args) {278try {279if (args.length == 0) {280runInteractiveMode();281} else if (args.length == 1) {282calculateAndPrint(args[0], "10");283} else if (args.length == 2) {284calculateAndPrint(args[0], args[1]);285} else {286printUsage();287System.exit(1);288}289} catch (Exception e) {290System.err.println("Fehler: " + e.getMessage());291System.exit(1);292}293}294295/**296* Startet den interaktiven Modus.297*/298private static void runInteractiveMode() {299Scanner scanner = new Scanner(System.in);300301System.out.println("=================================");302System.out.println(" Quadratwurzel-Rechner v1.0");303System.out.println(" Newton-Raphson-Methode");304System.out.println("=================================");305System.out.println();306307while (true) {308try {309System.out.print("Zahl (oder 'quit' zum Beenden): ");310String numberInput = scanner.nextLine().trim();311312if ("quit".equalsIgnoreCase(numberInput) ||313"exit".equalsIgnoreCase(numberInput)) {314System.out.println("Auf Wiedersehen!");315break;316}317318System.out.print("Nachkommastellen (Standard: 10): ");319String precisionInput = scanner.nextLine().trim();320321if (precisionInput.isEmpty()) {322precisionInput = "10";323}324325calculateAndPrint(numberInput, precisionInput);326System.out.println();327328} catch (Exception e) {329System.err.println("Fehler: " + e.getMessage());330System.out.println();331}332}333334scanner.close();335}336337/**338* Berechnet und gibt das Ergebnis aus.339*/340private static void calculateAndPrint(String numberStr,341String precisionStr)342throws InvalidInputException, CalculationException {343344BigDecimal number;345int precision;346347try {348number = new BigDecimal(numberStr);349} catch (NumberFormatException e) {350throw new InvalidInputException(351"'" + numberStr + "' ist keine gültige Zahl.");352}353354try {355precision = Integer.parseInt(precisionStr);356} catch (NumberFormatException e) {357throw new InvalidInputException(358"'" + precisionStr +359"' ist keine gültige Anzahl von Nachkommastellen.");360}361362long startTime = System.nanoTime();363BigDecimal result = calculateSquareRoot(number, precision);364long endTime = System.nanoTime();365366System.out.println("Eingabe: " + number);367System.out.println("Nachkommastellen: " + precision);368System.out.println("Ergebnis: " + result);369System.out.printf("Berechnungszeit: %.2f ms%n",370(endTime - startTime) / 1_000_000.0);371372// Verifikation (Quadrat des Ergebnisses)373if (precision <= 20) { // Nur für kleinere Präzisionen374BigDecimal verification = result.multiply(result);375System.out.println("Verifikation (Quadrat): " +376verification.setScale(precision,377RoundingMode.HALF_UP));378}379}380381/**382* Gibt die Verwendungsinformationen aus.383*/384private static void printUsage() {385System.out.println("Quadratwurzel-Rechner - Newton-Raphson-Methode");386System.out.println();387System.out.println("Verwendung:");388System.out.println(" java SquareRootCalculator");389System.out.println(" Startet den interaktiven Modus");390System.out.println();391System.out.println(" java SquareRootCalculator <zahl>");392System.out.println(" Berechnet sqrt(<zahl>) mit 10 " +393"Nachkommastellen");394System.out.println();395System.out.println(" java SquareRootCalculator <zahl> " +396"<nachkommastellen>");397System.out.println(" Berechnet sqrt(<zahl>) mit der " +398"angegebenen Präzision");399System.out.println();400System.out.println("Beispiele:");401System.out.println(" java SquareRootCalculator 2");402System.out.println(" java SquareRootCalculator 2 20");403System.out.println(" java SquareRootCalculator 1234567890.123456");404}405}
Generierte Tests
1import static org.assertj.core.api.Assertions.*;2import static org.junit.jupiter.api.Assertions.*;34import java.io.ByteArrayInputStream;5import java.io.ByteArrayOutputStream;6import java.io.PrintStream;7import java.math.BigDecimal;8import java.math.RoundingMode;9import java.util.stream.Stream;10import org.junit.jupiter.api.AfterEach;11import org.junit.jupiter.api.BeforeEach;12import org.junit.jupiter.api.DisplayName;13import org.junit.jupiter.api.Test;14import org.junit.jupiter.api.TestInstance;15import org.junit.jupiter.params.ParameterizedTest;16import org.junit.jupiter.params.provider.Arguments;17import org.junit.jupiter.params.provider.MethodSource;18import org.junit.jupiter.params.provider.ValueSource;1920@TestInstance(TestInstance.Lifecycle.PER_CLASS)21@DisplayName("SquareRootCalculator Tests")22class SquareRootCalculatorTest {2324private final ByteArrayOutputStream outputStreamCaptor =25new ByteArrayOutputStream();26private final ByteArrayOutputStream errorStreamCaptor =27new ByteArrayOutputStream();28private final PrintStream standardOut = System.out;29private final PrintStream standardErr = System.err;3031@BeforeEach32void setUp() {33System.setOut(new PrintStream(outputStreamCaptor));34System.setErr(new PrintStream(errorStreamCaptor));35}3637@AfterEach38void tearDown() {39System.setOut(standardOut);40System.setErr(standardErr);41}4243@Test44@DisplayName("Should calculate square root of 2 with default precision")45void testSquareRootOfTwoDefaultPrecision() throws Exception {46BigDecimal result = SquareRootCalculator.calculateSquareRoot(47new BigDecimal("2"));4849assertThat(result).isNotNull();50assertThat(result.scale()).isEqualTo(10);5152// Verify precision (should be close to 1.4142135623)53BigDecimal expected = new BigDecimal("1.4142135624");54assertThat(result.subtract(expected).abs())55.isLessThan(new BigDecimal("0.0000000001"));56}5758@Test59@DisplayName("Should calculate square root with specified precision")60void testSquareRootWithSpecifiedPrecision() throws Exception {61BigDecimal result = SquareRootCalculator.calculateSquareRoot(62new BigDecimal("2"), 5);6364assertThat(result.scale()).isEqualTo(5);65assertThat(result.toString()).isEqualTo("1.41421");66}6768@Test69@DisplayName("Should return 0 for square root of 0")70void testSquareRootOfZero() throws Exception {71BigDecimal result = SquareRootCalculator.calculateSquareRoot(72BigDecimal.ZERO, 10);7374assertThat(result).isEqualTo(75BigDecimal.ZERO.setScale(10, RoundingMode.HALF_UP));76}7778@Test79@DisplayName("Should return 1 for square root of 1")80void testSquareRootOfOne() throws Exception {81BigDecimal result = SquareRootCalculator.calculateSquareRoot(82BigDecimal.ONE, 10);8384assertThat(result).isEqualTo(85BigDecimal.ONE.setScale(10, RoundingMode.HALF_UP));86}8788@ParameterizedTest89@MethodSource("validSquareRootTestCases")90@DisplayName("Should calculate square roots for various valid inputs")91void testValidSquareRoots(BigDecimal input, int precision,92BigDecimal expectedApprox) throws Exception {93BigDecimal result = SquareRootCalculator.calculateSquareRoot(94input, precision);9596assertThat(result).isNotNull();97assertThat(result.scale()).isEqualTo(precision);9899// Verify by squaring the result100BigDecimal squared = result.multiply(result);101BigDecimal tolerance = BigDecimal.ONE.divide(102BigDecimal.TEN.pow(Math.min(precision, 10)));103104assertThat(squared.subtract(input).abs())105.isLessThanOrEqualTo(tolerance);106}107108private static Stream<Arguments> validSquareRootTestCases() {109return Stream.of(110Arguments.of(new BigDecimal("4"), 5, new BigDecimal("2")),111Arguments.of(new BigDecimal("9"), 3, new BigDecimal("3")),112Arguments.of(new BigDecimal("16"), 2, new BigDecimal("4")),113Arguments.of(new BigDecimal("0.25"), 8, new BigDecimal("0.5")),114Arguments.of(new BigDecimal("0.01"), 10,115new BigDecimal("0.1")),116Arguments.of(new BigDecimal("100"), 1, new BigDecimal("10")),117Arguments.of(new BigDecimal("1000000"), 15,118new BigDecimal("1000")),119Arguments.of(new BigDecimal("0.000001"), 20,120new BigDecimal("0.001"))121);122}123124@Test125@DisplayName("Should throw InvalidInputException for null input")126void testNullInput() {127SquareRootCalculator.InvalidInputException exception =128assertThrows(SquareRootCalculator.InvalidInputException.class,129() -> SquareRootCalculator.calculateSquareRoot(130null, 10));131132assertThat(exception.getMessage())133.contains("darf nicht null sein");134}135136@Test137@DisplayName("Should throw InvalidInputException for negative input")138void testNegativeInput() {139SquareRootCalculator.InvalidInputException exception =140assertThrows(SquareRootCalculator.InvalidInputException.class,141() -> SquareRootCalculator.calculateSquareRoot(142new BigDecimal("-1"), 10));143144assertThat(exception.getMessage())145.contains("negativen Zahlen")146.contains("-1");147}148149@Test150@DisplayName("Should throw InvalidInputException for negative decimal places")151void testNegativeDecimalPlaces() {152SquareRootCalculator.InvalidInputException exception =153assertThrows(SquareRootCalculator.InvalidInputException.class,154() -> SquareRootCalculator.calculateSquareRoot(155new BigDecimal("2"), -1));156157assertThat(exception.getMessage())158.contains("nicht-negativ")159.contains("-1");160}161162@Test163@DisplayName("Should throw InvalidInputException for too high precision")164void testTooHighPrecision() {165SquareRootCalculator.InvalidInputException exception =166assertThrows(SquareRootCalculator.InvalidInputException.class,167() -> SquareRootCalculator.calculateSquareRoot(168new BigDecimal("2"), 1001));169170assertThat(exception.getMessage())171.contains("maximale Anzahl")172.contains("1000")173.contains("1001");174}175176@Test177@DisplayName("Should handle maximum allowed precision")178void testMaximumPrecision() throws Exception {179BigDecimal result = SquareRootCalculator.calculateSquareRoot(180new BigDecimal("2"), 1000);181182assertThat(result).isNotNull();183assertThat(result.scale()).isEqualTo(1000);184}185186@Test187@DisplayName("Should calculate square root for double input")188void testDoubleInput() throws Exception {189BigDecimal result = SquareRootCalculator.calculateSquareRoot(1904.0, 5);191192assertThat(result.toString()).isEqualTo("2.00000");193}194195@Test196@DisplayName("Should throw InvalidInputException for NaN double input")197void testNaNDoubleInput() {198SquareRootCalculator.InvalidInputException exception =199assertThrows(SquareRootCalculator.InvalidInputException.class,200() -> SquareRootCalculator.calculateSquareRoot(201Double.NaN, 5));202203assertThat(exception.getMessage())204.contains("NaN oder unendlich");205}206207@Test208@DisplayName("Should throw InvalidInputException for infinite double input")209void testInfiniteDoubleInput() {210SquareRootCalculator.InvalidInputException exception =211assertThrows(SquareRootCalculator.InvalidInputException.class,212() -> SquareRootCalculator.calculateSquareRoot(213Double.POSITIVE_INFINITY, 5));214215assertThat(exception.getMessage())216.contains("NaN oder unendlich");217}218219@Test220@DisplayName("Should handle very small numbers")221void testVerySmallNumbers() throws Exception {222BigDecimal result = SquareRootCalculator.calculateSquareRoot(223new BigDecimal("1e-50"), 10);224225assertThat(result).isNotNull();226assertThat(result.scale()).isEqualTo(10);227}228229@Test230@DisplayName("Should handle very large numbers")231void testVeryLargeNumbers() throws Exception {232BigDecimal result = SquareRootCalculator.calculateSquareRoot(233new BigDecimal("1e50"), 10);234235assertThat(result).isNotNull();236assertThat(result.scale()).isEqualTo(10);237}238239@Test240@DisplayName("Should handle numbers close to 1")241void testNumbersCloseToOne() throws Exception {242BigDecimal result = SquareRootCalculator.calculateSquareRoot(243new BigDecimal("1.000001"), 15);244245assertThat(result).isNotNull();246assertThat(result.scale()).isEqualTo(15);247}248249@Test250@DisplayName("Should run main with no arguments (interactive mode mock)")251void testMainWithNoArguments() throws Exception {252// Mock interactive input253String input = "4\n5\nquit\n";254System.setIn(new ByteArrayInputStream(input.getBytes()));255256SquareRootCalculator.main(new String[]{});257258String output = outputStreamCaptor.toString();259assertThat(output).contains("Quadratwurzel-Rechner v1.0");260assertThat(output).contains("Eingabe: 4");261assertThat(output).contains("Ergebnis: 2.00000");262assertThat(output).contains("Auf Wiedersehen!");263}264265@Test266@DisplayName("Should run main with one argument")267void testMainWithOneArgument() throws Exception {268SquareRootCalculator.main(new String[]{"9"});269270String output = outputStreamCaptor.toString();271assertThat(output).contains("Eingabe: 9");272assertThat(output).contains("Nachkommastellen: 10");273assertThat(output).contains("Ergebnis: 3.0000000000");274}275276@Test277@DisplayName("Should run main with two arguments")278void testMainWithTwoArguments() throws Exception {279SquareRootCalculator.main(new String[]{"16", "3"});280281String output = outputStreamCaptor.toString();282assertThat(output).contains("Eingabe: 16");283assertThat(output).contains("Nachkommastellen: 3");284assertThat(output).contains("Ergebnis: 4.000");285}286287@Test288@DisplayName("Should show usage for too many arguments")289void testMainWithTooManyArguments() {290assertThrows(SystemExit.class, () -> {291try {292SquareRootCalculator.main(new String[]{"1", "2", "3", "4"});293} catch (Exception e) {294// Convert to our custom exception for testing295throw new SystemExit();296}297});298299String output = outputStreamCaptor.toString();300assertThat(output).contains("Verwendung:");301}302303@Test304@DisplayName("Should handle invalid number in main")305void testMainWithInvalidNumber() {306assertThrows(SystemExit.class, () -> {307try {308SquareRootCalculator.main(new String[]{"not_a_number"});309} catch (Exception e) {310throw new SystemExit();311}312});313314String errorOutput = errorStreamCaptor.toString();315assertThat(errorOutput).contains("Fehler:");316}317318@Test319@DisplayName("Should handle invalid precision in main")320void testMainWithInvalidPrecision() {321assertThrows(SystemExit.class, () -> {322try {323SquareRootCalculator.main(new String[]{"4", "not_a_number"});324} catch (Exception e) {325throw new SystemExit();326}327});328329String errorOutput = errorStreamCaptor.toString();330assertThat(errorOutput).contains("Fehler:");331}332333@Test334@DisplayName("Should handle interactive mode with empty precision")335void testInteractiveModeEmptyPrecision() throws Exception {336String input = "25\n\nquit\n";337System.setIn(new ByteArrayInputStream(input.getBytes()));338339SquareRootCalculator.main(new String[]{});340341String output = outputStreamCaptor.toString();342assertThat(output).contains("Eingabe: 25");343assertThat(output).contains("Nachkommastellen: 10");344assertThat(output).contains("Ergebnis: 5.0000000000");345}346347@Test348@DisplayName("Should handle interactive mode with exit command")349void testInteractiveModeWithExit() throws Exception {350String input = "exit\n";351System.setIn(new ByteArrayInputStream(input.getBytes()));352353SquareRootCalculator.main(new String[]{});354355String output = outputStreamCaptor.toString();356assertThat(output).contains("Auf Wiedersehen!");357}358359@Test360@DisplayName("Should handle interactive mode with invalid input")361void testInteractiveModeInvalidInput() throws Exception {362String input = "invalid\n5\nquit\n";363System.setIn(new ByteArrayInputStream(input.getBytes()));364365SquareRootCalculator.main(new String[]{});366367String output = outputStreamCaptor.toString();368String errorOutput = errorStreamCaptor.toString();369370assertThat(errorOutput).contains("Fehler:");371assertThat(output).contains("Auf Wiedersehen!");372}373374@Test375@DisplayName("Should show verification for small precision")376void testVerificationOutput() throws Exception {377SquareRootCalculator.main(new String[]{"4", "5"});378379String output = outputStreamCaptor.toString();380assertThat(output).contains("Verifikation (Quadrat):");381}382383@Test384@DisplayName("Should not show verification for high precision")385void testNoVerificationForHighPrecision() throws Exception {386SquareRootCalculator.main(new String[]{"4", "25"});387388String output = outputStreamCaptor.toString();389assertThat(output).doesNotContain("Verifikation (Quadrat):");390}391392@ParameterizedTest393@ValueSource(doubles = {0.05, 0.5, 5.0, 50.0})394@DisplayName("Should handle different number ranges for initial guess")395void testDifferentInitialGuessRanges(double input) throws Exception {396BigDecimal result = SquareRootCalculator.calculateSquareRoot(397BigDecimal.valueOf(input), 10);398399assertThat(result).isNotNull();400401// Verify accuracy by squaring402BigDecimal squared = result.multiply(result);403BigDecimal tolerance = new BigDecimal("0.0000000001");404405assertThat(squared.subtract(BigDecimal.valueOf(input)).abs())406.isLessThanOrEqualTo(tolerance);407}408409@Test410@DisplayName("Should test exception constructors")411void testExceptionConstructors() {412SquareRootCalculator.InvalidInputException invalidException =413new SquareRootCalculator.InvalidInputException(414"Test message");415assertThat(invalidException.getMessage()).isEqualTo("Test message");416417SquareRootCalculator.CalculationException calcException =418new SquareRootCalculator.CalculationException(419"Calc error");420assertThat(calcException.getMessage()).isEqualTo("Calc error");421}422423@Test424@DisplayName("Should handle convergence edge cases")425void testConvergenceEdgeCases() throws Exception {426// Test with a number that requires more iterations427BigDecimal result = SquareRootCalculator.calculateSquareRoot(428new BigDecimal("123456789012345678901234567890"), 20);429430assertThat(result).isNotNull();431assertThat(result.scale()).isEqualTo(20);432}433434@Test435@DisplayName("Should handle precision boundary values")436void testPrecisionBoundaryValues() throws Exception {437// Test with 0 decimal places438BigDecimal result = SquareRootCalculator.calculateSquareRoot(439new BigDecimal("4"), 0);440assertThat(result.scale()).isEqualTo(0);441assertThat(result.toString()).isEqualTo("2");442443// Test with maximum precision444result = SquareRootCalculator.calculateSquareRoot(445new BigDecimal("4"), 1000);446assertThat(result.scale()).isEqualTo(1000);447}448449// Helper class to simulate System.exit calls in tests450private static class SystemExit extends RuntimeException {451}452}
Zusammenfassung
Aufwand: ca. 30 Minuten (ca. 15 Minuten für den Prompt und ca. 15 Minuten für Claude Sonnet).
Die Generierung musste explizit terminiert werden, da der Agent beim Ausführen der Anwendung nicht in der Lage war diese korrekt zu bedienen und in einer Endlos-Schleife hing.
Der Code verwendet eigene Exception für Standarfälle. Dies ist ungeschickt.
Projektstruktur und Tests entsprechen den Erwartungen.
Die verwendeten Libraries waren auf den Ständen, die bei GPT nach der Aktualisierung verwendet wurden. D. h. nicht aktuell.
Es wurden noch einige weitere Dateien generiert, die nicht gefordert wurden: README.md zum Beispiel mit Lizenzinformationen...
Anwendung funktioniert und (viele) Tests auch - wenn man diese manuell ausführt.
Achtung aufgrund des Testens der main Methode welche System.exit Aufrufe hat kommt es zu Fehlern!
Durch einen weiteren Prompt mit dem Fehler konnte dies behoben werden. Dabei wurde auch gleich ein Test fachlich korrigiert (Thinking Model). Leider wurde auch das Build-Skript abgeändert und (wieder) veraltete Versionen der Tools eingetragen.
Die Codeabdeckung ist gut, aber die meisten Sonderfälle werden nicht abgedeckt.
Das Build-Skript funktionierte erst nicht, da die Versionen nicht korrekt ermittelt wurden!
Der Code ist besser modularisiert in mehrere Methoden wodurch das Verständnis gefördert wird.
Es wurden Hilfsmethoden für anzunehmende gängige Fälle implementiert.