/* retorna TRUE cuando encuentra una solucion valida */
int backtrack(int a[], int n, int k) {
if (n == k) {
if (is_valid_solution(a, n)) {
print_solution(a, n);
return TRUE;
}
else
return FALSE;
}
else {
int nr_candidates;
int candidates[N];
find_candidates(a, n, k, candidates, &nr_candidates);
int found;
int i;
for (i = 0; i < nr_candidates; ++i) {
a[k] = candidates[i];
found = backtrack(a, n, k + 1);
if (found)
return TRUE;
}
return FALSE;
}
}
void sieve_factor(mpz_t num)
{
mpz_t gmp_root;
mpz_init(gmp_root);
mpz_sqrt(gmp_root, num);
if(mpz_root(gmp_root, num, 2) != 0)
{
mpz_set(factors[num_factors++], gmp_root);
mpz_set(factors[num_factors++], gmp_root);
mpz_clear(gmp_root);
return;
}
fail = true;
find_candidates(num, gmp_root);
mpz_clear(gmp_root);
}
/**
* Generates edge groups over the mesh.
*/
void SnowModel::generateEdgeGroups()
{
std::cout << "[Snow Model] Generating edge groups" << std::endl;
std::vector< std::set<Mesh::face*>* > candidate_meshes;
::Utilities::Timer t;
t.start();
/* clear the current edge group container */
RemoveEdgeGroups();
/* go through every mesh */
#pragma omp parallel for
for (unsigned int i=0; i < m_meshPool->getNrMeshs(); ++i) {
/* copy the whole mesh to work on it */
Mesh* tmpMesh = m_meshPool->getMesh(i);
Mesh::face* f = tmpMesh->mesh()->face_source;
candidate_meshes.clear();
/* init all marks to false */
do {
f->marked = false;
f = f->next_face;
} while (f != NULL);
std::cout << "\t*Growing edge groups...";
std::flush(std::cout);
int percent_step = static_cast<int>(tmpMesh->mesh()->number_faces * 0.1f);
int step = 10;
if (percent_step < 1)
{
step = static_cast<int>(100.0f / tmpMesh->mesh()->number_faces);
percent_step = 1;
}
unsigned int percent_count = 0;
int percent = 0;
int face_count = 0;
/* go through all faces */
f = tmpMesh->mesh()->face_source;
unsigned int eg_count = 0;
do {
if (face_count > percent_count)
{
std::cout << " " << percent;
std::flush(std::cout);
percent_count += percent_step;
percent += step;
}
/* get only those faces that could potentially get
* covered with snow (slope angle < 90� and facing outside) */
if (!f->marked) {
if (f->slope_angle < ( PI_2 - NearlyZero) )
{
++eg_count;
std::set<Mesh::face*> * candidate_mesh = new std::set<Mesh::face*>();
candidate_meshes.push_back(candidate_mesh);
/* find the candidate faces that are reachable
* from the current face */
find_candidates(f, candidate_mesh, tmpMesh);
face_count += candidate_mesh->size();
} else {
++face_count;
}
}
f = f->next_face;
} while (f != NULL);
std::cout << " ...ready" << std::endl << "\t*Initializating " << candidate_meshes.size() << " edge groups...";
std::flush(std::cout);
percent_step = static_cast<int>(candidate_meshes.size() * 0.1f);
step = 10;
if (percent_step < 1)
{
step = static_cast<int>(100.0f / candidate_meshes.size());
percent_step = 1;
}
percent_count = 0;
percent = 0;
for (unsigned int i = 0; i < candidate_meshes.size(); ++i) {
try {
//std::cout << "\tFound new edge group (#" << (i + 1) << ")" << std::endl;
// TODO: go through the found candidates and see if they overlap in Y-Order (top)
EdgeGroup* eg = new EdgeGroup(m_world, candidate_meshes[i], m_iLaunchSiteOptimizations);
if ( m_rememberColors && i < m_vecRememberedColors.size() ) {
eg->SetEdgeGroupFaceColor(m_vecRememberedColors[i]);
}
edge_groups.push_back(eg);
if (i == percent_count)
{
std::cout << " " << percent;
std::flush(std::cout);
percent_count += percent_step;
percent += step;
}
} catch (exception &e) {
std::cerr << "[Error] Error within the creation of EdgeGroup " << i + 1 << ": " << e.what() << std::endl;
}
}
std::cout << " ...ready" << std::endl;
if (m_rememberColors) {
save_colors();
}
}
t.stop();
std::cout << "\tTime: " << t.diffTimeInMSec() << "msec" << std::endl;
}
/* peak_tracking
* =============
* connects peaks from one analysis frame to tracks
* returns a pointer to two frames of orphaned peaks.
* tracks: pointer to the tracks
* tracks_size: numeber of tracks
* peaks: peaks to connect
* peaks_size: number of peaks
* frq_dev: frequency deviation from tracks
* SMR_cont: contribution of SMR to tracking
* n_partials: pointer to the number of partials before tracking
*/
ATS_FRAME *peak_tracking(ATS_PEAK *tracks, int *tracks_size, ATS_PEAK *peaks, int *peaks_size, float frq_dev, float SMR_cont, int *n_partials)
{
ATS_CANDS *track_candidates = (ATS_CANDS *)malloc(*peaks_size*sizeof(ATS_CANDS));
double lo, hi;
int k, j, used, goback;
ATS_FRAME *returned_peaks = (ATS_FRAME *)malloc(2*sizeof(ATS_FRAME));
returned_peaks[0].peaks = returned_peaks[1].peaks = NULL;
returned_peaks[0].n_peaks = returned_peaks[1].n_peaks = 0;
/* sort data to prepare for matching */
qsort(tracks, *tracks_size, sizeof(ATS_PEAK), peak_frq_inc);
qsort(peaks, *peaks_size, sizeof(ATS_PEAK), peak_frq_inc);
/* find candidates for each peak and set each peak to best candidate */
for (k=0; k<*peaks_size; k++) {
/* find frq limits for candidates */
lo = peaks[k].frq - (.5 * peaks[k].frq * frq_dev);
hi = peaks[k].frq + (.5 * peaks[k].frq * frq_dev);
/* get possible candidates */
track_candidates[k].size = 0;
track_candidates[k].cands = find_candidates(tracks, *tracks_size, lo, hi, &track_candidates[k].size);
if(track_candidates[k].size) {
sort_candidates(&track_candidates[k], peaks[k], SMR_cont);
peaks[k].track = track_candidates[k].cands[0].track;
}
}
/* compare adjacent peaks track numbers to insure unique track numbers */
do {
goback = 0;
for (j=0; j<(*peaks_size - 1); j++)
if((peaks[j].track == peaks[j+1].track) && (peaks[j].track > -1)) {
if(track_candidates[j].cands[0].amp > track_candidates[j+1].cands[0].amp) {
track_candidates[j].cands[0].amp = ATSA_HFREQ;
qsort(track_candidates[j].cands, track_candidates[j].size, sizeof(ATS_PEAK), peak_amp_inc);
if(track_candidates[j].cands[0].amp < ATSA_HFREQ) {
peaks[j].track = track_candidates[j].cands[0].track;
goback = 1;
} else peaks[j].track = -1;
} else {
track_candidates[j+1].cands[0].amp = ATSA_HFREQ;
qsort(track_candidates[j+1].cands, track_candidates[j+1].size, sizeof(ATS_PEAK), peak_amp_inc);
if(track_candidates[j+1].cands[0].amp < ATSA_HFREQ)
peaks[j+1].track = track_candidates[j+1].cands[0].track;
else peaks[j+1].track = -1;
}
}
} while (goback);
/* by this point, all peaks will either have a unique track number, or -1
now we need to take care of those left behind */
for(k=0; k<*peaks_size; k++)
if(peaks[k].track == -1) {
peaks[k].track = (*n_partials)++;
returned_peaks[1].peaks = push_peak(&peaks[k], returned_peaks[1].peaks, &returned_peaks[1].n_peaks);
}
/* check for tracks that didnt get assigned */
for(k=0; k<*tracks_size; k++) {
used = 0;
for(j=0; j<*peaks_size; j++)
if(tracks[k].track == peaks[j].track) {
used = 1;
break;
}
if(!used) returned_peaks[0].peaks = push_peak(&tracks[k], returned_peaks[0].peaks, &returned_peaks[0].n_peaks);
}
for (k=0; k<*peaks_size; k++) free(track_candidates[k].cands);
free(track_candidates);
return(returned_peaks);
}
