void correct(map_t* known_words, char *word) {
map_t *edits, *edits2;
if (find_map(known_words, word)) {
printf("%s\n", word);
return;
}
edits = create_map();
calc_edits1(word, edits, load_map);
int max = 0;
char max_word[WORD_LEN_MAX];
traverse_map(edits, 0, "", find_max, known_words, &max, max_word);
if (!max) {
edits2 = create_map();
traverse_map(edits, 0, "", calc_edits2, edits2, NULL, NULL);
traverse_map(edits2, 0, "", find_max, known_words, &max, max_word);
delete_map(edits2);
}
delete_map(edits);
printf("%s %d\n", max_word, max);
}
void add_map(Map* map, const void* key, int keylen, void* item)
{
assert(0 == find_map(map, key, keylen));
Key* new_key = alloc_resource(sizeof(Key) + keylen);
memcpy(new_key->data, key, keylen);
new_key->keylen = keylen;
add_list(map->key_list, new_key);
add_list(map->val_list, item);
}
static MapEntry* FindMapByAddr(const std::set<MapEntry*, MapComparator>& maps, uint64_t addr) {
// Construct a map_entry which is strictly after the searched map_entry, based on MapComparator.
MapEntry find_map(addr, std::numeric_limits<uint64_t>::max(), 0,
std::numeric_limits<uint64_t>::max(), nullptr);
auto it = maps.upper_bound(&find_map);
if (it != maps.begin() && IsAddrInMap(addr, *--it)) {
return *it;
}
return nullptr;
}
drn_map_id_t drn_writer_create_map(drn_writer_t *cache, const char * mapname)
{
drn_writer_map_t * map;
int32_t match = find_map(cache->maps, (void*) mapname);
if (match != -1)
return (drn_map_id_t) match;
map = sbadd(cache->maps, 1);
map->name = (char*) ALLOCATE(strlen(mapname)*sizeof(char)+1);
map->keys = 0;
strcpy(map->name, mapname);
return sbcount(cache->maps) - 1;
}
void find_max(char* word, void* arg1, void* arg2, void* arg3) {
result_t* found;
map_t* map = (map_t*)arg1;
int* max = (int*) arg2;
char*max_word = (char*)arg3;
if (found = find_map(map, word)) {
if (found->count > *max) {
*max = found->count;
scopy(max_word, word, strlen(word));
}
//printf("%s\n", word);
}
}
int do_init(int argc, char** argv)
{
FILE *list;
char line[1024];
struct map_data map;
char name[MAP_NAME_LENGTH_EXT];
grf_list_file = aStrdup("conf/grf-files.txt");
map_list_file = aStrdup("db/map_index.txt");
/* setup pre-defined, #define-dependant */
map_cache_file = aStrdup("db/map_cache.dat");
cmdline->exec(argc, argv, CMDLINE_OPT_PREINIT);
cmdline->exec(argc, argv, CMDLINE_OPT_NORMAL);
ShowStatus("Initializing grfio with %s\n", grf_list_file);
grfio_init(grf_list_file);
// Attempt to open the map cache file and force rebuild if not found
ShowStatus("Opening map cache: %s\n", map_cache_file);
if(!rebuild) {
map_cache_fp = fopen(map_cache_file, "rb");
if(map_cache_fp == NULL) {
ShowNotice("Existing map cache not found, forcing rebuild mode\n");
rebuild = 1;
} else
fclose(map_cache_fp);
}
if(rebuild)
map_cache_fp = fopen(map_cache_file, "w+b");
else
map_cache_fp = fopen(map_cache_file, "r+b");
if(map_cache_fp == NULL) {
ShowError("Failure when opening map cache file %s\n", map_cache_file);
exit(EXIT_FAILURE);
}
// Open the map list
ShowStatus("Opening map list: %s\n", map_list_file);
list = fopen(map_list_file, "r");
if(list == NULL) {
ShowError("Failure when opening maps list file %s\n", map_list_file);
exit(EXIT_FAILURE);
}
// Initialize the main header
if(rebuild) {
header.file_size = sizeof(struct main_header);
header.map_count = 0;
} else {
if(fread(&header, sizeof(struct main_header), 1, map_cache_fp) != 1){ printf("An error as occured while reading map_cache_fp \n"); }
header.file_size = GetULong((unsigned char *)&(header.file_size));
header.map_count = GetUShort((unsigned char *)&(header.map_count));
}
// Read and process the map list
while(fgets(line, sizeof(line), list))
{
if(line[0] == '/' && line[1] == '/')
continue;
if(sscanf(line, "%15s", name) < 1)
continue;
if(strcmp("map:", name) == 0 && sscanf(line, "%*s %15s", name) < 1)
continue;
name[MAP_NAME_LENGTH_EXT-1] = '\0';
remove_extension(name);
if (find_map(name)) {
ShowInfo("Map '"CL_WHITE"%s"CL_RESET"' already in cache.\n", name);
} else if(!read_map(name, &map)) {
ShowError("Map '"CL_WHITE"%s"CL_RESET"' not found!\n", name);
} else if (!cache_map(name, &map)) {
ShowError("Map '"CL_WHITE"%s"CL_RESET"' failed to cache (write error).\n", name);
} else {
ShowInfo("Map '"CL_WHITE"%s"CL_RESET"' successfully cached.\n", name);
}
}
ShowStatus("Closing map list: %s\n", map_list_file);
fclose(list);
// Write the main header and close the map cache
ShowStatus("Closing map cache: %s\n", map_cache_file);
fseek(map_cache_fp, 0, SEEK_SET);
fwrite(&header, sizeof(struct main_header), 1, map_cache_fp);
fclose(map_cache_fp);
ShowStatus("Finalizing grfio\n");
grfio_final();
ShowInfo("%d maps now in cache\n", header.map_count);
aFree(grf_list_file);
aFree(map_list_file);
aFree(map_cache_file);
return 0;
}
/*
* map_ioctl:
* process the supported ioctls
*/
static int map_ioctl(RP rp)
{
PARAM far *p = (PARAM far*)IOPARAM(rp);
DATA far *d;
int idx;
ULONG addr, lock, temp;
ULONG far *ud;
/* only accept class XFREE86_PMAP */
if (IOCAT(rp) != XFREE86_PMAP)
return RP_EBAD;
switch (IOFUNC(rp)) {
case PMAP_MAP:
/* test: Parameter packet is readable and has correct size
* get a free slot
*/
if (Verify(p,sizeof(PARAM),0)==0 &&
(idx = find_empty()) != -1) {
/* map the requested region */
addr = Pmap(p->u.physaddr,p->size);
/* was okay? */
if (addr) {
/* get the return packet of ioctl */
d = (DATA far*)IODATA(rp);
/* writable ? */
if (Verify(d,sizeof(DATA),1)==0) {
/* set the mapping address in
* process address space
*/
d->addr = addr;
d->sel = 0;
/* registrate stuff in mapping table */
maps[idx].phys = p->u.physaddr;
maps[idx].vmaddr = addr;
maps[idx].sfnum = IOSFN(rp);
maps[idx].lockhan = 0;
return RPDONE;
}
}
}
/* come here for error condition */
break;
case PMAP_UNMAP:
/* test: parameter packet readable and correct size
* entry found in table
* unmapping okay?
*/
if (Verify(p,sizeof(PARAM),0)==0 &&
(idx = find_map(IOSFN(rp),p->u.vmaddr)) != -1 &&
Punmap(p->u.vmaddr)==0) {
/* get the return packet of ioctl */
ud = (ULONG far*)IODATA(rp);
/* writable ? */
if (Verify(d,sizeof(ULONG),1)==0) {
/* set the vmaddress just invalidated
* into data packet
*/
*ud = maps[idx].vmaddr;
/* remove entry from table */
maps[idx].phys = 0;
maps[idx].vmaddr = 0;
maps[idx].sfnum = -1;
maps[idx].lockhan = 0;
return RPDONE;
}
}
/* arrive here for error condition */
break;
case PMAP_UNMAP2:
/* test: parameter packet readable and correct size
* entry found in table
* unmapping okay?
*/
if (Verify(p,sizeof(PARAM),0)==0 &&
(idx = find_mapphys(IOSFN(rp),p->u.physaddr,p->size)) != -1 &&
Punmap(maps[idx].vmaddr)==0) {
/* remove entry from table */
maps[idx].phys = 0;
maps[idx].vmaddr = 0;
maps[idx].sfnum = -1;
maps[idx].lockhan = 0;
return RPDONE;
}
/* arrive here for error condition */
break;
case PMAP_NAME:
if (Verify(d,14,1) == 0) {
bmove((char far*)d,"\\dev\\pmap$\0",11);
return RPDONE;
}
break;
case PMAP_DRVID:
return drvid(d,IODLEN(rp),PMAPDRV_ID);
case PMAP_READROM: /* testcfg.sys replacement function */
if (Verify(p,sizeof(ROMPARAM),0) == 0) {
ROMPARAM far *p1 = (ROMPARAM*)p;
USHORT n = p1->numbytes;
ULONG ad = p1->physaddr + n;
if (p1->command == 0 &&
p1->physaddr >= 0xc0000 &&
p1->physaddr <= 0xfffff &&
ad >= 0xc0000 &&
ad <= 0xfffff) {
char far *d1 = (char far*)IODATA(rp);
if (Verify(d1,n,1) == 0) {
char far *addr;
if (P2V(p1->physaddr,n,&addr)==0) {
bmove(d1,addr,n);
/*UnPhysToVirt == NOOP in OS/2 2.x */
return RPDONE;
}
}
}
}
break;
case PMAP_LOCKBUF:
/* test: Parameter packet is readable and has correct size
*
*/
lock = 0;
if (Verify(p,sizeof(PARAM),0)==0 &&
(idx = find_empty()) != -1) {
/* lock the requested region */
lock = Vlock(p->u.vmaddr,p->size);
temp = (p->u.vmaddr << 3) | 0x070000; /* Make sel */
/* was okay? */
if ((lock) &&
(Verify((FPVOID)temp, (USHORT)p->size, 0) ==0)) {
/* get the return packet of ioctl */
d = (DATA far*)IODATA(rp);
/* writable ? */
if (Verify(d,sizeof(DATA),1)==0) {
/* set the mapping address in
* process address space
*/
/* This is where things crash: VtoP does not like our addr */
d->addr = VtoP(p->u.vmaddr);
d->sel = 0;
maps[idx].phys = addr;
maps[idx].vmaddr = p->u.vmaddr;
maps[idx].sfnum = IOSFN(rp);
maps[idx].lockhan = lock;
return RPDONE;
}
}
if(lock) Vunlock(lock); /* In case Verify failed */
}
/* come here for error condition */
break;
default:
return RP_EBAD;
}
/* break from case */
return RP_EINVAL;
}
drn_map_id_t drn_writer_get_map_id(drn_writer_t *cache, const char * map)
{
drn_map_id_t match = find_map(cache->maps, (void*) map);
return match;
}
void known_load_map(map_t* map, char *word) {
if (find_map(s_known_words, word)) {
load_map(map, word);
}
}
int do_init(int argc, char** argv)
{
/* setup pre-defined, #define-dependant */
map_cache_file = std::string(db_path) + "/" + std::string(DBPATH) + "map_cache.dat";
// Process the command-line arguments
process_args(argc, argv);
ShowStatus("Initializing grfio with %s\n", grf_list_file.c_str());
grfio_init(grf_list_file.c_str());
// Attempt to open the map cache file and force rebuild if not found
ShowStatus("Opening map cache: %s\n", map_cache_file.c_str());
if(!rebuild) {
map_cache_fp = fopen(map_cache_file.c_str(), "rb");
if(map_cache_fp == NULL) {
ShowNotice("Existing map cache not found, forcing rebuild mode\n");
rebuild = 1;
} else
fclose(map_cache_fp);
}
if(rebuild)
map_cache_fp = fopen(map_cache_file.c_str(), "w+b");
else
map_cache_fp = fopen(map_cache_file.c_str(), "r+b");
if(map_cache_fp == NULL) {
ShowError("Failure when opening map cache file %s\n", map_cache_file.c_str());
exit(EXIT_FAILURE);
}
// Open the map list
FILE *list;
std::vector<std::string> directories = { std::string(db_path) + "/", std::string(db_path) + "/" + std::string(DBIMPORT) + "/" };
for (const auto &directory : directories) {
std::string filename = directory + map_list_file;
ShowStatus("Opening map list: %s\n", filename.c_str());
list = fopen(filename.c_str(), "r");
if (list == NULL) {
ShowError("Failure when opening maps list file %s\n", filename.c_str());
exit(EXIT_FAILURE);
}
// Initialize the main header
if (rebuild) {
header.file_size = sizeof(struct main_header);
header.map_count = 0;
} else {
if (fread(&header, sizeof(struct main_header), 1, map_cache_fp) != 1) { printf("An error as occured while reading map_cache_fp \n"); }
header.file_size = GetULong((unsigned char *)&(header.file_size));
header.map_count = GetUShort((unsigned char *)&(header.map_count));
}
// Read and process the map list
char line[1024];
while (fgets(line, sizeof(line), list))
{
if (line[0] == '/' && line[1] == '/')
continue;
char name[MAP_NAME_LENGTH_EXT];
if (sscanf(line, "%15s", name) < 1)
continue;
if (strcmp("map:", name) == 0 && sscanf(line, "%*s %15s", name) < 1)
continue;
struct map_data map;
name[MAP_NAME_LENGTH_EXT - 1] = '\0';
remove_extension(name);
if (find_map(name))
ShowInfo("Map '" CL_WHITE "%s" CL_RESET "' already in cache.\n", name);
else if (read_map(name, &map)) {
cache_map(name, &map);
ShowInfo("Map '" CL_WHITE "%s" CL_RESET "' successfully cached.\n", name);
}
else
ShowError("Map '" CL_WHITE "%s" CL_RESET "' not found!\n", name);
}
ShowStatus("Closing map list: %s\n", filename.c_str());
fclose(list);
}
// Write the main header and close the map cache
ShowStatus("Closing map cache: %s\n", map_cache_file.c_str());
fseek(map_cache_fp, 0, SEEK_SET);
fwrite(&header, sizeof(struct main_header), 1, map_cache_fp);
fclose(map_cache_fp);
ShowStatus("Finalizing grfio\n");
grfio_final();
ShowInfo("%d maps now in cache\n", header.map_count);
return 0;
}
int complement_match (Representation* X_rep, Representation* Y_rep,
Map * map, int map_max,
int * map_ctr, int * map_best, int best_max, int parent_map){
Penalty_parametrization penalty_params; /* for SW */
double **x = X_rep->full;
int * x_type = X_rep->full_type;
int NX = X_rep->N_full;
double **y = Y_rep->full;
int * y_type = Y_rep->full_type;
int NY = Y_rep->N_full;
double F_effective = 0.0;
double F_current;
double q[4] = {0.0}, q_init[4] = {0.0};
double **x_rotated = NULL;
double **tr_x_rotated = NULL;
double **R;
double z_scr = 0.0, *z_best;
double avg, avg_sq, stdev;
double alpha = options.alpha;
double rmsd, best_rmsd[TOP_RMSD];
double **best_quat;
double cutoff_rmsd = 3.0; /* <<<<<<<<<<<<<<<<< hardcoded */
int *x_type_fudg, *y_type_fudg;
int *anchor_x, *anchor_y, no_anchors;
int no_top_rmsd = TOP_RMSD, chunk;
int x_ctr, y_ctr, top_ctr;
int **best_triple_x;
int **best_triple_y;
int x_triple[3], y_triple[3];
int retval, done = 0;
int best_ctr;
int i, j;
int t;
int smaller;
int my_map_ctr;
int stored_new;
int * x2y, map_unstable;
//time_t time_now, time_start;
int cull_by_dna (Representation * X_rep, int *set_of_directions_x,
Representation * Y_rep, int *set_of_directions_y,
int set_size, Map *map, double cutoff_rmsd);
int distance_of_nearest_approach (Representation * X_rep, int *set_of_directions_x,
Representation * Y_rep, int *set_of_directions_y,
int set_size, double * rmsd_ptr);
int same_hand_triple (Representation * X_rep, int *set_of_directions_x,
Representation * Y_rep, int *set_of_directions_y, int set_size);
int find_map (Penalty_parametrization * params, Representation *X_rep, Representation *Y_rep,
double ** R, double alpha, double * F_effective, Map *map,
int *anchor_x, int * anchor_y, int anchor_size );
int find_next_triple (double **X, double **Y,
int *x_type, int *y_type, int NX, int NY,
int *x_triple, int *y_triple);
int gradient_descent (int first_call, double alpha,
double **x, int * x_type, int NX,
double **y, int * y_type, int NY,
double *q_best, double *F_best_ptr) ;
int map_quality_metrics (Representation *X_rep, Representation *Y_rep,
double ** tr_x_rotated, Map * map, int *reasonable_angle_ct);
int monte_carlo (double alpha,
double **x, int * x_type, int NX,
double **y, int * y_type, int NY,
double *q_best, double *F_best_ptr);
int opt_quat (double ** x, int NX, int *set_of_directions_x,
double ** y, int NY, int *set_of_directions_y,
int set_size, double * q, double * rmsd);
int qmap (double *x0, double *x1, double *y0, double *y1, double * quat);
int store_sorted (Map * map, int NX, int NY, int *map_best, int map_max,
double * z_best, int best_ctr,
double z_scr, int my_map_ctr, int *stored);
map_best[0] = -1; /* it is the end-of-array flag */
if ( *map_ctr >= map_max ) {
fprintf (stderr, "Map array undersized.\n");
exit (1);
}
smaller = (NX <= NY) ? NX : NY;
/***********************/
/* memory allocation */
/***********************/
if ( ! (R=dmatrix(3,3) ) ) return 1; /* compiler is bugging me otherwise */
if ( ! (x_rotated = dmatrix (NX,3)) ) return 1;
if ( ! (tr_x_rotated = dmatrix (NX,3)) ) return 1;
if ( ! (best_quat = dmatrix (no_top_rmsd,4)) ) return 1;
if ( ! (best_triple_x = intmatrix (no_top_rmsd,3)) ) return 1;
if ( ! (best_triple_y = intmatrix (no_top_rmsd,3)) ) return 1;
if ( ! (z_best = emalloc(NX*NY*sizeof(double) )) ) return 1;
if ( ! (x_type_fudg = emalloc(NX*sizeof(int) )) ) return 1;
if ( ! (y_type_fudg = emalloc(NY*sizeof(int) )) ) return 1;
if ( ! (anchor_x = emalloc(NX*sizeof(int) )) ) return 1;
if ( ! (anchor_y = emalloc(NY*sizeof(int) )) ) return 1;
penalty_params.custom_gap_penalty_x = NULL;
penalty_params.custom_gap_penalty_y = NULL;
//if ( ! (penalty_params.custom_gap_penalty_x = emalloc(NX*sizeof(double) )) ) return 1;
//if ( ! (penalty_params.custom_gap_penalty_y = emalloc(NY*sizeof(double) )) ) return 1;
/***********************/
/***********************/
/* expected quantities */
/***********************/
avg = avg_sq = stdev = 0.0;
//if (options.postprocess) {
if (0) {
if (F_moments (x, x_type, NX, y, y_type, NY, alpha, &avg, &avg_sq, &stdev)) return 1;
}
/***********************/
/***********************/
/* initialization */
/***********************/
best_ctr = 0;
penalty_params.gap_opening = options.gap_open;
penalty_params.gap_extension = options.gap_extend;
penalty_params.endgap = options.endgap;
penalty_params.endgap_special_treatment = options.use_endgap;
/***********************/
/***************************************/
/* find reasonble triples of SSEs */
/* that correspond in type */
/* and can be mapped onto each other */
/***************************************/
for (top_ctr=0; top_ctr<no_top_rmsd; top_ctr++) {
best_rmsd[top_ctr] = BAD_RMSD+1;
best_triple_x[top_ctr][0] = -1;
}
for (x_ctr=0; x_ctr < NX-2 && !done; x_ctr++) {
for (y_ctr=0; y_ctr < NY-2 && !done; y_ctr++) {
if ( y_type[y_ctr] != x_type[x_ctr] ) continue;
x_triple[0] = x_ctr;
y_triple[0] = y_ctr;
if (find_next_triple (x, y, x_type, y_type,
NX, NY, x_triple, y_triple) ){
continue;
}
if ( x_triple[1] < 0 || x_triple[2] < 0 ) continue;
if ( y_triple[1] < 0 || y_triple[2] < 0 ) continue;
/* do these three have kind-of similar layout in space?*/
/* is handedness the same? */
if ( ! same_hand_triple ( X_rep, x_triple, Y_rep, y_triple, 3)) continue;
/* are distances comparab;e? */
if (distance_of_nearest_approach ( X_rep, x_triple,
Y_rep, y_triple, 3, &rmsd)) continue;
if ( rmsd > cutoff_rmsd) continue;
/* find q_init that maps the two triples as well as possible*/
if ( opt_quat ( x, NX, x_triple, y, NY, y_triple, 3, q_init, &rmsd)) continue;
for (top_ctr=0; top_ctr<no_top_rmsd; top_ctr++) {
if ( rmsd <= best_rmsd[top_ctr] ) {
chunk = no_top_rmsd - top_ctr -1;
if (chunk) {
memmove (best_rmsd+top_ctr+1, best_rmsd+top_ctr, chunk*sizeof(double));
memmove (best_quat[top_ctr+1],
best_quat[top_ctr], chunk*4*sizeof(double));
memmove (best_triple_x[top_ctr+1],
best_triple_x[top_ctr], chunk*3*sizeof(int));
memmove (best_triple_y[top_ctr+1],
best_triple_y[top_ctr], chunk*3*sizeof(int));
}
best_rmsd[top_ctr] = rmsd;
memcpy (best_quat[top_ctr], q_init, 4*sizeof(double));
memcpy (best_triple_x[top_ctr], x_triple, 3*sizeof(int));
memcpy (best_triple_y[top_ctr], y_triple, 3*sizeof(int));
break;
}
}
}
}
# if 0
for (top_ctr=0; top_ctr<no_top_rmsd; top_ctr++) {
if ( best_rmsd[top_ctr] > BAD_RMSD ) break;
printf (" %3d %8.3lf ", top_ctr, best_rmsd[top_ctr]);
vec_out ( best_quat[top_ctr], 4, "quat: ");
for (t=0; t<3; t++ ) {
printf ("\t %3d %3d \n", best_triple_x[top_ctr][t]+1, best_triple_y[top_ctr][t]+1 );
}
}
exit (1);
# endif
/*********************************************/
/* main loop */
/*********************************************/
for (top_ctr=0; top_ctr<no_top_rmsd; top_ctr++) {
if ( best_rmsd[top_ctr] > BAD_RMSD ) break;
quat_to_R (best_quat[top_ctr], R);
rotate (x_rotated, NX, R, x);
F_current = F( y, y_type, NY, x_rotated, x_type, NX, alpha);
# if 0
printf ("\n***********************************\n");
printf (" %3d %8.3lf %8.3lf ", top_ctr, best_rmsd[top_ctr], F_current);
vec_out ( best_quat[top_ctr], 4, "quat: ");
for (t=0; t<3; t++ ) {
printf ("\t %3d %3d \n", best_triple_x[top_ctr][t]+1, best_triple_y[top_ctr][t]+1 );
}
# endif
/* find map which uses the 2 triples as anchors */
no_anchors = 3;
find_map (&penalty_params, X_rep, Y_rep, R, alpha, &F_effective, map + (*map_ctr),
best_triple_x[top_ctr], best_triple_y[top_ctr], no_anchors);
x2y = ( map + (*map_ctr) ) ->x2y;
map_unstable = 0;
for (t=0; t<3; t++ ) {
if ( x2y[best_triple_x[top_ctr][t]] != best_triple_y[top_ctr][t] ) {
map_unstable = 1;
}
}
if ( map_unstable) continue;
/* dna here is not DNA but "distance of nearest approach" */
cull_by_dna ( X_rep, best_triple_x[top_ctr],
Y_rep, best_triple_y[top_ctr], 3, map + (*map_ctr), cutoff_rmsd );
//printf ("map after culling by dna:\n");
//print_map (stdout, map+ (*map_ctr), NULL, NULL, NULL, NULL, 1);
/* monte that optimizes the aligned vectors only */
for (i=0; i<NX; i++) {
x_type_fudg[i] = JACKFRUIT;
}
for (j=0; j<NY; j++) {
y_type_fudg[j] = JACKFRUIT*2;
}
no_anchors = 0;
for (i=0; i<NX; i++) {
j = (map+(*map_ctr))->x2y[i];
if (j < 0 ) continue;
x_type_fudg[i] = x_type[i];
y_type_fudg[j] = y_type[j];
anchor_x[no_anchors] = i;
anchor_y[no_anchors] = j;
no_anchors ++;
}
if ( opt_quat ( x, NX, anchor_x, y, NY, anchor_y, no_anchors, q, &rmsd)) continue;
retval = monte_carlo ( alpha, x, x_type_fudg, NX,
y, y_type_fudg, NY, q, &F_current);
if (retval) return retval;
if (options.postprocess) {
z_scr = stdev ? (F_current - avg)/stdev : 0.0;
} else {
z_scr = 0.0;
}
quat_to_R (q, R);
/* store_image() is waste of time, but perhaps not critical */
store_image (X_rep, Y_rep, R, alpha, map + (*map_ctr));
map_assigned_score ( X_rep, map + (*map_ctr));
//printf ("map %2d assigned score: %8.3lf z_score: %8.3lf \n\n",
// *map_ctr+1, (map + (*map_ctr)) -> assigned_score, z_scr);
/* store the map that passed all the filters down to here*/
my_map_ctr = *map_ctr;
map[my_map_ctr].F = F_current;
map[my_map_ctr].avg = avg;
map[my_map_ctr].avg_sq = avg_sq;
map[my_map_ctr].z_score = z_scr;
memcpy ( map[my_map_ctr].q, q, 4*sizeof(double) );
/* recalculate the assigned score*/
//if (top_ctr==24) exit (1);
/************************/
/* store sorted */
/************************/
/* find the place for the new z-score */
store_sorted (map, NX, NY, map_best, map_max,
z_best, best_ctr, -map[my_map_ctr].assigned_score, my_map_ctr, &stored_new);
if ( stored_new ) { /* we want to keep this map */
(*map_ctr) ++;
best_ctr++;
} /* otherwise this map space is reusable */
/* is this pretty much as good as it can get ? */
if ( fabs (map[my_map_ctr].assigned_score - smaller)
< options.tol ) done = 1;
}
map_best[best_ctr] = -1;
/******************************************************/
/* look for the sub-map of a couple of best hits */
/******************************************************/
/* initialization:*/
map_consistence ( NX, NY, NULL, NULL, NULL, NULL, NULL);
best_ctr = 0;
while ( map_best[best_ctr] > -1 ) {
best_ctr ++;
}
//exit (1);
if (best_ctr) {
int nr_maps = (best_ctr<options.number_maps_cpl)?
best_ctr : options.number_maps_cpl;
int best_i;
int consistent;
double z;
double total_assigned_score, score, best_score = -100;
double gap_score;
for (i=0; i<nr_maps; i++) { /* look for the complement */
best_i = map_best[i];
/*intialize the (list of) submatch map(s) */
if ( !map[best_i].submatch_best) {
/* for now look for a single map only */
/* TODO - would it be worth any to look at more maps?*/
int map_max = 1;
map[best_i].submatch_best = emalloc (map_max*sizeof(int) );
if (! map[best_i].submatch_best) return 1;
}
map[best_i].submatch_best[0] = -1;
map[best_i].score_with_children = 0;
map[best_i].compl_z_score = 0;
for (j=0; j<best_ctr; j++) {
if (i==j) continue;
map_complementarity ( map+best_i, map + map_best[j], &z);
map_consistence ( NX, NY, map+best_i, map + map_best[j],
&total_assigned_score, &gap_score, NULL);
consistent = ( (map+best_i)->assigned_score < total_assigned_score
&& (map + map_best[j])->assigned_score
< total_assigned_score);
if ( consistent ) {
score = total_assigned_score;
if ( score > best_score ) {
best_score = score;
map[best_i].submatch_best[0] = map_best[j];
map[best_i].score_with_children = total_assigned_score;
map[best_i].compl_z_score = z;
}
}
}
}
}
/**********************/
/* garbage collection */
gradient_descent (1, 0.0, NULL, NULL, 0,
NULL, NULL, 0, NULL, NULL);
free_dmatrix (R);
free_dmatrix (x_rotated);
free_dmatrix (tr_x_rotated);
free_dmatrix (best_quat);
free_imatrix (best_triple_x);
free_imatrix (best_triple_y);
free (z_best);
free (x_type_fudg);
free (y_type_fudg);
free (anchor_x);
free (anchor_y);
if (penalty_params.custom_gap_penalty_x) free (penalty_params.custom_gap_penalty_x);
if (penalty_params.custom_gap_penalty_y) free (penalty_params.custom_gap_penalty_y);
/*********************/
return 0;
}