C:/Documents and Settings/Stephen/Desktop/Biostatistics Library and Program/Biostatistics/Group.cs

Go to the documentation of this file.

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Windows.Forms;

[assembly: CLSCompliant(true)]
namespace StephenAshley.Biostatistics
{
   using NUMBER = Decimal;

   #region ***delegates***
   public delegate ColumnData GroupValidatorDelegateClass(TextBox[] textBoxesArray,
         Int32 columnIndex);
   #endregion

   #region *********enums**********
   public enum Status
   {
      OneElement,
      TwoElements,
      MoreThanTwoElements,
      Empty,
      FewerThanThree,
      OK,
      Undetermined
   }
   #endregion

   public class Group : IEnumerable
   {
      #region ******** fields ********
      protected List<NUMBER> dataList;
      private readonly Int32 iSize;
      private readonly bool isFixedSize;
      private readonly bool isReadOnly;
      private ColumnData columnData;
      protected Int16 iIdentificationNumber;
      #endregion
      #region ***** constructors *****

      public Group() : this(0) { }

      public Group(Int16 IDNumber)
      {
         iIdentificationNumber = IDNumber;
         isFixedSize =
         isReadOnly = false;
         dataList = new List<NUMBER>();
         columnData = new ColumnData(false, Status.Undetermined);
      }

      public Group(Int16 IDNumber, IList data)
         : this(IDNumber)
      {
         if (data == null)
            throw new BiostatisticsException(
   "groups parameter in contructor in Group is a null reference.");

         foreach (object obj in data)
            Add(obj);
      }

      public Group(Int16 IDNumber, IList data,
          bool fixedSize, bool readOnly)
         : this(IDNumber, data)
      {
         if (readOnly && !fixedSize)
            throw new BiostatisticsException(
   "Parameter fixedSize must be set to True if parameter readOnly is set to True.");

         isFixedSize = fixedSize;
         isReadOnly = readOnly;
         iSize = dataList.Count();
      }

      public Group(Group group)
         : this(group.Number())
      {
         if (group == null)
            throw new BiostatisticsException(
   "group parameter in Group constructor is a null reference.");

         foreach (NUMBER value in group)
         {
            dataList.Add(value);
         }
      }

      public Group(Group group,
          bool fixedSize, bool readOnly)
         : this(group)
      {
         isFixedSize = fixedSize;
         isReadOnly = readOnly;
      }

      public Group(Int16 IDNumber, TextBox[] textBoxesArray,
         GroupValidatorDelegateClass groupValidator, Int32 index)
         : this(IDNumber)
      {
         if (textBoxesArray == null)
            throw new BiostatisticsException(
               "textBoxesArray in Group constructor is null.");
         if (groupValidator == null)
            throw new BiostatisticsException(
               "groupValidator parameter in Group constructor is null.");

         columnData = groupValidator(textBoxesArray, index);
         if (columnData.IsValid())
         {
            foreach (TextBox textbox in textBoxesArray)
            {
               NUMBER decTemp;
               try
               {
                  decTemp = Convert.ToDecimal(textbox.Text); 
               }
               catch (Exception)
               {
                  throw new BiostatisticsException("textbox.Text is not a Decimal.");
               }
               dataList.Add(decTemp);
            }
         }
      }
      #endregion
      #region ******* methods ********
      public void Add(Object item)
      {
         if (isReadOnly)
            throw new BiostatisticsException(
               "Addition of item to a read-only Group.");

         if (isFixedSize && n() >= iSize)
            throw new BiostatisticsException(
               "Addition of item to a full fixed-size Group.");
         Type type = item.GetType();
         try
         {
            if (type == typeof(NUMBER))
               dataList.Add((NUMBER)item);
            else if (type == typeof(double))
               dataList.Add(new NUMBER((double)item));
            else if (type == typeof(float))
               dataList.Add(new NUMBER((float)item));
            else if (type == typeof(int))
               dataList.Add(new NUMBER((int)item));
            else if (type == typeof(int[]))
               dataList.Add(new NUMBER((int[])item));
            else if (type == typeof(long))
               dataList.Add(new NUMBER((long)item));
            else if (type == typeof(uint))
               dataList.Add(new NUMBER((uint)item));
            else if (type == typeof(ulong))
               dataList.Add(new NUMBER((ulong)item));
            else if (type == typeof(byte))
               dataList.Add(new NUMBER((byte)item));
            else if (type == typeof(sbyte))
               dataList.Add(new NUMBER((sbyte)item));
            else
            {
               throw new BiostatisticsException(
                  "Item to be added to Group cannot be converted to a Decimal.");
            }
         }
         catch
         {
            throw new BiostatisticsException(
               "Item to be added to Group cannot be converted to a Decimal.");
         }
      }

