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

Go to the documentation of this file.

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

namespace StephenAshley.Biostatistics
{
   using NUMBER = Decimal;

   public class MannWhitneyGroupsCollection : GroupsCollection
   {
      #region *** fields ***
      private Int32 iN, iN1, iN2;

      private NUMBER decR1, decR2, decU;

      Decimal? decSDt, decT, decZt, decZtUncorrected, decPt, decPtUncorrected;

      private Boolean bInitialized;

      private string sPt, sPtUncorrected;
      #endregion

      public MannWhitneyGroupsCollection()
         : base()
      {
         bInitialized = false;
      }

      // <summary>
      // Constructs a <see cref="MannWhitneyGroupsCollection"/> with a 
      // given capacity.
      // </summary>
      // <param name="capacity">The capacity.</param>
      //public MannWhitneyGroupsCollection(Int32 capacity)
      //   : base(capacity)
      //{
      //   bInitialized = false;
      //}

      public MannWhitneyGroupsCollection(List<Group> lstGroups)
         : base(lstGroups)
      {
         if (lstGroups.Count == 2)
         {
            Initialize();
            bInitialized = true;
         }
         else
            bInitialized = false;
      }

      #region ***** methods ******
      public override void Add(Group group)
      {
         if (group == null)
         {
            throw new BiostatisticsException(
"Addition of null Group to MannWhitneyGroupsCollection.");
         }

         if (groupsArray == null || (groupsArray.Length < 2))
            base.Add(group);
         else
            throw new BiostatisticsException(
   "Addition of Group would result in MannWhitneyGroupsCollection with more than 2 Groups.");
         if (k() == 2)
            Initialize();
      }

      public override void AddRange(List<Group> lstGroups)
      {
         if (lstGroups == null)
         {
            throw new BiostatisticsException(
               "lstGroups is a null reference.");
         }

         if (groupsArray == null || (groupsArray.Length + lstGroups.Count <= 2))
            base.AddRange(lstGroups);
         else
            throw new BiostatisticsException(
"Addition of a Group would result in a MannWhitneyGroupsCollection with more than 2 Groups.");
         if (groupsArray.Length == 2)
            Initialize();
      }

      public Int32 N()
      {
         if (!bInitialized)
            throw new BiostatisticsException(
"The MannWhitneyGroupsCollection must contain 2 Groups before N can be calculated.");
         return groupsArray[0].n() + groupsArray[1].n();
      }

      public Int32 N1()
      {
         if (!bInitialized)
            throw new BiostatisticsException(
"The MannWhitneyGroupsCollection must contain 2 Groups before N1 can be calculated.");
         return iN1;
      }

      public Int32 N2()
      {
         if (!bInitialized)
            throw new BiostatisticsException(
"The MannWhitneyGroupsCollection must contain 2 Groups before N2 can be calculated.");
         return iN2;
      }

      public NUMBER R1()
      {
         if (!bInitialized)
            throw new BiostatisticsException(
"The MannWhitneyGroupsCollection must contain 2 Groups before R1 can be calculated.");
         return decR1;
      }

      public NUMBER R2()
      {
            if (!bInitialized)
               throw new BiostatisticsException(
   "The MannWhitneyGroupsCollection must contain 2 Groups before R2 can be calculated.");
            return decR2;
      }

      public NUMBER? t()
      {
         if (!bInitialized)
               throw new BiostatisticsException(
   "The MannWhitneyGroupsCollection must contain 2 Groups before T can be calculated.");
            return decT;
      }

      public NUMBER U()
      {
         if (!bInitialized)
               throw new BiostatisticsException(
   "The MannWhitneyGroupsCollection must contain 2 Groups before U can be calculated.");
            return decU;
      }

      public NUMBER? Zt()
      {
         if (!bInitialized)
               throw new BiostatisticsException(
   "The MannWhitneyGroupsCollection must contain 2 Groups before Zt can be calculated.");
            return decZt;
      }

      public NUMBER? ZtUncorrected()
      {
         if (!bInitialized)
               throw new BiostatisticsException(
   "The MannWhitneyGroupsCollection must contain 2 Groups before Zt can be calculated.");
            return decZtUncorrected;
      }

