Sale!

# CS2030/S Practical Assessment #2

\$30.00

Category:

## Description

CS2030/S Practical Assessment #2
Tags & Categories
Tags:
Categories:
Related Tutorials
CS2030/S Practical Assessment #2
Java provides a Random class with a nextInt(int bound) method that returns a random (more precisely
pseudorandom), uniformly distributed integer value between 0 (inclusive) and the specified bound (exclusive).
Random integer values within the range 0 (inclusive) to Integer.MAX_VALUE (exclusive) can be generated as
follows:
jshell> Random r = new Random(2030)
r ==> [email protected]
jshell> r.nextInt(Integer.MAX_VALUE)
\$.. ==> 1327734301
jshell> r.nextInt(Integer.MAX_VALUE)
\$.. ==> 588347554
jshell> r.nextInt(Integer.MAX_VALUE)
\$.. ==> 1132554824
Notice that each time the statement r.nextInt(Integer.MAX_VALUE) is invoked, a different random value is
produced. Clearly, some changes in mutable state happens after every invocation of the nextInt method.
In order to realize an immutable random number generator, we generate a random integer based on a given seed,
jshell> new Random(2030).nextInt(Integer.MAX_VALUE)
\$.. ==> 1327734301
and use this new value as the seed to generate the next random value,
jshell> new Random(new Random(2030).nextInt(Integer.MAX_VALUE)).
…> nextInt(Integer.MAX_VALUE)
\$.. ==> 1503777125
Each invocation of the above now returns the same value. Using this technique of seed replacement, the first five
random values generated using this method is as follows. We consider the initial seed to be the first random number.
jshell> int i = 2030
i ==> 2030
jshell> i = new Random(i).nextInt(Integer.MAX_VALUE)
i ==> 1327734301
jshell> i = new Random(i).nextInt(Integer.MAX_VALUE)
i ==> 1503777125
Search search for…
in NUS Websites
NUS WebMail IVLE LIBRARY MAPS
26/11/2021, 03:08 CodeCrunch
jshell> i = new Random(i).nextInt(Integer.MAX_VALUE)
i ==> 1593627480
jshell> i = new Random(i).nextInt(Integer.MAX_VALUE)
i ==> 222432456
Your task is to create a context that handles the implementation details of random number generation.
There are altogether five levels. You need to complete ALL levels.
Take Note!
Write each class/interface/enum in its own file with meaningful names.
Ensure that ALL object properties and class constants are declared private final.
Ensure that your classes are NOT cyclic dependent.
You are NOT allowed to use the following java keywords/literals: null, instanceof
Java reflection is NOT allowed.
There should be NO type cast with SuppressWarnings
There is no restriction on Java libraries. However, if you use java.util.Optional, do not use the
get/isPresent/isEmpty methods.
Do not use * wildcard imports.
For ease of implementation, you need NOT include bounded/unbounded wildcards.
Do NOT define anonymous inner classes; define lambdas instead.
Do NOT use method references :: (the grader cannot handle it).
Do NOT use ellipsis, e.g. String…
In essence, keep to the constructs and programming discipline that is instilled throughout the module. Moreover, for
brevity in presenting test cases, we do not “type-witness” static methods unless necessary, i.e. Optional.
<Integer>of(1) is more concisely represented as Optional.of(1).
Level 1
Define a Rand class to generate random values using the seed replacement technique described above. The Rand
class comprises of the following:
a static of method that takes in an integer seed and creates a Rand object
a toString method that simply outputs Rand
a get method that returns the random integer value
a next method that returns the “next” Rand object
You may assume that the of method is used only at the start of a chain of Rand methods.
jshell> Rand.of(2030) instanceof Rand
\$.. ==> true
jshell> Rand.of(2030).get()
\$.. ==> 2030
jshell> Rand.of(2030).next() instanceof Rand
\$.. ==> true
jshell> Rand.of(2030).next().get()
\$.. ==> 1327734301
jshell> Rand.of(2030).next().next().get()
\$.. ==> 1503777125
jshell> Rand r = Rand.of(2030)
r ==> Rand
jshell> r.get()
\$.. ==> 2030
jshell> r.next().get()
\$.. ==> 1327734301
jshell> r.get()
\$.. ==> 2030
jshell> r.next().next().get()
\$.. ==> 1503777125
26/11/2021, 03:08 CodeCrunch
jshell> r.get()
\$.. ==> 2030
Level 2
Random numbers are generated repeatedly during simulations. Include a stream() method to generate a
Stream<Integer> of random numbers as shown in the sample run below:
jshell> Rand.of(2030).
…> stream().
…> limit(5).
…> forEach(x -> System.out.println(x))
2030
1327734301
1503777125
1593627480
222432456
jshell> Rand.of(2030).
…> next().
…> stream().
…> limit(5).
…> forEach(x -> System.out.println(x))
1327734301
1503777125
1593627480
222432456
1414485811
Moreover, generating sequences of random integer values within a specific range is very common. Include a static
method randRange that takes in an integer seed, and a Function that maps the random generated values to the
specified range.
As an example, the first five random values generated from Rand.of(2030), i.e. 2030, 1327734301, 1503777125,
1593627480, 222432456 can be mapped to the range 0 to 9, by taking the remainder after dividing by 10, i.e. 0, 1, 5,
0, 6.
jshell> Function<Integer,Integer> f = x -> x % 10
f ==> \$Lambda\$19/[email protected]
jshell> Rand.randRange(2030, f).
…> limit(20).
…> forEach(x -> System.out.print(x + ” “))
0 1 5 0 6 1 0 4 4 2 0 9 1 8 1 5 3 1 3 8
Level 3
Include a method map that maps the random value in the Rand object. Note how the order of method calls to next and
map can be interchanged while still generating the same outcome.
jshell> Rand.of(2030).map(x -> x – 1).get()
\$.. ==> 2029
jshell> Rand.of(2030).next().map(x -> x – 1).get()
\$.. ==> 1327734300
jshell> Rand.of(2030).map(x -> x – 1).next().get()
\$.. ==> 1327734300
jshell> Rand.of(2030).next().map(x -> x – 1).next().get()
\$.. ==> 1503777124
jshell> Rand.of(2030).map(x -> x – 1).stream().
…> limit(5).
…> forEach(x -> System.out.print(x % 10 + ” “))
9 0 4 9 5
jshell> Rand.of(2030).next().map(x -> x – 1).stream().
…> limit(5).
…> forEach(x -> System.out.print(x % 10 + ” “))
0 4 9 5 0
jshell> Rand.of(2030).map(x -> x – 1).next().stream().
…> limit(5).
…> forEach(x -> System.out.print(x % 10 + ” “))
26/11/2021, 03:08 CodeCrunch
0 4 9 5 0
jshell> Rand.of(2030).next().map(x -> x – 1).next().stream().
…> limit(5).
…> forEach(x -> System.out.print(x % 10 + ” “))
4 9 5 0 9
jshell> Rand.of(2030).next().map(x -> x % 2 == 0).next().stream().
…> limit(5).
…> forEach(x -> System.out.print(x + ” “))
false true true false true
Now, modify the randRange method so that it can generate a stream of values of any type.
jshell> Rand.randRange(2030, x -> x % 10).
…> limit(5).
…> forEach(System.out::println)
0
1
5
0
6
jshell> Rand.randRange(2030, x -> String.format(“[%02d]”, x % 100)).
…> limit(5).
…> forEach(System.out::println)
[30]
[01]
[25]
[80]
[56]
jshell> double lo = -1.0
lo ==> -1.0
jshell> double hi = 1.0
hi ==> 1.0
jshell> // random floating point values from lo to hi, both inclusive.
jshell> Rand.
…> randRange(2030, x -> (hi – lo) * x / (Integer.MAX_VALUE – 1) + lo).
…> limit(10).
…> forEach(System.out::println)
-0.9999981094151718
0.23654892876422862
0.4005015850071809
0.4841812490338284
-0.7928436322071064
0.31734256848445397
-0.5744591109216763
-0.4216896737196386
-0.2363805372606782
0.2196226168606641
The following are additional sample runs that illustrates the evaluation of a Rand object.
jshell> Rand.of(2030).
…> next().
…> map(x -> { System.out.println(“ouch!”); return x; }).
…> next()
\$.. ==> Rand
jshell> Rand.of(2030).next().
…> map(x -> { System.out.println(“ouch!”); return x; }).
…> next().
…> get()
ouch!
\$.. ==> 1503777125
jshell> Stream<Integer> ints = Rand.randRange(2030, x -> {
…> System.out.println(“ouch!”); return x; }).
…> limit(5)
ints ==> [email protected]
jshell> ints.forEach(x -> System.out.println(x))
26/11/2021, 03:08 CodeCrunch
ouch!
2030
ouch!
1327734301
ouch!
1503777125
ouch!
1593627480
ouch!
222432456
Level 4
So far, we have been generating sequences of individual values. How do we generate say, random lists of two integer
elements? We use flatMap!
Let’s first look at how flatMap behaves in the context of individual elements.
jshell> Rand.of(2030).map(x -> x / 2).get()
\$.. ==> 1015
jshell> Rand.of(2030).map(x -> x / 2).next().get()
\$.. ==> 663867150
jshell> Rand.of(2030).flatMap(x -> Rand.of(x).map(y -> y / 2)).get()
\$.. ==> 1015
jshell> Rand.of(2030).flatMap(x -> Rand.of(x).map(y -> y / 2)).next().get()
\$.. ==> 663867150
jshell> Rand.of(2030).map(x -> x / 2).next().
…> stream().limit(5).forEach(x -> System.out.println(x))
663867150
751888562
796813740
111216228
707242905
jshell> Rand.of(2030).next().flatMap(x -> Rand.of(x).map(y -> y / 2)).
…> stream().limit(5).forEach(x -> System.out.println(x))
663867150
751888562
796813740
111216228
707242905
jshell> Rand.of(2030).flatMap(x -> Rand.of(x).next().map(y -> y / 2)).
…> stream().limit(5).forEach(x -> System.out.println(x))
663867150
751888562
796813740
111216228
707242905
jshell> Rand.of(2030).flatMap(x -> Rand.of(x).map(y -> y / 2).next()).
…> stream().limit(5).forEach(x -> System.out.println(x))
663867150
751888562
796813740
111216228
707242905
jshell> Rand.of(2030).flatMap(x -> Rand.of(x).map(y -> y / 2)).next().
…> stream().limit(5).forEach(x -> System.out.println(x))
663867150
751888562
796813740
111216228
707242905
Now to generate random lists of two elements each, we need to replace the map function within flatMap.
26/11/2021, 03:08 CodeCrunch
jshell> Rand.of(2030).
…> flatMap(x -> Rand.of(x).map(y -> List.of(x,y))) instanceof Rand
\$.. ==> true
jshell> Rand.of(2030).
…> flatMap(x -> Rand.of(x).map(y -> List.of(x,y))).get()
\$.. ==> [2030, 2030]
jshell> Rand.of(2030).
…> flatMap(x -> Rand.of(x).map(y -> List.of(x,y))).next().get()
\$.. ==> [1327734301, 1327734301]
jshell> Rand.of(2030).
…> flatMap(x -> Rand.of(x).map(y -> List.of(x,y))).
…> stream().limit(5).forEach(x -> System.out.println(x))
[2030, 2030]
[1327734301, 1327734301]
[1503777125, 1503777125]
[1593627480, 1593627480]
[222432456, 222432456]
The above flatMap operations generates a list of two elements which are the same.
Let’s include a next within the flatMap.
jshell> Rand.of(2030).
…> flatMap(x -> Rand.of(x).map(y -> List.of(x,y)).next()).
…> get()
\$.. ==> [2030, 1327734301]
jshell> Rand.of(2030).
…> flatMap(x -> Rand.of(x).map(y -> List.of(x,y)).next()).
…> next().
…> get()
\$.. ==> [1327734301, 1503777125]
jshell> Rand.of(2030).
…> flatMap(x -> Rand.of(x).map(y -> List.of(x,y)).next()).
…> stream().limit(5).forEach(x -> System.out.println(x))
[2030, 1327734301]
[1327734301, 1503777125]
[1503777125, 1593627480]
[1593627480, 222432456]
[222432456, 1414485811]
The two values within a list are now consecutive random numbers. Also the first element of a list, is the second element
of the previous list. This is the expected behaviour.
Below are some other sample tests.
jshell> Rand.of(2030).
…> flatMap(x -> Rand.of(1010).map(y -> List.of(x,y))).
…> stream().limit(5).forEach(x -> System.out.println(x))
[2030, 1010]
[1327734301, 1010]
[1503777125, 1010]
[1593627480, 1010]
[222432456, 1010]
jshell> Rand.of(2030).
…> flatMap(x -> Rand.of(1010).map(y -> List.of(x,y)).next()).
…> stream().limit(5).forEach(x -> System.out.println(x))
[2030, 1530112223]
[1327734301, 1530112223]
[1503777125, 1530112223]
[1593627480, 1530112223]
[222432456, 1530112223]
jshell> Rand.of(2030).
…> flatMap(x -> Rand.of(x).map(y -> List.<Number>of(x, (y % 10) / 2.0))).
…> stream().limit(5).forEach(x -> System.out.println(x))
[2030, 0.0]
[1327734301, 0.5]
[1503777125, 2.5]
26/11/2021, 03:08 CodeCrunch
[1593627480, 0.0]
[222432456, 3.0]
jshell> Stream<Integer> ints = Rand.of(2030).
…> flatMap(x -> {
…> System.out.println(“ouch!”);
…> return Rand.of(x); }).
…> stream().limit(5)
ints ==> [email protected]
jshell> ints.forEach(x -> {})
ouch!
ouch!
ouch!
ouch!
ouch!
jshell> ints = Rand.of(2030).
…> flatMap(x -> {
…> System.out.println(“ouch!”);
…> return Rand.of(x).map(y -> {
…> System.out.println(“aiyo!”);
…> return y + 1; }); }).
…> stream().limit(5)
ints ==> [email protected]
jshell> ints.forEach(x -> System.out.println(x))
ouch!
aiyo!
2031
ouch!
aiyo!
1327734302
ouch!
aiyo!
1503777126
ouch!
aiyo!
1593627481
ouch!
aiyo!
222432457
Level 5
Finally, let us use our random number generator for a classic Monte-Carlo simulation — that of estimating the value of
pi.
Briefly, we can generate random points within the square region spanning bottom-left (-1,-1) to top-right (1,1), and
determine how many of these points fall into the circle centred at (0, 0) with radius 1.0. The proportion of points that
falls within the circle will be approximately equals to pi/4.
You are given the Circle and Point classes. Define a Main class with a static method double simulate(int
seed, int n) that takes in the seed and the number of simulation trials n. The method generates n number of
points within the region (-1,-1) and (1,1), determines how many of these fall within the circle, and returns the
estimated value of pi as a double value.
Take note that unlike the levels above, we wish to avoid duplicate random values. Here is a peek on what the first ten
points should look like using 2030 as the seed. You may compare this with the random floating point values generated
from one of the test cases in level 3.
(-0.9999981094151718, 0.23654892876422862)
(0.4005015850071809, 0.4841812490338284)
(-0.7928436322071064, 0.31734256848445397)
(-0.5744591109216763, -0.4216896737196386)
(-0.2363805372606782, 0.2196226168606641)
(-0.0677647097667351, 0.05293416423065045)
(-0.87413697771182, 0.7369958010846709)
(-0.563276542875242, -0.03873627450199446)
(-0.2820637172852305, -0.46053203051959357)
(0.07041811018289823, -0.8967840819589645)
Below are simulations over an increasing number of trials with the same seed 2030. Notice the convergence to the
value of pi.
26/11/2021, 03:08 CodeCrunch
Rights Reserved.