static ALIGNZONE detect_for_char(SWFFONT * f, int nr, float*row, float*column, SRECT font_bbox, SRECT char_bbox) { ALIGNZONE a = {0xffff,0xffff,0xffff,0xffff}; int width = font_bbox.xmax - font_bbox.xmin; int height = font_bbox.ymax - font_bbox.ymin; if(!width || !height) return a; /* find two best x values */ int x1=-1,y1=-1,x2=-1,y2=-1; int nr_x = 0; find_best(row, width, &x1, &x2, f->use->smallest_size, char_bbox.xmin - font_bbox.xmin, char_bbox.xmax - font_bbox.xmin, nr_x, 0); if(nr_x>0 && x1>=0) a.x = floatToF16((x1+font_bbox.xmin) / 20480.0); if(nr_x>1 && x2>=0) a.dx = floatToF16((x2-x1) / 20480.0); find_best(column, height, &y1, &y2, f->use->smallest_size, char_bbox.ymin - font_bbox.ymin, char_bbox.ymax - font_bbox.ymin, 2, 0); if(y1>=0) a.y = floatToF16((y1+font_bbox.ymin) / 20480.0); if(y2>=0) a.dy = floatToF16((y2-y1) / 20480.0); return a; }
/** * \brief Configure the filter and call the next filter's config function. */ static int config(struct vf_instance *vf, int width, int height, int d_width, int d_height, unsigned int flags, unsigned int outfmt) { if(!(vf->priv->fmt=find_best(vf))) return 0; else return vf_next_config(vf,width,height,d_width,d_height,flags,vf->priv->fmt); }
static int query_format(struct vf_instance *vf, unsigned int fmt){ int best; if(fmt!=IMGFMT_RGB1 && fmt!=IMGFMT_BGR1) return 0; best=find_best(vf); if(!best) return 0; // no match return vf->next->query_format(vf->next,best); }
void APG::ConstraintSolver::run() { if ( !m_readyToRun ) { error() << "DANGER WILL ROBINSON! A ConstraintSolver (serial no:" << m_serialNumber << ") tried to run before its QueryMaker finished!"; m_abortRequested = true; return; } if ( m_domain.empty() ) { debug() << "The QueryMaker returned no tracks"; return; } else { debug() << "Domain has" << m_domain.size() << "tracks"; } debug() << "Running ConstraintSolver" << m_serialNumber; emit totalSteps( m_maxGenerations ); // GENETIC ALGORITHM LOOP Population population; quint32 generation = 0; Meta::TrackList* best = NULL; while ( !m_abortRequested && ( generation < m_maxGenerations ) ) { quint32 s = m_constraintTreeRoot->suggestPlaylistSize(); m_suggestedPlaylistSize = (s > 0) ? s : m_suggestedPlaylistSize; fill_population( population ); best = find_best( population ); if ( population.value( best ) < m_satisfactionThreshold ) { select_population( population, best ); mutate_population( population ); generation++; emit incrementProgress(); } else { break; } } debug() << "solution at" << (void*)(best); m_solvedPlaylist = best->mid( 0 ); m_finalSatisfaction = m_constraintTreeRoot->satisfaction( m_solvedPlaylist ); /* clean up */ Population::iterator it = population.begin(); while ( it != population.end() ) { delete it.key(); it = population.erase( it ); } emit endProgressOperation( this ); }
static int config(struct vf_instance *vf, int width, int height, int d_width, int d_height, unsigned int flags, unsigned int outfmt){ if (!vf->priv->fmt) vf->priv->fmt=find_best(vf); if(!vf->priv->fmt){ // no matching fmt, so force one... if(outfmt==IMGFMT_RGB8) vf->priv->fmt=IMGFMT_RGB32; else if(outfmt==IMGFMT_BGR8) vf->priv->fmt=IMGFMT_BGR32; else return 0; } return vf_next_config(vf,width,height,d_width,d_height,flags,vf->priv->fmt); }
/*---------------------------------------------------------------------- * main entry point *----------------------------------------------------------------------*/ int main(int argc, char *argv[]) { progname = argv[0]; read_board(); /* read the board file */ dict = Dict_open(NULL); /* open the dictionary */ play.dirn = ACROSS; board = horiz_board; value = horiz_value; xboard = vert_board; xvalue = vert_value; find_best(); play.dirn = DOWN; board = vert_board; value = vert_value; xboard = horiz_board; xvalue = horiz_value; find_best(); if (nb_count == 0) { printf("Cannot play\n"); }else{ int i; nb_sort(); for (i=0; i<nb_count; i++) { NBTYPE *p = nb_sorted[i]; if (p->dirn==ACROSS) { printf("[%d,%d]a", p->row, p->col); }else{ printf("[%d,%d]d", p->col, p->row); } printf(" %s %d\n", p->word, p->score); } } Dict_close(dict); return 0; }
static void find_best_inorder(struct file *a, struct file *b, int alo, int ahi, int blo, int bhi, struct best *best, int bestlo, int besthi) { /* make sure the best matches we find are inorder. * If they aren't we find a overall best, and * recurse either side of that */ int i; int bad = 0; int bestval, bestpos = 0; for (i = bestlo; i < besthi; i++) best[i].val = 0; find_best(a, b, alo, ahi, blo, bhi, best); for (i = bestlo + 1; i < besthi; i++) if (best[i-1].val > 0 && best[i].val > 0 && best[i-1].xhi >= best[i].xlo) bad = 1; if (!bad) return; bestval = 0; for (i = bestlo; i < besthi; i++) if (best[i].val > bestval) { bestval = best[i].val; bestpos = i; } if (bestpos > bestlo) { /* move top down below chunk marker */ int y = best[bestpos].ylo; while (b->list[y].start[0]) y--; find_best_inorder(a, b, alo, best[bestpos].xlo, blo, y, best, bestlo, bestpos); } if (bestpos < besthi-1) { /* move bottom up to chunk marker */ int y = best[bestpos].yhi; while (b->list[y].start[0]) y++; find_best_inorder(a, b, best[bestpos].xhi, ahi, y, bhi, best, bestpos+1, besthi); } }
static gpudata *cuda_alloc(void *c, size_t size, void *data, int flags, int *ret) { gpudata *res = NULL, *prev = NULL; cuda_context *ctx = (cuda_context *)c; size_t asize; int err; if ((flags & GA_BUFFER_INIT) && data == NULL) FAIL(NULL, GA_VALUE_ERROR); if ((flags & (GA_BUFFER_READ_ONLY|GA_BUFFER_WRITE_ONLY)) == (GA_BUFFER_READ_ONLY|GA_BUFFER_WRITE_ONLY)) FAIL(NULL, GA_VALUE_ERROR); /* TODO: figure out how to make this work */ if (flags & GA_BUFFER_HOST) FAIL(NULL, GA_DEVSUP_ERROR); /* We don't want to manage really small allocations so we round up * to a multiple of FRAG_SIZE. This also ensures that if we split a * block, the next block starts properly aligned for any data type. */ if (!(ctx->flags & GA_CTX_DISABLE_ALLOCATION_CACHE)) { asize = roundup(size, FRAG_SIZE); find_best(ctx, &res, &prev, asize); } else { asize = size; } if (res == NULL) { err = allocate(ctx, &res, &prev, asize); if (err != GA_NO_ERROR) FAIL(NULL, err); } err = extract(res, prev, asize); if (err != GA_NO_ERROR) FAIL(NULL, err); /* It's out of the freelist, so add a ref */ res->ctx->refcnt++; /* We consider this buffer allocated and ready to go */ res->refcnt = 1; if (flags & GA_BUFFER_INIT) { err = cuda_write(res, 0, data, size); if (err != GA_NO_ERROR) { cuda_free(res); FAIL(NULL, err); } } return res; }
int ast_cli_command(int fd, char *s) { char *argv[AST_MAX_ARGS]; struct ast_cli_entry *e; int x; char *dup; x = AST_MAX_ARGS; if ((dup = parse_args(s, &x, argv))) { /* We need at least one entry, or ignore */ if (x > 0) { ast_mutex_lock(&clilock); e = find_cli(argv, 0); if (e) e->inuse++; ast_mutex_unlock(&clilock); if (e) { switch(e->handler(fd, x, argv)) { case RESULT_SHOWUSAGE: ast_cli(fd, e->usage); break; } } else ast_cli(fd, "No such command '%s' (type 'help' for help)\n", find_best(argv)); if (e) { ast_mutex_lock(&clilock); e->inuse--; ast_mutex_unlock(&clilock); } } free(dup); } else { ast_log(LOG_WARNING, "Out of memory\n"); return -1; } return 0; }
void generate_2D_sample (FILE *output, struct speed_params2D param) { mpfr_t temp; double incr_prec; mpfr_t incr_x; mpfr_t x, x2; double prec; struct speed_params s; int i; int test; int nb_functions; double *t; /* store the timing of each implementation */ /* We first determine how many implementations we have */ nb_functions = 0; while (param.speed_funcs[nb_functions] != NULL) nb_functions++; t = malloc (nb_functions * sizeof (double)); if (t == NULL) { fprintf (stderr, "Can't allocate memory.\n"); abort (); } mpfr_init2 (temp, MPFR_SMALL_PRECISION); /* The precision is sampled from min_prec to max_prec with */ /* approximately nb_points_prec points. If logarithmic_scale_prec */ /* is true, the precision is multiplied by incr_prec at each */ /* step. Otherwise, incr_prec is added at each step. */ if (param.logarithmic_scale_prec) { mpfr_set_ui (temp, (unsigned long int)param.max_prec, MPFR_RNDU); mpfr_div_ui (temp, temp, (unsigned long int)param.min_prec, MPFR_RNDU); mpfr_root (temp, temp, (unsigned long int)param.nb_points_prec, MPFR_RNDU); incr_prec = mpfr_get_d (temp, MPFR_RNDU); } else { incr_prec = (double)param.max_prec - (double)param.min_prec; incr_prec = incr_prec/((double)param.nb_points_prec); } /* The points x are sampled according to the following rule: */ /* If logarithmic_scale_x = 0: */ /* nb_points_x points are equally distributed between min_x and max_x */ /* If logarithmic_scale_x = 1: */ /* nb_points_x points are sampled from 2^(min_x) to 2^(max_x). At */ /* each step, the current point is multiplied by incr_x. */ /* If logarithmic_scale_x = -1: */ /* nb_points_x/2 points are sampled from -2^(max_x) to -2^(min_x) */ /* (at each step, the current point is divided by incr_x); and */ /* nb_points_x/2 points are sampled from 2^(min_x) to 2^(max_x) */ /* (at each step, the current point is multiplied by incr_x). */ mpfr_init2 (incr_x, param.max_prec); if (param.logarithmic_scale_x == 0) { mpfr_set_d (incr_x, (param.max_x - param.min_x)/(double)param.nb_points_x, MPFR_RNDU); } else if (param.logarithmic_scale_x == -1) { mpfr_set_d (incr_x, 2.*(param.max_x - param.min_x)/(double)param.nb_points_x, MPFR_RNDU); mpfr_exp2 (incr_x, incr_x, MPFR_RNDU); } else { /* other values of param.logarithmic_scale_x are considered as 1 */ mpfr_set_d (incr_x, (param.max_x - param.min_x)/(double)param.nb_points_x, MPFR_RNDU); mpfr_exp2 (incr_x, incr_x, MPFR_RNDU); } /* Main loop */ mpfr_init2 (x, param.max_prec); mpfr_init2 (x2, param.max_prec); prec = (double)param.min_prec; while (prec <= param.max_prec) { printf ("prec = %d\n", (int)prec); if (param.logarithmic_scale_x == 0) mpfr_set_d (temp, param.min_x, MPFR_RNDU); else if (param.logarithmic_scale_x == -1) { mpfr_set_d (temp, param.max_x, MPFR_RNDD); mpfr_exp2 (temp, temp, MPFR_RNDD); mpfr_neg (temp, temp, MPFR_RNDU); } else { mpfr_set_d (temp, param.min_x, MPFR_RNDD); mpfr_exp2 (temp, temp, MPFR_RNDD); } /* We perturb x a little bit, in order to avoid trailing zeros that */ /* might change the behavior of algorithms. */ mpfr_const_pi (x, MPFR_RNDN); mpfr_div_2ui (x, x, 7, MPFR_RNDN); mpfr_add_ui (x, x, 1, MPFR_RNDN); mpfr_mul (x, x, temp, MPFR_RNDN); test = 1; while (test) { mpfr_fprintf (output, "%e\t", mpfr_get_d (x, MPFR_RNDN)); mpfr_fprintf (output, "%Pu\t", (mpfr_prec_t)prec); s.r = (mp_limb_t)mpfr_get_exp (x); s.size = (mpfr_prec_t)prec; s.align_xp = (mpfr_sgn (x) > 0)?1:2; mpfr_set_prec (x2, (mpfr_prec_t)prec); mpfr_set (x2, x, MPFR_RNDU); s.xp = x2->_mpfr_d; for (i=0; i<nb_functions; i++) { t[i] = speed_measure (param.speed_funcs[i], &s); mpfr_fprintf (output, "%e\t", t[i]); } fprintf (output, "%d\n", 1 + find_best (t, nb_functions)); if (param.logarithmic_scale_x == 0) { mpfr_add (x, x, incr_x, MPFR_RNDU); if (mpfr_cmp_d (x, param.max_x) > 0) test=0; } else { if (mpfr_sgn (x) < 0 ) { /* if x<0, it means that logarithmic_scale_x=-1 */ mpfr_div (x, x, incr_x, MPFR_RNDU); mpfr_abs (temp, x, MPFR_RNDD); mpfr_log2 (temp, temp, MPFR_RNDD); if (mpfr_cmp_d (temp, param.min_x) < 0) mpfr_neg (x, x, MPFR_RNDN); } else { mpfr_mul (x, x, incr_x, MPFR_RNDU); mpfr_set (temp, x, MPFR_RNDD); mpfr_log2 (temp, temp, MPFR_RNDD); if (mpfr_cmp_d (temp, param.max_x) > 0) test=0; } } } prec = ( (param.logarithmic_scale_prec) ? (prec * incr_prec) : (prec + incr_prec) ); fprintf (output, "\n"); } free (t); mpfr_clear (incr_x); mpfr_clear (x); mpfr_clear (x2); mpfr_clear (temp); return; }
/**Function******************************************************************** Synopsis [Genetic algorithm for DD reordering.] Description [Genetic algorithm for DD reordering. The two children of a crossover will be stored in storedd[popsize] and storedd[popsize+1] --- the last two slots in the storedd array. (This will make comparisons and replacement easy.) Returns 1 in case of success; 0 otherwise.] SideEffects [None] SeeAlso [] ******************************************************************************/ int cuddGa( DdManager * table /* manager */, int lower /* lowest level to be reordered */, int upper /* highest level to be reorderded */) { int i,n,m; /* dummy/loop vars */ int index; #ifdef DD_STATS double average_fitness; #endif int small; /* index of smallest DD in population */ /* Do an initial sifting to produce at least one reasonable individual. */ if (!cuddSifting(table,lower,upper)) return(0); /* Get the initial values. */ numvars = upper - lower + 1; /* number of variables to be reordered */ if (table->populationSize == 0) { popsize = 3 * numvars; /* population size is 3 times # of vars */ if (popsize > 120) { popsize = 120; /* Maximum population size is 120 */ } } else { popsize = table->populationSize; /* user specified value */ } if (popsize < 4) popsize = 4; /* enforce minimum population size */ /* Allocate population table. */ storedd = ALLOC(int,(popsize+2)*(numvars+1)); if (storedd == NULL) { table->errorCode = CUDD_MEMORY_OUT; return(0); } /* Initialize the computed table. This table is made up of two data ** structures: A hash table with the key given by the order, which says ** if a given order is present in the population; and the repeat ** vector, which says how many copies of a given order are stored in ** the population table. If there are multiple copies of an order, only ** one has a repeat count greater than 1. This copy is the one pointed ** by the computed table. */ repeat = ALLOC(int,popsize); if (repeat == NULL) { table->errorCode = CUDD_MEMORY_OUT; FREE(storedd); return(0); } for (i = 0; i < popsize; i++) { repeat[i] = 0; } computed = st_init_table(array_compare,array_hash); if (computed == NULL) { table->errorCode = CUDD_MEMORY_OUT; FREE(storedd); FREE(repeat); return(0); } /* Copy the current DD and its size to the population table. */ for (i = 0; i < numvars; i++) { STOREDD(0,i) = table->invperm[i+lower]; /* order of initial DD */ } STOREDD(0,numvars) = table->keys - table->isolated; /* size of initial DD */ /* Store the initial order in the computed table. */ if (st_insert(computed,(char *)storedd,(char *) 0) == ST_OUT_OF_MEM) { FREE(storedd); FREE(repeat); st_free_table(computed); return(0); } repeat[0]++; /* Insert the reverse order as second element of the population. */ for (i = 0; i < numvars; i++) { STOREDD(1,numvars-1-i) = table->invperm[i+lower]; /* reverse order */ } /* Now create the random orders. make_random fills the population ** table with random permutations. The successive loop builds and sifts ** the DDs for the reverse order and each random permutation, and stores ** the results in the computed table. */ if (!make_random(table,lower)) { table->errorCode = CUDD_MEMORY_OUT; FREE(storedd); FREE(repeat); st_free_table(computed); return(0); } for (i = 1; i < popsize; i++) { result = build_dd(table,i,lower,upper); /* build and sift order */ if (!result) { FREE(storedd); FREE(repeat); st_free_table(computed); return(0); } if (st_lookup_int(computed,(char *)&STOREDD(i,0),&index)) { repeat[index]++; } else { if (st_insert(computed,(char *)&STOREDD(i,0),(char *)(long)i) == ST_OUT_OF_MEM) { FREE(storedd); FREE(repeat); st_free_table(computed); return(0); } repeat[i]++; } } #if 0 #ifdef DD_STATS /* Print the initial population. */ (void) fprintf(table->out,"Initial population after sifting\n"); for (m = 0; m < popsize; m++) { for (i = 0; i < numvars; i++) { (void) fprintf(table->out," %2d",STOREDD(m,i)); } (void) fprintf(table->out," : %3d (%d)\n", STOREDD(m,numvars),repeat[m]); } #endif #endif small = find_best(); #ifdef DD_STATS average_fitness = find_average_fitness(); (void) fprintf(table->out,"\nInitial population: best fitness = %d, average fitness %8.3f",STOREDD(small,numvars),average_fitness); #endif /* Decide how many crossovers should be tried. */ if (table->numberXovers == 0) { cross = 3*numvars; if (cross > 60) { /* do a maximum of 50 crossovers */ cross = 60; } } else { cross = table->numberXovers; /* use user specified value */ } /* Perform the crossovers to get the best order. */ for (m = 0; m < cross; m++) { if (!PMX(table->size)) { /* perform one crossover */ table->errorCode = CUDD_MEMORY_OUT; FREE(storedd); FREE(repeat); st_free_table(computed); return(0); } /* The offsprings are left in the last two entries of the ** population table. These are now considered in turn. */ for (i = popsize; i <= popsize+1; i++) { result = build_dd(table,i,lower,upper); /* build and sift child */ if (!result) { FREE(storedd); FREE(repeat); st_free_table(computed); return(0); } large = largest(); /* find the largest DD in population */ /* If the new child is smaller than the largest DD in the current ** population, enter it into the population in place of the ** largest DD. */ if (STOREDD(i,numvars) < STOREDD(large,numvars)) { /* Look up the largest DD in the computed table. ** Decrease its repetition count. If the repetition count ** goes to 0, remove the largest DD from the computed table. */ result = st_lookup_int(computed,(char *)&STOREDD(large,0), &index); if (!result) { FREE(storedd); FREE(repeat); st_free_table(computed); return(0); } repeat[index]--; if (repeat[index] == 0) { int *pointer = &STOREDD(index,0); result = st_delete(computed, (char **)&pointer,NULL); if (!result) { FREE(storedd); FREE(repeat); st_free_table(computed); return(0); } } /* Copy the new individual to the entry of the ** population table just made available and update the ** computed table. */ for (n = 0; n <= numvars; n++) { STOREDD(large,n) = STOREDD(i,n); } if (st_lookup_int(computed,(char *)&STOREDD(large,0), &index)) { repeat[index]++; } else { if (st_insert(computed,(char *)&STOREDD(large,0), (char *)(long)large) == ST_OUT_OF_MEM) { FREE(storedd); FREE(repeat); st_free_table(computed); return(0); } repeat[large]++; } } } } /* Find the smallest DD in the population and build it; ** that will be the result. */ small = find_best(); /* Print stats on the final population. */ #ifdef DD_STATS average_fitness = find_average_fitness(); (void) fprintf(table->out,"\nFinal population: best fitness = %d, average fitness %8.3f",STOREDD(small,numvars),average_fitness); #endif /* Clean up, build the result DD, and return. */ st_free_table(computed); computed = NULL; result = build_dd(table,small,lower,upper); FREE(storedd); FREE(repeat); return(result); } /* end of cuddGa */
void add_addr(struct address *addr) { remove_entry(addr); add_entry(addr); find_best(); }