/* prepare window for FFT
* INPUT
* n : # of samples for FFT
* flag_window : 0 : no-window (default -- that is, other than 1 ~ 6)
* 1 : parzen window
* 2 : welch window
* 3 : hanning window
* 4 : hamming window
* 5 : blackman window
* 6 : steeper 30-dB/octave rolloff window
* OUTPUT
* density factor as RETURN VALUE
*/
double
init_den (int n, char flag_window)
{
double den;
int i;
den = 0.0;
for (i = 0; i < n; i ++)
{
switch (flag_window)
{
case 1: // parzen window
den += parzen (i, n) * parzen (i, n);
break;
case 2: // welch window
den += welch (i, n) * welch (i, n);
break;
case 3: // hanning window
den += hanning (i, n) * hanning (i, n);
break;
case 4: // hamming window
den += hamming (i, n) * hamming (i, n);
break;
case 5: // blackman window
den += blackman (i, n) * blackman (i, n);
break;
case 6: // steeper 30-dB/octave rolloff window
den += steeper (i, n) * steeper (i, n);
break;
default:
fprintf (stderr, "invalid flag_window\n");
case 0: // square (no window)
den += 1.0;
break;
}
}
den *= (double)n;
return den;
}
/* apply window function to data[]
* INPUT
* flag_window : 0 : no-window (default -- that is, other than 1 ~ 6)
* 1 : parzen window
* 2 : welch window
* 3 : hanning window
* 4 : hamming window
* 5 : blackman window
* 6 : steeper 30-dB/octave rolloff window
*/
void
windowing (int n, const double *data, int flag_window, double scale,
double *out)
{
int i;
for (i = 0; i < n; i ++)
{
switch (flag_window)
{
case 1: // parzen window
out [i] = data [i] * parzen (i, n) / scale;
break;
case 2: // welch window
out [i] = data [i] * welch (i, n) / scale;
break;
case 3: // hanning window
out [i] = data [i] * hanning (i, n) / scale;
break;
case 4: // hamming window
out [i] = data [i] * hamming (i, n) / scale;
break;
case 5: // blackman window
out [i] = data [i] * blackman (i, n) / scale;
break;
case 6: // steeper 30-dB/octave rolloff window
out [i] = data [i] * steeper (i, n) / scale;
break;
default:
fprintf (stderr, "invalid flag_window\n");
case 0: // square (no window)
out [i] = data [i] / scale;
break;
}
}
}
void cpTestRho(double *X, int *n, int *d, double *rho, double *fbin,
double *influ, int *influest, int *M, int *w, int *bw,
int *method, double *rho0, double *avar, double *initseq)
{
int i, j, k, m, ln;
double *U = Calloc((*n) * (*d), double); // pseudo-obs depending on k
int *index = Calloc(*n, int);
double *V = Calloc((*n) * (*d), double); // pseudo-obs not depending on k
double *x = Calloc((*n) * (*d), double);
double *influa = Calloc(*n, double);
double *proda = Calloc(*n, double);
double *multipliers = Calloc((*n) * (*M), double);
double s, sumk, meank, sumnk, meannk, sqrtn = sqrt(*n);
/* generate (dependent) multipliers */
if (*method == 1 || *method == 2)
gendepmult(*n, *M, *bw, *w, initseq, multipliers);
/* compute pseudo-obs V not depending on k */
if (*method == 2 || *method == 3)
{
for (i = 0; i < (*n) * (*d); i++)
x[i] = X[i];
makepseudoobs(x, index, *n, *d, 0, *n, V);
}
/* for each possible breakpoint */
for (k = 1; k <= *n-1; k++)
{
s = (double)k / (*n);
/* compute pseudo-obs U depending on k */
for (i = 0; i < (*n) * (*d); i++)
x[i] = X[i];
makepseudoobs(x, index, *n, *d, 0, k, U);
makepseudoobs(x, index, *n, *d, k, *n, U);
/* sequential multiplier method */
if (*method == 1)
{
/* initialization */
rho[k - 1] = 0.0;
for (i = 0; i < *n; i++)
influ[i] = 0.0;
/* update statistic and influence matrix for subset i */
for (i = 0; i < (1<<*d); i++)
if (fbin[i])
statinflu_seq(*n, *d, k, U, i, fbin[i], proda,
influa, rho, influ);
/* statistic for breakpoint k */
rho[k-1] = sqrtn * s * (1.0 - s) * fabs(rho[k-1]);
/* generate M approximate realizations */
for (m = 0; m < *M; m++)
{
meank = 0.0;
for (i = 0; i < k; i++)
meank += multipliers[i + m * (*n)];
meank /= k;
sumk = 0.0;
for (i = 0; i < k; i++)
sumk += (multipliers[i + m * (*n)] - meank)
* influ[i];
meannk = 0.0;
for (i = k; i < *n; i++)
meannk += multipliers[i + m * (*n)];
meannk /= *n - k;
sumnk = 0.0;
for (i = k; i < *n; i++)
sumnk += (multipliers[i + m * (*n)] - meannk)
* influ[i];
rho0[m + (k - 1) * (*M)] =
fabs( (1.0 - s) * sumk - s * sumnk ) / sqrtn;
}
}
else /* nonsequential multiplier method or asymptotic variance */
{
rho[k - 1] = 0.0;
/* update statistic and influence matrix for subset i */
for (i = 0; i < (1<<*d); i++)
if (fbin[i])
stat_nonseq(*n, *d, k, U, i, fbin[i], proda, rho);
/* statistic for breakpoint k */
rho[k-1] = sqrtn * s * (1.0 - s) * fabs(rho[k-1]);
}
}
/* nonsequential multiplier method or asymptotic variance */
if ((*method == 2 || *method == 3) && *influest == 0)
{
/* update influence matrix for subset i */
for (i = 0; i < *n; i++)
influ[i] = 0.0;
for (i = 0; i < (1<<*d); i++)
if (fbin[i])
influ_nonseq(*n, *d, V, i, fbin[i],
proda, influa, influ);
}
/* nonsequential multiplier method */
if (*method == 2)
{
/* generate M approximate realizations */
for (m = 0; m < *M; m++)
{
sumk = 0.0;
sumnk = 0.0;
for (i = 0; i < *n; i++)
sumnk += multipliers[i + m * (*n)] * influ[i];
for (k = 1; k <= *n-1; k++)
{
s = (double)k / (*n);
rho0[m + (k - 1) * (*M)] = 0.0;
sumk += multipliers[k - 1 + m * (*n)] * influ[k - 1];
rho0[m + (k - 1) * (*M)] =
fabs(sumk - s * sumnk) / sqrtn;
}
}
}
/* asymptotic variance */
if (*method == 3)
{
ln = 2 * (*bw) - 1;
*avar = 0.0;
for (i = 0; i < *n; i++)
for (j = MAX(0, i - ln + 1); j < MIN(*n, i + ln); j++)
//abs(i - j) < ln
if (*w == 1)
*avar += parzen( (double)(i - j) / (double)ln)
* influ[i] * influ[j];
else
*avar += convrect( 4.0 * (double)(i - j) / (double)ln, 8)
* influ[i] * influ[j];
//*avar /= *n;
}
Free(U);
Free(index);
Free(V);
Free(x);
Free(influa);
Free(proda);
Free(multipliers);
}
