# Numerical Methods Helper

The full source code for my numerical methods helper is now available on the GitHub repository.

Numerical Methods Helper is a learning tool for numerical algorithms in AS and A2 Mathematics modules. The program supports methods of numerical integration, root finding through iteration, local extrema, and tangents and normal lines to functions.

The progress of each algorithm is drawn onto a freely movable and interactive graph to allow students the most engaging learning experience. All parameters for each algorithm are completely customisable, and the results and graphs will be re drawn to accommodate the new values.

Not only does Numerical Methods Helper give a final result to an algorithm, but it also gives the calculations needed for students to get the final answer for themselves. For example, all integration algorithms are accompanied with list of ordinates used in the algorithm, along with a final formula that can be typed into any calculator to yield the final same final result.

Functions for use in any of the algorithms can be freely customised and changed using a number of built operators including trigonometry and logarithms. Not only can the program be used for the tuition of numerical methods, but the graphs can also be utilised for other topics such as transformations of graphs.

### Main Features -

• Freely scrollable and zoomable graphing view
• Worked examples of all numerical algorithms and AS and A2 Maths including -
• The Trapezium rule
• The Mid - Ordinate Rule
• Simpsons Rule
• Root Finding by iteration
• Teaching aids for other topics such as local extrema and tangents and normal lines to functions
• Every parameter for each algorithm is fully customisable to meet a wide range of questions
• Functions for use in any algorithm can be changed using a wide range of built in operators
• Graphing views can be copied to the clipboard to paste into other applications for annotation and printing
• Main parameters for algorithms can be modified by dragging points on the graph itself. This allows for a more interactive and visual approach to the progress and inaccuracies of the algorithm
• Numerical data used in the calculations of the results of the algorithm is also provided to allow students themselves to reach a solution

This screenshot shows the integration tab of the program. The user is able to enter a custom function along with the upper and lower bounds of the integration, the numerical algorithm to use and the number of iterations. The results are then shown to the user, with a formula of the chosen algorithm and the ordinates used. Te application of the algorithm to the equation is also shown graphically on an interactive plotting view.

# Maximum Sum Area

As a follow up to my previous post where we found the maximum sum subsequence of a one dimensional array, in this post the idea will be extended to cover 2d arrays or grids of numbers.

Instead of finding the subsequence of the array that contains the maximum sum, now the region of the array with the maximum sum will be found. For example in the image below, the region of the array with the largest sum is found to be enclosed by the points `(1,1)` and `(3,2)`.

Here is the algorithm. Note that this is massively inefficient with an order of `O(n^6)` - meaning that if we double the input size, the time taken calculate the result will increase by a factor of `64 (2^6)`.

Here is also a small tester method displaying how the method can be used with the same 2d as shown in the example above -

Which generates the output -

# Domain Change

So I’ve finally managed to change my domain name to ryanharrison.co.uk. It was the original one I wanted, but was unavailable when I created the site so I had to pick an alternative. But recently when I came to renew my alternative domain name, I checked the availability and I quickly snatched it up. Not before however I had already renewed my old domain name for another three years which was a bit of a waste in hindsight.

My hosting company made the change of domain names really quickly and easy. It was literally just a case of changing the domain name in a textfield and hitting ‘confirm’. The migration of this WordPress site to the new domain was a little more work but still was pretty easy. It just involved modifying a couple of the WordPress PHP configuration files along with the database itself to update the home URL.

Currently my hosting plan only includes support for one domain name, so raharrison.co.uk will probably go unused unless I upgrade my plain when I next renew. I could then forward the old domain to this new one, but we’ll see how large the price jump is.

In the meantime I also need to update a load of links in my previous posts which might take a while. So some links might be broken at the moment until I fix them.

# Maximum Sum Subsequence

The maximum sum subsequence of an array is the consecutive group of numbers that have the largest sum.

For example with the array `{1, 11, -9, -20, 7, 10, -6, 3, 4, -2}`, the maximum sum subsequence is 18 using the elements `{7, 10, -6, 3, 4}` starting from index `4` and ending at index `8`.

Here are a few algorithms implemented in Java of increasing efficiency that can be used to solve this problem.

1. Brute Force -; take each element as a starting point and each element after as an ending point, sum the elements in between and keep track of the largest sum.

Efficiency (Order of Growth) = O(n^3)

Although this works well, it scales extremely badly with the algorithm taking nearly half a second with only 2000 elements. As the size of the input doubles, the time taken will increase by a factor of 8 - not good.

2. Remember the current sum. Instead of computing the sum of elements i to j on each iteration of the innermost loop, we can instead remember the current sum of the elements. This increases the efficiency by a factor of O(n).

Efficiency (Order of Growth) = O(n^2)

This optimisation, although small saves a lot of execution time. Now as the size of the input array doubles, the time taken will increase by a factor of 4. However we can still improve this and gain a linear relationship between size and execution time.

3. Single loop -; now we only traverse the array once. We keep track of the maximal sum subsequence so far and the maximal sum subsequence ending at the current position.

Efficiency (Order of Growth) = O(n)

Now we have the best case scenario for this problem. We cannot get any better as in the worst case scenario each element of the array has to be looked at at least once. With the now linear order of growth as the size of the input doubles, the time taken also doubles.

# Installed Visual Studio 2012

Today I decided to take the step and upgrade from Visual Studio 2012 Professional to Visual Studio 2012 Premium so that I could take advantage of some of the language updates in .Net 4.5 and also be able to produce applications for the Windows Store. It also seemed like a good move as I can now get the software for free with the MSDNAA (Dreamspark Premium) account from my university.

I would have done it sooner but I knew it would probably be a long and laborious process trying to uninstall every element of my previous Visual Studio 2010 to then install the newer versions for 2012. I was not wrong. I really wish Microsoft would provide a good uninstaller for Visual Studio. At the moment the main uninstaller gets rid of just the main application, not any of the other stuff that it installs with it. You therefore have to manually go through your control panel trying to find things that may have been installed from VS 2010 - which takes a long time considering that Windows uninstallers are not the quickest of things at the best of times.

When I was finally able to get rid of just about everything, the installation process for Visual Studio 2012 went through without a hitch (the same for which could not be said for 2010). The installer itself was also very nicely designed and seemed to me at least faster than for VS 2010.

Here are a few screenshots -

I really like the look and feel of the new styled interface so far. However I may have to try and figure out a way of reverting back to the old non-capitalised versions of the menu items.