}
    for(i=0;i<lay2_num;i++)
       { for(j=0;j<w_num;j++)
            weight[j]=jul[i*in_num+j];
         for(j=0;j<t_num;j++)
            t[j]=div[i];
         lable=Layer[1].Lay_node[i]->InitNode(weight,t,w_num,t_num);
         if(lable!=0)
           return lable;
       }
    srand( (unsigned)time( NULL ) );
    for(i=0;i<Layer_node_num[2];i++)
       {
         w_num=Layer[2].Lay_node[i]->GetWtNum();
		 for(j=0;j<w_num;j++)
            weight[j]=(double)(rand()%100)/50-1;
         t_num=Layer[2].Lay_node[i]->GetTdNum();
         for(j=0;j<t_num;j++)
            { if(j==0)
               t[j]=0;
              else
               t[j]=1;
            }
         lable=Layer[2].Lay_node[i]->InitNode(weight,t,w_num,t_num);
         if(lable!=0)
           break;
       }

    delete [] jul;
    delete [] cla;
    return lable;
 }

//....................................................................
//...................LSE_RBF_NET.................

LSE_RBF_NET :: LSE_RBF_NET(short lay_num,short lay0_num,short lay1_num,short lay2_num)
               :RBF_NET(lay_num,lay0_num,lay1_num,lay2_num)
               {
                 strcpy(Lable,"Radical Basis Function  Nenual Network with LSE learning mathod");
               }
LSE_RBF_NET :: LSE_RBF_NET(short lay_num)
               :RBF_NET(lay_num)
               {
                 strcpy(Lable,"Radical Basis Function  Nenual Network with LSE learning mathod");
               }

void
LSE_RBF_NET :: For_pro(double * sam_in,double * sam_out,const short sam_num,
                       const short sam_inNum,const short sam_outNum)
{
   if(Net_inNum!=sam_inNum||Net_outNum!=sam_outNum)
      { cout<<"\n The in_number or out_number of exemples are not equal"
            <<"to those of ANN_NET"<<endl;
	return ;
      }
   short wt_num=Layer[2].Lay_node[0]->GetWtNum();
   short td_num=Layer[2].Lay_node[0]->GetTdNum();
   short number1=wt_num+td_num;
   if(wt_num!=Layer_node_num[1])
     { cout<<"\n Data erros";
       return;
     }
   double * a=new double[sam_num*number1];
   double * dm=new double[number1];
   double * x=new double[number1*sam_outNum];
   double in[Layer_node_max],out[Layer_node_max];
   for(short i=0;i<sam_num;i++)
       { for(short j=0;j<Net_inNum;j++)
            in[j]=sam_in[i*sam_inNum+j];
         NetWork(*this,in,out,sam_inNum,sam_outNum);
         GetLayerOut(dm,1);
         double sum=0.0;
         for(j=0;j<wt_num;j++)
            sum+=dm[j];
         for(j=0;j<wt_num;j++)
            a[i*number1+j]=dm[j]/sum;
         for(j=0;j<td_num;j++)
            a[i*number1+wt_num+j]=1.0;
       }
   lse(x,a,sam_out,number1,sam_outNum,sam_num);
   for(i=0;i<sam_outNum;i++)
      { for(short j=0;j<number1;j++)
           dm[j]=x[i+j*sam_outNum];
        Layer[2].Lay_node[i]->Loadw(dm,number1);
      }
   delete [] a;
   delete [] dm;
   delete [] x;
}

double
LSE_RBF_NET :: Back_pro(double * sam_in,double * sam_out,double * w,const short sam_number,
                       const short sam_inNum,const short sam_outNum,short erro_type)
{  if(!(Net_inNum==sam_inNum&&Net_outNum==sam_outNum)) {
      cout<<"\n The in_number or out_number of exemples are not equal to "
          <<"those of ANN_NET in back program"<<endl;
      return false;
   }
   double * in=new double[Net_inNum];
   double * out=new double[Net_outNum];
   double * rvalue=new double[Net_outNum];
   double * deri_out=new double[Layer_node_max];

   double  diff=0.0;
   Clearl(1);
   for(short i=0;i<sam_number;i++)
      {
	for(short j=0;j<Net_inNum;j++)
	   in[j]=sam_in[i*sam_inNum+j];
	for(j=0;j<Net_outNum;j++)
	  rvalue[j]=sam_out[i*sam_outNum+j];
	NetWork(*this,in,out,sam_inNum,sam_outNum);
	double erro=SquareErro(rvalue,deri_out,erro_type);
	diff+=erro;
        for(j=Layer_num-1;j>0;j--)
           { for(short k=0;k<Layer_node_num[j];k++)
                Layer[j].Lay_node[k]->Adjustl(deri_out[k],w[i]);
             GetDeriOut(deri_out,j-1);
           }
      }
   delete [] in;
   delete [] out;
   delete [] rvalue;
   delete [] deri_out;
   return diff/sam_number;

}

