void test1d(int nfft,int isinverse,int arch)
{
mdct_lookup cfg;
size_t buflen = sizeof(kiss_fft_scalar)*nfft;
kiss_fft_scalar * in = (kiss_fft_scalar*)malloc(buflen);
kiss_fft_scalar * in_copy = (kiss_fft_scalar*)malloc(buflen);
kiss_fft_scalar * out= (kiss_fft_scalar*)malloc(buflen);
opus_val16 * window= (opus_val16*)malloc(sizeof(opus_val16)*nfft/2);
int k;
clt_mdct_init(&cfg, nfft, 0, arch);
for (k=0;k<nfft;++k) {
in[k] = (rand() % 32768) - 16384;
}
for (k=0;k<nfft/2;++k) {
window[k] = Q15ONE;
}
for (k=0;k<nfft;++k) {
in[k] *= 32768;
}
if (isinverse)
{
for (k=0;k<nfft;++k) {
in[k] /= nfft;
}
}
for (k=0;k<nfft;++k)
in_copy[k] = in[k];
/*for (k=0;k<nfft;++k) printf("%d %d ", in[k].r, in[k].i);printf("\n");*/
if (isinverse)
{
for (k=0;k<nfft;++k)
out[k] = 0;
clt_mdct_backward(&cfg,in,out, window, nfft/2, 0, 1, arch);
/* apply TDAC because clt_mdct_backward() no longer does that */
for (k=0;k<nfft/4;++k)
out[nfft-k-1] = out[nfft/2+k];
check_inv(in,out,nfft,isinverse);
} else {
clt_mdct_forward(&cfg,in,out,window, nfft/2, 0, 1, arch);
check(in_copy,out,nfft,isinverse);
}
/*for (k=0;k<nfft;++k) printf("%d %d ", out[k].r, out[k].i);printf("\n");*/
free(in);
free(in_copy);
free(out);
free(window);
clt_mdct_clear(&cfg, arch);
}
void init()
{
object ob;
ob=this_player();
if(interactive(ob)/* && !wizardp(ob)*/)
if(check_inv(ob)==0)
{
tell_object(ob,HIY+query("short")+"是特殊的地方，你只能带食物和水进来。\n"+
HIB+"你被赶了出来！\n"+NOR);
ob->move(query("exits")[query("throw_exit")],1);
}
}
void test1d(int nfft,int isinverse)
{
mdct_lookup cfg;
size_t buflen = sizeof(kiss_fft_scalar)*nfft;
kiss_fft_scalar * in = (kiss_fft_scalar*)malloc(buflen);
kiss_fft_scalar * out= (kiss_fft_scalar*)malloc(buflen);
celt_word16 * window= (celt_word16*)malloc(sizeof(celt_word16)*nfft/2);
int k;
clt_mdct_init(&cfg, nfft);
for (k=0;k<nfft;++k) {
in[k] = (rand() % 32768) - 16384;
}
for (k=0;k<nfft/2;++k) {
window[k] = Q15ONE;
}
#ifdef DOUBLE_PRECISION
for (k=0;k<nfft;++k) {
in[k] *= 32768;
}
#endif
if (isinverse)
{
for (k=0;k<nfft;++k) {
in[k] /= nfft;
}
}
/*for (k=0;k<nfft;++k) printf("%d %d ", in[k].r, in[k].i);printf("\n");*/
if (isinverse)
{
for (k=0;k<nfft;++k)
out[k] = 0;
clt_mdct_backward(&cfg,in,out, window, nfft/2);
check_inv(in,out,nfft,isinverse);
} else {
clt_mdct_forward(&cfg,in,out,window, nfft/2);
check(in,out,nfft,isinverse);
}
/*for (k=0;k<nfft;++k) printf("%d %d ", out[k].r, out[k].i);printf("\n");*/
free(in);
free(out);
clt_mdct_clear(&cfg);
}
int smo(bow_wv **docs, int *yvect, double *weights, double *a_b, double **W,
int ndocs, double *error, float *cvect, int *nsv) {
int changed;
int inspect_all;
struct svm_smo_model model;
int nchanged;
int num_words;
double *original_weights;
int i,j,k,n;
num_words = bow_num_words();
m1 = m2 = m3 = m4 = 0;
model.n_pair_suc = model.n_pair_tot = model.n_single_suc =
model.n_single_tot = model.n_outer = 0;
model.nsv = *nsv;
model.docs = docs;
model.error = error;
model.ndocs = ndocs;
model.cvect = cvect;
original_weights = NULL;
if (svm_kernel_type == 0 && !(*W)) {
*W = model.W = (double *) malloc(sizeof(double)*num_words);
} else {
model.W = NULL;
}
model.weights = weights;
model.yvect = yvect;
/* figure out the # of positives */
for (i=j=k=n=0; i<ndocs; i++) {
if (yvect[i] == 1) {
k = i;
j++;
} else {
n = i;
}
}
/* k is set to the last positive example found, n is the last negative */
make_set(ndocs,ndocs,&(model.I0));
make_set(ndocs,j,&(model.I1));
make_set(ndocs,ndocs-j,&(model.I2));
make_set(ndocs,j,&(model.I3));
make_set(ndocs,ndocs-j,&(model.I4));
/* this is the code which initializes the sets according to the weights values */
for (i=0; i<ndocs; i++) {
struct set *s;
if (weights[i] > svm_epsilon_a && weights[i] < cvect[i] - svm_epsilon_a) {
s = &(model.I0);
} else if (yvect[i] == 1) {
if (weights[i] < svm_epsilon_a) s = &(model.I1);
else s = &(model.I3);
} else {
if (weights[i] < svm_epsilon_a) s = &(model.I4);
else s = &(model.I2);
}
set_insert(i, s);
}
if (model.W) {
for (i=0; i<num_words; i++) {
model.W[i] = 0.0;
}
}
if (model.I0.ilength == 0) {
model.blow = 1;
model.bup = -1;
model.iup = k;
model.ilow = n;
error[k] = -1;
error[n] = 1;
} else { /* compute bup & blow */
int efrom, nitems;
int *items;
double e;
nitems = model.I0.ilength;
items = model.I0.items;
for (i=0, e=-1*MAXDOUBLE; i<nitems; i++) {
if (e < error[items[i]]) {
e = error[items[i]];
efrom = items[i];
}
}
model.blow = e;
model.ilow = efrom;
for (i=0, e=MAXDOUBLE; i<nitems; i++) {
if (e > error[items[i]]) {
e = error[items[i]];
efrom = items[i];
}
}
model.bup = e;
model.iup = efrom;
if (model.W) {
for (i=0; i<nitems; i++) {
for (j=0; j<docs[items[i]]->num_entries; j++) {
model.W[docs[items[i]]->entry[j].wi] +=
yvect[items[i]] * weights[items[i]] * docs[items[i]]->entry[j].weight;
}
}
/* also need to include bound sv's (I2 & I3) */
for (k=0, nitems=model.I2.ilength, items=model.I2.items;
k<2;
k++, nitems=model.I3.ilength, items=model.I3.items) {
for (i=0; i<nitems; i++) {
for (j=0; j<docs[items[i]]->num_entries; j++) {
model.W[docs[items[i]]->entry[j].wi] +=
yvect[items[i]] * weights[items[i]] * docs[items[i]]->entry[j].weight;
}
}
}
}
}
if (!model.W) {
model.W = *W;
}
if (svm_weight_style == WEIGHTS_PER_MODEL) {
kcache_init(ndocs);
}
inspect_all = 1;
nchanged = 0;
changed = 0;
while (nchanged || inspect_all) {
nchanged = 0;
#ifdef DEBUG
check_inv(&model,ndocs);
#endif
model.n_outer ++;
PRINT_SMO_PROGRESS(stderr, &model);
fflush(stderr);
if (1 && inspect_all) {
int ub = ndocs;
i=j=random() % ndocs;
for (k=0; k<2; k++,ub=j,i=0) {
for (; i<ub; i++) {
nchanged += opt_single(i, &model);
#ifdef DEBUG
check_inv(&model,ndocs);
#endif
}
}
inspect_all = 0;
} else {
/* greg's modification to keerthi, et al's modification 2 */
/* loop of optimizing all pairwise in a row with all elements
* in I0 (just like above, but only those in I0) */
do {
nchanged = 0;
/* here's the continuous iup/ilow loop */
while (1) {
if (!set_lookup(model.iup, &(model.I0))) {
error[model.iup] = smo_evaluate_error(&model,model.iup);
}
if (!set_lookup(model.ilow, &(model.I0))) {
error[model.ilow] = smo_evaluate_error(&model,model.ilow);
}
if (opt_pair(model.iup, model.ilow, &model)) {
#ifdef DEBUG
check_inv(&model,ndocs);
#endif
nchanged ++;
} else {
break;
}
if (model.bup > model.blow - 2*svm_epsilon_crit)
break;
}
if (nchanged) {
changed = 1;
}
nchanged = 0;
/* now inspect all of the elements in I0 */
{
int ub = ndocs;
i=j=random() % ndocs;
for (k=0; k<2; k++,ub=j,i=0) {
for (; i<ub; i++) {
if (set_lookup(i, &(model.I0))) {
nchanged += opt_single(i, &model);
#ifdef DEBUG
check_inv(&model,ndocs);
#endif
}
}
}
}
} while (nchanged);
/* of of the loop */
if (nchanged) {
changed = 1;
}
inspect_all = 1;
}
/* note: both of the above blocks no when they are done so they flip inspect_all */
if (nchanged) {
changed = 1;
}
}
free_set(&model.I0);
free_set(&model.I1);
free_set(&model.I2);
free_set(&model.I3);
free_set(&model.I4);
if (svm_weight_style == WEIGHTS_PER_MODEL) {
kcache_clear();
}
if (svm_verbosity > 3)
fprintf(stderr,"\n");
//printf("bup=%f, blow=%f\n",model.bup,model.blow);
*a_b = (model.bup + model.blow) / 2;
if (svm_kernel_type == 0) {
for (i=j=0; i<num_words; i++) {
if (model.W[i] != 0.0)
j++;
}
}
//printf("m1: %d, m2: %d, m3: %d, m4: %d", m1,m2,m3,m4);
*nsv = model.nsv;
return (changed);
}
void check_exit_all_inv() { check_inv(false, false, true); }
void check_exit_static_inv() { check_inv(false, true, false); }
void check_exit_inv() { check_inv(false, false, false); }
void check_entry_all_inv() { check_inv(true, false, true); }
void check_entry_static_inv() { check_inv(true, true, false); }
void check_entry_inv() { check_inv(true, false, false); }
/**
* 'victim' moves onto 'trap' (trap has FLAG_WALK_ON or FLAG_FLY_ON set) or
* 'victim' leaves 'trap' (trap has FLAG_WALK_OFF or FLAG_FLY_OFF) set.
*
* I added the flags parameter to give the single events more information
* about whats going on:
*
* Most important is the "MOVE_APPLY_VANISHED" flag.
* If set, a object has left a tile but "vanished" and not moved (perhaps
* it exploded or something). This means that some events are not
* triggered like trapdoors or teleporter traps for example which have a
* "FLY/MOVE_OFF" set. This will avoid that they touch invalid objects.
* @param trap Object victim moved on.
* @param victim The object that moved on trap.
* @param originator Player, monster or other object that caused 'victim'
* to move onto 'trap'. Will receive messages caused by this action. May
* be NULL, however, some types of traps require an originator to
* function.
* @param flags Flags. */
void move_apply(object *trap, object *victim, object *originator, int flags)
{
static int recursion_depth = 0;
/* move_apply() is the most likely candidate for causing unwanted and
* possibly unlimited recursion. */
/* The following was changed because it was causing perfeclty correct
* maps to fail. 1) it's not an error to recurse:
* rune detonates, summoning monster. monster lands on nearby rune.
* nearby rune detonates. This sort of recursion is expected and
* proper. This code was causing needless crashes. */
if (recursion_depth >= 500)
{
LOG(llevDebug, "WARNING: move_apply(): aborting recursion [trap arch %s, name %s; victim arch %s, name %s]\n", trap->arch->name, trap->name, victim->arch->name, victim->name);
return;
}
if (trap->head)
{
trap = trap->head;
}
/* Trigger the TRIGGER event */
if (trigger_event(EVENT_TRIGGER, victim, trap, originator, NULL, 0, 0, 0, SCRIPT_FIX_NOTHING))
{
return;
}
recursion_depth++;
switch (trap->type)
{
/* these objects can trigger other objects connected to them.
* We need to check them at map loading time and other special
* events to be sure to have a 100% working map state. */
case BUTTON:
case PEDESTAL:
update_button(trap);
break;
case TRIGGER_BUTTON:
case TRIGGER_PEDESTAL:
case TRIGGER_ALTAR:
check_trigger(trap, victim);
break;
case CHECK_INV:
check_inv(victim, trap);
break;
/* these objects trigger to but they are "instant".
* We don't need to check them when loading. */
case ALTAR:
/* sacrifice victim on trap */
apply_altar(trap, victim, originator);
break;
case CONVERTER:
if (!(flags & MOVE_APPLY_VANISHED))
{
convert_item(victim, trap);
}
break;
case PLAYERMOVER:
break;
/* should be walk_on/fly_on only */
case SPINNER:
if (victim->direction)
{
if ((victim->direction = victim->direction + trap->direction) > 8)
{
victim->direction = (victim->direction % 8) + 1;
}
update_turn_face(victim);
}
break;
case DIRECTOR:
if (victim->direction)
{
victim->direction = trap->direction;
update_turn_face(victim);
}
break;
/* no need to hit anything */
case MMISSILE:
if (IS_LIVE(victim) && !(flags&MOVE_APPLY_VANISHED))
{
tag_t trap_tag = trap->count;
hit_player(victim, trap->stats.dam, trap, AT_MAGIC);
if (!was_destroyed(trap, trap_tag))
{
remove_ob(trap);
}
check_walk_off(trap, NULL, MOVE_APPLY_VANISHED);
}
break;
case THROWN_OBJ:
if (trap->inv == NULL || (flags & MOVE_APPLY_VANISHED))
{
break;
}
/* fallthrough */
case ARROW:
/* bad bug: monster throw a object, make a step forwards, step on object ,
* trigger this here and get hit by own missile - and will be own enemy.
* Victim then is his own enemy and will start to kill herself (this is
* removed) but we have not synced victim and his missile. To avoid senseless
* action, we avoid hits here */
if ((IS_LIVE(victim) && trap->speed) && trap->owner != victim)
{
hit_with_arrow(trap, victim);
}
break;
case CONE:
case LIGHTNING:
break;
case BULLET:
if ((QUERY_FLAG(victim, FLAG_NO_PASS) || IS_LIVE(victim)) && !(flags & MOVE_APPLY_VANISHED))
{
check_fired_arch(trap);
}
break;
case TRAPDOOR:
{
int max, sound_was_played;
object *ab;
if ((flags & MOVE_APPLY_VANISHED))
{
break;
}
if (!trap->value)
{
sint32 tot;
for (ab = trap->above, tot = 0; ab != NULL; ab = ab->above)
{
if (!QUERY_FLAG(ab, FLAG_FLYING))
{
tot += (ab->nrof ? ab->nrof : 1) * ab->weight + ab->carrying;
}
}
if (!(trap->value = (tot > trap->weight) ? 1 : 0))
{
break;
}
SET_ANIMATION(trap, (NUM_ANIMATIONS(trap) / NUM_FACINGS(trap)) * trap->direction + trap->value);
update_object(trap, UP_OBJ_FACE);
}
for (ab = trap->above, max = 100, sound_was_played = 0; --max && ab && !QUERY_FLAG(ab, FLAG_FLYING); ab = ab->above)
{
if (!sound_was_played)
{
play_sound_map(trap->map, trap->x, trap->y, SOUND_FALL_HOLE, SOUND_NORMAL);
sound_was_played = 1;
}
if (ab->type == PLAYER)
{
new_draw_info(NDI_UNIQUE, ab, "You fall into a trapdoor!");
}
transfer_ob(ab, EXIT_X(trap), EXIT_Y(trap), trap->last_sp, ab, trap);
}
break;
}
case PIT:
/* Pit not open? */
if ((flags & MOVE_APPLY_VANISHED) || trap->stats.wc > 0)
{
break;
}
play_sound_map(victim->map, victim->x, victim->y, SOUND_FALL_HOLE, SOUND_NORMAL);
if (victim->type == PLAYER)
{
new_draw_info(NDI_UNIQUE, victim, "You fall through the hole!\n");
}
transfer_ob(victim->head ? victim->head : victim, EXIT_X(trap), EXIT_Y(trap), trap->last_sp, victim, trap);
break;
case EXIT:
/* If no map path specified, we assume it is the map path of the exit. */
if (!EXIT_PATH(trap))
{
FREE_AND_ADD_REF_HASH(EXIT_PATH(trap), trap->map->path);
}
if (!(flags & MOVE_APPLY_VANISHED) && victim->type == PLAYER && EXIT_PATH(trap) && EXIT_Y(trap) != -1 && EXIT_X(trap) != -1)
{
/* Basically, don't show exits leading to random maps the players output. */
if (trap->msg && strncmp(EXIT_PATH(trap), "/!", 2) && strncmp(EXIT_PATH(trap), "/random/", 8))
{
new_draw_info(NDI_NAVY, victim, trap->msg);
}
enter_exit(victim, trap);
}
break;
case SHOP_MAT:
if (!(flags & MOVE_APPLY_VANISHED))
{
apply_shop_mat(trap, victim);
}
break;
/* Drop a certain amount of gold, and have one item identified */
case IDENTIFY_ALTAR:
if (!(flags & MOVE_APPLY_VANISHED))
{
apply_identify_altar(victim, trap, originator);
}
break;
case SIGN:
/* Only player should be able read signs */
if (victim->type == PLAYER)
{
apply_sign(victim, trap);
}
break;
case CONTAINER:
if (victim->type == PLAYER)
{
(void) esrv_apply_container(victim, trap);
}
break;
case RUNE:
if (!(flags & MOVE_APPLY_VANISHED) && trap->level && IS_LIVE(victim))
{
spring_trap(trap, victim);
}
break;
#if 0
/* we don't have this atm. */
case DEEP_SWAMP:
if (!(flags & MOVE_APPLY_VANISHED))
{
walk_on_deep_swamp(trap, victim);
}
break;
#endif
default:
LOG(llevDebug, "name %s, arch %s, type %d with fly/walk on/off not handled in move_apply()\n", trap->name, trap->arch->name, trap->type);
break;
}
recursion_depth--;
}
