In FHsort.java use the static mutator FHsort.setRecursionLimit$($int$)$ which you will use to change this limit to any int value in the range of $2$ to $300.$ In this project, the goal is to find the optimal recursion limit arrays of various sizes.

What's different about this project?notation.png

Unlike previous projects, this project is computationally expensive, so make sure to give your machine enough time to run all the test cases.

Client Requirements

Write a test file that investigates the recursion limit of arrays of various sizes. Your test file must be in a separate class than FHsort class, which means a new $.$java file.

Note: Provide a descriptive name for your test file. Examples of badly named test files are Main.java, TestFHsort.java, and Sort.java. The latter two are misleading.

Your test must show the following:

Investigate all recursion limits from $2$ to $300$ in steps of $2.$ For example: $2,4,6,8...$

Run them on different size arrays from $20,000$ up to the largest you can get in your computer $($you should be able to get close to $10$ million or more$)$ with at least $20$ intervals.

NOTE: Make sure that for each array size you use the same randomly generated numbers to test the different recursion limits$.$

Run each test case at least $3$ times. That way you can filter out non$-$significant differences in run time.

Provide a table that summarizes the results.

Share a table of your results in either HTML or Excel$*$ format. If you are not able to access either, then your table should be a well formatted plain$-$text file, such as Comma Separated Value $($CSV$)$Links to an external site. file. Your file should only be in one of these three formats $($for example, do not submit a Microsoft document$).$

Augment your results with a diagram that visualizes the trends you found as you changed the recursion limit and array size. Include the following:

An automatically generated graphical representation of your table $($i$.$e$.$ the raw data$).$

Why "automatic"? Hand$-$drawn representations are inaccurate, especially at the scales we are dealing with. To avoid use a data visualization application or library$*$;

A line graphLinks to an external site. of the impact of recursion limit $($x$-$axis$)$ on different array sizes in terms of runtime $($y$-$axis$).$ Include axis labels and a legend for your graph.

A graph of the different line$-$plots over$-$laid. This means that at least one of your graph diagrams must have all the array sizes overlaid.

NOTE: Don't forget to annotate this graph with any interesting patterns you discover!

A second graph where you filtered and zoomed$*$ to a particular range of interest for recursion$-$limit vs array size.

NOTE: Once you identify an interesting pattern for potential range of recursion limit where the optimal may lie, create a second graph that displays only the data for that range. To decrease the clutter in your graph, try filtering out the plot that seem to have similar patterns.

How do I zoom in$?$notation.png

This step requires a re$-$plot using a subset of your results. If your data is in a table format, this means that you select a subset of the columns and rows for your second plot. Zooming does not mean that you magnify the first graph via a pixel editing application such as paint.

Annotations on your graph$($s$)$ with your findings $($such as optimal recursion limit$).$ This means manually circling and adding comments that describe the range of interest you describe in your observations.

A snapshot of your two $($or more$)$ plots visualizing the table.

Include the graph along with the rest of your implementation under the resources folder in your assigned repository.

Comment on the results. For example, describe:

the range that seems to be minimal $($and flat$)$;

observations whether there are fluctuations in the runtime.

As usual, your results and comments must be outside your test file in the same resources folder.