Big O Algorithm Analyzer for .NET

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

using WPFBigOAnalyzer;
namespace WPFBigOAnalyzer.BigOFunction
{
    class Functions
    {
        #region Linear Functions

        //O(1)
        static double n1(int n)
        {
            Random r = new Random(n);

            return r.Next(Convert.ToInt32(WPFBigOAnalyzer.AnalysisFactory.Min),Convert.ToInt32(WPFBigOAnalyzer.AnalysisFactory.Max));
        }

        public static DecoratedMarker n1Line(int n)
        {
            double[] ret = new double[n];

            for (int y = 0; y < n; y++)
            {
                if (y == 0)
                    ret[y] = Functions.n1(y);
                else
                    ret[y] = Functions.n1(y) + ret[y - 1];
            }

            return new DecoratedMarker(ret,"O(1)",null);
        }

        //O(n)
        static double n(int n)
        {
            return n*2;
        }

        public static DecoratedMarker nLine(int n)
        {
            double[] ret = new double[n];

            for (int y = 0; y < n; y++)
                ret[y] = Functions.n(y);

            return new DecoratedMarker(ret, "O(n)", null);
        }

        #endregion

        #region Log Functions

        //O(n log n)
        static double nLogn(int n)
        {
            double r = Math.Log(n) * n;

            if (r.ToString() == "NaN" || r.ToString().IndexOf("Infinity") != -1)
                return 0;
            else
                return r;
        }

        public static DecoratedMarker nLognLine(int n)
        {
            double[] ret = new double[n];

            for (int y = 0; y < n; y++)
                ret[y] = Functions.nLogn(y);

            return new DecoratedMarker(ret, "O(n log n)", null);
        }
        //O(log n)
        static double logn(int n)
        {
            double r = Math.Log(n);

            if (r.ToString() == "NaN" || r.ToString().IndexOf("Infinity") != -1)
                return 0;
            else
                return r;
        }
        public static DecoratedMarker lognLine(int n)
        {
            double[] ret = new double[n];

            for (int y = 0; y < n; y++)
                ret[y] = Functions.logn(y);

            return new DecoratedMarker(ret, "O(log n)", null);
        }

        //O(log log n)
        static double loglogn(int n)
        {
            double r = Math.Log(Math.Log(n));

            if (r.ToString() == "NaN" || r.ToString().IndexOf("Infinity") != -1)
                return 0;
            else
                return r;
        }
        public static DecoratedMarker loglognLine(int n)
        {
            double[] ret = new double[n];

            for (int y = 0; y < n; y++)
                ret[y] = Functions.loglogn(y);

            return new DecoratedMarker(ret, "O(log log n)", null);
        }        
        #endregion

        #region Exponential Functions

        //O(n^2)
        static double nPow2(int n)
        {
            double r = Math.Pow(n, 2);

            if (r.ToString() == "NaN" || r.ToString().IndexOf("Infinity") != -1)
                return 0;
            else
                return r;
        }
        public static DecoratedMarker nPow2Line(int n)
        {
            double[] ret = new double[n];

            for (int y = 0; y < n; y++)
                ret[y] = Functions.nPow2(y);

            return new DecoratedMarker(ret, "O(n^2)", null);
        }

        //O(n^3)
        static double nPow3(int n)
        {
            double r = Math.Pow(n, 3);

            if (r.ToString() == "NaN" || r.ToString().IndexOf("Infinity") != -1)
                return 0;
            else
                return r;
        }
        public static DecoratedMarker nPow3Line(int n)
        {
            double[] ret = new double[n];

            for (int y = 0; y < n; y++)
                ret[y] = Functions.nPow3(y);

            return new DecoratedMarker(ret, "O(n^3)", null);
        }
        //O(n^n)
        static double nPown(int n)
        {
            double r = Math.Pow(n, n);

            if (r.ToString() == "NaN" || r.ToString().IndexOf("Infinity") != -1)
                return 0;
            else
                return r;
        }
        public static DecoratedMarker nPownLine(int n)
        {
            double[] ret = new double[n];

            for (int y = 0; y < n; y++)
                ret[y] = Functions.nPown(y);

            return new DecoratedMarker(ret, "O(n^n)", null);
        }
        #endregion

        #region Factorial 
        static double nFractorial(int n)
        {
            double r = Meta.Numerics.Functions.AdvancedIntegerMath.Factorial(n);

            if (r.ToString() == "NaN" || r.ToString().IndexOf("Infinity") != -1)
                return 0;
            else
                return r;
        }
        public static DecoratedMarker nFractorialLine(int n)
        {
            double[] ret = new double[n];

            for (int y = 0; y < n; y++)
                ret[y] = Functions.nFractorial(y);

            return new DecoratedMarker(ret, "O(n!)", null);
        }
        #endregion

        //Not Implimented yet...
        //O(α(n))
        //O((log n)^c)
        //O(n^c)
        //O(n^c)
    }
}