Diff of /src/goertzel.c [dbf0ef] .. [6db11f]  Maximize  Restore

Switch to unified view

a/src/goertzel.c b/src/goertzel.c
...
...
14
#ifndef PI
14
#ifndef PI
15
#   define PI 3.141592653589793
15
#   define PI 3.141592653589793
16
#endif
16
#endif
17
17
18
18
19
LTFAT_EXTERN
20
LTFAT_NAME(gga_plan) LTFAT_NAME(create_gga_plan)(const double *indVecPtr, const size_t M, const size_t L)
21
{
22
LTFAT_REAL* cos_term = (LTFAT_REAL*) ltfat_malloc(M*sizeof(LTFAT_REAL));
23
LTFAT_COMPLEXH* cc_term = (LTFAT_COMPLEXH*) ltfat_malloc(M*sizeof(LTFAT_COMPLEXH));
24
LTFAT_COMPLEXH* cc2_term = (LTFAT_COMPLEXH*) ltfat_malloc(M*sizeof(LTFAT_COMPLEXH));
25
26
LTFAT_REAL pik_term_pre = (LTFAT_REAL) (2.0*PI/((double) L));
27
LTFAT_REAL _Complex cc2_pre = (LTFAT_REAL _Complex) (-1.0*I*((double)(L-1)));
28
LTFAT_REAL _Complex cc_pre =  (LTFAT_REAL _Complex) (-1.0*I*((double)(L)));
29
30
for(size_t m=0;m<M;m++)
31
{
32
   LTFAT_REAL pik_term = pik_term_pre*indVecPtr[m];
33
   cos_term[m] = (LTFAT_REAL) cos(pik_term)*2.0;
34
   cc_term[m] = (LTFAT_COMPLEXH) cexp(cc_pre*pik_term);
35
   cc2_term[m] = (LTFAT_COMPLEXH) cexp(cc2_pre*pik_term);
36
}
37
38
39
LTFAT_NAME(gga_plan) plan = {.cos_term=cos_term,.cc_term=cc_term,.cc2_term=cc2_term,.M=M,.L=L};
40
return plan;
41
}
42
43
LTFAT_EXTERN
44
void LTFAT_NAME(destroy_gga_plan)(LTFAT_NAME(gga_plan) plan)
45
{
46
   ltfat_free(plan.cos_term);
47
   ltfat_free(plan.cc_term);
48
   ltfat_free(plan.cc2_term);
49
}
50
51
52
LTFAT_EXTERN
53
void LTFAT_NAME(gga_with_plan)(LTFAT_NAME(gga_plan) p,
54
                               const LTFAT_TYPE *fPtr,
55
                               LTFAT_COMPLEXH *cPtr,
56
                               const size_t W )
