Centre of the Universe

Creating an application to draw graphs of mathematical equations has two components to it, namely, parsing the equation and drawing the results.

Parsing an equation is quite a complicated endeavor. However, I found on the internet a very useful C# library that parses equations very well called dotMath by Steve Hebert. You can visit the website for the library at . Rather than write my own library, I used this library to do all the parsing for me.

The fun part – for me anyway – is trying to draw the graph of an expression. I created a Windows Forms control that contains a picture box that fills the entire control. This picture box will contain the graph that we draw.

The actual generation of the image we are going to draw happens using a Bitmap object.

We set up the pens and brushes we need for the axis, graph, grid and background using the configuration settings that the class contains.

If the flag to draw the axes is set, we first draw the x and y axes, and then label it, using the scale we specify. The offset allows us to move the graph so that the centre of the screen does not need to be the position (0,0), which is the default. The LabelIncrement determines how many pixels apart the labels need to be.

If we set the draw grid flag to true, we also draw a grid, which will make it easier to see what value the graph shows.

Drawing the axes and grid works by taking the centre point and working out along each axis to the end of the screen.

Now that we have set everything up, we can draw the graph.

Here is where we use the dotMath class to parse our equation we want to draw.

So given an example equation of something like “x*x + 3 * X + 23″ or “sin(x)”, we iterate through each pixel, and get the value of x at that pixel based on the scale and offset.

We then replace the character “x” in the equation with our value for x, and pass the string to the equation parser, which then calculates the y value.

From this we can, again using the scale and offset, determine the y value of the coordinate we need.

To actually draw the point, we draw a line from the previous pixel to the current pixel which we have calculated.
continue reading…

The greatest common divisor of two numbers is the largest number that divides evenly into both numbers.

The method of calculating this is is to use a little bit of recursion.

If the numbers are even, then work out the GCD by dividing both numbers by 2 and passing as parameters to the GCD function recursively, multiplying the result by 2.

If only one number is even, then pass that number divided by 2, and the whole second number to the GCD function to get the GCD.

If both numbers are odd, then call the GCS function with the average of the two numbers and the second number as the parameters.

If the numbers are equal then return that number, and if either number is equal to then return 1.

By the time execution reached the top again after the recursion, you should have the greatest common divisor as your resulting number.

        public static int GCD(int A, int B)
        {
            if (A == B)
            {
                return A;
            }
            if ((A == 1) || (B == 1))
            {
                return 1;
            }
            if ((A % 2 == 0) && (B % 2 == 0))
            {
                return 2 * GCD(A / 2, B / 2);
            }
            else if ((A % 2 == 0) && (B % 2 != 0))
            {
                return GCD(A / 2, B);
            }
            else if ((A % 2 != 0) && (B % 2 == 0))
            {
                return GCD(A, B / 2);
            }
            else
            {
                return GCD(Math.Abs(A - B) / 2, B);
            }

        }

A prime number is any number that can only be evenly divided by itself and 1. So for example 2, 3 and 5 are prime, but 6 and 9 are not.

Now, to find all the prime numbers that are factors in a number, we need to first fcheck if the number is even. If it is , then 2 is a factor, and then we keep dividing until the number is odd.

Then, starting at 3, and counting up in 2’s, we try and find a number which divides into the number, each time dividing by the divisor if a match is found.

 using System.Collections;

       public static int[] PrimeFactors(int num)
        {
            ArrayList factors = new ArrayList();

            bool alreadyCounted = false;
            while (num % 2 == 0)
            {
                if (alreadyCounted == false)
                {
                    factors.Add(2);
                    alreadyCounted = true;
                }
                num = num / 2;
            }

            int divisor = 3;
            alreadyCounted = false;
            while (divisor <= num)
            {
                if (num % divisor == 0)
                {
                    if (alreadyCounted == false)
                    {
                        factors.Add(divisor);
                        alreadyCounted = true;
                    }
                    num = num / divisor;
                }
                else
                {
                    alreadyCounted = false;
                    divisor += 2;
                }
            }

            int[] returnFactors = (int[])factors.ToArray(typeof(int));

            return returnFactors;
        }

Factorials are defined as a number that is multiplied by every positive number below it, and is denoted by an exclamation mark, ie n! = n * (n – 1) * (n – 2) … 2 * 1.

This is a very easy function to write.

        public static long Factorial(int num)
        {
            long fact = 1;
            for (int i = 2; i <= num; i++)
            {
                fact = fact * i;
            }
            return fact;
        }

Combinations in Combinatorics (a branch of mathematics covering combinations and permutations) gives you the number of combinations that exist for a given sample. With combinations, items selected cannot be repeated, much like selecting names out of a hat, and then after taking one out, you do not put it back in again, and then select again until you have required amount.

So, given a set of values of size n, if you select r items from the set, the number of different combinations which you can select is given by the formula
C = n! / r!(n - r)!

        public static int Combination(int n, int r)
        {
            int Comb = 0;
            Comb = (int)(MathExt.Factorial(n) / (MathExt.Factorial(r) * MathExt.Factorial(n - r)));
            return Comb;
        }

        public static int Permutation(int n, int r)
        {
            int Perm = 0;
            Perm = (int)(MathExt.Factorial(n) / MathExt.Factorial(n - r));
            return Perm;
        }