pmatlib.c

压缩文件中是Error Correction Coding - Mathematical Methods and Algorithms(Wiley 2005)作者:(Todd K. Moon )的配

  a is rows x cols.
  Return value:
  double ||a|| where ||a|| is the frobenius norm.
*********************************************************/
double pfrobeniuslf( double **a, int rows, int cols )
{
   int i, j;         /*Counters.*/
   double sum;       /*The running frobenius norm value.*/
   
   sum = 0.0;
   for ( i = 0; i < rows; i++ ) {
      for ( j=0,pd=a[i]; j < cols; j++,pd++ ) {
         sum += (*pd)*(*pd);
      }
   }
   return( sqrt( sum ) );
}


float pfrobeniusf( float **a, int rows, int cols )
{
   int i, j;         /*Counters.*/
   float sum;       /*The running frobenius norm value.*/
   
   sum = 0.0;
   for ( i = 0; i < rows; i++ ) {
      for ( j=0,pf=a[i]; j < cols; j++,pf++ ) {
         sum += (*pf)*(*pf);
      }
   }
   return( sqrt( sum ) );
}

/*****************************************************************/
void ptencopylf(double ***a, double ***b, int nstack, int r, int c)
{
   int i,j,k;

   for(i = 0; i < nstack; i++) {
      for(j = 0; j < r; j++) {
	 for(k = 0; k < c; k++) {
	    b[i][j][k] = a[i][j][k];
	 }
      }
   }
}

void ptencopyf(float ***a, float ***b, int nstack, int r, int c)
{
   int i,j,k;

   for(i = 0; i < nstack; i++) {
      for(j = 0; j < r; j++) {
	 for(k = 0; k < c; k++) {
	    b[i][j][k] = a[i][j][k];
	 }
      }
   }
}


/*****************************************************************/


void pmatprint(char *name, void **mat, int m,int n, int type)
{
   switch(type) {
   case TKSCHAR:
      pmatprintsc(name,(signed char **)mat,m,n);
      break;
   case TKUCHAR:
      pmatprintuc(name,(unsigned char **)mat,m,n);
      break;
   case TKCHAR:
      pmatprints(name,(char **)mat,m);
      break;
   case TKSHINT:
      pmatprinthd(name,(short **)mat,m,n);
      break;
   case TKINT:
      pmatprintd(name,(int **)mat,m,n);
      break;
   case TKFLOAT:
      pmatprintf(name,(float **)mat,m,n);
      break;
   case TKDOUBLE:
      pmatprintlf(name,(double **)mat,m,n);
      break;
   case TKLINT:
      pmatprintld(name,(long **)mat,m,n);
      break;
   case TKHEX:
      pmatprintx(name,(int **)mat,m,n);
      break;
   default:
      fprintf(stderr,"undefined type %d\n",type);
   }
}



void pmatprints(char *name,char **mat,int n)
{
   int i,j;
   
   if(fout == NULL) fout = stdout;

   fprintf(fout,"%s",name);
   if(matprintnamewnl) fprintf(fout,"\n");
   if(mat == NULL) {
      fprintf(fout,"(null)\n");
      return;
   }

   fprintf(fout,"%s",matleftdelim);
   for(i = 0; i < n; i++) {
      fprintf(fout,"%s",mat[i]);
      if(i < n-1) fprintf(fout,"%s",matrowdelim);
   }
   fprintf(fout,"%s",matrightdelim);
   if(matprintnlafter) fprintf(fout,"\n");
}

void pmatprintsc(char *name,signed char **mat,int n,int m)
{
   int i,j;
   
   if(fout == NULL) fout = stdout;
   if(strlen(name)) fprintf(fout,"%s",name);
   if(matprintnamewnl) fprintf(fout,"\n");

   if(mat == NULL) {
      fprintf(fout,"(null)\n");
      return;
   }
   fprintf(fout,"%s",matleftdelim);
   for(i = 0; i < n; i++) {
      for(j = 0; j < m; j++) {
         fprintf(fout,"%*.*d\t",intwid1,intwid2,(int)mat[i][j]);
      }
      if(i < n-1) fprintf(fout,"%s",matrowdelim);
   }
   fprintf(fout,"%s",matrightdelim);
   if(matprintnlafter) fprintf(fout,"\n");
}

