value_disambiguator::result_type
value_disambiguator::operator()(ast::measure& measure)
{
value_disambiguation::measure_interpretations
interpretations(measure, time_signature, prev_duration, prev_doubled_tuplets);
if (!interpretations.contains_complete_measure() && !interpretations.empty()) {
if (!anacrusis) {
anacrusis = interpretations;
prev_duration = 0;
prev_doubled_tuplets.clear();
return true;
}
if (anacrusis->completes_uniquely(interpretations)) {
for (auto& lhs: *anacrusis) {
for (auto& rhs: interpretations) {
if (duration(lhs) + duration(rhs) == time_signature) {
lhs.accept(), rhs.accept();
prev_duration = duration(rhs);
prev_doubled_tuplets = rhs.get_doubled_tuplets();
anacrusis.reset();
return true;
}
}
}
}
}
if (interpretations.size() == 1) {
auto &proxied_measure = interpretations.front();
proxied_measure.accept();
prev_duration = duration(proxied_measure);
prev_doubled_tuplets = proxied_measure.get_doubled_tuplets();
return true;
}
if (interpretations.empty()) {
report_error(measure.id, L"No possible interpretations");
} else {
std::wstringstream s;
s << interpretations.size() << L" possible interpretations:";
for (auto& interpretation: interpretations) {
rational const score(interpretation.harmonic_mean());
s << std::endl
<< boost::rational_cast<float>(score) << L": " << interpretation;
}
report_error(measure.id, s.str());
}
return false;
}
//---------------------------------------------------------------------------
bool AntSolver2::solve( int numSteps )
{
init();
vector<int> uninstantiatedVariables( problem->getNumVars(), 0 );
vector<int> numSatisfiedConstraints( numAnts );
vector< vector<double> > valuesScore( problem->getNumVars() );
calculateValuesScore( valuesScore );
MinConflicts *minConflicts = NULL;
if ( useLocalSearch )
{
minConflicts = MinConflicts::create( problem );
}
int maxSatisfiedConstraints;
int i, j;
for ( i = 0; i < numSteps; i++ )
{
maxSatisfiedConstraints = 0;
vector< CSPInterpretation > interpretations( numAnts );
for ( j = 0; j < numAnts; j++ )
{
int numVars = problem->getNumVars();
// Initialize the vector of uninstantiated variables
int k;
for ( k = 0; k < numVars; k++ )
{
uninstantiatedVariables[k] = k;
}
// Build a path
interpretations[j].setNumVariables( problem->getNumVars() );
for ( k = 0; k < problem->getNumVars(); k++ )
{
// Pick a variable.
int variable = pickUninstantiatedVariable( interpretations[j], uninstantiatedVariables , problem->getNumVars() - k );
// pick a value from this variable
int value = pickValue( variable, valuesScore );
interpretations[j].setVariableValue( variable, value );
}
if ( useLocalSearch )
{
minConflicts->localSearch( interpretations[j], interpretations[j] );
}
numSatisfiedConstraints[j] = problem->getNumSatisfiedConstraints( interpretations[j] );
if ( numSatisfiedConstraints[j] == problem->getConstraintList()->getNumConstraints() )
{
result = interpretations[j];
stepsPerformed = i;
if ( minConflicts )
minConflicts->release();
return true;
}
if ( numSatisfiedConstraints[j] > maxSatisfiedConstraints )
{
maxSatisfiedConstraints = numSatisfiedConstraints[j];
}
}
// Now that we've built all assignments
// let's choose the best ones
// Only the assignmenst with the max number of satisfied
// constraints will lay pheromone
for ( j = 0; j < numAnts; j++ )
{
if ( numSatisfiedConstraints[j] == maxSatisfiedConstraints )
{
layPheromone( interpretations[j] );
}
}
//cout << "Step " << i << ", maxSatisfiedConstraints: " << maxSatisfiedConstraints << endl;
cout << i << ", " << maxSatisfiedConstraints << endl;
//if ( i % 10 == 0 )
{
//printPheromones ( i, maxSatisfiedConstraints );
}
}
stepsPerformed = i;
if ( useLocalSearch )
{
minConflicts->release();
}
return false;
}
