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

Go to the documentation of this file.

using System;
using System.Collections.Generic;

namespace StephenAshley.Biostatistics
{
   using NUMBER = Decimal;
   public class CorrelationRegressionGroupsCollection : GroupsCollection
   {
      #region *** constructors ***
      public CorrelationRegressionGroupsCollection() : base() { }

      public CorrelationRegressionGroupsCollection(List<Group> lstGroups)
         : base(lstGroups)
      {
      }
      #endregion
      #region ***** methods ******
      public override void Add(Group group)
      {
         if (group == null)
            throw new BiostatisticsException(
               "group parameter in Add method of CorrelationRegressionGroupsCollection is null.");

         if (groupsArray != null && groupsArray.Length > 0)
         {
            if (groupsArray[0].n() != group.n())
               throw new BiostatisticsException(
"Added group does not have an equal number of elements to the other Group objects in the collection.");
         }

         base.Add(group);
      }

      public override void AddRange(List<Group> lstGroups)
      {
         if (lstGroups == null)
            throw new BiostatisticsException(
   "lstGroups paramter in AddRange method of CorrelationRegressionGroupsCollection is null.");

         foreach (Group group in lstGroups)
            Add(group);
      }

      public NUMBER CoefficientOfDetermination()
      {
         return CorrelationCoefficient() * CorrelationCoefficient();
      }

      public Int32 DegreesOfFreedom()
      {
         return N() - 2;
      }

      public Int32 DF() { return DegreesOfFreedom(); }

      public Int32 N() { return groupsArray[0].n(); }

      public NUMBER p() { return Distributions.ProbabilityT(t(), DegreesOfFreedom()); }

      public NUMBER RSquared() { return CoefficientOfDetermination(); }

      public NUMBER CorrelationCoefficient()
      {
         NUMBER decCorrelationCoefficient;
         try
         {
            decCorrelationCoefficient = SumOfCoDeviatesXY()
               / DecMath.Sqrt(groupsArray[0].SumOfSquaredDeviates()
               * groupsArray[1].SumOfSquaredDeviates());
         }
         catch (Exception e)
         {
            throw new BiostatisticsException(e.Source + ": " + e.Message, e);
         }
         return decCorrelationCoefficient;
      }

      public NUMBER R() { return CorrelationCoefficient(); }

      public NUMBER ResidualVarianceOfY()
      {
         NUMBER decResidualVarianceOfY;
         try
         {
            decResidualVarianceOfY = SumOfSquaredResiduals() /
               N();
         }
         catch (Exception e)
         {
            throw new BiostatisticsException(e.Source + ": " + e.Message, e);
         }
         return decResidualVarianceOfY;
      }

      public NUMBER Slope()
      {
         NUMBER decSlope;
         try
         {
            decSlope = SumOfCoDeviatesXY() /
               groupsArray[0].SumOfSquaredDeviates();
         }
         catch (Exception e)
         {
            throw new BiostatisticsException(e.Source + ": " + e.Message, e);
         }
         return decSlope;
      }

      public NUMBER StandardDeviationOfResiduals()
      {
         return DecMath.Sqrt(ResidualVarianceOfY());
      }

      public NUMBER StandardErrorOfEstimate()
      {
         NUMBER decStandardErrorOfEstimate;
         try
         {
            decStandardErrorOfEstimate = DecMath.Sqrt(SumOfSquaredResiduals()
               / (N() - 2));
         }
         catch (Exception e)
         {
            throw new BiostatisticsException(e.Source + ": " + e.Message, e);
         }
         return decStandardErrorOfEstimate;
      }

      public NUMBER SE() { return StandardErrorOfEstimate(); }

      public NUMBER StandardErrorOfIntercept()
      {
         NUMBER decStandardErrorOfIntercept;
         try
         {
            decStandardErrorOfIntercept = StandardErrorOfEstimate() * DecMath.Sqrt((1.0m / N())
               + (((groupsArray[0].Sum() / N()) * (groupsArray[0].Sum() / N()))
               / groupsArray[0].SumOfSquaredDeviates()));
         }
         catch (Exception e)
         {
            throw new BiostatisticsException(e.Source + ": " + e.Message, e);
         }
         return decStandardErrorOfIntercept;
      }

      public NUMBER StandardErrorOfSlope()
      {
         NUMBER decStandardErrorOfSlope;
         try
         {
            decStandardErrorOfSlope = StandardErrorOfEstimate() /
               DecMath.Sqrt(groupsArray[0].SumOfSquaredDeviates());
         }
         catch (Exception e)
         {
            throw new BiostatisticsException(e.Source + ": " + e.Message, e);
         }
         return decStandardErrorOfSlope;
      }

      public NUMBER SumOfCoDeviatesXY()
      {
         NUMBER decSumOfCoDeviatesXY;
         try
         {
            Group grpX = groupsArray[0];
            Group grpY = groupsArray[1];
            NUMBER decSumOfProducts = 0.0m;
            for (Int32 i = 0; i < grpX.n(); i++)
               decSumOfProducts += grpX[i] * grpY[i];
            decSumOfCoDeviatesXY = decSumOfProducts - ((grpX.Sum() * grpY.Sum()) / grpX.n());
         }
         catch (Exception e)
         {
            throw new BiostatisticsException(e.Source + ": " + e.Message, e);
         }

         return decSumOfCoDeviatesXY;
      }

      public NUMBER SCxy() { return SumOfCoDeviatesXY(); }

      public NUMBER SumOfSquaredResiduals()
      {
         return groupsArray[1].SumOfSquaredDeviates() *
               (1.0m - CoefficientOfDetermination());
      }

      public NUMBER SSResidual() { return SumOfSquaredResiduals(); }

      public NUMBER t()
      {
         if (StandardErrorOfSlope() == 0.0m)
            return Decimal.MaxValue;
         else return Slope() / StandardErrorOfSlope();
      }

      public NUMBER YIntercept()
      {
         return groupsArray[1].Mean() - Slope() *
               groupsArray[0].Mean();
      }
      #endregion
   }
}

---