diff --git a/src/.gitignore b/src/.gitignore index 1f3bdcd..9fd6c58 100644 --- a/src/.gitignore +++ b/src/.gitignore @@ -8,3 +8,4 @@ */target/ */.apt_generated/ */.apt_generated_tests/ +*/.vscode/ diff --git a/src/pp.08.01-ConcurrencyMonteCarloPiSeq/README.md b/src/pp.08.01-ConcurrencyMonteCarloPiSeq/README.md new file mode 100644 index 0000000..4613eaf --- /dev/null +++ b/src/pp.08.01-ConcurrencyMonteCarloPiSeq/README.md @@ -0,0 +1,7 @@ +# Laboraufgabe "Monte-Carlo-Algorithmus zur Annäherung von pi - sequenziell" +- [Aufgabenstellung](https://services.informatik.hs-mannheim.de/~s.leuchter/pp/labs/08-01-ConcurrencyMonteCarloPiSeq.html) +- [Musterlösung](https://services.informatik.hs-mannheim.de/~s.leuchter/pp/labs/08-Solutions.html#laboraufgabe-monte-carlo-algorithmus-zur-annäherung-von-pi-sequenziell) + +# Materialien +- [Folien](https://services.informatik.hs-mannheim.de/~s.leuchter/pp/slides/08-completableFuture.html) +- [Skript](https://services.informatik.hs-mannheim.de/~s.leuchter/pp/notes/08-completableFuture.html) diff --git a/src/pp.08.01-ConcurrencyMonteCarloPiSeq/justfile b/src/pp.08.01-ConcurrencyMonteCarloPiSeq/justfile new file mode 100644 index 0000000..6ca7111 --- /dev/null +++ b/src/pp.08.01-ConcurrencyMonteCarloPiSeq/justfile @@ -0,0 +1,18 @@ +# Justfile (https://just.systems/) for starting Maven standard targets + +default: clean compile package + +exec class args: compile + mvn exec:java -Dexec.args="{{args}}" -Dexec.mainClass={{class}} +# exec class args: +# java -cp target/app.jar {{class}} {{args}} +clean: + mvn clean +compile: + mvn compile +test: compile + mvn test +javadoc: + mvn javadoc:javadoc +package: + mvn package diff --git a/src/pp.08.01-ConcurrencyMonteCarloPiSeq/pom.xml b/src/pp.08.01-ConcurrencyMonteCarloPiSeq/pom.xml new file mode 100644 index 0000000..9aba5ed --- /dev/null +++ b/src/pp.08.01-ConcurrencyMonteCarloPiSeq/pom.xml @@ -0,0 +1,71 @@ + + 4.0.0 + pp + pp.08.01-ConcurrencyMonteCarloPiSeq + 1.0-SNAPSHOT + jar + + + 16 + edge-SNAPSHOT + UTF-8 + + + + org.junit.jupiter + junit-jupiter + 5.10.0 + test + + + org.projectlombok + lombok + ${lombok.version} + provided + + + net.jcip + jcip-annotations + 1.0 + provided + + + + clean compile + + + org.apache.maven.plugins + maven-surefire-plugin + 3.0.0 + + + org.apache.maven.plugins + maven-compiler-plugin + 3.9.0 + + + + org.projectlombok + lombok + ${lombok.version} + + + + + + org.codehaus.mojo + exec-maven-plugin + 3.1.0 + + + org.apache.maven.plugins + maven-javadoc-plugin + 3.5.0 + + private + en_US + + + + + diff --git a/src/pp.08.01-ConcurrencyMonteCarloPiSeq/src/main/java/pp/InOutTuple.java b/src/pp.08.01-ConcurrencyMonteCarloPiSeq/src/main/java/pp/InOutTuple.java new file mode 100644 index 0000000..86f2182 --- /dev/null +++ b/src/pp.08.01-ConcurrencyMonteCarloPiSeq/src/main/java/pp/InOutTuple.java @@ -0,0 +1,56 @@ +package pp; + +public record InOutTuple(int in, int out) { +} + +//record seit Java 16 (preview seit Java 14). +//identisch zu ... +//public final class InOutTuple { +// final private int in; +// final private int out; +// +// public InOutTuple(int in, int out) { +// this.in = in; +// this.out = out; +// } +// +// public int in() { +// return this.in; +// } +// +// public int out() { +// return this.out; +// } +// +// @Override +// public String toString() { +// return String.format("InOutTuple [in=%s, out=%s]", this.in, this.out); +// } +// +// @Override +// public int hashCode() { +// var prime = 31; +// var result = 1; +// result = (prime * result) + this.in; +// result = (prime * result) + this.out; +// return result; +// } +// +// @Override +// public boolean equals(Object obj) { +// if (this == obj) { +// return true; +// } +// if (!(obj instanceof InOutTuple)) { +// return false; +// } +// var other = (InOutTuple) obj; +// if (this.in != other.in) { +// return false; +// } +// if (this.out != other.out) { +// return false; +// } +// return true; +// } +//} diff --git a/src/pp.08.01-ConcurrencyMonteCarloPiSeq/src/main/java/pp/MonteCarloPiSeq.java b/src/pp.08.01-ConcurrencyMonteCarloPiSeq/src/main/java/pp/MonteCarloPiSeq.java new file mode 100644 index 0000000..897131f --- /dev/null +++ b/src/pp.08.01-ConcurrencyMonteCarloPiSeq/src/main/java/pp/MonteCarloPiSeq.java @@ -0,0 +1,46 @@ +package pp; + +import java.util.Random; + +/** + * Berechnung von pi durch Monte Carlo Verfahren: Vergleich der Anzahl von + * zufällig gewähten Punkten innerhalb eines Viertelkreises (Radius r = 1) bzw. + * innerhalb eines Quadrates (Kantenlänge 1) analog zu Fläche eines + * Viertelkreises (pi * r^2 / 4) mit der Fläche des Quadrates (1 = 1 * 1). + * + * Sequenzielle Berechnung (im Main-Thread) + * + * @author Sandro Leuchter + * + */ +public class MonteCarloPiSeq { + static final int TOTAL_CYCLES = 10000000; + + public static InOutTuple getResultMonteCarloPiDraw(int cycles) { + var in = 0; + var out = 0; + var r = new Random(); + for (var i = 0; i < cycles; i++) { + var x = r.nextDouble(); + var y = r.nextDouble(); + if (Math.sqrt((x * x) + (y * y)) <= 1.0) { + in++; + } else { + out++; + } + } + return new InOutTuple(in, out); + } + + /** + * main-Methode + * + * @param args Kommandozeilenparameter (nicht benutzt) + */ + public static void main(String... args) { + var result = getResultMonteCarloPiDraw(TOTAL_CYCLES); + var pi = ((4.0 * result.in()) / (result.in() + result.out())); + System.out.println(pi); + } + +} diff --git a/src/pp.08.01-ConcurrencyMonteCarloPiSeq_solution/README.md b/src/pp.08.01-ConcurrencyMonteCarloPiSeq_solution/README.md new file mode 100644 index 0000000..4613eaf --- /dev/null +++ b/src/pp.08.01-ConcurrencyMonteCarloPiSeq_solution/README.md @@ -0,0 +1,7 @@ +# Laboraufgabe "Monte-Carlo-Algorithmus zur Annäherung von pi - sequenziell" +- [Aufgabenstellung](https://services.informatik.hs-mannheim.de/~s.leuchter/pp/labs/08-01-ConcurrencyMonteCarloPiSeq.html) +- [Musterlösung](https://services.informatik.hs-mannheim.de/~s.leuchter/pp/labs/08-Solutions.html#laboraufgabe-monte-carlo-algorithmus-zur-annäherung-von-pi-sequenziell) + +# Materialien +- [Folien](https://services.informatik.hs-mannheim.de/~s.leuchter/pp/slides/08-completableFuture.html) +- [Skript](https://services.informatik.hs-mannheim.de/~s.leuchter/pp/notes/08-completableFuture.html) diff --git a/src/pp.08.01-ConcurrencyMonteCarloPiSeq_solution/justfile b/src/pp.08.01-ConcurrencyMonteCarloPiSeq_solution/justfile new file mode 100644 index 0000000..6ca7111 --- /dev/null +++ b/src/pp.08.01-ConcurrencyMonteCarloPiSeq_solution/justfile @@ -0,0 +1,18 @@ +# Justfile (https://just.systems/) for starting Maven standard targets + +default: clean compile package + +exec class args: compile + mvn exec:java -Dexec.args="{{args}}" -Dexec.mainClass={{class}} +# exec class args: +# java -cp target/app.jar {{class}} {{args}} +clean: + mvn clean +compile: + mvn compile +test: compile + mvn test +javadoc: + mvn javadoc:javadoc +package: + mvn package diff --git a/src/pp.08.01-ConcurrencyMonteCarloPiSeq_solution/pom.xml b/src/pp.08.01-ConcurrencyMonteCarloPiSeq_solution/pom.xml new file mode 100644 index 0000000..90c78aa --- /dev/null +++ b/src/pp.08.01-ConcurrencyMonteCarloPiSeq_solution/pom.xml @@ -0,0 +1,70 @@ + + 4.0.0 + pp + pp.08.01-ConcurrencyMonteCarloPiSeq_solution + 1.0-SNAPSHOT + jar + + + 16 + edge-SNAPSHOT + UTF-8 + + + + org.junit.jupiter + junit-jupiter + 5.10.0 + test + + + org.projectlombok + lombok + ${lombok.version} + provided + + + net.jcip + jcip-annotations + 1.0 + provided + + + + + + org.apache.maven.plugins + maven-surefire-plugin + 3.0.0 + + + org.apache.maven.plugins + maven-compiler-plugin + 3.9.0 + + + + org.projectlombok + lombok + ${lombok.version} + + + + + + org.codehaus.mojo + exec-maven-plugin + 3.1.0 + + + org.apache.maven.plugins + maven-javadoc-plugin + 3.5.0 + + private + en_US + + + + + \ No newline at end of file diff --git a/src/pp.08.01-ConcurrencyMonteCarloPiSeq_solution/src/main/java/pp/InOutTuple.java b/src/pp.08.01-ConcurrencyMonteCarloPiSeq_solution/src/main/java/pp/InOutTuple.java new file mode 100644 index 0000000..86f2182 --- /dev/null +++ b/src/pp.08.01-ConcurrencyMonteCarloPiSeq_solution/src/main/java/pp/InOutTuple.java @@ -0,0 +1,56 @@ +package pp; + +public record InOutTuple(int in, int out) { +} + +//record seit Java 16 (preview seit Java 14). +//identisch zu ... +//public final class InOutTuple { +// final private int in; +// final private int out; +// +// public InOutTuple(int in, int out) { +// this.in = in; +// this.out = out; +// } +// +// public int in() { +// return this.in; +// } +// +// public int out() { +// return this.out; +// } +// +// @Override +// public String toString() { +// return String.format("InOutTuple [in=%s, out=%s]", this.in, this.out); +// } +// +// @Override +// public int hashCode() { +// var prime = 31; +// var result = 1; +// result = (prime * result) + this.in; +// result = (prime * result) + this.out; +// return result; +// } +// +// @Override +// public boolean equals(Object obj) { +// if (this == obj) { +// return true; +// } +// if (!(obj instanceof InOutTuple)) { +// return false; +// } +// var other = (InOutTuple) obj; +// if (this.in != other.in) { +// return false; +// } +// if (this.out != other.out) { +// return false; +// } +// return true; +// } +//} diff --git a/src/pp.08.01-ConcurrencyMonteCarloPiSeq_solution/src/main/java/pp/MonteCarloPiSeq.java b/src/pp.08.01-ConcurrencyMonteCarloPiSeq_solution/src/main/java/pp/MonteCarloPiSeq.java new file mode 100644 index 0000000..2aeb5e3 --- /dev/null +++ b/src/pp.08.01-ConcurrencyMonteCarloPiSeq_solution/src/main/java/pp/MonteCarloPiSeq.java @@ -0,0 +1,48 @@ +package pp; + +import java.util.Random; + +/** + * Berechnung von pi durch Monte Carlo Verfahren: Vergleich der Anzahl von + * zufällig gewähten Punkten innerhalb eines Viertelkreises (Radius r = 1) bzw. + * innerhalb eines Quadrates (Kantenlänge 1) analog zu Fläche eines + * Viertelkreises (pi * r^2 / 4) mit der Fläche des Quadrates (1 = 1 * 1). + * + * Sequenzielle Berechnung (im Main-Thread) + * + * @author Sandro Leuchter + * + */ +public class MonteCarloPiSeq { + static final int TOTAL_CYCLES = 10000000; + + public static InOutTuple getResultMonteCarloPiDraw(int cycles) { + var in = 0; + var out = 0; + var r = new Random(); + for (var i = 0; i < cycles; i++) { + var x = r.nextDouble(); + var y = r.nextDouble(); + if (Math.sqrt((x * x) + (y * y)) <= 1.0) { + in++; + } else { + out++; + } + } + return new InOutTuple(in, out); + } + + /** + * main-Methode + * + * @param args Kommandozeilenparameter (nicht benutzt) + */ + public static void main(String... args) { + var now = System.currentTimeMillis(); + var result = getResultMonteCarloPiDraw(TOTAL_CYCLES); + var time = System.currentTimeMillis() - now; + var pi = ((4.0 * result.in()) / (result.in() + result.out())); + System.out.println(pi + ", " + time + " ms"); + } + +} diff --git a/src/pp.08.02-ConcurrencyMonteCarloPiFuture/README.md b/src/pp.08.02-ConcurrencyMonteCarloPiFuture/README.md new file mode 100644 index 0000000..3d33007 --- /dev/null +++ b/src/pp.08.02-ConcurrencyMonteCarloPiFuture/README.md @@ -0,0 +1,7 @@ +# Laboraufgabe "Monte-Carlo-Algorithmus zur Annäherung von pi – mit Future" +- [Aufgabenstellung](https://services.informatik.hs-mannheim.de/~s.leuchter/pp/labs/08-02-ConcurrencyMonteCarloPiFuture.html) +- [Musterlösung](https://services.informatik.hs-mannheim.de/~s.leuchter/pp/labs/08-Solutions.html#laboraufgabe-monte-carlo-algorithmus-zur-annäherung-von-pi-mit-future) + +# Materialien +- [Folien](https://services.informatik.hs-mannheim.de/~s.leuchter/pp/slides/08-completableFuture.html) +- [Skript](https://services.informatik.hs-mannheim.de/~s.leuchter/pp/notes/08-completableFuture.html) diff --git a/src/pp.08.02-ConcurrencyMonteCarloPiFuture/justfile b/src/pp.08.02-ConcurrencyMonteCarloPiFuture/justfile new file mode 100644 index 0000000..6ca7111 --- /dev/null +++ b/src/pp.08.02-ConcurrencyMonteCarloPiFuture/justfile @@ -0,0 +1,18 @@ +# Justfile (https://just.systems/) for starting Maven standard targets + +default: clean compile package + +exec class args: compile + mvn exec:java -Dexec.args="{{args}}" -Dexec.mainClass={{class}} +# exec class args: +# java -cp target/app.jar {{class}} {{args}} +clean: + mvn clean +compile: + mvn compile +test: compile + mvn test +javadoc: + mvn javadoc:javadoc +package: + mvn package diff --git a/src/pp.08.02-ConcurrencyMonteCarloPiFuture/pom.xml b/src/pp.08.02-ConcurrencyMonteCarloPiFuture/pom.xml new file mode 100644 index 0000000..ae6b99b --- /dev/null +++ b/src/pp.08.02-ConcurrencyMonteCarloPiFuture/pom.xml @@ -0,0 +1,70 @@ + + 4.0.0 + pp + pp.08.02-ConcurrencyMonteCarloPiFuture + 1.0-SNAPSHOT + jar + + + 16 + edge-SNAPSHOT + UTF-8 + + + + org.junit.jupiter + junit-jupiter + 5.10.0 + test + + + org.projectlombok + lombok + ${lombok.version} + provided + + + net.jcip + jcip-annotations + 1.0 + provided + + + + + + org.apache.maven.plugins + maven-surefire-plugin + 3.0.0 + + + org.apache.maven.plugins + maven-compiler-plugin + 3.9.0 + + + + org.projectlombok + lombok + ${lombok.version} + + + + + + org.codehaus.mojo + exec-maven-plugin + 3.1.0 + + + org.apache.maven.plugins + maven-javadoc-plugin + 3.5.0 + + private + en_US + + + + + \ No newline at end of file diff --git a/src/pp.08.02-ConcurrencyMonteCarloPiFuture/src/main/java/pp/InOutTuple.java b/src/pp.08.02-ConcurrencyMonteCarloPiFuture/src/main/java/pp/InOutTuple.java new file mode 100644 index 0000000..86f2182 --- /dev/null +++ b/src/pp.08.02-ConcurrencyMonteCarloPiFuture/src/main/java/pp/InOutTuple.java @@ -0,0 +1,56 @@ +package pp; + +public record InOutTuple(int in, int out) { +} + +//record seit Java 16 (preview seit Java 14). +//identisch zu ... +//public final class InOutTuple { +// final private int in; +// final private int out; +// +// public InOutTuple(int in, int out) { +// this.in = in; +// this.out = out; +// } +// +// public int in() { +// return this.in; +// } +// +// public int out() { +// return this.out; +// } +// +// @Override +// public String toString() { +// return String.format("InOutTuple [in=%s, out=%s]", this.in, this.out); +// } +// +// @Override +// public int hashCode() { +// var prime = 31; +// var result = 1; +// result = (prime * result) + this.in; +// result = (prime * result) + this.out; +// return result; +// } +// +// @Override +// public boolean equals(Object obj) { +// if (this == obj) { +// return true; +// } +// if (!(obj instanceof InOutTuple)) { +// return false; +// } +// var other = (InOutTuple) obj; +// if (this.in != other.in) { +// return false; +// } +// if (this.out != other.out) { +// return false; +// } +// return true; +// } +//} diff --git a/src/pp.08.02-ConcurrencyMonteCarloPiFuture/src/main/java/pp/MonteCarloPiSeq.java b/src/pp.08.02-ConcurrencyMonteCarloPiFuture/src/main/java/pp/MonteCarloPiSeq.java new file mode 100644 index 0000000..2aeb5e3 --- /dev/null +++ b/src/pp.08.02-ConcurrencyMonteCarloPiFuture/src/main/java/pp/MonteCarloPiSeq.java @@ -0,0 +1,48 @@ +package pp; + +import java.util.Random; + +/** + * Berechnung von pi durch Monte Carlo Verfahren: Vergleich der Anzahl von + * zufällig gewähten Punkten innerhalb eines Viertelkreises (Radius r = 1) bzw. + * innerhalb eines Quadrates (Kantenlänge 1) analog zu Fläche eines + * Viertelkreises (pi * r^2 / 4) mit der Fläche des Quadrates (1 = 1 * 1). + * + * Sequenzielle Berechnung (im Main-Thread) + * + * @author Sandro Leuchter + * + */ +public class MonteCarloPiSeq { + static final int TOTAL_CYCLES = 10000000; + + public static InOutTuple getResultMonteCarloPiDraw(int cycles) { + var in = 0; + var out = 0; + var r = new Random(); + for (var i = 0; i < cycles; i++) { + var x = r.nextDouble(); + var y = r.nextDouble(); + if (Math.sqrt((x * x) + (y * y)) <= 1.0) { + in++; + } else { + out++; + } + } + return new InOutTuple(in, out); + } + + /** + * main-Methode + * + * @param args Kommandozeilenparameter (nicht benutzt) + */ + public static void main(String... args) { + var now = System.currentTimeMillis(); + var result = getResultMonteCarloPiDraw(TOTAL_CYCLES); + var time = System.currentTimeMillis() - now; + var pi = ((4.0 * result.in()) / (result.in() + result.out())); + System.out.println(pi + ", " + time + " ms"); + } + +} diff --git a/src/pp.08.02-ConcurrencyMonteCarloPiFuture_solution/README.md b/src/pp.08.02-ConcurrencyMonteCarloPiFuture_solution/README.md new file mode 100644 index 0000000..3d33007 --- /dev/null +++ b/src/pp.08.02-ConcurrencyMonteCarloPiFuture_solution/README.md @@ -0,0 +1,7 @@ +# Laboraufgabe "Monte-Carlo-Algorithmus zur Annäherung von pi – mit Future" +- [Aufgabenstellung](https://services.informatik.hs-mannheim.de/~s.leuchter/pp/labs/08-02-ConcurrencyMonteCarloPiFuture.html) +- [Musterlösung](https://services.informatik.hs-mannheim.de/~s.leuchter/pp/labs/08-Solutions.html#laboraufgabe-monte-carlo-algorithmus-zur-annäherung-von-pi-mit-future) + +# Materialien +- [Folien](https://services.informatik.hs-mannheim.de/~s.leuchter/pp/slides/08-completableFuture.html) +- [Skript](https://services.informatik.hs-mannheim.de/~s.leuchter/pp/notes/08-completableFuture.html) diff --git a/src/pp.08.02-ConcurrencyMonteCarloPiFuture_solution/justfile b/src/pp.08.02-ConcurrencyMonteCarloPiFuture_solution/justfile new file mode 100644 index 0000000..6ca7111 --- /dev/null +++ b/src/pp.08.02-ConcurrencyMonteCarloPiFuture_solution/justfile @@ -0,0 +1,18 @@ +# Justfile (https://just.systems/) for starting Maven standard targets + +default: clean compile package + +exec class args: compile + mvn exec:java -Dexec.args="{{args}}" -Dexec.mainClass={{class}} +# exec class args: +# java -cp target/app.jar {{class}} {{args}} +clean: + mvn clean +compile: + mvn compile +test: compile + mvn test +javadoc: + mvn javadoc:javadoc +package: + mvn package diff --git a/src/pp.08.02-ConcurrencyMonteCarloPiFuture_solution/pom.xml b/src/pp.08.02-ConcurrencyMonteCarloPiFuture_solution/pom.xml new file mode 100644 index 0000000..0ffd59d --- /dev/null +++ b/src/pp.08.02-ConcurrencyMonteCarloPiFuture_solution/pom.xml @@ -0,0 +1,70 @@ + + 4.0.0 + pp + pp.08.02-ConcurrencyMonteCarloPiFuture_solution + 1.0-SNAPSHOT + jar + + + 16 + edge-SNAPSHOT + UTF-8 + + + + org.junit.jupiter + junit-jupiter + 5.10.0 + test + + + org.projectlombok + lombok + ${lombok.version} + provided + + + net.jcip + jcip-annotations + 1.0 + provided + + + + + + org.apache.maven.plugins + maven-surefire-plugin + 3.0.0 + + + org.apache.maven.plugins + maven-compiler-plugin + 3.9.0 + + + + org.projectlombok + lombok + ${lombok.version} + + + + + + org.codehaus.mojo + exec-maven-plugin + 3.1.0 + + + org.apache.maven.plugins + maven-javadoc-plugin + 3.5.0 + + private + en_US + + + + + \ No newline at end of file diff --git a/src/pp.08.02-ConcurrencyMonteCarloPiFuture_solution/src/main/java/pp/InOutTuple.java b/src/pp.08.02-ConcurrencyMonteCarloPiFuture_solution/src/main/java/pp/InOutTuple.java new file mode 100644 index 0000000..bea2f92 --- /dev/null +++ b/src/pp.08.02-ConcurrencyMonteCarloPiFuture_solution/src/main/java/pp/InOutTuple.java @@ -0,0 +1,63 @@ +package pp; + +public record InOutTuple(int in, int out) { + InOutTuple add(InOutTuple other) { + return new InOutTuple(in() + other.in(), out() + other.out()); + } +} + +//record seit Java 16 (preview seit Java 14). +//identisch zu ... +//public final class InOutTuple { +// final private int in; +// final private int out; +// +// public InOutTuple(int in, int out) { +// this.in = in; +// this.out = out; +// } +// +// public int in() { +// return this.in; +// } +// +// public int out() { +// return this.out; +// } +// +// @Override +// public String toString() { +// return String.format("InOutTuple [in=%s, out=%s]", this.in, this.out); +// } +// +// @Override +// public int hashCode() { +// var prime = 31; +// var result = 1; +// result = (prime * result) + this.in; +// result = (prime * result) + this.out; +// return result; +// } +// +// @Override +// public boolean equals(Object obj) { +// if (this == obj) { +// return true; +// } +// if (!(obj instanceof InOutTuple)) { +// return false; +// } +// var other = (InOutTuple) obj; +// if (this.in != other.in) { +// return false; +// } +// if (this.out != other.out) { +// return false; +// } +// return true; +// } +// +// InOutTuple add(InOutTuple other) { +// return new InOutTuple(in() + other.in(), out() + other.out()); +// } +//} diff --git a/src/pp.08.02-ConcurrencyMonteCarloPiFuture_solution/src/main/java/pp/MonteCarloPiFuture.java b/src/pp.08.02-ConcurrencyMonteCarloPiFuture_solution/src/main/java/pp/MonteCarloPiFuture.java new file mode 100644 index 0000000..f095dcd --- /dev/null +++ b/src/pp.08.02-ConcurrencyMonteCarloPiFuture_solution/src/main/java/pp/MonteCarloPiFuture.java @@ -0,0 +1,66 @@ +package pp; + +import java.util.LinkedList; +import java.util.Random; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.Executors; +import java.util.concurrent.Future; + +/** + * Berechnung von pi durch Monte Carlo Verfahren: Vergleich der Anzahl von + * zufällig gewähten Punkten innerhalb eines Viertelkreises (Radius r = 1) bzw. + * innerhalb eines Quadrates (Kantenlänge 1) analog zu Fläche eines + * Viertelkreises (pi * r^2 / 4) mit der Fläche des Quadrates (1 = 1 * 1). + * + * Parallele Berechnung (mit Futures im FixedThreadPool) + * + * @author Sandro Leuchter + * + */ +public class MonteCarloPiFuture { + static final int PARALLELISM = 8; + static final int TOTAL_CYCLES = 10000000; + + public static InOutTuple getResultMonteCarloPiDraw(int cycles) { + var in = 0; + var out = 0; + var r = new Random(); + for (var i = 0; i < cycles; i++) { + var x = r.nextDouble(); + var y = r.nextDouble(); + if (Math.sqrt((x * x) + (y * y)) <= 1.0) { + in++; + } else { + out++; + } + } + return new InOutTuple(in, out); + } + + /** + * main-Methode + * + * @param args Kommandozeilenparameter (nicht benutzt) + * @throws ExecutionException + * @throws InterruptedException + */ + public static void main(String... args) + throws InterruptedException, ExecutionException { + var pool = Executors.newFixedThreadPool(PARALLELISM); + var futures = new LinkedList>(); + var now = System.currentTimeMillis(); + for (var i = 0; i < PARALLELISM; i++) { + futures.add(pool.submit(() -> getResultMonteCarloPiDraw( + TOTAL_CYCLES / PARALLELISM))); + } + pool.shutdown(); + var time = System.currentTimeMillis() - now; + var result = new InOutTuple(0, 0); + for (var f : futures) { + result = result.add(f.get()); + } + var pi = ((4.0 * result.in()) / (result.in() + result.out())); + System.out.println(pi + ", " + time + " ms"); + } + +} diff --git a/src/pp.08.02-ConcurrencyMonteCarloPiFuture_solution/src/main/java/pp/MonteCarloPiSeq.java b/src/pp.08.02-ConcurrencyMonteCarloPiFuture_solution/src/main/java/pp/MonteCarloPiSeq.java new file mode 100644 index 0000000..2aeb5e3 --- /dev/null +++ b/src/pp.08.02-ConcurrencyMonteCarloPiFuture_solution/src/main/java/pp/MonteCarloPiSeq.java @@ -0,0 +1,48 @@ +package pp; + +import java.util.Random; + +/** + * Berechnung von pi durch Monte Carlo Verfahren: Vergleich der Anzahl von + * zufällig gewähten Punkten innerhalb eines Viertelkreises (Radius r = 1) bzw. + * innerhalb eines Quadrates (Kantenlänge 1) analog zu Fläche eines + * Viertelkreises (pi * r^2 / 4) mit der Fläche des Quadrates (1 = 1 * 1). + * + * Sequenzielle Berechnung (im Main-Thread) + * + * @author Sandro Leuchter + * + */ +public class MonteCarloPiSeq { + static final int TOTAL_CYCLES = 10000000; + + public static InOutTuple getResultMonteCarloPiDraw(int cycles) { + var in = 0; + var out = 0; + var r = new Random(); + for (var i = 0; i < cycles; i++) { + var x = r.nextDouble(); + var y = r.nextDouble(); + if (Math.sqrt((x * x) + (y * y)) <= 1.0) { + in++; + } else { + out++; + } + } + return new InOutTuple(in, out); + } + + /** + * main-Methode + * + * @param args Kommandozeilenparameter (nicht benutzt) + */ + public static void main(String... args) { + var now = System.currentTimeMillis(); + var result = getResultMonteCarloPiDraw(TOTAL_CYCLES); + var time = System.currentTimeMillis() - now; + var pi = ((4.0 * result.in()) / (result.in() + result.out())); + System.out.println(pi + ", " + time + " ms"); + } + +} diff --git a/src/pp.08.03-CommonPool/README.md b/src/pp.08.03-CommonPool/README.md new file mode 100644 index 0000000..db5c375 --- /dev/null +++ b/src/pp.08.03-CommonPool/README.md @@ -0,0 +1,7 @@ +# Laboraufgabe "commonPool" +- [Aufgabenstellung](https://services.informatik.hs-mannheim.de/~s.leuchter/pp/labs/08-03-CommonPool.html) +- [Musterlösung](https://services.informatik.hs-mannheim.de/~s.leuchter/pp/labs/08-Solutions.html#laboraufgabe-commonpool) + +# Materialien +- [Folien](https://services.informatik.hs-mannheim.de/~s.leuchter/pp/slides/08-completableFuture.html) +- [Skript](https://services.informatik.hs-mannheim.de/~s.leuchter/pp/notes/08-completableFuture.html) diff --git a/src/pp.08.03-CommonPool/justfile b/src/pp.08.03-CommonPool/justfile new file mode 100644 index 0000000..a6ad318 --- /dev/null +++ b/src/pp.08.03-CommonPool/justfile @@ -0,0 +1,21 @@ +# Justfile (https://just.systems/) for starting Maven standard targets + +default: clean compile package + +par parallelism: + mvn exec:java -Dexec.mainClass=pp.CommonPoolTest -Djava.util.concurrent.ForkJoinPool.common.parallelism={{parallelism}} + +exec class args: compile + mvn exec:java -Dexec.args="{{args}}" -Dexec.mainClass={{class}} +# exec class args: +# java -cp target/app.jar {{class}} {{args}} +clean: + mvn clean +compile: + mvn compile +test: compile + mvn test +javadoc: + mvn javadoc:javadoc +package: + mvn package diff --git a/src/pp.08.03-CommonPool/pom.xml b/src/pp.08.03-CommonPool/pom.xml new file mode 100644 index 0000000..5935fa4 --- /dev/null +++ b/src/pp.08.03-CommonPool/pom.xml @@ -0,0 +1,70 @@ + + 4.0.0 + pp + pp.08.03-CommonPool + 1.0-SNAPSHOT + jar + + + 10 + edge-SNAPSHOT + UTF-8 + + + + org.junit.jupiter + junit-jupiter + 5.10.0 + test + + + org.projectlombok + lombok + ${lombok.version} + provided + + + net.jcip + jcip-annotations + 1.0 + provided + + + + + + org.apache.maven.plugins + maven-surefire-plugin + 3.0.0 + + + org.apache.maven.plugins + maven-compiler-plugin + 3.9.0 + + + + org.projectlombok + lombok + ${lombok.version} + + + + + + org.codehaus.mojo + exec-maven-plugin + 3.1.0 + + + org.apache.maven.plugins + maven-javadoc-plugin + 3.5.0 + + private + en_US + + + + + diff --git a/src/pp.08.03-CommonPool/src/main/java/pp/CommonPoolTest.java b/src/pp.08.03-CommonPool/src/main/java/pp/CommonPoolTest.java new file mode 100644 index 0000000..2d23d1b --- /dev/null +++ b/src/pp.08.03-CommonPool/src/main/java/pp/CommonPoolTest.java @@ -0,0 +1,43 @@ +package pp; + +import java.util.concurrent.ExecutionException; +import java.util.concurrent.ForkJoinPool; +import java.util.concurrent.Future; +import java.util.LinkedList; + +public class CommonPoolTest { + private static void sleep() { + try { + Thread.sleep(2000); + } catch (InterruptedException e) { + Thread.currentThread().interrupt(); + } + } + + private static void output(int task, String event) { + var thread = Thread.currentThread().getName(); + System.out.printf("Task-%02d %s by %s\n", task, event, thread); + } + + public static void main(String... args) + throws InterruptedException, ExecutionException { + var cores = Runtime.getRuntime().availableProcessors(); + var commonPool = ForkJoinPool.commonPool(); + System.out.println("# Cores: " + cores); + System.out.println("# Threads: " + commonPool.getParallelism()); + var futures = new LinkedList>(); + for (var task : new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }) { + futures.add(commonPool.submit(() -> { + output(task, "started"); + sleep(); + output(task, "finished"); + return task; + })); + output(task, "submitted"); + } + for (var future : futures) { + output((int) future.get(), "delivered"); + } + commonPool.shutdown(); + } +} diff --git a/src/pp.08.04-ConcurrencyMonteCarloPiCF/README.md b/src/pp.08.04-ConcurrencyMonteCarloPiCF/README.md new file mode 100644 index 0000000..a1ac83a --- /dev/null +++ b/src/pp.08.04-ConcurrencyMonteCarloPiCF/README.md @@ -0,0 +1,7 @@ +# Laboraufgabe "Monte-Carlo-Algorithmus zur Annäherung von pi – mit CompletableFuture" +- [Aufgabenstellung](https://services.informatik.hs-mannheim.de/~s.leuchter/pp/labs/08-04-ConcurrencyMonteCarloPiCF.html) +- [Musterlösung](https://services.informatik.hs-mannheim.de/~s.leuchter/pp/labs/08-Solutions.html#laboraufgabe-monte-carlo-algorithmus-zur-annäherung-von-pi-mit-completablefuture) + +# Materialien +- [Folien](https://services.informatik.hs-mannheim.de/~s.leuchter/pp/slides/08-completableFuture.html) +- [Skript](https://services.informatik.hs-mannheim.de/~s.leuchter/pp/notes/08-completableFuture.html) diff --git a/src/pp.08.04-ConcurrencyMonteCarloPiCF/justfile b/src/pp.08.04-ConcurrencyMonteCarloPiCF/justfile new file mode 100644 index 0000000..6ca7111 --- /dev/null +++ b/src/pp.08.04-ConcurrencyMonteCarloPiCF/justfile @@ -0,0 +1,18 @@ +# Justfile (https://just.systems/) for starting Maven standard targets + +default: clean compile package + +exec class args: compile + mvn exec:java -Dexec.args="{{args}}" -Dexec.mainClass={{class}} +# exec class args: +# java -cp target/app.jar {{class}} {{args}} +clean: + mvn clean +compile: + mvn compile +test: compile + mvn test +javadoc: + mvn javadoc:javadoc +package: + mvn package diff --git a/src/pp.08.04-ConcurrencyMonteCarloPiCF/pom.xml b/src/pp.08.04-ConcurrencyMonteCarloPiCF/pom.xml new file mode 100644 index 0000000..0ceaf09 --- /dev/null +++ b/src/pp.08.04-ConcurrencyMonteCarloPiCF/pom.xml @@ -0,0 +1,70 @@ + + 4.0.0 + pp + pp.08.04-ConcurrencyMonteCarloPiCF + 1.0-SNAPSHOT + jar + + + 16 + edge-SNAPSHOT + UTF-8 + + + + org.junit.jupiter + junit-jupiter + 5.10.0 + test + + + org.projectlombok + lombok + ${lombok.version} + provided + + + net.jcip + jcip-annotations + 1.0 + provided + + + + + + org.apache.maven.plugins + maven-surefire-plugin + 3.0.0 + + + org.apache.maven.plugins + maven-compiler-plugin + 3.9.0 + + + + org.projectlombok + lombok + ${lombok.version} + + + + + + org.codehaus.mojo + exec-maven-plugin + 3.1.0 + + + org.apache.maven.plugins + maven-javadoc-plugin + 3.5.0 + + private + en_US + + + + + \ No newline at end of file diff --git a/src/pp.08.04-ConcurrencyMonteCarloPiCF/src/main/java/pp/InOutTuple.java b/src/pp.08.04-ConcurrencyMonteCarloPiCF/src/main/java/pp/InOutTuple.java new file mode 100644 index 0000000..ef7bd8f --- /dev/null +++ b/src/pp.08.04-ConcurrencyMonteCarloPiCF/src/main/java/pp/InOutTuple.java @@ -0,0 +1,63 @@ +package pp; + +public record InOutTuple(int in, int out) { + InOutTuple add(InOutTuple other) { + return new InOutTuple(in() + other.in(), out() + other.out()); + } +} + +//record seit Java 15 (preview in Java 14). +//identisch zu ... +//public final class InOutTuple { +// final private int in; +// final private int out; +// +// public InOutTuple(int in, int out) { +// this.in = in; +// this.out = out; +// } +// +// public int in() { +// return this.in; +// } +// +// public int out() { +// return this.out; +// } +// +// @Override +// public String toString() { +// return String.format("InOutTuple [in=%s, out=%s]", this.in, this.out); +// } +// +// @Override +// public int hashCode() { +// var prime = 31; +// var result = 1; +// result = (prime * result) + this.in; +// result = (prime * result) + this.out; +// return result; +// } +// +// @Override +// public boolean equals(Object obj) { +// if (this == obj) { +// return true; +// } +// if (!(obj instanceof InOutTuple)) { +// return false; +// } +// var other = (InOutTuple) obj; +// if (this.in != other.in) { +// return false; +// } +// if (this.out != other.out) { +// return false; +// } +// return true; +// } +// +// InOutTuple add(InOutTuple other) { +// return new InOutTuple(in() + other.in(), out() + other.out()); +// } +//} diff --git a/src/pp.08.04-ConcurrencyMonteCarloPiCF/src/main/java/pp/MonteCarloPiSeq.java b/src/pp.08.04-ConcurrencyMonteCarloPiCF/src/main/java/pp/MonteCarloPiSeq.java new file mode 100644 index 0000000..2aeb5e3 --- /dev/null +++ b/src/pp.08.04-ConcurrencyMonteCarloPiCF/src/main/java/pp/MonteCarloPiSeq.java @@ -0,0 +1,48 @@ +package pp; + +import java.util.Random; + +/** + * Berechnung von pi durch Monte Carlo Verfahren: Vergleich der Anzahl von + * zufällig gewähten Punkten innerhalb eines Viertelkreises (Radius r = 1) bzw. + * innerhalb eines Quadrates (Kantenlänge 1) analog zu Fläche eines + * Viertelkreises (pi * r^2 / 4) mit der Fläche des Quadrates (1 = 1 * 1). + * + * Sequenzielle Berechnung (im Main-Thread) + * + * @author Sandro Leuchter + * + */ +public class MonteCarloPiSeq { + static final int TOTAL_CYCLES = 10000000; + + public static InOutTuple getResultMonteCarloPiDraw(int cycles) { + var in = 0; + var out = 0; + var r = new Random(); + for (var i = 0; i < cycles; i++) { + var x = r.nextDouble(); + var y = r.nextDouble(); + if (Math.sqrt((x * x) + (y * y)) <= 1.0) { + in++; + } else { + out++; + } + } + return new InOutTuple(in, out); + } + + /** + * main-Methode + * + * @param args Kommandozeilenparameter (nicht benutzt) + */ + public static void main(String... args) { + var now = System.currentTimeMillis(); + var result = getResultMonteCarloPiDraw(TOTAL_CYCLES); + var time = System.currentTimeMillis() - now; + var pi = ((4.0 * result.in()) / (result.in() + result.out())); + System.out.println(pi + ", " + time + " ms"); + } + +} diff --git a/src/pp.08.04-ConcurrencyMonteCarloPiCF_solution/README.md b/src/pp.08.04-ConcurrencyMonteCarloPiCF_solution/README.md new file mode 100644 index 0000000..a1ac83a --- /dev/null +++ b/src/pp.08.04-ConcurrencyMonteCarloPiCF_solution/README.md @@ -0,0 +1,7 @@ +# Laboraufgabe "Monte-Carlo-Algorithmus zur Annäherung von pi – mit CompletableFuture" +- [Aufgabenstellung](https://services.informatik.hs-mannheim.de/~s.leuchter/pp/labs/08-04-ConcurrencyMonteCarloPiCF.html) +- [Musterlösung](https://services.informatik.hs-mannheim.de/~s.leuchter/pp/labs/08-Solutions.html#laboraufgabe-monte-carlo-algorithmus-zur-annäherung-von-pi-mit-completablefuture) + +# Materialien +- [Folien](https://services.informatik.hs-mannheim.de/~s.leuchter/pp/slides/08-completableFuture.html) +- [Skript](https://services.informatik.hs-mannheim.de/~s.leuchter/pp/notes/08-completableFuture.html) diff --git a/src/pp.08.04-ConcurrencyMonteCarloPiCF_solution/justfile b/src/pp.08.04-ConcurrencyMonteCarloPiCF_solution/justfile new file mode 100644 index 0000000..6ca7111 --- /dev/null +++ b/src/pp.08.04-ConcurrencyMonteCarloPiCF_solution/justfile @@ -0,0 +1,18 @@ +# Justfile (https://just.systems/) for starting Maven standard targets + +default: clean compile package + +exec class args: compile + mvn exec:java -Dexec.args="{{args}}" -Dexec.mainClass={{class}} +# exec class args: +# java -cp target/app.jar {{class}} {{args}} +clean: + mvn clean +compile: + mvn compile +test: compile + mvn test +javadoc: + mvn javadoc:javadoc +package: + mvn package diff --git a/src/pp.08.04-ConcurrencyMonteCarloPiCF_solution/pom.xml b/src/pp.08.04-ConcurrencyMonteCarloPiCF_solution/pom.xml new file mode 100644 index 0000000..6635ab7 --- /dev/null +++ b/src/pp.08.04-ConcurrencyMonteCarloPiCF_solution/pom.xml @@ -0,0 +1,70 @@ + + 4.0.0 + pp + pp.08.04-ConcurrencyMonteCarloPiCF_solution + 1.0-SNAPSHOT + jar + + + 16 + edge-SNAPSHOT + UTF-8 + + + + org.junit.jupiter + junit-jupiter + 5.10.0 + test + + + org.projectlombok + lombok + ${lombok.version} + provided + + + net.jcip + jcip-annotations + 1.0 + provided + + + + + + org.apache.maven.plugins + maven-surefire-plugin + 3.0.0 + + + org.apache.maven.plugins + maven-compiler-plugin + 3.9.0 + + + + org.projectlombok + lombok + ${lombok.version} + + + + + + org.codehaus.mojo + exec-maven-plugin + 3.1.0 + + + org.apache.maven.plugins + maven-javadoc-plugin + 3.5.0 + + private + en_US + + + + + \ No newline at end of file diff --git a/src/pp.08.04-ConcurrencyMonteCarloPiCF_solution/src/main/java/pp/InOutTuple.java b/src/pp.08.04-ConcurrencyMonteCarloPiCF_solution/src/main/java/pp/InOutTuple.java new file mode 100644 index 0000000..ef7bd8f --- /dev/null +++ b/src/pp.08.04-ConcurrencyMonteCarloPiCF_solution/src/main/java/pp/InOutTuple.java @@ -0,0 +1,63 @@ +package pp; + +public record InOutTuple(int in, int out) { + InOutTuple add(InOutTuple other) { + return new InOutTuple(in() + other.in(), out() + other.out()); + } +} + +//record seit Java 15 (preview in Java 14). +//identisch zu ... +//public final class InOutTuple { +// final private int in; +// final private int out; +// +// public InOutTuple(int in, int out) { +// this.in = in; +// this.out = out; +// } +// +// public int in() { +// return this.in; +// } +// +// public int out() { +// return this.out; +// } +// +// @Override +// public String toString() { +// return String.format("InOutTuple [in=%s, out=%s]", this.in, this.out); +// } +// +// @Override +// public int hashCode() { +// var prime = 31; +// var result = 1; +// result = (prime * result) + this.in; +// result = (prime * result) + this.out; +// return result; +// } +// +// @Override +// public boolean equals(Object obj) { +// if (this == obj) { +// return true; +// } +// if (!(obj instanceof InOutTuple)) { +// return false; +// } +// var other = (InOutTuple) obj; +// if (this.in != other.in) { +// return false; +// } +// if (this.out != other.out) { +// return false; +// } +// return true; +// } +// +// InOutTuple add(InOutTuple other) { +// return new InOutTuple(in() + other.in(), out() + other.out()); +// } +//} diff --git a/src/pp.08.04-ConcurrencyMonteCarloPiCF_solution/src/main/java/pp/MonteCarloPiCF1.java b/src/pp.08.04-ConcurrencyMonteCarloPiCF_solution/src/main/java/pp/MonteCarloPiCF1.java new file mode 100644 index 0000000..2de7766 --- /dev/null +++ b/src/pp.08.04-ConcurrencyMonteCarloPiCF_solution/src/main/java/pp/MonteCarloPiCF1.java @@ -0,0 +1,82 @@ +package pp; + +import java.util.Random; +import java.util.concurrent.CompletableFuture; + +/** + * Berechnung von pi durch Monte Carlo Verfahren: Vergleich der Anzahl von + * zufällig gewähten Punkten innerhalb eines Viertelkreises (Radius r = 1) bzw. + * innerhalb eines Quadrates (Kantenlänge 1) analog zu Fläche eines + * Viertelkreises (pi * r^2 / 4) mit der Fläche des Quadrates (1 = 1 * 1). + * + * Parallele Berechnung (im Common Pool über Completable Future) + * + * @author Sandro Leuchter + * + */ +public class MonteCarloPiCF1 { + static final int TOTAL_CYCLES = 10000000; + static final int PARALLELISM = 7; + + public static InOutTuple getResultMonteCarloPiDraw(int cycles) { + var in = 0; + var out = 0; + var r = new Random(); + for (var i = 0; i < cycles; i++) { + var x = r.nextDouble(); + var y = r.nextDouble(); + if (Math.sqrt((x * x) + (y * y)) <= 1.0) { + in++; + } else { + out++; + } + } + return new InOutTuple(in, out); + } + + /** + * main-Methode + * + * @param args Kommandozeilenparameter (nicht benutzt) + */ + public static void main(String... args) { + var now = System.currentTimeMillis(); + var result = CompletableFuture.supplyAsync( + () -> getResultMonteCarloPiDraw(TOTAL_CYCLES / PARALLELISM)) + .thenCombineAsync( + CompletableFuture + .supplyAsync(() -> getResultMonteCarloPiDraw( + TOTAL_CYCLES / PARALLELISM)), + (InOutTuple x, InOutTuple y) -> x.add(y)) + .thenCombineAsync( + CompletableFuture + .supplyAsync(() -> getResultMonteCarloPiDraw( + TOTAL_CYCLES / PARALLELISM)), + (InOutTuple x, InOutTuple y) -> x.add(y)) + .thenCombineAsync( + CompletableFuture + .supplyAsync(() -> getResultMonteCarloPiDraw( + TOTAL_CYCLES / PARALLELISM)), + (InOutTuple x, InOutTuple y) -> x.add(y)) + .thenCombineAsync( + CompletableFuture + .supplyAsync(() -> getResultMonteCarloPiDraw( + TOTAL_CYCLES / PARALLELISM)), + (InOutTuple x, InOutTuple y) -> x.add(y)) + .thenCombineAsync( + CompletableFuture + .supplyAsync(() -> getResultMonteCarloPiDraw( + TOTAL_CYCLES / PARALLELISM)), + (InOutTuple x, InOutTuple y) -> x.add(y)) + .thenCombineAsync( + CompletableFuture + .supplyAsync(() -> getResultMonteCarloPiDraw( + TOTAL_CYCLES / PARALLELISM)), + (InOutTuple x, InOutTuple y) -> x.add(y)) + .join(); + var time = System.currentTimeMillis() - now; + var pi = ((4.0 * result.in()) / (result.in() + result.out())); + System.out.println(pi + ", " + time + " ms"); + } + +} diff --git a/src/pp.08.04-ConcurrencyMonteCarloPiCF_solution/src/main/java/pp/MonteCarloPiCF2.java b/src/pp.08.04-ConcurrencyMonteCarloPiCF_solution/src/main/java/pp/MonteCarloPiCF2.java new file mode 100644 index 0000000..05d0637 --- /dev/null +++ b/src/pp.08.04-ConcurrencyMonteCarloPiCF_solution/src/main/java/pp/MonteCarloPiCF2.java @@ -0,0 +1,60 @@ +package pp; + +import java.util.Random; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.ForkJoinPool; + +/** + * Berechnung von pi durch Monte Carlo Verfahren: Vergleich der Anzahl von + * zufällig gewähten Punkten innerhalb eines Viertelkreises (Radius r = 1) bzw. + * innerhalb eines Quadrates (Kantenlänge 1) analog zu Fläche eines + * Viertelkreises (pi * r^2 / 4) mit der Fläche des Quadrates (1 = 1 * 1). + * + * Parallele Berechnung (im Common Pool über Completable Future) + * + * @author Sandro Leuchter + * + */ +public class MonteCarloPiCF2 { + static final int TOTAL_CYCLES = 10000000; + static final int PARALLELISM = ForkJoinPool.commonPool().getParallelism(); + + public static InOutTuple getResultMonteCarloPiDraw(int cycles) { + var in = 0; + var out = 0; + var r = new Random(); + for (var i = 0; i < cycles; i++) { + var x = r.nextDouble(); + var y = r.nextDouble(); + if (Math.sqrt((x * x) + (y * y)) <= 1.0) { + in++; + } else { + out++; + } + } + return new InOutTuple(in, out); + } + + /** + * main-Methode + * + * @param args Kommandozeilenparameter (nicht benutzt) + */ + public static void main(String... args) { + var now = System.currentTimeMillis(); + var resultStage = CompletableFuture.supplyAsync( + () -> getResultMonteCarloPiDraw(TOTAL_CYCLES / PARALLELISM)); + for (var i = 1; i < PARALLELISM; i++) { + resultStage = resultStage.thenCombineAsync( + CompletableFuture + .supplyAsync(() -> getResultMonteCarloPiDraw( + TOTAL_CYCLES / PARALLELISM)), + (InOutTuple x, InOutTuple y) -> x.add(y)); + } + var result = resultStage.join(); + var time = System.currentTimeMillis() - now; + var pi = ((4.0 * result.in()) / (result.in() + result.out())); + System.out.println(pi + ", " + time + " ms"); + } + +} diff --git a/src/pp.08.04-ConcurrencyMonteCarloPiCF_solution/src/main/java/pp/MonteCarloPiSeq.java b/src/pp.08.04-ConcurrencyMonteCarloPiCF_solution/src/main/java/pp/MonteCarloPiSeq.java new file mode 100644 index 0000000..2aeb5e3 --- /dev/null +++ b/src/pp.08.04-ConcurrencyMonteCarloPiCF_solution/src/main/java/pp/MonteCarloPiSeq.java @@ -0,0 +1,48 @@ +package pp; + +import java.util.Random; + +/** + * Berechnung von pi durch Monte Carlo Verfahren: Vergleich der Anzahl von + * zufällig gewähten Punkten innerhalb eines Viertelkreises (Radius r = 1) bzw. + * innerhalb eines Quadrates (Kantenlänge 1) analog zu Fläche eines + * Viertelkreises (pi * r^2 / 4) mit der Fläche des Quadrates (1 = 1 * 1). + * + * Sequenzielle Berechnung (im Main-Thread) + * + * @author Sandro Leuchter + * + */ +public class MonteCarloPiSeq { + static final int TOTAL_CYCLES = 10000000; + + public static InOutTuple getResultMonteCarloPiDraw(int cycles) { + var in = 0; + var out = 0; + var r = new Random(); + for (var i = 0; i < cycles; i++) { + var x = r.nextDouble(); + var y = r.nextDouble(); + if (Math.sqrt((x * x) + (y * y)) <= 1.0) { + in++; + } else { + out++; + } + } + return new InOutTuple(in, out); + } + + /** + * main-Methode + * + * @param args Kommandozeilenparameter (nicht benutzt) + */ + public static void main(String... args) { + var now = System.currentTimeMillis(); + var result = getResultMonteCarloPiDraw(TOTAL_CYCLES); + var time = System.currentTimeMillis() - now; + var pi = ((4.0 * result.in()) / (result.in() + result.out())); + System.out.println(pi + ", " + time + " ms"); + } + +}