Пример #1
0
int main(){vsip_init((void*)0);
{
   FILE *vfptr = fopen("vector.data","r");
   FILE *mfptr = fopen("matrix.data","r");
   vsip_mview_f *B = vsip_mcreate_f(3,5,VSIP_ROW,0);
   vsip_mview_f *R = vsip_mcreate_f(3,5,VSIP_ROW,0);
   vsip_vview_f *a = vsip_vcreate_f(5,0);
   VU_vreadf_f(vfptr,a);
   VU_mreadf_f(mfptr,B);
   fclose(vfptr); fclose(mfptr);
   vsip_vmmul_f(a,B,VSIP_ROW,R);
   printf("a = "); VU_vprintm_f("6.2",a);
   printf("B = "); VU_mprintm_f("6.2",B);
   printf("R = "); VU_mprintm_f("6.2",R);
   { /* test for VSIP_COL */
     vsip_mview_f *BT = vsip_mtransview_f(B);
     vsip_mview_f *RT = vsip_mtransview_f(R);
     vsip_vmmul_f(a,BT,VSIP_COL,RT);
     printf("a = "); VU_vprintm_f("6.2",a);
     printf("BT = "); VU_mprintm_f("6.2",BT);
     printf("RT = "); VU_mprintm_f("6.2",RT);
     vsip_mdestroy_f(BT);
     vsip_mdestroy_f(RT);
   }
   vsip_valldestroy_f(a);
   vsip_malldestroy_f(B);
   vsip_malldestroy_f(R);
   } vsip_finalize((void*)0); return 0;
}
Пример #2
0
void svdFinalize_f(svdObj_f *s)
{
    vsip_vdestroy_f(s->ts);
    vsip_valldestroy_f(s->t);
    vsip_vdestroy_f(s->rs_one);
    vsip_vdestroy_f(s->rs_two);
    vsip_mdestroy_f(s->Rs);
    vsip_vdestroy_f(s->ls_one);
    vsip_vdestroy_f(s->ls_two);
    vsip_mdestroy_f(s->Ls);
    vsip_mdestroy_f(s->Bs);
    vsip_vdestroy_f(s->bs);
    vsip_malldestroy_f(s->B);
    vsip_malldestroy_f(s->R);
    vsip_malldestroy_f(s->L);
    vsip_valldestroy_vi(s->indx_L);
    vsip_valldestroy_vi(s->indx_R);
    vsip_vdestroy_f(s->ds);
    vsip_valldestroy_f(s->d);
    vsip_vdestroy_f(s->fs);
    vsip_valldestroy_f(s->f);
    s=NULL;
}
vsip_mview_f* VU_I_f(vsip_length M)
{
  vsip_mview_f *I = vsip_mcreate_f(M,M,VSIP_ROW,VSIP_MEM_NONE);
  if(I != NULL){
      vsip_vview_f *row = vsip_mrowview_f(I,0);
      if(row != NULL){
          vsip_vputlength_f(row,(vsip_length)(M * M));
          vsip_vfill_f((vsip_scalar_f)0.0,row);
          vsip_vputlength_f(row,M);
          vsip_vputstride_f(row,(vsip_stride) (M + 1));
          vsip_vfill_f((vsip_scalar_f)1.0,row);
          vsip_vdestroy_f(row);
      } else {
          vsip_mdestroy_f(I);
          return (vsip_mview_f*) NULL;
      }
   } else {
      return (vsip_mview_f*) NULL;
   }
   return I;
}
Пример #4
0
int main(){vsip_init((void*)0);
{  int i,j; /* counters */
   vsip_vview_f *windowt = vsip_vcreate_hanning_f(Ns,0);
   vsip_vview_f *windowp = vsip_vcreate_hanning_f(Mp,0);
   vsip_vview_f *kernel = 
         vsip_vcreate_kaiser_f(Nfilter,kaiser,0);
   vsip_fir_f *fir = vsip_fir_create_f(kernel,
                         VSIP_NONSYM,2 * Nn,2,VSIP_STATE_SAVE,0,0);
   vsip_vview_f *t =vsip_vcreate_f(Ns,0); /*time vector*/
   vsip_vview_f *noise[Nnoise];
   vsip_vview_f *nv = vsip_vcreate_f(2 * Nn,0);
   vsip_vview_f *tt = vsip_vcreate_f(Ns,0); 
   vsip_mview_f *data = vsip_mcreate_f(Mp,Ns,VSIP_ROW,0),
                *rmview;
   vsip_vview_f *data_v, *gram_v;
   vsip_cvview_f *gram_data_v;
   vsip_cmview_f *gram_data = 
        vsip_cmcreate_f(Mp,Ns/2 + 1,VSIP_COL,0);
   vsip_mview_f  *gram = 
         vsip_mcreate_f(Mp,Ns/2 + 1,VSIP_ROW,0);
   vsip_mview_f  *Xim = 
         vsip_mcreate_f(Mp,Mp+1,VSIP_ROW,0);
   vsip_scalar_f alpha = (D * Fs) / c;
vsip_vview_f *m = vsip_vcreate_f(Mp,0);
   vsip_vview_f *Xi = vsip_vcreate_f(Mp + 1,0);
   vsip_randstate *state =
          vsip_randcreate(15,1,1,VSIP_PRNG);
   vsip_scalar_f w0 = 2 * M_PI * F0/Fs;
   vsip_scalar_f w1 = 2 * M_PI * F1/Fs;
   vsip_scalar_f w2 = 2 * M_PI * F2/Fs;
   vsip_scalar_f w3 = 2 * M_PI * F3/Fs;
   vsip_scalar_f cnst1 = M_PI/Nnoise;  
   vsip_offset offset0 = (vsip_offset)(alpha * Mp + 1);
   vsip_fftm_f *rcfftmop_obj = /* time fft */
   vsip_rcfftmop_create_f(Mp,Ns,1,VSIP_ROW,0,0);
   vsip_fftm_f *ccfftmip_obj =
         vsip_ccfftmip_create_f(Mp,Ns/2 +
             1,VSIP_FFT_FWD,1,VSIP_COL,0,0);
   vsip_vramp_f(0,1,m);
   vsip_vramp_f(0,M_PI/Mp,Xi); 
   vsip_vcos_f(Xi,Xi);
   vsip_vouter_f(alpha,m,Xi,Xim);
   { vsip_vview_f *gram_v = vsip_mrowview_f(gram,0);
     vsip_vputlength_f(gram_v,Mp*(Ns/2 + 1));
     vsip_vfill_f(0,gram_v);
     vsip_vdestroy_f(gram_v);
   }
   for(j=0; j<Nnoise; j++){
      noise[j] = vsip_vcreate_f(Nn,0);
      vsip_vrandn_f(state,nv);
      vsip_firflt_f(fir,nv,noise[j]);
      vsip_svmul_f(12.0/(Nnoise),noise[j],noise[j]);
      vsip_vputlength_f(noise[j],Ns);
   }
   vsip_vramp_f(0,1.0,t); /* time vector */
for(i=0; i<Mp; i++){
      vsip_scalar_f Xim_val = vsip_mget_f(Xim,i,Theta_o);
      data_v = vsip_mrowview_f(data,i);
      vsip_vsmsa_f(t,w0,-w0 * Xim_val,tt);
      vsip_vcos_f(tt,data_v); /*F0 time series */
      vsip_vsmsa_f(t,w1,-w1 * Xim_val,tt);
      vsip_vcos_f(tt,tt); /*F1 time series */
      vsip_vadd_f(tt,data_v,data_v);
      vsip_vsmsa_f(t,w2,-w2 * Xim_val,tt);
      vsip_vcos_f(tt,tt); /*F2 time series */
      vsip_vadd_f(tt,data_v,data_v);
      vsip_vsmsa_f(t,w3,-w3 * Xim_val,tt);
      vsip_vcos_f(tt,tt); /*F3 time series */
      vsip_svmul_f(3.0,tt,tt); /* scale by 3.0 */
      vsip_vadd_f(tt,data_v,data_v);
      vsip_svmul_f(3,data_v,data_v);
      for(j=0; j<Nnoise; j++){ 
          /* simple time delay beam forming for noise */
         vsip_vputoffset_f(noise[j],offset0 + 
           (int)( i * alpha * cos(j * cnst1)));
         vsip_vadd_f(noise[j],data_v,data_v); 
      } 
      /* need to destroy before going on to next phone */
      vsip_vdestroy_f(data_v);
   }
   /* window the data and the array to reduce sidelobes */
   vsip_vmmul_f(windowt,data,VSIP_ROW,data);
   vsip_vmmul_f(windowp,data,VSIP_COL,data);

   /* do ffts */
   vsip_rcfftmop_f(rcfftmop_obj,data,gram_data);
   vsip_ccfftmip_f(ccfftmip_obj,gram_data);

   { /* scale gram to db, min 0 max 255 */
      vsip_index ind;
      gram_v = vsip_mrowview_f(gram,0);
      gram_data_v = vsip_cmcolview_f(gram_data,0);
      rmview = vsip_mrealview_f(gram_data);
      vsip_vputlength_f(gram_v,Mp*(Ns/2 + 1)); 
      vsip_cvputlength_f(gram_data_v,Mp*(Ns/2 + 1));
data_v = vsip_vrealview_f(gram_data_v);
      vsip_vcmagsq_f(gram_data_v,data_v);
      vsip_mcopy_f_f(rmview,gram);
      vsip_vdestroy_f(data_v);
      vsip_svadd_f(1.0 -
      vsip_vminval_f(gram_v,&ind),gram_v,gram_v);
      vsip_vlog10_f(gram_v,gram_v); 
      vsip_svmul_f(256.0 / vsip_vmaxval_f(gram_v,&ind),
                    gram_v,gram_v);/* scale */
      /* reorganize the data to place zero in the 
          center for direction space */
      data_v = vsip_vcloneview_f(gram_v);
      vsip_vputlength_f(data_v,(Mp/2) * (Ns/2 + 1));
      vsip_vputoffset_f(data_v,(Mp/2) * (Ns/2 + 1));
      vsip_vputlength_f(gram_v,(Mp/2) * (Ns/2 + 1));
      vsip_vswap_f(data_v,gram_v);
      vsip_vdestroy_f(gram_v);
      vsip_vdestroy_f(data_v);
      vsip_cvdestroy_f(gram_data_v);
      vsip_mdestroy_f(rmview);
   }
   VU_mprintgram_f(gram,"gram_output");
   } vsip_finalize((void*)0); return 0;        
}
Пример #5
0
int
main(int argc, char **argv)
{
  size_t i, j;

  vsip_init(0);

  vsip_scalar_f data[27] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
                            16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26};
  vsip_block_f *block = vsip_blockbind_f(data, 27, VSIP_MEM_NONE);
  vsip_blockadmit_f(block, 1);
  vsip_tview_f *src = vsip_tbind_f(block, 0, 9, 3, 3, 3, 1, 3);

  vsip_tview_f *dest1 = vsip_tcreate_f(3, 3, 3, VSIP_TRAILING, VSIP_MEM_NONE);
  vsip_tview_f *dest2 = vsip_tcreate_f(3, 3, 3, VSIP_LEADING, VSIP_MEM_NONE);

  vsip_mview_f *plane_yx = vsip_tmatrixview_f(src, VSIP_TMYX, 1);
  vsip_mview_f *plane_zx = vsip_tmatrixview_f(src, VSIP_TMZX, 1);
  vsip_mview_f *plane_zy = vsip_tmatrixview_f(src, VSIP_TMZY, 1);

  vsip_tcopy_f_f(src, dest1);
  test_assert(tequal_f(src, dest1));

  vsip_tcopy_f_f(src, dest2);
  test_assert(tequal_f(src, dest2));

