几种满足特定数学分布数据产生函数

均匀分布数据

 /* ********************************************
 Function Description
 *产生均匀分布数据
 *输入参数：均匀分布的最小值min，最大值max
 *返回值：满足要求的一个double型满足在（min,max）均匀分布的数据
 *********************************************/ 
double AverageRandom(double min,double max)       
{       
  int minInteger = (int)(min*10000);      
  int maxInteger = (int)(max*10000);        
  int randInteger = rand()*rand();        
  int diffInteger = maxInteger - minInteger;        
  int resultInteger = randInteger % diffInteger + minInteger;        
  return resultInteger/10000.0;        
}

概率密度函数

/**************
*概率密度函数
*miu 是期望
*sigma是方差
*************/ 
double Normal(double x,double miu,double sigma)   
{      
   return 1.0/sqrt(2*PI*sigma) * exp(-1*(x-miu)*(x-miu)/(2*sigma*sigma));     
}  

正太分布随机数

 /***********************************************
 *产生正态分布随机数
 *miu是期望，sigma是方差，min是正正态分布的最小值，max是最大值
 *返回值：满足要求的随机数
 ***********************************************/
double NormalRandom(double miu,  double sigma,double min,double max)  
{     
   double x; 
   double dScope;      
   double y;  
do 
{  
   x = AverageRandom(min,max);      
   y = Normal(x, miu, sigma);      
   dScope = AverageRandom(0, Normal(miu,miu,sigma));      
}while( dScope > y);      
return x;     
}

线性拟合

/*void spir(int n,int m,double x[],double y[],double a[], double dt[])

     int n               给定数据点的个数
     int m               拟合多项式的项数，即拟合多项式的次数为m-1。要求m<=n且m<=20
     double x[n]         存放给定n个数据点的x坐标
     double y[n]         存放给定n个数据点的y坐标
     double a[m]         返回m-1次拟合多项式的m个系数。拟合多项式形式为
                         Pm-1(x)=a(0)+a(1)*x+a(2)*x2+-----a(m-1)*x(m-1)
     double dt[3]        其中dt[0]返回拟合多项式与数据点误差的平方和；dt[1]返回拟合拟合多项式与数据点
                         误差的绝对值之和；dt[2]返回拟合拟合多项式与数据点误差绝对值的最大值
     void spir()         过程
*/
void spir(int n,int m,double x[],double y[],double a[], double dt[])
  {
      int i,j,k;
      double alpha,p,q,g,w,beta,d1,d2,s[20],t[20],b[20];
      for (i=0; i<=m-1;i++) a[i]=0.0;
      if (m>n) m=n;
      if (m>20) m=20;
      b[0]=1.0;d1=n; alpha=0.0;q=0.0;
      for (i=0;i<=n-1;i++)  {alpha=alpha+x[i];q=q+y[i];}
      q=q/d1;                                          //q0
      alpha=alpha/d1;                                  //alpha(0)
      a[0]=q*b[0];
      if (m>1)
      {
          t[1]=1.0;t[0]=-alpha;
          d2=0.0;q=0.0;g=0.0;
          for (i=0;i<=n-1;i++)    //计算q1,alpha(1)与d1
          {
               w=x[i]-alpha;
               d2=d2+w*w;
               q=q+y[i]*w;
               g=g+x[i]*w*w;
           }
           q=q/d2;                                     //q1
           alpha=g/d2;                                 //alpha(1)
           beta=d2/d1;                                 //计算beta(1)
           d1=d2;
           a[1]=q*t[1];
           a[0]=q*t[0]+a[0];
      }
     for (j=2;j<=m-1;j++)                              //递推计算Qj(x)
     {
          s[j]=t[j-1];
          s[j-1]=-alpha*t[j-1]+t[j-2];
          if (j>=3)
          for (k=j-2;k>=1;k--) s[k]=-alpha*t[k]+t[k-1]-beta*b[k];
          s[0]=-alpha*t[0]-beta*b[0];
          d2=0.0; q=0.0; g=0.0;
          for (i=0; i<=n-1;i++)                       //计算qj,alpha(j)与dj，
          { 
             w=s[j];
             for (k=j-1;k>=0;k--)  w=w*x[i]+s[k];
             d2=d2+w*w; q=q+y[i]*w;
             g=g+x[i]*w*w;
          }
          q=q/d2;                                    //qj
          alpha=g/d2;                               //alpha(j)
          beta=d2/d1;                               //计算beta(j)
          d1=d2;
          a[j]=q*s[j];t[j]=s[j];
          for (k=j-1;k>=0;k--)
          {
               a[k]=q*s[k]+a[k];
               b[k]=t[k];t[k]=s[k];
          }
      }
          dt[0]=0.0; dt[1]=0.0;dt[2]=0.0;
          for (i=0;i<=n-1;i++)
          {    
              w=a[m-1];
              for (k=m-2;k>=0;k--) w=a[k]+w*x[i];
              p=w-y[i];
              if (fabs(p)>dt[2]) dt[2]=fabs(p);
              dt[0]=dt[0]+p*p;
              dt[1]=dt[1]+fabs(p);
          }
    
   }