/*--------------------------------------------------------------------*/
void source_estim_GG_from_histo (vec pdf, vec symbols, double *palpha,
double *pbeta)
{
double step_alpha, step_beta;
double dK, last_dK;
int i;
/* derivatives of the Kullback distance on alpha and beta */
double derdK_alpha, derdK_beta;
vec pdf_GG, pdf_GGbisalpha, pdf_GGbisbeta;
/* Kind of a gradient descent with the derivative of kullback distance. */
step_alpha = *palpha / 10;
step_beta = *pbeta / 10;
last_dK = 666;
/* Initial Kullback distance */
pdf_GG = source_pdf_GG (symbols, *palpha, *pbeta);
dK = vec_distance_kullback_leibler (pdf, pdf_GG);
vec_delete (pdf_GG);
/* "Geometric" decreasing of the convergence step */
for (i = 0; i < 5; i++) {
do {
pdf_GGbisalpha = source_pdf_GG (symbols, *palpha + IT_EPSILON, *pbeta);
derdK_alpha =
(vec_distance_kullback_leibler (pdf, pdf_GGbisalpha) -
dK) / IT_EPSILON;
vec_delete (pdf_GGbisalpha);
pdf_GGbisbeta = source_pdf_GG (symbols, *palpha, *pbeta + IT_EPSILON);
derdK_beta =
(vec_distance_kullback_leibler (pdf, pdf_GGbisbeta) -
dK) / IT_EPSILON;
vec_delete (pdf_GGbisbeta);
*palpha = *palpha - derdK_alpha * step_alpha;
*pbeta = *pbeta - derdK_beta * step_beta;
last_dK = dK;
pdf_GG = source_pdf_GG (symbols, *palpha, *pbeta);
dK = vec_distance_kullback_leibler (pdf, pdf_GG);
vec_delete (pdf_GG);
// printf( "alpha = %f, beta = %f, dK = %f\n", *palpha, *pbeta, dK );
}
while (dK + IT_EPSILON * 1e3 < last_dK);
step_alpha *= 0.5;
step_beta *= 0.5;
}
}
void print_dist(mat Y, mat Y_attack, double wcr)
{
uint i;
for (i=0; i < mat_width(Y); i++)
{
vec y = mat_get_col(Y,i),
ya = mat_get_col(Y_attack,i);
printf("%f, %f;\n", wcr,vec_norm(ya,1.0)/vec_norm(y,1.0));
vec_delete( y );
vec_delete( ya );
}
}
int exe_xDestroy(sqlite3_vtab *pVTab) {
exe_table_t* table = (exe_table_t*) pVTab;
vec_delete_elems(table->content,exe_release);
vec_delete(table->content);
free(pVTab);
return SQLITE_OK;
}
mat make_Y(uint Nv, uint Ns, uint Nc, mat U, double wcr)
{
uint i;
mat Y = mat_new(Nv,Ns);
it_randomize();
for (i=0; i < Ns; i++) {
vec x, y, w;
bvec m;
x = make_x( Nv );
m = make_m( Nc );
w = make_w( U, m );
y = make_y( x, w, wcr );
mat_set_col(Y,i,y);
vec_delete( x );
vec_delete( w );
vec_delete( y );
bvec_delete( m );
}
return Y;
}
/*
* Convert a key sequence string into a key code sequence.
*/
int keystrtovec(char *key, size_t **keys)
{
vector *v = vec_new(sizeof(size_t));
size_t size;
for (size = 0; *key != '\0'; size++) {
size_t len, code = strtochord(key, &len);
vec_item(v, size, size_t) = code;
if ((vec_item(v, size, size_t) = code) == KBD_NOKEY) {
vec_delete(v);
return -1;
}
key += len;
}
*keys = vec_toarray(v);
return size;
}
static void
notify_value (svmdb_value_t * v, svmdb_action_t a)
{
int i;
int rv;
union sigval sv;
u32 value;
u32 *dead_registrations = 0;
svmdb_notify_t *np;
for (i = 0; i < vec_len (v->notifications); i++)
{
np = vec_elt_at_index (v->notifications, i);
if (np->action == a)
{
value = (np->action << 28) | (np->opaque);
sv.sival_ptr = (void *) (uword) value;
do
{
rv = 0;
if (sigqueue (np->pid, np->signum, sv) == 0)
break;
rv = errno;
}
while (rv == EAGAIN);
if (rv == 0)
continue;
vec_add1 (dead_registrations, i);
}
}
for (i = 0; i < vec_len (dead_registrations); i++)
{
np = vec_elt_at_index (v->notifications, dead_registrations[i]);
clib_warning ("dead reg pid %d sig %d action %d opaque %x",
np->pid, np->signum, np->action, np->opaque);
vec_delete (v->notifications, 1, dead_registrations[i]);
}
vec_free (dead_registrations);
}
int main ()
{
it_wavelet_t *wavelet;
it_wavelet2D_t *wavelet2D;
it_separable2D_t *separable;
const char *image_in = "../data/test.pgm";
const char *image_out = "out.pgm";
const char *sound_in = "../data/test.wav";
const char *sound_out = "out.wav";
char pnm_type, comments[1000];
int width, height, maxval;
int levels;
int length, channels, srate, depth;
mat m, mt;
vec v, vt;
levels = 4;
/* Read the sound */
if (!wav_info (sound_in, &channels, &srate, &depth, &length)) {
fprintf (stderr, "unable to open file %s\n", sound_in);
return (1);
}
printf
("file name = %s\nchannels = %d\nsampling rate = %d\ndepth = %d\nlength = %d samples/channel\n",
sound_in, channels, srate, depth, length);
m = mat_wav_read (sound_in);
v = m[0]; /* consider only the first channel */
/* Transform the sound */
vt = it_dwt (v, it_wavelet_lifting_53, levels);
vec_delete (v);
/* Write down the coefficients */
v = vec_new_eval (vt, rescale_sound, NULL);
m[0] = v;
mat_wav_write ("wavelet.wav", m, srate, depth);
vec_delete (v);
/* Reconstruct the sound */
v = it_idwt (vt, it_wavelet_lifting_53, levels);
vec_delete (vt);
m[0] = v;
mat_wav_write (sound_out, m, srate, depth);
mat_delete (m);
/* Test the separable transform */
/* Warning: note that for the wavelet with more than 1 level of */
/* decomposition, the transform obtained by applying the wavelet */
/* on the rows, then on the columns of the image is *not* what is */
/* usually called the separable wavelet. See this example: */
/* separable(wavelet1D) wavelet2D */
/* */
/* +------+------+------+ +------+------+------+ */
/* | L1L1 | L1H1 | L1H0 | | L1L1 | LH1 | | */
/* +------+------+------+ +------+------+ LH0 | */
/* | H1L1 | H1H1 | H1H0 | | HL1 | HH1 | | */
/* +------+------+------+ +------+------+------+ */
/* | | | | | | | */
/* | H0L1 | H0H1 | H0H0 | | HL0 | HH0 | */
/* +------+------+------+ +-------------+------+ */
m = mat_pgm_read (image_in);
printf ("PGM %dx%d\n", mat_height (m), mat_width (m));
levels = 1;
/* create a 1D wavelet object */
wavelet = it_wavelet_new (it_wavelet_lifting_97, levels);
/* create a separable transform out of the wavelet */
separable = it_separable2D_new (wavelet);
/* Transform the image */
mt = (mat) it_transform2D (separable, m);
mat_delete (m);
/* Write down the coefficients (shifted & saturated) */
m = mat_new_eval (mt, rescale_image, NULL);
mat_pgm_write ("wavelet_separable.pgm", m);
mat_delete (m);
/* Reconstruct the image */
m = (mat) it_itransform2D (separable, mt);
mat_delete (mt);
it_delete (separable);
it_delete (wavelet);
mat_pgm_write ("separable.pgm", m);
mat_delete (m);
/* Read the image */
pnm_info (image_in, &pnm_type, &width, &height, &maxval, comments, 1000);
printf ("file name = %s\npnm type = %c\n%dx%d -> maxval=%d\ncomments=%s\n",
image_in, pnm_type, width, height, maxval, "");
m = mat_pgm_read (image_in);
printf
("height(m) = %d\tmaxheight(m) = %d\nwidth(m) = %d\tmaxwidth(m) = %d\n",
mat_height (m), mat_height_max (m), mat_width (m), mat_width_max (m));
levels = 5;
/* create a 2D wavelet object */
wavelet2D = it_wavelet2D_new (it_wavelet_lifting_97, levels);
/* Transform the image */
mt = it_wavelet2D_transform (wavelet2D, m);
mat_delete (m);
/* Write down the coefficients (shifted & saturated) */
m = mat_new_eval (mt, rescale_image, NULL);
mat_pgm_write ("wavelet.pgm", m);
mat_delete (m);
/* Reconstruct the image */
m = it_wavelet2D_itransform (wavelet2D, mt);
mat_delete (mt);
it_delete (wavelet2D);
mat_pgm_write (image_out, m);
mat_delete (m);
return 0;
}
int
svmdb_local_add_del_notification (svmdb_client_t * client,
svmdb_notification_args_t * a)
{
uword *h;
void *oldheap;
hash_pair_t *hp;
svmdb_shm_hdr_t *shm;
u8 *dummy_value = 0;
svmdb_value_t *value;
svmdb_notify_t *np;
int i;
int rv = 0;
ASSERT (a->elsize);
region_lock (client->db_rp, 18);
shm = client->shm;
oldheap = svm_push_data_heap (client->db_rp);
h = shm->namespaces[a->nspace];
hp = hash_get_pair_mem (h, a->var);
if (hp == 0)
{
local_set_variable_nolock (client, a->nspace, (u8 *) a->var,
dummy_value, a->elsize);
/* might have moved */
h = shm->namespaces[a->nspace];
hp = hash_get_pair_mem (h, a->var);
ASSERT (hp);
}
value = pool_elt_at_index (shm->values, hp->value[0]);
for (i = 0; i < vec_len (value->notifications); i++)
{
np = vec_elt_at_index (value->notifications, i);
if ((np->pid == client->pid)
&& (np->signum == a->signum)
&& (np->action == a->action) && (np->opaque == a->opaque))
{
if (a->add_del == 0 /* delete */ )
{
vec_delete (value->notifications, 1, i);
goto out;
}
else
{ /* add */
clib_warning
("%s: ignore dup reg pid %d signum %d action %d opaque %x",
a->var, client->pid, a->signum, a->action, a->opaque);
rv = -2;
goto out;
}
}
}
if (a->add_del == 0)
{
rv = -3;
goto out;
}
vec_add2 (value->notifications, np, 1);
np->pid = client->pid;
np->signum = a->signum;
np->action = a->action;
np->opaque = a->opaque;
out:
svm_pop_heap (oldheap);
region_unlock (client->db_rp);
return rv;
}
