A computational statistics class

• Download source - 4.34 Kb

Introduction

This is a computational statistics class written in C#. The public methods are described below.

Public methods

• Constructor: public statistics(params double[] list)
• Update the design: public void update(params double[] list)
• Compute the mode: public double mode() - If there is more then one mode the NaN value will be returned.
• Compute the size of the design: public int length()
• Compute the minimum value of the design: public double min()
• Compute the maximum value of the design: public double max()
• Compute the first quarter : public double Q1()
• Compute the median : public double Q2()
• Compute the third quarter : public double Q3()
• Compute the average: public double mean()
• Compute the range: public double range()
• Compute the inter quantile range: public double IQ()
• Compute middle of range: public double middle_of_range()
• Compute sample variance: public double var()
• Compute standard deviation: public double s()
• Compute the YULE index: public double YULE()
• compute the index standard of a given member of the design: public double Z(double member)
• compute the covariance: public double cov(statistics s), public static double cov(statistics s1,statistics s2)
• compute the correlation coefficient: public double r(statistics design), public static double r(statistics design1,statistics design2)
• compute the "a" factor of the linear function of design: public double a(statistics design)
• compute the "a" factor of the linear function of design2: public static double a(statistics design1,statistics design2)
• compute the "b" factor of the linear function of design: public double b(statistics design)
• compute the "b" factor of the linear function of design 2: public static double b(statistics design1,statistics design2)

Source Code

using System;
 
namespace statistic
{
    
    public class statistics
    {
 
      private double[] list;
 
      public statistics(params double[] list)
      {
        this.list=list;
      }
      
      public void update(params double[] list)
      {
         this.list=list;
      }
 
      public double mode()
      {
         try
         {
                  double[] i=new double[list.Length];
                  list.CopyTo(i,0);
                  sort(i);
                  double val_mode=i[0],help_val_mode=i[0];
                  int old_counter=0,new_counter=0;
                  int j=0;
                  for (;j<=i.Length-1;j++)
                           if (i[j]==help_val_mode) new_counter++;
                           else if (new_counter>old_counter) 
                           {
                                   old_counter=new_counter;
                                   new_counter=1;
                                   help_val_mode=i[j];
                                   val_mode=i[j-1];
                           }
                           else if (new_counter==old_counter) 
                           {
                                   val_mode=double.NaN;
                                   help_val_mode=i[j];
                                   new_counter=1;
                           }
                           else 
                           {
                                   help_val_mode=i[j];
                                   new_counter=1;
                           }
                  if (new_counter>old_counter) val_mode=i[j-1]; 
                  else if (new_counter==old_counter) val_mode=double.NaN;
                  return val_mode;
         }
         catch (Exception)
         {
                  return double.NaN;
         }
      }
 
      public int length()
      {
         return list.Length;
      }
 
      public double min()
      {
         double minimum=double.PositiveInfinity;
         for (int i=0;i<=list.Length-1;i++)
                  if (list[i]<minimum) minimum=list[i];
         return minimum;
      }
 
      public double max()
      {
         double maximum=double.NegativeInfinity;
         for (int i=0;i<=list.Length-1;i++)
                  if (list[i]>maximum) maximum=list[i];
         return maximum;
      }   
    
      public double Q1()
      {
         return Qi(0.25);
      }
 
      public double Q2()
      {
         return Qi(0.5);
      }
 
      public double Q3()
      {
         return Qi(0.75);
      }
 
      public double mean()
      {
         try
         {
                  double sum=0;
                  for (int i=0;i<=list.Length-1;i++)
                           sum+=list[i];
                  return sum/list.Length;
         }
         catch (Exception)
         {
                  return double.NaN;
         }
      }
 
      public double range()
      {
         double minimum=min();
         double maximum=max();
         return (maximum-minimum);
      }
 
      public double IQ()
      { 
         return Q3()-Q1();
      }
 
      public double middle_of_range()
      {
         double minimum=min();
         double maximum=max();
         return (minimum+maximum)/2; 
      }
 
      public double var()
      {
         try
         {
                  double s=0;
                  for (int i=0;i<=list.Length-1;i++)
                           s+=Math.Pow(list[i],2);
                  return (s-list.Length*Math.Pow(mean(),2))/(list.Length-1);
         }
         catch (Exception)
         {
                  return double.NaN;
         }
      }
 
      public double s()
      {
         return Math.Sqrt(var());
      }
 
      public double YULE()
      {
         try
         {
                  return ((Q3()-Q2())-(Q2()-Q1()))/(Q3()-Q1());
         }
         catch (Exception)
         {
      return double.NaN;
         }
      }
 