57
{
58
#ifndef GGA_UNROLL
59
60
for(int w=0;w<W;w++)
61
{
62
LTFAT_COMPLEXH *cPtrTmp = (LTFAT_COMPLEXH*) cPtr+w*p.M;
63
64
for(int m=0;m<p.M;m++)
65
{
66
      LTFAT_TYPE s0 =  0.0;
67
      LTFAT_TYPE s1 =  0.0;
68
      LTFAT_TYPE s2 =  0.0;
69
      LTFAT_TYPE *fPtrTmp = (LTFAT_TYPE*) fPtr+w*p.L;
70
71
      for(int ii=0;ii<p.L-1;ii++)
72
      {
73
         s0 = *fPtrTmp++ + p.cos_term[m]*s1 - s2;
74
         s2=s1;
75
         s1=s0;
76
      }
77
      s0 = *fPtrTmp + p.cos_term[m]*s1 - s2;
78
79
      *cPtrTmp++ = (s0*p.cc2_term[m] - s1*p.cc_term[m]);
80
   }
81
}
82
#else
83
for(int w=0;w<W;w++)
84
{
85
   LTFAT_COMPLEXH *cPtrTmp = (LTFAT_COMPLEXH*) cPtr+w*p.M;
86
   int unrollRem = p.M%GGA_UNROLL;
87
88
   const LTFAT_REAL* cos_term = p.cos_term;
89
   const LTFAT_COMPLEXH* cc_term = p.cc_term;
90
   const LTFAT_COMPLEXH* cc2_term = p.cc2_term;
91
//#pragma omp parallel for
92
   for(int m=0;m<p.M-unrollRem;m+=GGA_UNROLL)
93
   {
94
      LTFAT_TYPE s0[GGA_UNROLL];
95
      LTFAT_TYPE s1[GGA_UNROLL];
96
      LTFAT_TYPE s2[GGA_UNROLL];
97
98
      for(int un=0;un<GGA_UNROLL;un++)
99
      {
100
         s0[un] = 0.0;
101
         s1[un] = 0.0;
102
         s2[un] = 0.0;
103
      }
104
105
      LTFAT_TYPE *fPtrTmp = (LTFAT_TYPE*) fPtr+w*p.L;
106
107
      for(int ii=0;ii<p.L-1;ii++)
108
      {
109
         for(int un=0;un<GGA_UNROLL;un++)
110
         {
111
            s0[un] = *fPtrTmp + cos_term[un]*s1[un] - s2[un];
112
            s2[un]=s1[un];
113
            s1[un]=s0[un];
114
         }
115
         fPtrTmp++;
116
      }
117
      for(int un=0;un<GGA_UNROLL;un++)
118
      {
119
         s0[un] = *fPtrTmp + cos_term[un]*s1[un] - s2[un];
120
         cPtrTmp[m+un] = (s0[un]*cc2_term[un] - s1[un]*cc_term[un]);
121
      }
122
      cos_term+=GGA_UNROLL;
123
      cc_term+=GGA_UNROLL;
124
      cc2_term+=GGA_UNROLL;
125
   }
126
127
   int m= p.M-unrollRem;
128
129
130
      LTFAT_TYPE s0[GGA_UNROLL];
131
      LTFAT_TYPE s1[GGA_UNROLL];
132
      LTFAT_TYPE s2[GGA_UNROLL];
133
134
   for(int un=0;un<unrollRem;un++)
135
   {
136
       s0[un] = 0.0;
137
       s1[un] = 0.0;
138
       s2[un] = 0.0;
139
   }
140
141
      LTFAT_TYPE *fPtrTmp = (LTFAT_TYPE*) fPtr+w*p.L;
142
143
      for(int ii=0;ii<p.L-1;ii++)
144
      {
145
         for(int un=0;un<unrollRem;un++)
146
         {
147
            s0[un] = *fPtrTmp + cos_term[un]*s1[un] - s2[un];
148
            s2[un]=s1[un];
149
            s1[un]=s0[un];
150
         }
151
         fPtrTmp++;
152
      }
153
154
      for(int un=0;un<unrollRem;un++)
155
      {
156
         s0[un] = *fPtrTmp + cos_term[un]*s1[un] - s2[un];
157
         cPtrTmp[m+un] = (s0[un]*cc2_term[un] - s1[un]*cc_term[un]);
158
      }
159
160
}
161
#endif
162
}
163
164
19
165
20
LTFAT_EXTERN
166
LTFAT_EXTERN
21
void LTFAT_NAME(gga)(const LTFAT_TYPE *fPtr, const double *indVecPtr,
167
void LTFAT_NAME(gga)(const LTFAT_TYPE *fPtr, const double *indVecPtr,
22
                const int L, const int W, const int M, LTFAT_COMPLEXH *cPtr)
168
                const size_t L, const size_t W, const size_t M, LTFAT_COMPLEXH *cPtr)
23
{
169
{
24
170
25
double pik_term_pre = 2.0*PI/((double) L);
171
double pik_term_pre = 2.0*PI/((double) L);
26
double _Complex cc2_pre = -1.0*I*((double)(L-1));
172
double _Complex cc2_pre = -1.0*I*((double)(L-1));
27
double _Complex cc_pre = -1.0*I*((double)(L));
173
double _Complex cc_pre = -1.0*I*((double)(L));
...
...
149
#endif
295
#endif
150
296
151
297
152
}
298
}
153
299
300
301
302
LTFAT_EXTERN
303
void LTFAT_NAME(chzt)(const LTFAT_TYPE *fPtr, const size_t L, const size_t W, const size_t K,
304
                      const double deltao, const double o, LTFAT_COMPLEXH *cPtr)