      public NUMBER? pT()
      {
         if (!bInitialized)
               throw new BiostatisticsException(
   "The MannWhitneyGroupsCollection must contain 2 Groups before Pt can be calculated.");
            return decPt;
      }

      public NUMBER? pTUncorrected()
      {
         if (!bInitialized)
               throw new BiostatisticsException(
   "The MannWhitneyGroupsCollection must contain 2 Groups before PtUncorrected can be calculated.");
            return decPtUncorrected;
      }

      public string StringPt()
      {
         if (!bInitialized)
               throw new BiostatisticsException(
   "The MannWhitneyGroupsCollection must contain 2 Groups before StringPt can be calculated.");
            return sPt;
      }

      public NUMBER? StandardDeviationT()
      {
         if (!bInitialized)
               throw new BiostatisticsException(
"The MannWhitneyGroupsCollection must contain 2 Groups before StandardDeviationT can be calculated.");
            return decSDt;
      }

      public NUMBER UPrime()
      {
         if (!bInitialized)
               throw new BiostatisticsException(
   "The MannWhitneyGroupsCollection must contain 2 Groups before UPrime can be calculated.");
            return groupsArray[0].n() * groupsArray[1].n() - U();
      }

      #endregion

      private void Initialize()
      {
         if (groupsArray == null || groupsArray[0] == null || groupsArray[0].n()
            == 0 || groupsArray[1] == null || groupsArray[1].n() == 0)
            throw new BiostatisticsException(
"groupsArray in MannWhitneyGroupsCollection does not contain 2 Groups with a positive number of members.");
         iN1 = groupsArray[0].n();
         iN2 = groupsArray[1].n();

         Int32 iNTemp;
         // Combine the two Groups in a single list.
         List<Rank> lstRanks = new List<Rank>(iNTemp = groupsArray[0].n() + 
            groupsArray[1].n());
         for (Int32 i = 0; i < groupsArray[0].n(); i++)
            lstRanks.Add(new Rank(0, groupsArray[0][i], 0));
         for (Int32 i = 0; i < groupsArray[1].n(); i++)
            lstRanks.Add(new Rank(1, groupsArray[1][i], 0));

         // Sort the combined list.
         lstRanks.Sort(Rank.CompareRanks);

         // Assign ranks to the combined list.
         for (Int32 i = 0; i < iNTemp; i++)
            lstRanks[i] = new Rank(
               lstRanks[i].iGroup,
               lstRanks[i].decValue,
               i + 1);

         // Adjust ties.
         Int32 iTieAdjustment = Rank.AdjustTies(ref lstRanks);

         bInitialized = true;

         List<Rank> lstGroup0 = new List<Rank>();
         List<Rank> lstGroup1 = new List<Rank>();
         foreach (Rank rank in lstRanks)
         {
            if (rank.iGroup == 0)
               lstGroup0.Add(rank);
            else
               lstGroup1.Add(rank);
         }

         // Sum the ranks.
         decR1 = decR2 = 0.0m;
         foreach (Rank rank in lstRanks)
            if (rank.iGroup == 0)
               decR1 += rank.decRank;
            else
               decR2 += rank.decRank;

         // Compute U.
         decU = groupsArray[0].n() * groupsArray[1].n();
         decU += groupsArray[0].n() * (groupsArray[0].n() + 1) / 2.0m;
         decU -= decR1;

         NUMBER dUPrime = iN1 * iN2 - decU;
         if (dUPrime > decU)
         {
            NUMBER dTemp = dUPrime;
            dUPrime = decU;
            decU = dTemp;
         }

         // Compute T.
         List<Rank> lstSmall, lstBig;
         Int32 iSmall, iBig;
         if (lstGroup1.Count() > lstGroup0.Count())
         {
            lstBig = lstGroup1;
            lstSmall = lstGroup0;
         }
         else
         {
            lstBig = lstGroup0;
            lstSmall = lstGroup1;
         }
         iBig = lstBig.Count();
         iSmall = lstSmall.Count();

         decT = 0.0m;
         foreach (Rank rank in lstSmall)
         {
            decT += rank.decRank;
         }

         // Compute sPt
         iN = iSmall + iBig;

         NUMBER decMu = (NUMBER)(iSmall * (iN + 1))
            / 2.0m;

         NUMBER decSigma = (iSmall * iBig * (iN + 1)) / 12.0m;
         decSigma -= (iSmall * iBig * iTieAdjustment) / (12.0m * N() * (N() - 1));
         decSigma = DecMath.Sqrt(decSigma);
         decSDt = decSigma;

         decZt = (DecMath.Abs((NUMBER)decT - decMu) - 0.5m) / (Decimal)decSDt;
         decZtUncorrected = ((NUMBER)decT - decMu) / (NUMBER)decSDt;

         decPt = (Distributions.ProbabilityZ((NUMBER)decZt));
         decPtUncorrected = Distributions.ProbabilityZ((NUMBER)decZtUncorrected);

         sPt = decPt.ToString();
         sPtUncorrected = decPtUncorrected.ToString();
         char cWhichWay;
         if (iBig <= 8)
         {
            decSDt =
            decZt =
            decZtUncorrected = null;
            sPt =
            sPtUncorrected = null;
            cWhichWay = '>';
            switch (iSmall)
            {
               case 1:
               case 2:
                  cWhichWay = '!';
                  break;

               case 3:
                  switch (iBig)
                  {
                     case 3:
                        cWhichWay = '!';
                        break;

                     case 4:
                        if ((decT <= 6) || (decT >= 18))
                           cWhichWay = '<';
                        break;

                     case 5:
                        if ((decT <= 6) || (decT >= 21))
                           cWhichWay = '<';
                        break;

                     case 6:
                        if ((decT <= 7) || (decT >= 23))
                           cWhichWay = '<';
                        break;

                     case 7:
                        if ((decT <= 7) || (decT >= 26))
                           cWhichWay = '<';
                        break;

                     case 8:
                        if ((decT <= 8) || (decT >= 28))
                           cWhichWay = '<';
                        break;
                  }
                  break;

               case 4:
                  switch (iBig)
                  {
                     case 4:
                        if ((decT <= 11) || (decT >= 25))
                           cWhichWay = '<';
                        break;

                     case 5:
                        if ((decT <= 12) || (decT >= 28))
                           cWhichWay = '<';
                        break;

                     case 6:
                        if ((decT <= 12) || (decT >= 32))
                           cWhichWay = '<';
                        break;

                     case 7:
                        if ((decT <= 13) || (decT >= 35))
                           cWhichWay = '<';
                        break;

                     case 8:
                        if ((decT <= 14) || (decT >= 38))
                           cWhichWay = '<';
                        break;
                  }
                  break;

               case 5:
                  switch (iBig)
                  {
                     case 5:
                        if ((decT <= 18) || (decT >= 37))
                           cWhichWay = '<';
                        break;

                     case 6:
                        if ((decT <= 19) || (decT >= 41))
                           cWhichWay = '<';
                        break;

                     case 7:
                        if ((decT <= 20) || (decT >= 45))
                           cWhichWay = '<';
                        break;

                     case 8:
                        if ((decT <= 21) || (decT >= 49))
                           cWhichWay = '<';
                        break;
                  }
                  break;

               case 6:
                  switch (iBig)
                  {
                     case 6:
                        if ((decT <= 26) || (decT >= 52))
                           cWhichWay = '<';
                        break;

                     case 7:
                        if ((decT <= 28) || (decT >= 56))
                           cWhichWay = '<';
                        break;

                     case 8:
                        if ((decT <= 30) || (decT >= 60))
                           cWhichWay = '<';
                        break;
                  }
                  break;

               case 7:
                  switch (iBig)
                  {
                     case 7:
                        if ((decT <= 37) || (decT >= 68))
                           cWhichWay = '<';
                        break;

                     case 8:
                        if ((decT <= 39) || (decT >= 73))
                           cWhichWay = '<';
                        break;
                  }
                  break;

               case 8:
                  if ((decT <= 49) || (decT >= 87))
                     cWhichWay = '<';
                  break;
            }

            switch (cWhichWay)
            {
               case '!':
                  sPt = "Sample size too small to reach statistical significance.";
                  break;

               case '<':
                  sPt = "p < 0.06";
                  break;

               case '>':
                  sPt = "P > 0.06";
                  break;
            }
         }
         bInitialized = true;
      }
   }
}

---