      public void AddRange(IList data)
      {
         if (isReadOnly)
            throw new BiostatisticsException(
               "Addition of items to a read-only Group.");
         if (isFixedSize && data.Count + n() >= iSize)
            throw new BiostatisticsException(
               "Addition of items would exceed the size of a fixed-size Group.");

         List<NUMBER> lstItems = new List<NUMBER>();
         foreach (Object item in data)
         {
            Type type = item.GetType();
            try
            {
               if (type == typeof(NUMBER))
                  lstItems.Add((NUMBER)item);
               else if (type == typeof(double))
                  lstItems.Add(new NUMBER((double)item));
               else if (type == typeof(float))
                  lstItems.Add(new NUMBER((float)item));
               else if (type == typeof(int))
                  lstItems.Add(new NUMBER((int)item));
               else if (type == typeof(int[]))
                  lstItems.Add(new NUMBER((int[])item));
               else if (type == typeof(long))
                  lstItems.Add(new NUMBER((long)item));
               else if (type == typeof(uint))
                  lstItems.Add(new NUMBER((uint)item));
               else if (type == typeof(ulong))
                  lstItems.Add(new NUMBER((ulong)item));
               else if (type == typeof(byte))
                  lstItems.Add(new NUMBER((byte)item));
               else if (type == typeof(sbyte))
                  lstItems.Add(new NUMBER((sbyte)item));
               else
               {
                  throw new BiostatisticsException(
"Parameter sourceCollection contains an element that cannot be converted to a Decimal.");
               }
            }
            catch
            {
               throw new BiostatisticsException(
"Parameter sourceCollection contains an element that cannot be converted to a Decimal.");
            }
         }
         dataList.AddRange(lstItems);
      }

      public Group AsFixedSize()
      {
         return new Group(this, true, false);
      }

      public Group AsReadOnly()
      {
         return new Group(this, true, true);
      }

      public void Clear()
      {
         dataList.Clear();
      }

      public bool Contains(object value)
      {
         if (!IsNumericType(value))
            throw new BiostatisticsException(
               "value parameter in Contains method of Group is not a numeric type.");
         return dataList.Contains((NUMBER)value);
      }

      public void CopyTo(NUMBER[] DecimalArray)
      {
         try
         {
            dataList.CopyTo(DecimalArray);
         }
         catch (Exception e)
         {
            throw new BiostatisticsException(e.Source + ": " + e.Message, e);
         }
      }

      public void CopyTo(NUMBER[] DecimalArray, int index)
      {
         try
         {
         dataList.CopyTo(DecimalArray, index);
         }
         catch (Exception e)
         {
            throw new BiostatisticsException(e.Source + ": " + e.Message, e);
         }
      }

      public void CopyTo(Int32 groupIndex, NUMBER[] DecimalArray, int arrayIndex, Int32 count)
      {
         try
         {
         dataList.CopyTo(groupIndex, DecimalArray, arrayIndex, count);
         }
         catch (Exception e)
         {
            throw new BiostatisticsException(e.Source + ": " + e.Message, e);
         }
      }

      IEnumerator IEnumerable.GetEnumerator()
      {
         return dataList.GetEnumerator();
      }

      public int IndexOf(NUMBER value)
      {
         return dataList.IndexOf(value);
      }

      public Int32 IndexOf(NUMBER value, Int32 index)
      {
         return dataList.IndexOf(value, index);
      }

      public Int32 IndexOf(NUMBER value, Int32 index, Int32 count)
      {
         return dataList.IndexOf(value, index, count);
      }

      public void Insert(int index, NUMBER value)
      {
         try
         {
            dataList.Insert(index, value);
         }
         catch (Exception e)
         {
            throw new BiostatisticsException(e.Source + ": " + e.Message, e);
         }
      }

      public bool Remove(NUMBER value)
      {
         return dataList.Remove(value);
      }

      public void RemoveAt(int index)
      {
         dataList.RemoveAt(index);
      }

      public NUMBER[] ToArray()
      {
         return dataList.ToArray();
      }

      private static bool IsNumericType(object item)
      {
         Type type = item.GetType();
         if (type == typeof(Decimal) ||
             type == typeof(Double) ||
             type == typeof(Single) ||
             type == typeof(Int16) ||
             type == typeof(Int32) ||
             type == typeof(Int64) ||
             type == typeof(UInt16) ||
             type == typeof(UInt32) ||
             type == typeof(UInt64) ||
             type == typeof(Byte) ||
             type == typeof(SByte))
            return true;
         else return false;
      }

      public NUMBER Average()
      { return Mean(); }

      public Status GroupStatus()
      {
         return columnData.ColumnState();
      }

      public Int16 IdentificationNumber()
      { return iIdentificationNumber; }

      public void SetIndentificationNumber(Int16 value)
      {
         iIdentificationNumber = value;
      }

      public bool IsFixedSize()
      {
         return isFixedSize;
      }

      public bool IsNull()
      {
         if (dataList == null)
            return true;
         else
            return false;
      }