305
{
306
LTFAT_NAME(chzt_plan) p = LTFAT_NAME(create_chzt_plan)(K,L,deltao, o,FFTW_ESTIMATE,CZT_NEXTFASTFFT);
307
308
LTFAT_NAME(chzt_with_plan)(p, fPtr, W,deltao, o, cPtr);
309
310
LTFAT_NAME(destroy_chzt_plan)(p);
311
}
312
313
314
LTFAT_EXTERN
315
void LTFAT_NAME(chzt_with_plan)(LTFAT_NAME(chzt_plan) p, const LTFAT_TYPE *fPtr, const size_t W,
316
                        const double deltao, const double o, LTFAT_COMPLEXH *cPtr)
317
{
318
319
    size_t L = p.L;
320
    size_t K = p.K;
321
    size_t Lfft = p.Lfft;
322
    LTFAT_COMPLEXH* fbuffer = p.fbuffer;
323
    LTFAT_FFTW(plan) plan_f = p.plan;
324
    LTFAT_FFTW(plan) plan_fi = p.plan2;
325
    LTFAT_COMPLEXH* W2 = p.W2;
326
    LTFAT_COMPLEXH* Wo = p.Wo;
327
    LTFAT_COMPLEXH* chirpF = p.chirpF;
328
329
330
    // Temporal storage of the post chirp as a last channel of the output
331
    //LTFAT_COMPLEXH *cPtrLast = cPtr+K*(W-1);
332
    //memcpy(cPtrLast,W2,K*sizeof(LTFAT_COMPLEXH));
333
334
    for(size_t w = 0;w<W;w++)
335
    {
336
       memset(fbuffer,0,Lfft*sizeof(LTFAT_COMPLEXH));
337
       LTFAT_NAME(array2complex)(fPtr+w*L,fbuffer,L);
338
339
       //1) Premultiply by a chirp
340
341
       for(size_t ii=0;ii<L;ii++)
342
       {
343
           fbuffer[ii]*=Wo[ii];
344
       }
345
346
       // 2) FFT of input
347
       LTFAT_FFTW(execute)(plan_f);
348
349
/*
350
       LTFAT_NAME_COMPLEX(conjugate_array)(W2,W2,L);
351
       LTFAT_NAME_COMPLEX(reverse_array)(W2,W2,L);
352
       memcpy(W2+L,cPtrLast+1,(K-1)*sizeof(LTFAT_COMPLEXH));
353
       LTFAT_NAME_COMPLEX(conjugate_array)(W2+L,W2+L,K-1);
354
355
       // FFT of the chirp filter
356
       LTFAT_FFTW(execute_dft)(plan_f,W2,W2);
357
*/
358
       // Frequency domain filtering
359
       for(size_t ii=0;ii<Lfft;ii++)
360
       {
361
           fbuffer[ii]*=chirpF[ii];
362
       }
363
364
365
       // Inverse FFT using forward FFT plan
366
       LTFAT_COMPLEXH *fPtrTmp = fbuffer;
367
       //LTFAT_NAME_COMPLEX(conjugate_array)(fbuffer,fbuffer,Lfft);
368
       LTFAT_FFTW(execute)(plan_fi);
369
       //LTFAT_NAME_COMPLEX(conjugate_array)(fPtrTmp,fPtrTmp,K);
370
371
372
       // Final chirp multiplication and normalization
373
       LTFAT_COMPLEXH *cPtrTmp = cPtr + w*K;
374
       for(size_t ii=0;ii<K;ii++)
375
       {
376
           cPtrTmp[ii]=fPtrTmp[ii]*W2[ii];
377
       }
378
379
    }
380
381
}
382
383
LTFAT_EXTERN
384
LTFAT_NAME(chzt_plan) LTFAT_NAME(create_chzt_plan)(const size_t K, size_t L, const double deltao, const double o, const unsigned fftw_flags, const unsigned czt_flags)
385
{
386
    size_t Lfft = L+K-1;
387
388
    if(czt_flags == 0)
389
     Lfft = nextPow2_st(Lfft);
390
    else
391
     Lfft = nextfastfft(Lfft);
392
393
    LTFAT_COMPLEXH* fbuffer = ltfat_malloc(Lfft*sizeof(LTFAT_COMPLEXH));
394
    LTFAT_FFTW(plan) plan_f =  LTFAT_FFTW(plan_dft_1d)(Lfft, (LTFAT_COMPLEX*)fbuffer, (LTFAT_COMPLEX*) fbuffer,
395
                                                       FFTW_FORWARD, fftw_flags);
396
        LTFAT_FFTW(plan) plan_fi =  LTFAT_FFTW(plan_dft_1d)(Lfft, (LTFAT_COMPLEX*)fbuffer, (LTFAT_COMPLEX*) fbuffer,
397
                                                       FFTW_BACKWARD, fftw_flags);
398
399
    // Pre and post chirp
400
    size_t N = L>K?L:K;
401
    LTFAT_COMPLEXH* W2 = ltfat_malloc(Lfft*sizeof(LTFAT_COMPLEXH));
402
    LTFAT_COMPLEXH* chirpF = ltfat_malloc(Lfft*sizeof(LTFAT_COMPLEXH));
403
    LTFAT_COMPLEXH* Wo = ltfat_malloc(L*sizeof(LTFAT_COMPLEXH));
404
405
406
    for(size_t ii=0;ii<N;ii++)
407
    {
408
        W2[ii] = (LTFAT_COMPLEXH) cexp(-1.0*I*deltao*ii*ii/2.0);
409
    }
410
411
    for(size_t ii=0;ii<L;ii++)
412
    {
413
        Wo[ii] = (LTFAT_COMPLEXH) cexp(-1.0*I*o*ii)*W2[ii];
414
    }
415
    // Set the rest to zero
416
    memset(W2+N,0,(Lfft-N)*sizeof(LTFAT_COMPLEXH));
417
418
    LTFAT_NAME_COMPLEX(conjugate_array)(W2,chirpF,K);
419
    //LTFAT_NAME_COMPLEX(reverse_array)(chirpF,chirpF,L);
420
    // memcpy(chirpF+Lfft-L,W2+1,(K-1)*sizeof(LTFAT_COMPLEXH));
421
    //LTFAT_NAME_COMPLEX(conjugate_array)(chirpF+L,chirpF+L,K-1);
422
    LTFAT_NAME_COMPLEX(conjugate_array)(W2+1,chirpF+Lfft-L+1,L-1);
423
    LTFAT_NAME_COMPLEX(reverse_array)(chirpF+Lfft-L+1,chirpF+Lfft-L+1,L-1);
424
    memset(chirpF+K,0,(Lfft-(L+K-1))*sizeof(LTFAT_COMPLEXH));
425
426
    LTFAT_FFTW(execute_dft)(plan_f,chirpF,chirpF);
427
428
429
    for(size_t ii=0;ii<K;ii++)
430
    {
431
        W2[ii] = (LTFAT_COMPLEXH) cexp(-1.0*I*deltao*ii*ii/2.0)/((LTFAT_REAL) Lfft);
432
    }
433
434
435
436
    /*
437
    We could have shrinked the W2 to length K here.
438
    */
439
    LTFAT_NAME(chzt_plan) p = {.fbuffer = fbuffer, .plan=plan_f,.plan2=plan_fi,.L=L,
440
                               .K=K, .W2 = W2, .Wo=Wo,.chirpF=chirpF,.Lfft=Lfft};
441
    return  p;
442
}
443
444
LTFAT_EXTERN
445
void LTFAT_NAME(destroy_chzt_plan)(LTFAT_NAME(chzt_plan) p)
446
{
447
   ltfat_free(p.fbuffer);
448
   ltfat_free(p.W2);
449
   ltfat_free(p.Wo);
450
   ltfat_free(p.chirpF);
451
   LTFAT_FFTW(destroy_plan)(p.plan);
452
   LTFAT_FFTW(destroy_plan)(p.plan2);
453
}
454
455
456
457
458
LTFAT_EXTERN
459
void LTFAT_NAME(chzt_fact)(const LTFAT_TYPE *fPtr, const size_t L, const size_t W, const size_t K,
460
                        const double deltao, const double o, LTFAT_COMPLEXH *cPtr)