#if DEBUG
  printf("source:\n");
  toutput_f(src);
  printf("\n");

  printf("dest1:\n");
  toutput_f(dest1);
  printf("\n");

  printf("dest2:\n");
  toutput_f(dest2);
  printf("\n");

  printf("yx plane:\n");
  moutput_f(plane_yx);
  printf("\n");

  printf("zx plane:\n");
  moutput_f(plane_zx);
  printf("\n");

  printf("zy plane:\n");
  moutput_f(plane_zy);
  printf("\n");

#endif

  vsip_mdestroy_f(plane_yx);
  vsip_mdestroy_f(plane_zx);
  vsip_mdestroy_f(plane_zy);
  vsip_talldestroy_f(dest2);
  vsip_talldestroy_f(dest1);
  vsip_talldestroy_f(src);

  vsip_finalize(0);
  return 0;
};
Пример #6
0
int main(){vsip_init((void*)0);
{
    vsip_mview_f *Adummy  = vsip_mcreate_f(5*NN,5*NN,VSIP_COL,0);
    vsip_mview_f *A = vsip_msubview_f(Adummy,3,2,NN,NN);
    vsip_vview_f *x0 = vsip_vcreate_f(NN,0);
    vsip_mview_f *X  = vsip_mcreate_f(NN,3,VSIP_ROW,0);
    vsip_mview_f *XT  = vsip_mcreate_f(NN,3,VSIP_COL,0);
    vsip_mputrowstride_f(A,2*vsip_mgetrowstride_f(A));
    vsip_mputcolstride_f(A,3*vsip_mgetcolstride_f(A));

    /* matrix data */
    vsip_mput_f(A,0,0,0.5); vsip_mput_f(A,0,1,7); vsip_mput_f(A,0,2,10); vsip_mput_f(A,0,3,12);
    vsip_mput_f(A,0,4,-3); vsip_mput_f(A,0,5,0); vsip_mput_f(A,0,6,.05);

    vsip_mput_f(A,1,0,2); vsip_mput_f(A,1,1,13); vsip_mput_f(A,1,2,18); vsip_mput_f(A,1,3,6);
    vsip_mput_f(A,1,4,0); vsip_mput_f(A,1,5,130); vsip_mput_f(A,1,6,8);

    vsip_mput_f(A,2,0,3); vsip_mput_f(A,2,1,-9); vsip_mput_f(A,2,2,2); vsip_mput_f(A,2,3,3);
    vsip_mput_f(A,2,4,2); vsip_mput_f(A,2,5,-9); vsip_mput_f(A,2,6,6);

    vsip_mput_f(A,3,0,4); vsip_mput_f(A,3,1,2); vsip_mput_f(A,3,2,2); vsip_mput_f(A,3,3,4);
    vsip_mput_f(A,3,4,1); vsip_mput_f(A,3,5,2); vsip_mput_f(A,3,6,3);

    vsip_mput_f(A,4,0,.2); vsip_mput_f(A,4,1,2); vsip_mput_f(A,4,2,9); vsip_mput_f(A,4,3,4);
    vsip_mput_f(A,4,4,1); vsip_mput_f(A,4,5,2); vsip_mput_f(A,4,6,3);

    vsip_mput_f(A,5,0,.1); vsip_mput_f(A,5,1,2); vsip_mput_f(A,5,2,.3); vsip_mput_f(A,5,3,4);
    vsip_mput_f(A,5,4,1); vsip_mput_f(A,5,5,2); vsip_mput_f(A,5,6,3);

    vsip_mput_f(A,6,0,.01); vsip_mput_f(A,6,1,.2); vsip_mput_f(A,6,2,3); vsip_mput_f(A,6,3,4);
    vsip_mput_f(A,6,4,1); vsip_mput_f(A,6,5,2); vsip_mput_f(A,6,6,3);

    {int i,j; printf("A = [\n"); for(i=0; i<NN; i++){
                  for(j=0; j<NN; j++) printf("%9.2f%s",vsip_mget_f(A,i,j),(j == NN-1) ? "":",");
                  printf(";\n");
              }
              printf("]\n");
    }
    { /* were solving for NTRANS Ax = B */
      /* use a known X, calculate B using Ax */
      int k; 
      vsip_vview_f *x;
      vsip_mview_f *AT = vsip_mtransview_f(A);
      vsip_length L    = vsip_mgetrowlength_f(X);
      vsip_vramp_f(1,1,x0);
      for(k=0; k<L; k++){
        x  = vsip_mcolview_f(X,k);
        vsip_mvprod_f(A,x0,x);
        vsip_svmul_f(2.0,x0,x0);
        vsip_vdestroy_f(x);
      }
      vsip_vramp_f(1,1,x0);
      for(k=0; k<L; k++){
        x  = vsip_mcolview_f(XT,k);
        vsip_mvprod_f(AT,x0,x);
        vsip_svmul_f(2.0,x0,x0);
        vsip_vdestroy_f(x);
      }
      vsip_mdestroy_f(AT);
      printf("X = 1  2  4\n    2  4  8\n    3  6 12\n    4  8 16\n    5 10 20\n    6 12 24\n    7 14 28\n");
      { 
         int i,j; printf("B = [\n");for(i=0; i<NN; i++){
                    for(j=0; j<3; j++) printf("%9.2f%s",vsip_mget_f(X,i,j),(j == 2) ? "":",");
                    printf(";\n");
                }
                printf("]\n");
      }
      {
        /* then solve for B to see if we get X back */
        vsip_lu_f* luAop = vsip_lud_create_f(NN);
        if(luAop == NULL) exit(1);
        vsip_lud_f(luAop,A);
        {  vsip_lu_attr_f attr;
           vsip_lud_getattr_f(luAop,&attr);
           printf("lud size %lu\n",attr.n);
        }  
        vsip_lusol_f(luAop,VSIP_MAT_NTRANS,X);
        vsip_lusol_f(luAop,VSIP_MAT_TRANS,XT);
        vsip_lud_destroy_f(luAop);
      }
    }
    {int i,j; printf("A\\X\n"); for(i=0; i<NN; i++){
                  for(j=0; j<3; j++) printf("%9.2f%s",vsip_mget_f(X,i,j),(j == 2) ? "":",");
                  printf(";\n");
              }
    }
    {int i,j; printf("A'\\X\n"); for(i=0; i<NN; i++){
                  for(j=0; j<3; j++) printf("%9.2f%s",vsip_mget_f(XT,i,j),(j == 2) ? "":",");
                  printf(";\n");
              }
    }
    {
       vsip_malldestroy_f(XT);
       vsip_valldestroy_f(x0);
       vsip_malldestroy_f(X);
       vsip_mdestroy_f(A);
       vsip_malldestroy_f(Adummy);
    }
    } vsip_finalize((void*)0); return 1;
}
Пример #7
0
int main(){
   int init = vsip_init((void*)0);
   int i,j, cholsol_retval,chold_retval;
   double t0 = VU_ansi_c_clock(); /* for doing some timeing */
   vsip_cscalar_f czero = vsip_cmplx_f((vsip_scalar_f)0.0,(vsip_scalar_f)0.0);
   vsip_cmview_f *A  = vsip_cmcreate_f(N,N,VSIP_COL,0);
   vsip_cmview_f *RU  = vsip_cmcreate_f(N,N,VSIP_COL,0);
   vsip_cmview_f *RL  = vsip_cmcreate_f(N,N,VSIP_COL,0);
   vsip_cmview_f *XB  = vsip_cmcreate_f(N,M,VSIP_ROW,0);
   vsip_cchol_f* chol = vsip_cchold_create_f(UPORLO,N);   /* NOTE: UPORLO macro above main() */

   /* to make sure we have a valid Positive Symetric define */
   /* an upper triangular (RU) with positive pivots and     */
   /* zero below the main diagonal.                         */
   /* Then initialize RL with hermitian of RU               */
   /* finally create A as the matrix product of RL and RU   */

   /* Initialise matrix RU  */
   /* time this             */
   t0 = VU_ansi_c_clock();
   for (i=0; i<N; i++){
      for(j = i; j < N; j++){
         #ifdef OBNOXIOUS
         /* make up some reasonably obnoxious data                */
         vsip_scalar_f a = cos(1.5/((j+1)*(i+1)))+sqrt(i*j);
         vsip_scalar_f b = (i + j + 1) * cos(M_PI * a);
         #else
         /* the above was to obnoxious for bigger than about N = 10 */
         /* the following works for N > 100 */
         vsip_scalar_f a = 1; vsip_scalar_f b = 1; 
         #endif
         if(i == j) /* fill diagonal */
             vsip_cmput_f(RU,i,j, vsip_cmplx_f(sqrt(N) + sqrt(i),0));
         else { /* fill off diagonal */
                vsip_cmput_f(RU,i,j,vsip_cmplx_f(b,a)); 
                vsip_cmput_f(RU,j,i,czero); 
         }
      }
   }
   /* initialize RL */
   vsip_cmherm_f(RU,RL);
   #ifdef PRINT
      VU_cmprintm_f("7.4",RU);
      VU_cmprintm_f("7.4",RL);
   #endif
   printf("Matrix initialize for RU and RL = %f seconds\n",VU_ansi_c_clock() - t0);

   /* initialize A */
   /* this step will take a long time so time it */
   t0 = VU_ansi_c_clock();
   vsip_cmprod_f(RL,RU,A);
   #ifdef OBNOXIOUS
      for(i=0; i<N; i++){
         vsip_cvview_f *aview = vsip_cmrowview_f(A,i);
         vsip_cvrsdiv_f(aview,vsip_cmag_f(vsip_cvmeanval_f(aview)),aview);
         vsip_cvdestroy_f(aview);
      }
   #endif
   printf("Matrix multiply for initialization of A = %f seconds\n",VU_ansi_c_clock() - t0);

   /* print  A                                                      */
   /* we only want to do this if A is something reasonable to print */
   /* selected as an option in the make file                        */
   #ifdef PRINT
      printf("Matrix A =\n");
      VU_cmprintm_f("4.2",A);
      fflush(stdout);
   #endif

   /* initialise rhs                      */
   /* start out with XB = {1,2,3,...,M}   */
   /* calculate what B must be using A    */
   /* then solve to see if we get XB back */
   {  vsip_index i;
      vsip_vview_f *y = vsip_vcreate_f(vsip_cmgetcollength_f(A),VSIP_MEM_NONE);
      vsip_vview_f *x_r,*x_i;
      vsip_cvview_f *x;
      vsip_mview_f *A_r = vsip_mrealview_f(A),
                   *A_i = vsip_mimagview_f(A);
      /* time this */
      t0 = VU_ansi_c_clock();
      for(i=0; i<M; i++){
         vsip_vfill_f((vsip_scalar_f)i+1.0,y);
         x = vsip_cmcolview_f(XB,i);
         x_r = vsip_vrealview_f(x);
         x_i = vsip_vimagview_f(x);
         vsip_mvprod_f(A_r,y,x_r);
         vsip_mvprod_f(A_i,y,x_i);
         vsip_cvdestroy_f(x);
         vsip_vdestroy_f(x_r);
         vsip_vdestroy_f(x_i);
      }
      vsip_mdestroy_f(A_r);
      vsip_mdestroy_f(A_i);
      printf("Matrix init for B = %f seconds\n",VU_ansi_c_clock() - t0);
   }

   /* print  XB                                                      */
   /* we only want to do this if XB is something reasonable to print */
   /* selected as an option in the make file                         */
   #ifdef PRINT
      printf("Matrix B = \n");
      VU_cmprintm_f("7.4",XB);
      fflush(stdout);
   #endif

   if(chol != NULL){
      t0 = VU_ansi_c_clock(); /* we want to time the decomposition */
      chold_retval = vsip_cchold_f(chol,A);
      printf("time decomp %f\n",VU_ansi_c_clock() - t0);
      printf("decompostion returns %d\n",chold_retval);
   
      /* now do the solution */
      t0 = VU_ansi_c_clock(); /* we want to time the solution */
      cholsol_retval=vsip_ccholsol_f(chol,XB);
      printf("time solution %f\n",VU_ansi_c_clock() - t0);
      printf("cholsol returns %d\n",cholsol_retval);

      /* print  XB                                                      */
      /* we only want to do this if XB is something reasonable to print */
      /* selected as an option in the make file; otherwise              */
      /* we print a single row of XB if the matrix is to large since    */
      /* M is usally reasonable. Printed as a column vector             */
      #ifdef PRINT
         printf("Matrix X = \n");
         VU_cmprintm_f("7.4",XB);
         fflush(stdout);
      #else
         {  /* pick a row in the middle */
            vsip_cvview_f *x = vsip_cmrowview_f(XB,N/2);
            printf("This output sould be 1,2,...,M\n");
            VU_cvprintm_f("7.4",x);
            fflush(stdout);
            vsip_cvdestroy_f(x);
         }
      #endif
   } else {
         printf("failed to create cholesky object \n");
   }
   vsip_cmalldestroy_f(XB);
   vsip_cmalldestroy_f(A);
   vsip_cmalldestroy_f(RL);
   vsip_cmalldestroy_f(RU);
   vsip_cchold_destroy_f(chol);
   vsip_finalize((void*)0);
   return 1;
}