void pmatprintuc(char *name,unsigned char **mat,int n,int m)
{
   int i,j;
   
   if(fout == NULL) fout = stdout;
   if(strlen(name)) fprintf(fout,"%s",name);
   if(matprintnamewnl) fprintf(fout,"\n");

   if(mat == NULL) {
      fprintf(fout,"(null)\n");
      return;
   }
   fprintf(fout,"%s",matleftdelim);
   for(i = 0; i < n; i++) {
      for(j = 0; j < m; j++) {
         fprintf(fout,"%*.*ud\t",intwid1,intwid2,(unsigned int)mat[i][j]);
      }
      if(i < n-1) fprintf(fout,"%s",matrowdelim);
   }
   fprintf(fout,"%s",matrightdelim);
   if(matprintnlafter) fprintf(fout,"\n");
}

/*****************************************************************/
void pmatprinthd(char *name,short int **mat,int n,int m)
{
   int i,j;
   
   if(fout == NULL) fout = stdout;
   if(strlen(name)) fprintf(fout,"%s",name);
   if(matprintnamewnl) fprintf(fout,"\n");

   if(mat == NULL) {
      fprintf(fout,"(null)\n");
      return;
   }
   fprintf(fout,"%s",matleftdelim);
   for(i = 0; i < n; i++) {
      for(j = 0; j < m; j++) {
         fprintf(fout,"%*.*hd\t",intwid1,intwid2,mat[i][j]);
      }
      if(i < n-1) fprintf(fout,"%s",matrowdelim);
   }
   fprintf(fout,"%s",matrightdelim);
   if(matprintnlafter) fprintf(fout,"\n");
}


/*****************************************************************/
void pmatprintd(char *name,int **mat,int n,int m)
{
   int i,j;
   
   if(fout == NULL) fout = stdout;
   if(strlen(name)) fprintf(fout,"%s",name);
   if(matprintnamewnl) fprintf(fout,"\n");

   if(mat == NULL) {
      fprintf(fout,"(null)\n");
      return;
   }
   fprintf(fout,"%s",matleftdelim);
   for(i = 0; i < n; i++) {
      for(j = 0; j < m; j++) {
         fprintf(fout,"%*.*d\t",intwid1,intwid2,mat[i][j]);
      }
      if(i < n-1) fprintf(fout,"%s",matrowdelim);
   }
   fprintf(fout,"%s",matrightdelim);
   if(matprintnlafter) fprintf(fout,"\n");
}

void pmatprintx(char *name,int **mat,int n,int m)
{
   int i,j;
   
   if(fout == NULL) fout = stdout;
   if(strlen(name)) fprintf(fout,"%s",name);
   if(matprintnamewnl) fprintf(fout,"\n");

   if(mat == NULL) {
      fprintf(fout,"(null)\n");
      return;
   }
   fprintf(fout,"%s",matleftdelim);
   for(i = 0; i < n; i++) {
      for(j = 0; j < m; j++) {
         fprintf(fout,"%*.*x\t",intwid1,intwid2,mat[i][j]);
      }
      if(i < n-1) fprintf(fout,"%s",matrowdelim);
   }
   fprintf(fout,"%s",matrightdelim);
   if(matprintnlafter) fprintf(fout,"\n");
}

/*****************************************************************/
void pmatprintf(char *name,float **mat,int n,int m)
{
   int i,j;
   
   if(fout == NULL) fout = stdout;
   if(strlen(name)) fprintf(fout,"%s",name);
   if(matprintnamewnl) fprintf(fout,"\n");

   if(mat == NULL) {
      fprintf(fout,"(null)\n");
      return;
   }
   fprintf(fout,"%s",matleftdelim);
   for(i = 0; i < n; i++) {
      for(j = 0; j < m; j++) {
         fprintf(fout,"%*.*g\t",flwid1,flwid2,mat[i][j]);
      }
      if(i < n-1) fprintf(fout,"%s",matrowdelim);
   }
   fprintf(fout,"%s",matrightdelim);
   if(matprintnlafter) fprintf(fout,"\n");
}

