programming question! Options

[pebkac]

Ok, so I'm taking Desrosiers (yeah, he sucks) for CS 1412 and I'm working on a programming assignment right now (in C#).

What I basically have to do is create a class that stores a fraction. One of the things it's supposed to do is take a floating point number and convert that to a fraction. What my class basically does is round the floating point number to 5 decimal places, then multiplies it by 100,000. It then uses the resulting integer as the numerator and 100,000 as the denominator and simplifies that.

That works fine for the most part, but what I would also like to be able to do is have it recognize .33333 as 1/3, .66667 as 2/3, 1.33333 as 4/3, etc.

I can take the modulus of the floating point number and see if the remainder is zero, but I think that way would be really prone to rounding errors.

I don't necessarily have to implement that (he said that the method can have limitations as long as we document them), but it would be nice if I could do that. Does anyone have any advice?

[impala454]

Finally got around to this in some bored time at work. Works pretty damn good so far. Feel free to break it and let me know what did it.

CODE

using System;
using System.Collections.Generic;
using System.Text;
//-------------------------
using System.Text.RegularExpressions;
using System.Collections;

namespace FractionConvert
{
    class Program
    {
        static void Main(string[] args)
        {
            Fraction f = new Fraction();
            double d = 0;
            Double.TryParse(args[0], out d);
            Fraction.TryParse(d, out f);
            Console.WriteLine(f.ToString());
        }
    }

    class Fraction
    {
        int m_nNumerator;
        int m_nDenominator;
        bool m_bNegative;
        double m_dDecimal;

        public Fraction()
        {
            m_nNumerator = 0;
            m_nDenominator = 0;
            m_dDecimal = 0;
            m_bNegative = false;
        }

        public Fraction(double DecimalToConvert)
        {
            m_nNumerator = 0;
            m_nDenominator = 0;
            m_dDecimal = DecimalToConvert;
            m_bNegative = false;

            ParseFraction();
        }

        public static bool TryParse(double DecimalInput, out Fraction FractionOutput)
        {
            try
            {
                FractionOutput = new Fraction(DecimalInput);
            }
            catch (Exception)
            {
                FractionOutput = new Fraction(0);
                return false;
            }

            return true;
        }

        public override string ToString()
        {
            if(m_bNegative)
                return string.Format("-{0}/{1}", m_nNumerator, m_nDenominator);
            else
                return string.Format("{0}/{1}", m_nNumerator, m_nDenominator);
        }

        private void ParseFraction()
        {
            if (m_dDecimal == 0)
            {
                m_nNumerator = 0;
                m_nDenominator = 1; // this could be any number really
                return;
            }

            string Whole = "";
            string Decimal = m_dDecimal.ToString();

            // strip off the minus sign if there is one
            if (Decimal[0] == '-')
            {
                m_bNegative = true;
                Decimal = Decimal.Substring(1, Decimal.Length - 1);
            }

            // split out the whole number, no need to parse that
            if (Decimal.Contains("."))
            {
                Whole = Decimal.Split('.')[0];
                Decimal = Decimal.Split('.')[1];
            }

            string Pattern = GetPattern(Decimal);

            int ParseInt = 0;
            int Divisor = 1;
            ArrayList Divisors = new ArrayList();

            if (!Int32.TryParse(Pattern, out ParseInt))
            {
                throw new Exception("Not a valid decimal number");
                return;
            }

            while (ParseInt > Divisor)
            {
                if (ParseInt % Divisor == 0)
                    Divisors.Insert(0, Divisor);

                Divisor++;
            }

            int WholeNumber = 0;
            Int32.TryParse(Whole, out WholeNumber);

            // if we only have one divisor, obviously it's 1
            if (Divisors.Count == 1)
            {
                m_nNumerator = 1;
                m_nDenominator = ParseInt;
                return;
            }

            foreach (int n in Divisors)
            {
                if (10 % n == 0)
                {
                    if(Pattern.Length <= 1)
                        m_nDenominator = 10 * n / ParseInt;
                    else
                        m_nDenominator = (Pattern.Length - 1) * (int)Math.Pow(10, (double)n+1) / ParseInt;

                    if (WholeNumber > 0)
                        m_nNumerator = m_nDenominator * WholeNumber + n;
                    else
                        m_nNumerator = n;
                    break;
                }
            }
        }

        private string GetPattern(string Decimal)
        {
            // the accuracy can't be any better than half the number of digits!
            //if (m_nAccuracy > Decimal.Length / 2)
            int Accuracy = Decimal.Length / 2;

            string Pattern = "";
            int NumRepeats = 0;
            int MeasuredAccuracy = 0;
            int MaxRepeats = 0;

            for (int i = 1; i <= Accuracy; i++)
            {
                NumRepeats = 0;

                Pattern = Decimal.Substring(0, i);
                for (int j = 0; j <= Decimal.Length - Accuracy; j += Pattern.Length)
                {
                    if (Decimal.Substring(j, Pattern.Length) == Pattern)
                        NumRepeats++;
                    else
                        break;
                }
                if (NumRepeats >= MaxRepeats)
                {
                    MaxRepeats = NumRepeats;
                    MeasuredAccuracy = Pattern.Length;
                }
            }

            // if we didn't find the pattern more than once, there is no pattern
            if (MaxRepeats <= 1)
                return Decimal;
            else
                return Decimal.Substring(0, MeasuredAccuracy);
        }
    }
}