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:
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,
and use this new value as the seed to generate the next random value,
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 | |||||
| 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 |
jshell> i = new Random(i).nextInt(Integer.MAX_VALUE)
i ==> 1593627480
jshell> i = new Random(i).nextInt(Integer.MAX_VALUE) i ==> 222432456
Task
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).> stream().> limit(5).> forEach(x -> System.out.println(x))2030132773430115037771251593627480222432456jshell> Rand.of(2030).> next().> stream().> limit(5).> forEach(x -> System.out.println(x))1327734301150377712515936274802224324561414485811 |
| 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 |
| 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()$.. ==> 1503777124jshell> 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 + )) |
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:
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.
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.
| 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 |
| jshell> Rand.randRange(2030, x -> x % 10).> limit(5).> forEach(System.out::println)01506 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.0jshell> // 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.99999810941517180.236548928764228620.40050158500718090.4841812490338284-0.79284363220710640.31734256848445397 -0.5744591109216763-0.4216896737196386-0.23638053726067820.2196226168606641 |
| jshell> Rand.of(2030).> next().> map(x -> { System.out.println(ouch!); return x; }).> next()$.. ==> Randjshell> 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)) |
Now, modify the randRange method so that it can generate a stream of values of any type.
| 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()$.. ==> 663867150jshell> Rand.of(2030).map(x -> x / 2).next().> stream().limit(5).forEach(x -> System.out.println(x))663867150751888562796813740111216228707242905jshell> Rand.of(2030).next().flatMap(x -> Rand.of(x).map(y -> y / 2)).> stream().limit(5).forEach(x -> System.out.println(x))663867150751888562796813740111216228707242905jshell> Rand.of(2030).flatMap(x -> Rand.of(x).next().map(y -> y / 2)).> stream().limit(5).forEach(x -> System.out.println(x))663867150751888562796813740111216228707242905jshell> Rand.of(2030).flatMap(x -> Rand.of(x).map(y -> y / 2).next()).> stream().limit(5).forEach(x -> System.out.println(x))663867150751888562796813740111216228707242905jshell> Rand.of(2030).flatMap(x -> Rand.of(x).map(y -> y / 2)).next().> stream().limit(5).forEach(x -> System.out.println(x))663867150751888562796813740111216228707242905 |
The following are additional sample runs that illustrates the evaluation of a Rand object. 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!
Lets first look at how flatMap behaves in the context of individual elements.
Now to generate random lists of two elements each, we need to replace the map function within flatMap.
| jshell> Rand.of(2030).> flatMap(x -> Rand.of(x).map(y -> List.of(x,y))) instanceof Rand$.. ==> truejshell> 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] |
| 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] |
| 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] |
The above flatMap operations generates a list of two elements which are the same.
Lets include a next within the flatMap.
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.
| [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.
| jshell> Stream.iterate(10, x -> x * 10).> limit(6).> map(x -> Main.simulate(2030, x)).> forEach(x -> System.out.println(x))3.23.03.2243.17883.1513.1474 |
Reviews
There are no reviews yet.