/*****************************************************************/
void pmatprintlf(char *name,double **mat,int n,int m)
{
   int i,j;
   
   if(fout == NULL) fout = stdout;
   if(strlen(name)) fprintf(fout,"%s",name);
   if(matprintnamewnl) fprintf(fout,"\n");

   if(mat == NULL) {
      fprintf(fout,"(null)\n");
      return;
   }
   fprintf(fout,"%s",matleftdelim);
   for(i = 0; i < n; i++) {
      for(j = 0; j < m; j++) {
         fprintf(fout,"%*.*g\t",flwid1,flwid2,mat[i][j]);
      }
      if(i < n-1) fprintf(fout,"%s",matrowdelim);
   }
   fprintf(fout,"%s",matrightdelim);
   if(matprintnlafter) fprintf(fout,"\n");
}

/*****************************************************************/
void pmatprintld(char *name,long int **mat,int n,int m)
{
   int i,j;
   
   if(fout == NULL) fout = stdout;
   if(strlen(name)) fprintf(fout,"%s",name);
   if(matprintnamewnl) fprintf(fout,"\n");
   if(mat == NULL) {
      fprintf(fout,"(null)\n");
      return;
   }
   fprintf(fout,"%s",matleftdelim);
   for(i = 0; i < n; i++) {
      for(j = 0; j < m; j++) {
         fprintf(fout,"%*.*ld\t",intwid1,intwid2,mat[i][j]);
      }
      if(i < n-1) fprintf(fout,"%s",matrowdelim);
   }
   fprintf(fout,"%s",matrightdelim);
   if(matprintnlafter) fprintf(fout,"\n");
}


/*****************************************************************/
/* set the format of integer printing for printf.  E.g., %4.3d is obtained with
    setintprintwidths(4,3);
   (default is 0.0)
*/
void setintprintwidths(int w1,int w2)
{  intwid1 = w1;
 intwid2 = w2;
}

/* set the format of float printing for printf.  E.g., %4.3d is obtained with
    setintprintwidths(4,3);
   (default is 7.4)
*/
void setfloatprintwidths(int w1,int w2)
{  flwid1 = w1;
 flwid2 = w2;
}

void setmatdelim(char *leftdelim, char *rightdelim)
{
   strcpy(matleftdelim,leftdelim);
   strcpy(matrightdelim,rightdelim);
}

void setmatrowdelim(char *rowdelim)
{  strcpy(matrowdelim,rowdelim);
}


void setprintnamewnl(int p)
{  matprintnamewnl = p;
}

void setprintnlafter(int p)
{  matprintnlafter = p;
}


/*****************************************************************/
void pprinttofile(FILE *f)
{   fout = f;
}

void pprinttostdout()
{   fout = stdout;
}


/*****************************************************************/
void pvecprint(char *name, void *vec, int n, int type)
{
   switch(type) {
   case TKSCHAR:
      pvecprintsc(name,(signed char *)vec,n);
      break;
   case TKUCHAR:
      pvecprintuc(name,(unsigned char *)vec,n);
      break;
   case TKCHAR:
      pvecprints(name,(char *)vec);
      break;
   case TKSHINT:
      pvecprinthd(name,(short *)vec,n);
      break;
   case TKINT:
      pvecprintd(name,(int *)vec,n);
      break;
   case TKFLOAT:
      pvecprintf(name,(float *)vec,n);
      break;
   case TKDOUBLE:
      pvecprintlf(name,(double *)vec,n);
      break;
   case TKLINT:
      pvecprintld(name,(long *)vec,n);
      break;
   case TKHEX:
      pvecprintx(name,(int *)vec,n);
      break;
   default:
      fprintf(stderr,"undefined type %d\n",type);
   }
}

   
/*****************************************************************/
void pvecprintd(char *name,int *v,int n) 
{
   int i;
   if(fout == NULL) fout = stdout;
   if(strlen(name)) fprintf(fout,"%s\t",name);
   if(v == NULL) {
      fprintf(fout,"(null)\n");
      return;
   }
   fprintf(fout,"%s",matleftdelim);
   for(i = 0; i < n; i++)
      fprintf(fout,"%*.*d\t",intwid1,intwid2,v[i]);
   fprintf(fout,"%s",matrightdelim);
   if(matprintnlafter) fprintf(fout,"\n");
}