      public bool IsReadOnly()
      {
         return isReadOnly;
      }

      public bool IsValid()
      {
         return columnData.IsValid();
      }

      public void SetIsValid(bool value)
      { columnData.SetIsValid(value); }

      public NUMBER Maximum()
      {
         if (dataList.Count == 0)
            throw new BiostatisticsException(
               "Group contains no elements.");
         NUMBER decMinimum = dataList[0];
         for (Int32 i = 1; i < n(); i++)
            if (dataList[i] > decMinimum)
               decMinimum = dataList[i];
         return decMinimum;
      }

      public NUMBER Minimum()
      {
         if (dataList.Count == 0)
            throw new BiostatisticsException(
               "Group contains no elements.");

         NUMBER decMinimum = dataList[0];
         for (Int32 i = 1; i < n(); i++)
            if (dataList[i] < decMinimum)
               decMinimum = dataList[i];
         return decMinimum;
      }

      public NUMBER Mean()
      {
         if (dataList.Count == 0)
            throw new BiostatisticsException(
               "Group contains no elements.");
         return Sum() / n(); }

      public NUMBER Median()
      {
         if (dataList.Count == 0)
            throw new BiostatisticsException(
               "Group contains no elements.");
         List<NUMBER> lstElements = new List<NUMBER>(dataList);
         lstElements.Sort();
         if (DecMath.IsOdd(n()))
         {
            return lstElements[n() / 2];
         }
         else
            return (lstElements[n() / 2] + lstElements[(n() / 2) - 1]) / 2m;
      }

      public Int32 n()
      { return dataList.Count(); }

      public Int16 Number()
      { return iIdentificationNumber; }

      public NUMBER PopulationStandardDeviation()
      {
         if (dataList.Count == 0)
            throw new BiostatisticsException(
               "Group contains no elements.");
         return DecMath.Sqrt(PopulationVariance()); }

      public NUMBER PopulationVariance()
      {
         if (dataList.Count == 0)
            throw new BiostatisticsException(
               "Group contains no elements.");
         Group grpSumOfSquares = new Group(0);
         foreach (NUMBER value in dataList)
         {
            grpSumOfSquares.Add(value * value);
         }
         return (grpSumOfSquares.Sum() - n() * Mean() * Mean()) / n();
      }

      public NUMBER SampleStandardDeviation()
      {
         if (n() < 2)
            throw new BiostatisticsException(
               "Group contains fewer than 2 elements.");
         return DecMath.Sqrt(SampleVariance()); }

      public NUMBER SampleVariance()
      {
         if (dataList.Count == 0)
            throw new BiostatisticsException(
               "Group contains fewer than 2 elements.");
         return (SumOfSquares() - n() * Mean() * Mean()) /
             (n() - 1);
      }

      public NUMBER StandardErrorOfMean()
      {
         if (n() < 1)
            throw new BiostatisticsException(
               "Group contains no elements.");
         return SampleStandardDeviation() / DecMath.Sqrt(n()); }

      public NUMBER Sum()
      {
         if (n() == 0)
            return 0m;
         NUMBER decSum = dataList[0];
         NUMBER decCorrection = 0m;
         NUMBER decCorrectedNextTerm,
                 decNewSum;

         for (Int32 i = 1; i < n(); i++)
         {
            decCorrectedNextTerm = dataList[i] - decCorrection;
            decNewSum = decSum + decCorrectedNextTerm;
            decCorrection = decNewSum - decSum;
            decCorrection = decCorrection - decCorrectedNextTerm;
            decSum = decNewSum;
         }
         return decSum;
      }

      public NUMBER SumOfSquaredDeviates()
      {
         if (dataList.Count == 0)
            throw new BiostatisticsException(
               "Group contains no elements.");
         NUMBER decTemp = Sum();
         return SumOfSquares() - (decTemp * decTemp / n());
      }


      public NUMBER SumOfSquares()
      {
         NUMBER decResult = 0m;
         foreach (NUMBER value in dataList)
            decResult += value * value;
         return decResult;
      }

      public NUMBER this[int index]
      {
         get { return dataList[index]; }
         set
         {
            if (!isReadOnly)
               dataList[index] = value;
         }
      }
      #endregion

   }

   public class ColumnData
   {
      private bool isValid;
      private Status columnState;
      public ColumnData()
      {
         columnState = Status.Undetermined;
      }

      public ColumnData(bool bValue)
         : this()
      {
         isValid = bValue;
      }

      public ColumnData(Status column)
         : this()
      {
         columnState = column;
      }

      public ColumnData(bool bValue, Status column)
      {
         isValid = bValue;
         columnState = column;
      }

      public bool IsValid()
      { return isValid; }

      public void SetIsValid(bool value)
      {
         isValid = value;
      }
      public Status ColumnState()
      {
         return columnState;
      }

      public void SetColumnState(Status column)
      {
         columnState = column;
      }
   }
}

---