short
LSE_RBF_NET :: Learn(double * sam_in,double * sam_out,double * w,const short sam_number,
                 const short sam_inNum,const short sam_outNum,double & diff,
                 short maxinum=1500,short erro_type=1)
{  diff=0.0;
   double prediff=0.0;
   short counter=0;
   short count1=0;
   short count2=0;
   short lable=0;
   short lable1=0;
   Clearl(0);
   PARA1=0.01;PARA2=0;
   double parameter1=PARA1;
   for( ; ; )
      {
        counter++;

        if(lable1<5)
          For_pro(sam_in,sam_out,sam_number,sam_inNum,sam_outNum);
        diff=Back_pro(sam_in,sam_out,w,sam_number,sam_inNum,sam_outNum,erro_type);
        if(diff<PRECISION) break;
        Adjustp(prediff,diff,count1,count2,lable,lable1);
        if(PARA1<parameter1/100)
          PARA1=parameter1;
        if(PARA1>parameter1*50)
          PARA1=parameter1;
        Adjustw(sam_number,Layer_num);
        prediff=diff;

        //cout<<"\n"<<counter<<"  "<<diff<<"  "<<PARA1<<"  "<<PARA2<<" "<<lable1;
        if(counter==maxinum)
        break;
      }
   return counter;
}

short
LSE_RBF_NET :: InitNet(double sam_in[],double sam_out[],short number,
                            short in_num,short out_num,short type=1)
{
   short lable=RBF_NET::InitNet(sam_in,sam_out,number,in_num,out_num,type);
   return lable;
}


void
seq_method(double * xi,double * ai,double * bi,double * si,const short m,const short n)
{    double d1=0.0;
     double * dm1=new double[m];
     double * dm2=new double[m];
     double * dm3=new double[m];
     double * dm4=new double[n];
     double * ds=new double[m*m];
     double * dx=new double[m*n];
     short i=0;short j=0;
     for(i=0;i<m;i++)
	{ dm1[i]=0.0;dm2[i]=0.0;dm3[i]=0.0;
	  for(short j=0;j<m;j++)
	     ds[i*m+j]=0.0;
	}
     for(i=0;i<n;i++)
	{ dm4[i]=0.0;
	  for(j=0;j<m;j++)
	     dx[i*n+j]=0.0;
	}
     for(i=0;i<m;i++)              //d1=(ai)~*si*ai
	{ double s1=0.0;
	  for(j=0;j<m;j++)
	     s1+=ai[j]*si[j*m+i];
	  d1+=s1*ai[i];
	}
     d1+=1.0;                    //d1=1-d1
     for(i=0;i<m;i++)            //dm1=si*ai    (m*1)
	for(j=0;j<m;j++)
	   dm1[i]+=si[i*m+j]*ai[j];
     for(i=0;i<m;i++)            //dm2=(ai)~*si  (1*m)
	for(j=0;j<m;j++)
	   dm2[i]+=ai[j]*si[j*m+i];
     for(i=0;i<m;i++)            //ds=dm1*dm2/d1   (m*m)
	for(j=0;j<m;j++)
	   ds[i*m+j]=dm1[i]*dm2[j]/d1; //
     for(i=0;i<m;i++)           //s(i+1)=si-ds   (m*m)
	for(j=0;j<m;j++)
	   si[i*m+j]-=ds[i*m+j];
     for(i=0;i<m;i++)          //dm3=s(i+1)*ai*d2 (m*1)
	for(j=0;j<m;j++)
	   dm3[i]+=si[i*m+j]*ai[j];
     for(i=0;i<n;i++)         //dm4=(ai)~*xi (1*n)
	for(j=0;j<m;j++)
	   dm4[i]+=ai[j]*xi[j*n+i];
    for(i=0;i<n;i++)          //dm4=bi-dm4 (1*n)
	dm4[i]=bi[i]-dm4[i];
    for(i=0;i<m;i++)         //dx=dm3*dm4 (m*n)
       for(j=0;j<n;j++)
	  dx[i*n+j]=dm3[i]*dm4[j];

    for(i=0;i<m;i++)         //x(i+1)=xi+dm3   (m*n)
	for(j=0;j<n;j++)
	   xi[i*n+j]+=dx[i*n+j];
     delete [] dm1;
     delete [] dm2;
     delete [] dm3;
     delete [] dm4;
     delete [] ds;
     delete [] dx;
     return;
}

void lse(double * x,double * a,double * b, short m,short n,short p)
	// x(m*n) a(p*m) b(p*n) m:inputs number n:out number p sample number
{    double * si=new double[m*m];
     double * ai=new double[m];
     double * bi=new double[n];
     double r=10000.0;
     short i=0;short j=0;
     for(i=0;i<m;i++)
	for(j=0;j<m;j++)
	   if(j==i)
	     si[i*m+j]=r;
	   else
	     si[i*m+j]=0.0;
     for(i=0;i<m;i++)
	for(j=0;j<n;j++)
	x[i*n+j]=0.0;
     for(i=0;i<p;i++)
	{ for(j=0;j<m;j++)
	     ai[j]=a[i*m+j];
	  for(j=0;j<n;j++)
	    bi[j]=b[i*n+j];
	  seq_method(x,ai,bi,si,m,n);
	}
     delete [] ai;
     delete [] si;
     delete [] bi;
     return;
}


#endif