/*****************************************************************/
void pvecprintx(char *name,int *v,int n) 
{
   int i;
   if(fout == NULL) fout = stdout;
   if(strlen(name)) fprintf(fout,"%s\t",name);
   if(v == NULL) {
      fprintf(fout,"(null)\n");
      return;
   }
   fprintf(fout,"%s",matleftdelim);
   for(i = 0; i < n; i++)
      fprintf(fout,"%*.*x\t",intwid1,intwid2,v[i]);
   fprintf(fout,"%s",matrightdelim);
   if(matprintnlafter) fprintf(fout,"\n");
}

/*****************************************************************/
void pvecprinthd(char *name,short int *v,int n) 
{
   int i;
   if(fout == NULL) fout = stdout;
   if(strlen(name)) fprintf(fout,"%s\t",name);
   if(v == NULL) {
      fprintf(fout,"(null)\n");
      return;
   }
   fprintf(fout,"%s",matleftdelim);
   for(i = 0; i < n; i++)
      fprintf(fout,"%*.*hd\t",intwid1,intwid2,v[i]);
   fprintf(fout,"%s",matrightdelim);
   if(matprintnlafter) fprintf(fout,"\n");
}


/*****************************************************************/
void pvecprintld(char *name,long int *v,int n) 
{
   int i;
   if(fout == NULL) fout = stdout;
   if(strlen(name)) fprintf(fout,"%s\t",name);
   if(v == NULL) {
      fprintf(fout,"(null)\n");
      return;
   }
   fprintf(fout,"%s",matleftdelim);
   for(i = 0; i < n; i++)
      fprintf(fout,"%*.*ld\t",intwid1,intwid2,v[i]);
   fprintf(fout,"%s",matrightdelim);
   if(matprintnlafter) fprintf(fout,"\n");
}


/*****************************************************************/
void pvecprintsc(char *name,signed char *v,int n) 
{
   int i;
   if(fout == NULL) fout = stdout;
   if(strlen(name)) fprintf(fout,"%s\t",name);
   if(v == NULL) {
      fprintf(fout,"(null)\n");
      return;
   }
   fprintf(fout,"%s",matleftdelim);
   for(i = 0; i < n; i++)
      fprintf(fout,"%*.*d\t",intwid1,intwid2,(int)v[i]);
   fprintf(fout,"%s",matrightdelim);
   if(matprintnlafter) fprintf(fout,"\n");
}


void pvecprintuc(char *name,unsigned char *v,int n) 
{
   int i;
   if(fout == NULL) fout = stdout;
   if(strlen(name)) fprintf(fout,"%s\t",name);
   if(v == NULL) {
      fprintf(fout,"(null)\n");
      return;
   }
   fprintf(fout,"%s",matleftdelim);
   for(i = 0; i < n; i++)
      fprintf(fout,"%*.*ud\t",intwid1,intwid2,(unsigned int)v[i]);
   fprintf(fout,"%s",matrightdelim);
   if(matprintnlafter) fprintf(fout,"\n");
}

void pvecprints(char *name,char *v) 
{
   int i;
   if(fout == NULL) fout = stdout;
   if(strlen(name)) fprintf(fout,"%s\t",name);
   if(v == NULL) {
      fprintf(fout,"(null)\n");
      return;
   }
   fprintf(fout,"%s",v);
   if(matprintnlafter) fprintf(fout,"\n");
}

/*****************************************************************/
void pvecprintf(char *name,float *v,int n) 
{
   int i;
   if(fout == NULL) fout = stdout;
   if(strlen(name)) fprintf(fout,"%s\t",name);
   if(v == NULL) {
      fprintf(fout,"(null)\n");
      return;
   }
   fprintf(fout,"%s",matleftdelim);
   for(i = 0; i < n; i++)
      fprintf(fout,"%*.*g\t",flwid1,flwid2,v[i]);
   fprintf(fout,"%s",matrightdelim);
   if(matprintnlafter) fprintf(fout,"\n");

}


/*****************************************************************/
void pvecprintlf(char *name,double *v,int n) 
{
   int i;
   if(fout == NULL) fout = stdout;
   if(strlen(name)) fprintf(fout,"%s\t",name);
   if(v == NULL) {
      fprintf(fout,"(null)\n");
      return;
   }