461
{
462
LTFAT_NAME(chzt_plan) p = LTFAT_NAME(create_chzt_plan_fact)(K,L,deltao, o,FFTW_ESTIMATE, CZT_NEXTFASTFFT);
463
464
LTFAT_NAME(chzt_with_plan_fact)(p, fPtr, W,deltao, o, cPtr);
465
466
LTFAT_NAME(destroy_chzt_plan)(p);
467
}
468
469
LTFAT_EXTERN
470
void LTFAT_NAME(chzt_with_plan_fact)(LTFAT_NAME(chzt_plan) p, const LTFAT_TYPE *fPtr, const size_t W,
471
                        const double deltao, const double o, LTFAT_COMPLEXH *cPtr)
472
{
473
    size_t L = p.L;
474
    size_t K = p.K;
475
    size_t Lfft = p.Lfft;
476
    LTFAT_COMPLEXH* fbuffer = p.fbuffer;
477
    LTFAT_FFTW(plan) plan_f = p.plan;
478
    LTFAT_FFTW(plan) plan_fi = p.plan2;
479
    LTFAT_COMPLEXH* W2 = p.W2;
480
    LTFAT_COMPLEXH* Wo = p.Wo;
481
    LTFAT_COMPLEXH* chirpF = p.chirpF;
482
483
    LTFAT_COMPLEXH* fBufTmp;
484
    size_t q = (size_t) ceil(((double)L)/((double)K));
485
486
    size_t lastK = (L/q);
487
488
    for(size_t w = 0;w<W;w++)
489
    {
490
      // *********************************
491
      // 1) Read and reorganize input data
492
      // *********************************
493
       memset(fbuffer,0,q*Lfft*sizeof(LTFAT_COMPLEXH));
494
       LTFAT_TYPE* fPtrTmp = fPtr + w*L;
495
496
       for(size_t k=0;k<lastK;k++)
497
       {
498
          LTFAT_TYPE* fTmp = fPtrTmp + k*q;
499
          fBufTmp = fbuffer + k;
500
          for(size_t jj=0;jj<q;jj++)
501
          {
502
            *fBufTmp = (LTFAT_COMPLEXH) fTmp[jj];
503
            fBufTmp+=Lfft;
504
          }
505
       }
506
507
       LTFAT_TYPE* fTmp = fPtrTmp + lastK*q;
508
       fBufTmp = fbuffer + lastK;
509
       for(size_t jj=0;jj<L-lastK*q;jj++)
510
       {
511
         *fBufTmp = (LTFAT_COMPLEXH) fTmp[jj];
512
         fBufTmp+=Lfft;
513
       }
514
515
      // *********************************
516
      // 2) Premultiply
517
      // *********************************
518
519
       fBufTmp = fbuffer;
520
       for(size_t jj=0;jj<q;jj++)
521
       {
522
          for(size_t k=0;k<K;k++)
523
          {
524
             fBufTmp[k]*=W2[k];
525
          }
526
          fBufTmp+=Lfft;
527
       }
528
529
      // *********************************
530
      // 3) q ffts of length Lfft
531
      // *********************************
532
       LTFAT_FFTW(execute)(plan_f);
533
534
      // *********************************
535
      // 4) Filter
536
      // *********************************
537
       fBufTmp = fbuffer;
538
       // Frequency domain filtering
539
       for(size_t jj=0;jj<q;jj++)
540
       {
541
          for(size_t ii=0;ii<Lfft;ii++)
542
          {
543
             fBufTmp[ii]*=chirpF[ii];
544
          }
545
          fBufTmp+=Lfft;
546
       }
547
548
      // *********************************
549
      // 5) q iffts of length Lfft
550
      // *********************************
551
       LTFAT_FFTW(execute)(plan_fi);
552
553
554
      // *********************************
555
      // 6) Postmultiply
556
      // *********************************
557
       fBufTmp = fbuffer;
558
       LTFAT_COMPLEXH* Wotmp = Wo;
559
       for(size_t jj=0;jj<q;jj++)
560
       {
561
          for(size_t k=0;k<K;k++)
562
          {
563
             fBufTmp[k]*=Wotmp[k];
564
          }
565
          fBufTmp+=Lfft;
566
          Wotmp+=K;
567
       }
568
569
      // *********************************
570
      // 7) Sum cols
571
      // *********************************
572
       LTFAT_COMPLEXH *cPtrTmp = cPtr + w*K;
573
       for(size_t k=0;k<K;k++)
574
       {
575
           fBufTmp = fbuffer + k;
576
           cPtrTmp[k] = (LTFAT_COMPLEXH) 0.0;
577
           for(size_t jj=0;jj<q;jj++)
578
           {
579
              cPtrTmp[k]+= *fBufTmp;
580
              fBufTmp+=Lfft;
581
           }
582
       }
583
584
    }
585
}
586
587
LTFAT_EXTERN
588
LTFAT_NAME(chzt_plan) LTFAT_NAME(create_chzt_plan_fact)(const size_t K, const size_t L, const double deltao, const double o, const unsigned fftw_flags, const unsigned czt_flags)
589
{
590
591
    size_t Lfft=2*K-1;
592
    if(czt_flags == 0)
593
     Lfft = nextPow2_st(Lfft);
594
    else
595
     Lfft = nextfastfft(Lfft);
596
597
    size_t q = (size_t) ceil(((double)L)/((double)K));
598
599
    LTFAT_COMPLEXH* fbuffer = ltfat_malloc(q*Lfft*sizeof(LTFAT_COMPLEXH));
600
601
    const LTFAT_FFTW(iodim) dims = {.n = Lfft, .is = 1, .os = 1};
602
    const LTFAT_FFTW(iodim) howmany_dims = {.n = q,.is = Lfft, .os = Lfft};
603
    LTFAT_FFTW(plan) plan_f =  LTFAT_FFTW(plan_guru_dft)(1, &dims, 1, &howmany_dims,
604
                                                         (LTFAT_COMPLEX*)fbuffer, (LTFAT_COMPLEX*) fbuffer,
605
                                                         FFTW_FORWARD, fftw_flags);
606
607
    LTFAT_FFTW(plan) plan_fi =  LTFAT_FFTW(plan_guru_dft)(1, &dims, 1, &howmany_dims,
608
                                                         (LTFAT_COMPLEX*)fbuffer, (LTFAT_COMPLEX*) fbuffer,
609
                                                         FFTW_BACKWARD, fftw_flags);
610
611
    LTFAT_COMPLEXH* W2 = ltfat_malloc(K*sizeof(LTFAT_COMPLEXH));
612
    LTFAT_COMPLEXH* chirpF = ltfat_malloc(Lfft*sizeof(LTFAT_COMPLEXH));
613
    LTFAT_COMPLEXH* Wo = ltfat_malloc(q*K*sizeof(LTFAT_COMPLEXH));
614
615
    LTFAT_FFTW(plan) plan_chirpF =  LTFAT_FFTW(plan_dft_1d)(Lfft, (LTFAT_COMPLEX*)chirpF, (LTFAT_COMPLEX*) chirpF,
616
                                                       FFTW_FORWARD, fftw_flags);
617
618
619
    // Pre and post chirp
620
    //size_t N = L>K?L:K;
621
622
    for(size_t k=0;k<K;k++)
623
    {
624
        W2[k] = (LTFAT_COMPLEXH) cexp(-1.0*q*I*deltao*k*k/2.0);
625
    }
626
627
    LTFAT_NAME_COMPLEX(conjugate_array)(W2,chirpF,K);
628
    LTFAT_NAME_COMPLEX(conjugate_array)(W2+1,chirpF+Lfft-K+1,K-1);
629
    LTFAT_NAME_COMPLEX(reverse_array)(chirpF+Lfft-K+1,chirpF+Lfft-K+1,K-1);
630
    memset(chirpF+K,0,(Lfft-(2*K-1))*sizeof(LTFAT_COMPLEXH));
631
    LTFAT_FFTW(execute)(plan_chirpF);
632
    LTFAT_FFTW(destroy_plan)(plan_chirpF);
633
634
    LTFAT_REAL oneoverLfft = 1.0/((LTFAT_REAL) Lfft);
635
636
    for(size_t jj=0;jj<q;jj++)
637
    {
638
       LTFAT_COMPLEXH* Wotmp = Wo + jj*K;
639
       for(size_t k=0;k<K;k++)
640
       {
641
          Wotmp[k] = (LTFAT_COMPLEXH) cexp(-1.0*I*jj*(k*deltao+o))*W2[k]*oneoverLfft;
642
       }
643
    }
644
645
    for(size_t k=0;k<K;k++)
646
    {
647
       W2[k] *= (LTFAT_COMPLEXH) cexp(-1.0*I*k*q*o);
648
    }
649
650
651
    LTFAT_NAME(chzt_plan) p = {.fbuffer = fbuffer, .plan=plan_f, .plan2=plan_fi,.L=L,
652
                               .K=K, .W2 = W2, .Wo=Wo,.chirpF=chirpF,.Lfft=Lfft};
653
    return  p;
654
}
655
656
657
154
#endif // LTFAT_TYPE
658
#endif // LTFAT_TYPE
155
659

Get latest updates about Open Source Projects, Conferences and News.

Sign up for the SourceForge newsletter:





No, thanks