      public double Z(double member)
      {
         try
         {
                  if (exist(member)) return (member-mean())/s();
                  else return double.NaN;
         }
         catch(Exception)
         {
                  return double.NaN;
         }
      }
 
      public double cov(statistics s)
      {
         try
         {
                  if (this.length()!=s.length()) return double.NaN;
                  int len=this.length();
                  double sum_mul=0;
                  for (int i=0;i<=len-1;i++)
                           sum_mul+=(this.list[i]*s.list[i]);
                  return (sum_mul-len*this.mean()*s.mean())/(len-1);
         }
         catch(Exception)
         {
      return double.NaN;
         }
      }
 
      public static double cov(statistics s1,statistics s2)
      {
         try
         {
                  if (s1.length()!=s2.length()) return double.NaN;
                  int len=s1.length();
                  double sum_mul=0;
                  for (int i=0;i<=len-1;i++)
                           sum_mul+=(s1.list[i]*s2.list[i]);
                  return (sum_mul-len*s1.mean()*s2.mean())/(len-1);
         }
         catch(Exception)
         {
                  return double.NaN;
         }
    }
 
      public double r(statistics design)
      {
         try
         {
                  return this.cov(design)/(this.s()*design.s());
         }
         catch(Exception)
         {
                  return double.NaN;
         }
      }
 
      public static double r(statistics design1,statistics design2)
      {
         try
         {
                  return cov(design1,design2)/(design1.s()*design2.s());
         }
         catch(Exception)
         {
                  return double.NaN;
         }
      }
 
      public double a(statistics design)
      {
         try
         {
                  return this.cov(design)/(Math.Pow(design.s(),2));
         }
         catch(Exception)
         {
             return double.NaN;
         }
      }
 
      public static double a(statistics design1,statistics design2)
      {
         try
         {
                  return cov(design1,design2)/(Math.Pow(design2.s(),2));
         }
         catch (Exception)
         {
                  return double.NaN;
         }
      }
 
      public double b(statistics design)
      {
         return this.mean()-this.a(design)*design.mean();
      }
 
      public static double b(statistics design1,statistics design2)
      {
         return design1.mean()-a(design1,design2)*design2.mean();
      }
 
      private double Qi(double i)
      {
         try
         {
                  double[] j=new double[list.Length];
                  list.CopyTo(j,0);
                  sort(j);
                  if (Math.Ceiling(list.Length*i)==list.Length*i) 
 return (j[(int)(list.Length*i-1)]+j[(int)(list.Length*i)])/2;
                  else return j[((int)(Math.Ceiling(list.Length*i)))-1];
          }
         catch(Exception)
         {
                  return double.NaN;
         }
      }
      
      private void sort(double[] i)
   {
         double[] temp=new double[i.Length];
          merge_sort(i,temp,0,i.Length-1);
    }
 
      private void  merge_sort(double[] source,
 double[] temp,int left,int right)
      {
         int mid;
         if (left<right) 
         {
                  mid=(left+right) / 2;
                  merge_sort(source,temp,left,mid);
                  merge_sort(source,temp,mid+1,right);
                  merge(source,temp,left,mid+1,right);
         }
      }
 
      private void  merge(double[] source,double[] temp,
int left,int mid,int right)
      {
         int i,left_end,num_elements,tmp_pos;
         left_end=mid - 1;
         tmp_pos=left;
         num_elements=right - left + 1;
         while ((left <= left_end) && (mid <= right)) 
         {
                  if (source[left] <= source[mid]) 
                  {            
                           temp[tmp_pos]= source[left];
                           tmp_pos++;
                           left++;
                  }
                  else
                  {   
                           temp[tmp_pos] = source[mid];
                           tmp_pos++;
                           mid++;
                  }
         }
         while (left <= left_end) 
         {
                  temp[tmp_pos]= source[left];
                  left++;
                  tmp_pos++;
         }
         while (mid <= right) 
         {
                  temp[tmp_pos]= source[mid];
                  mid++;
                  tmp_pos++;
         }
         for (i=1;i<=num_elements;i++)
         {
                  source[right]= temp[right];
                  right--;
         }
      }
 
      private bool exist(double member)
      {
         bool is_exist=false;
         int i=0;
    while (i<=list.Length-1 && !is_exist)
         {
          is_exist=(list[i]==member);
           i++;
         }
         return is_exist;
      }
      
    }
      
}

This article has no explicit license attached to it but may contain usage terms in the article text or the download files themselves. If in doubt please contact the author via the discussion board below.

A list of licenses authors might use can be found here