void dumpSolutions(int attack, int knightNumber, int coverage, const char* fileName, bool showCoverage, int counter)
{
FILE* inFile = mkSolDir(attack, coverage, knightNumber, fileName, true, false, counter);
FILE* outFile = mkSolDir(attack, coverage, knightNumber, fileName, false, true, 0);
initialiseXYs();
int maxSize = knightsYX[attack][1] > knightsYX[attack][0] ? knightsYX[attack][1] : knightsYX[attack][0];
maxSize += HASH_BORDER;
if (maxSize >= MAX_GRID)
{
maxSize = MAX_GRID;
}
char* grid = (char*)malloc(maxSize + 1);
char format[10];
sprintf(format, "%%.%ds\n", (maxSize + 1));
solution sol;
size_t loop = readSolution(&sol, inFile);
while (loop)
{
for (int row = 0; row <= maxSize; row++) {
char* start = grid;
unsigned long long test = UNIT;
for (int loop = 0; loop <= maxSize; loop++)
{
if (sol.knights[row] & test)
{
*start = 'K';
}
else if ((sol.coverage[row] & test) && showCoverage)
{
*start = '*';
}
else {
*start = '.';
}
start++;
test = _rotr64(test, 1);
}
fprintf(outFile, format, grid);
}
fprintf(outFile, "\n\n");
loop = readSolution(&sol, inFile);
}
fclose(inFile);
fclose(outFile);
}
/**************************************************************************************************
* Solution creation
* ***********************************************************************************************/
Game::Game Solver::PddlBaseClass::getSolution(){
createDomainFile("/tmp/domain.txt");
createProblemFile("/tmp/problem.txt");
startSolver("/tmp/domain.txt", "/tmp/problem.txt", "/tmp/ausg.txt");
readSolution("/tmp/ausg.txt");
return gameField;
}
/**++**********************************************************************************************
* Solutioncreation
* ***********************************************************************************************/
Game::Game Solver::SatBaseClass::getSolution(){
std::stringstream out;
createDimacs("./dimacs.txt");
// satSolver = "./SparrowToRiss.sh";
//outTmpDimacs << "./cp3 /tmp/dimacs.txt -enabled_cp3 -dimacs=/tmp/dimacsTmp.txt -enabled_cp3 -cp3_stats -up -subsimp -bve -no-bve_gates -no-bve_strength -bve_red_lits=1 -cp3_bve_heap=1 -bve_heap_updates=1 -bve_totalG -bve_cgrow_t=1000 -bve_cgrow=10";
//std::system(outTmpDimacs.str().c_str());
std::system("rm /tmp/model.txt");
out << satSolver << " ./dimacs.txt >> /tmp/model.txt";
std::cout << out.str() << std::endl;
std::system(out.str().c_str());
readSolution("/tmp/model.txt",satSolver);
return gameField;
}
Game::Game Solver::toSatDebug::getSolution(){
std::stringstream out;
boost::posix_time::ptime start, end;
boost::posix_time::time_duration diff;
start = boost::posix_time::microsec_clock::local_time();
createDimacs("/tmp/dimacs.txt");
end = boost::posix_time::microsec_clock::local_time();
diff = end-start;
neededTimeForCreateDimacs = diff.total_milliseconds();
// satSolver = "./SparrowToRiss.sh";
out << satSolver << " /tmp/dimacs.txt >> /tmp/ausg.txt";
std::system("rm /tmp/ausg.txt");
start = boost::posix_time::microsec_clock::local_time();
std::system(out.str().c_str());
end = boost::posix_time::microsec_clock::local_time();
diff = end-start;
neededTimeForSatsolving = diff.total_milliseconds();
readSolution("/tmp/ausg.txt",satSolver);
return gameField;
}
/** returns whether the debug solution is worse as the best known solution or if the debug solution was found */
static
SCIP_Bool debugSolIsAchieved(
SCIP_SET* set /**< global SCIP settings */
)
{
SCIP_SOL* bestsol;
SCIP* scip;
if( solisachieved )
return TRUE;
assert(set != NULL);
scip = set->scip;
assert(scip != NULL);
bestsol = SCIPgetBestSol(scip);
if( bestsol != NULL )
{
SCIP_Real solvalue;
/* don't check solution while in problem creation stage */
if( SCIPsetGetStage(set) == SCIP_STAGE_PROBLEM )
return TRUE;
solvalue = SCIPgetSolOrigObj(scip, bestsol);
/* make sure a debug solution has been read, so we do not compare against the initial debugsolval == 0 */
SCIP_CALL( readSolution(set) );
if( (SCIPgetObjsense(scip) == SCIP_OBJSENSE_MINIMIZE && SCIPsetIsLE(set, solvalue, debugsolval)) || (SCIPgetObjsense(scip) == SCIP_OBJSENSE_MAXIMIZE && SCIPsetIsGE(set, solvalue, debugsolval)) )
solisachieved = TRUE;
}
return solisachieved;
}
void tidySolutions(int attack, int knightNumber, int coverage, int counter)
{
FILE* inFile = mkSolDir(attack, coverage, knightNumber, maximisedFile, true, false, counter);
FILE* duplicatesOutFile = NULL;
FILE* tidiedOutFile = NULL;
solution sol;
solutionTree = (solutionLeaf *)malloc(sizeof(solutionLeaf) * MAX_SOLUTIONS);
solutionLeaf* slot = solutionTree;
unsigned long long count = 0;
bool error = false;
initialiseXYs();
int pos = knightsYX[attack][1] > knightsYX[attack][0] ? knightsYX[attack][1] : knightsYX[attack][0];
if (pos + HASH_BORDER >= MAX_GRID)
{
printf("Cannot hash more than %d rows", (MAX_GRID - HASH_BORDER));
return;
}
long long currentPosition = _ftelli64(inFile);
size_t loop = readSolution(&sol, inFile);
unsigned long long mask = _rotr64(MASK, pos);
while (loop)
{
int offset = 0;
int multiplierIndex = 0;
unsigned long long rowHash = 0;
unsigned long long hash = 0;
for (int row = 0; row < pos; row++)
{
unsigned long long part = (sol.coverage[row] & mask);
if (offset < pos)
{
part = _rotl64(part, pos - offset);
}
else if (offset > pos)
{
part = _rotr64(part, offset - pos);
}
rowHash |= part;
offset += HASH_BORDER;
if (offset > MAX_GRID)
{
offset -= MAX_GRID;
if (multiplierIndex == 0)
{
hash |= rowHash;
}
else
{
hash |= (rowHash + 1) * multiplier[multiplierIndex];
multiplierIndex++;
}
}
}
for (int row = pos; row < pos + HASH_BORDER; row++)
{
hash |= (_rotr64(sol.coverage[row], MAX_GRID - HASH_BORDER - pos) + 1) * multiplier[multiplierIndex];
multiplierIndex++;
}
slot->hash = hash;
slot->bigger = NULL;
slot->equal = NULL;
slot->lesser = NULL;
slot->solutionOffset = currentPosition;
if (count > 0)
{
solutionLeaf* root = solutionTree;
while (true)
{
if (hash == root->hash)
{
if (root->equal == NULL)
{
root->equal = slot;
break;
}
else
{
root = root->equal;
}
}
else if (hash > root->hash)
{
if (root->bigger == NULL)
{
root->bigger = slot;
break;
}
else
{
root = root->bigger;
}
}
else if (hash < root->hash)
{
if (root->lesser == NULL)
{
root->lesser = slot;
break;
}
else
{
root = root->lesser;
}
}
}
}
slot++;
count++;
currentPosition = _ftelli64(inFile);
loop = readSolution(&sol, inFile);
if ((count == MAX_SOLUTIONS) && loop)
{
printf("Too many solutions to manage.");
error = true;
break;
}
}
fclose(inFile);
if (error)
{
return;
}
inFile = mkSolDir(attack, coverage, knightNumber, maximisedFile, true, false, counter);
tidiedOutFile = mkSolDir(attack, coverage, knightNumber, tidiedFile, false, false, 0);
slot = solutionTree;
readSolution(&sol, inFile);
solution compare;
while (count)
{
if (slot->equal == NULL)
{
//Could be in a maximised file less than counter!
writeSolution(&sol, tidiedOutFile);
slot++;
}
else
{
solutionLeaf* test = slot->equal;
int state = STATE_KEEP;
while (test != NULL)
{
_fseeki64(inFile, test->solutionOffset, SEEK_SET);
readSolution(&compare, inFile);
int cmp = memcmp(sol.coverage, compare.coverage, sizeof(unsigned long long) * MAX_GRID);
if (cmp == 0)
{
cmp = memcmp(sol.knights, compare.knights, sizeof(unsigned long long) * MAX_GRID);
if (cmp == 0)
{
state = STATE_SCRAP;
break;
}
else
{
state = STATE_DUPLICATE;
}
}
test = test->equal;
}
if (state == STATE_KEEP)
{
writeSolution(&sol, tidiedOutFile);
}
else if (state == STATE_DUPLICATE)
{
if (duplicatesOutFile == NULL)
{
duplicatesOutFile = mkSolDir(attack, coverage, knightNumber, duplicatesFile, false, false, 0);
}
writeSolution(&sol, duplicatesOutFile);
}
slot++;
_fseeki64(inFile, slot->solutionOffset, SEEK_SET);
}
readSolution(&sol, inFile);
count--;
}
fclose(inFile);
fclose(tidiedOutFile);
if (duplicatesOutFile != NULL)
{
fclose(duplicatesOutFile);
}
}
void maximiseSolutions(int attack, int knightSoFar, int coverage, int counter)
{
FILE* inFile;
FILE* outFile[MAX_GRID * MAX_GRID];
solution sol;
solution flippedSol;
solution* assessedSol;
memset(outFile, 0, sizeof(outFile));
inFile = mkSolDir(attack, coverage, knightSoFar, solutionFile, true, false, counter);
size_t loop = readSolution(&sol, inFile);
while (loop) {
bool flip = false;
unsigned long long column = UNIT;
for (int row = 0; row < MAX_GRID; row++)
{
unsigned long long columnImpact = UNIT;
unsigned long long columnVal = 0;
for (int i = 0; i < MAX_GRID; i++)
{
if (sol.knights[i] & column)
{
columnVal |= columnImpact;
}
columnImpact = _rotr64(columnImpact, 1);
}
if (!flip)
{
if (sol.knights[row] > columnVal)
{
break;
}
else if (sol.knights[row] < columnVal)
{
flip = true;
}
}
flippedSol.knights[row] = columnVal;
column = _rotr64(column, 1);
}
if (flip)
{
assessedSol = &flippedSol;
unsigned long long column = UNIT;
for (int row = 0; row < MAX_GRID; row++)
{
unsigned long long columnImpact = UNIT;
unsigned long long columnVal = 0;
for (int i = 0; i < MAX_GRID; i++)
{
if (sol.coverage[i] & column)
{
columnVal |= columnImpact;
}
columnImpact = _rotr64(columnImpact, 1);
}
flippedSol.coverage[row] = columnVal;
column = _rotr64(column, 1);
}
}
else
{
assessedSol = /
}
// find next square to attack
// In folder
int newAttack = 0;
bool exit = false;
for (int maxLine = 0; (maxLine < MAX_GRID) && !exit; maxLine++)
{
unsigned long long test = UNIT;
for (int x = 0; x <= maxLine; x++)
{
if ((assessedSol->coverage[maxLine] & test) == 0)
{
exit = true;
break;
}
test = _rotr64(test, 1);
newAttack++;
}
if ((maxLine < MAX_GRID - 1) && !exit)
{
for (int y = 0; y <= maxLine; y++)
{
if ((assessedSol->coverage[y] & test) == 0)
{
exit = true;
break;
}
newAttack++;
}
}
}
if (outFile[newAttack] == NULL)
{
outFile[newAttack] = mkSolDir(newAttack, coverage, knightSoFar, maximisedFile, false, false, 0);
}
writeSolution(assessedSol, outFile[newAttack]);
loop = readSolution(&sol, inFile);
}
fclose(inFile);
for (int i = 0; i < MAX_GRID * MAX_GRID; i++)
{
if (outFile[i] != NULL)
{
fclose(outFile[i]);
}
}
}
void addKnights(int currentAttack, int currentKnight, int currentCoverage, int counter)
{
solution sol;
FILE* outFile[MAX_GRID * MAX_GRID];
FILE* inFile = NULL;
int knightsAttacks[10];
int knightsAttacksCount = 0;
memset(outFile, 0, sizeof(outFile));
memset(placements, 0, sizeof(placements));
initialiseXYs();
int y = knightsYX[currentAttack][0];
int x = knightsYX[currentAttack][1];
knightsAttacks[knightsAttacksCount] = currentAttack;
knightsAttacksCount++;
if ((y >= STEP_X) && (x >= STEP_Y))
{
knightsAttacks[knightsAttacksCount] = knights[y - STEP_X][x - STEP_Y];
knightsAttacksCount++;
}
if (y >= STEP_X) {
knightsAttacks[knightsAttacksCount] = knights[y - STEP_X][x + STEP_Y];
knightsAttacksCount++;
}
if (x >= STEP_Y) {
knightsAttacks[knightsAttacksCount] = knights[y + STEP_X][x - STEP_Y];
knightsAttacksCount++;
}
knightsAttacks[knightsAttacksCount] = knights[y + STEP_X][x + STEP_Y];
knightsAttacksCount++;
if ((y >= STEP_Y) && (x >= STEP_X))
{
knightsAttacks[knightsAttacksCount] = knights[y - STEP_Y][x - STEP_X];
knightsAttacksCount++;
}
if (y >= STEP_Y)
{
knightsAttacks[knightsAttacksCount] = knights[y - STEP_Y][x + STEP_X];
knightsAttacksCount++;
}
if (x >= STEP_X)
{
knightsAttacks[knightsAttacksCount] = knights[y + STEP_Y][x - STEP_X];
knightsAttacksCount++;
}
knightsAttacks[knightsAttacksCount] = knights[y + STEP_Y][x + STEP_X];
knightsAttacksCount++;
size_t loop = 1;
if (currentAttack == 0)
{
memset(&sol, 0, sizeof(solution));
}
else
{
inFile = mkSolDir(currentAttack, currentCoverage, currentKnight, tidiedFile, true, false, counter);
loop = readSolution(&sol, inFile);
}
while (loop)
{
solution newSol;
for (int i = 0; i < knightsAttacksCount; i++)
{
int coverage = 0;
_memccpy(&newSol, &sol, 1, sizeof(solution));
addKnight(&newSol, knightsAttacks[i], &coverage);
if (outFile[coverage] == NULL)
{
outFile[coverage] = mkSolDir(currentAttack, coverage, currentKnight + 1, solutionFile, false, false, 0);
}
writeSolution(&newSol, outFile[coverage]);
}
if (inFile)
{
loop = readSolution(&sol, inFile);
}
else
{
loop = 0;
}
}
for (int i = 0; i < MAX_GRID * MAX_GRID; i++)
{
if (outFile[i] != NULL)
{
fclose(outFile[i]);
}
}
}
/** gets value of given variable in debugging solution */
static
SCIP_RETCODE getSolutionValue(
SCIP_SET* set, /**< global SCIP settings */
SCIP_VAR* var, /**< variable to get solution value for */
SCIP_Real* val /**< pointer to store solution value */
)
{
SCIP_VAR* solvar;
SCIP_Real scalar;
SCIP_Real constant;
const char* name;
int left;
int right;
int middle;
int cmp;
assert(set != NULL);
assert(var != NULL);
assert(val != NULL);
SCIP_CALL( readSolution(set) );
SCIPdebugMessage("Now handling variable <%s>, which has status %d, is of type %d, and was deleted: %d, negated: %d, transformed: %d\n",
SCIPvarGetName(var), SCIPvarGetStatus(var), SCIPvarGetType(var), SCIPvarIsDeleted(var), SCIPvarIsNegated(var),SCIPvarIsTransformedOrigvar(var));
/* ignore deleted variables */
if( SCIPvarIsDeleted(var) )
{
SCIPdebugMessage("**** unknown solution value for deleted variable <%s>\n", SCIPvarGetName(var));
*val = SCIP_UNKNOWN;
return SCIP_OKAY;
}
/* retransform variable onto original variable space */
solvar = var;
scalar = 1.0;
constant = 0.0;
if( SCIPvarIsNegated(solvar) )
{
scalar = -1.0;
constant = SCIPvarGetNegationConstant(solvar);
solvar = SCIPvarGetNegationVar(solvar);
}
if( SCIPvarIsTransformed(solvar) )
{
SCIP_CALL( SCIPvarGetOrigvarSum(&solvar, &scalar, &constant) );
if( solvar == NULL )
{
/* if no original counterpart, then maybe someone added a value for the transformed variable, so search for var (or its negation) */
SCIPdebugMessage("variable <%s> has no original counterpart\n", SCIPvarGetName(var));
solvar = var;
scalar = 1.0;
constant = 0.0;
if( SCIPvarIsNegated(solvar) )
{
scalar = -1.0;
constant = SCIPvarGetNegationConstant(solvar);
solvar = SCIPvarGetNegationVar(solvar);
}
}
}
/* perform a binary search for the variable */
name = SCIPvarGetName(solvar);
left = 0;
right = nsolvals-1;
while( left <= right )
{
middle = (left+right)/2;
cmp = strcmp(name, solnames[middle]);
if( cmp < 0 )
right = middle-1;
else if( cmp > 0 )
left = middle+1;
else
{
*val = scalar * solvals[middle] + constant;
return SCIP_OKAY;
}
}
*val = constant;
if( *val < SCIPvarGetLbGlobal(var) - 1e-06 || *val > SCIPvarGetUbGlobal(var) + 1e-06 )
{
SCIPwarningMessage("invalid solution value %.15g for variable <%s>[%.15g,%.15g]\n",
*val, SCIPvarGetName(var), SCIPvarGetLbGlobal(var), SCIPvarGetUbGlobal(var));
}
return SCIP_OKAY;
}
