STDMETHODIMP CTestCases::ExecuteVariation(LONG iVariation, VARIATION_STATUS *pdwResult)
{
TRACE("CTestCases::ExecuteVariation\n");
if(pdwResult)
*pdwResult = eVariationStatusNonExistent;
//Range Checking
if(iVariation < 0 || iVariation >= (LONG)GetVarCount())
return E_INVALIDARG;
//Find the correct Variation funcion to execute
VARINFO* rgVarInfo = (VARINFO*)GetVarInfoArray();
PFNVARIATION pVarFunction = rgVarInfo[iVariation].pfnVariation;
//TODO: (compiler file 'E:\8168\vc98\p2\src\P2\main.c', line 494)
//Please choose the Technical Support command on the Visual C++
//Help menu, or open the Technical Support help file for more information
//if(!pVarFunction)
if(pVarFunction == NULL)
return E_FAIL;
//Execute the Variation...
VARIATION_STATUS dwResult = (VARIATION_STATUS)((this->*pVarFunction)());
//Result
if(pdwResult)
*pdwResult = dwResult;
return S_OK;
}
STDMETHODIMP CTestCases::GetVariationCount(LONG *pc)
{
TRACE("CTestCases::GetVariationCount\n");
if(pc == NULL)
return E_INVALIDARG;
*pc = GetVarCount();
return S_OK;
}
STDMETHODIMP CTestCases::GetVariationID(LONG iVariation, LONG *pdwID)
{
TRACE("CTestCases::GetVariationID\n");
//Range Checking
if(iVariation < 0 || iVariation >= (LONG)GetVarCount() || pdwID == NULL)
{
if(pdwID)
*pdwID = 0;
return E_INVALIDARG;
}
const VARINFO* rgVarInfo = GetVarInfoArray();
*pdwID = rgVarInfo[iVariation].id;
return S_OK;
}
STDMETHODIMP CTestCases::GetVariationDesc(LONG iVariation, BSTR *pbstrDesc)
{
TRACE("CTestCases::GetVariationDesc\n");
//Range Checking
if(iVariation < 0 || iVariation >= (LONG)GetVarCount() || pbstrDesc == NULL)
{
if(pbstrDesc)
*pbstrDesc = NULL;
return E_INVALIDARG;
}
const VARINFO* rgVarInfo = GetVarInfoArray();
*pbstrDesc = SysAllocString(rgVarInfo[iVariation].wszDescription);
return S_OK;
}
// --[ Method ]---------------------------------------------------------------
//
// - Class : CEffect
// - prototype : bool RightScale(float fNewEnd)
//
// - Purpose : Sets a new end time for the effect, without changing
// the end.
//
// -----------------------------------------------------------------------------
bool CEffect::RightScale(float fNewEnd)
{
if(fNewEnd < m_fBegin)
{
return false;
}
float fScale = (fNewEnd - m_fBegin) / (m_fEnd - m_fBegin);
// Scale all variables
for(int i = 0; i < GetVarCount(); i++)
{
CVar* pVar = GetVar(i);
pVar->ScaleTime(fScale);
}
m_fEnd = fNewEnd;
return true;
}
int main(int argc, char **arg) {
clock_t start, endc, endt;
double elapsedc, elapsedt;
extmanager MyManager;
DdNode *bdd;
bddfileheader fileheader;
int i, ivarcnt, code;
gradientpair tvalue;
double probability = -1.0;
char *varpattern;
varpattern = NULL;
code = -1;
params = loadparam(argc, arg);
if (params.errorcnt > 0) {
printhelp(argc, arg);
for (i = 0; i < params.errorcnt; i++) {
fprintf(stderr, "Error: not known or error at parameter %s.\n",
arg[params.error[i]]);
}
return -1;
}
if (params.online == 0 && params.loadfile == -1) {
printhelp(argc, arg);
fprintf(stderr, "Error: you must specify a loading file.\n");
return -1;
}
if (params.method != 0 && arg[params.method][0] != 'g' &&
arg[params.method][0] != 'p' && arg[params.method][0] != 'o' &&
arg[params.method][0] != 'l') {
printhelp(argc, arg);
fprintf(stderr, "Error: you must choose a calculation method beetween "
"[p]robability, [g]radient, [l]ine search, [o]nline.\n");
return -1;
}
if (params.debug)
DEBUGON;
RAPIDLOADON;
SETMAXBUFSIZE(params.maxbufsize);
#ifndef _WIN32
signal(SIGINT, termhandler);
if (params.ppid != NULL) {
signal(SIGALRM, pidhandler);
alarm(5);
} else {
signal(SIGALRM, handler);
alarm(params.timeout);
}
#endif
if (params.online) {
MyManager.manager = simpleBDDinit(0);
MyManager.t = HIGH(MyManager.manager);
MyManager.f = LOW(MyManager.manager);
MyManager.varmap = InitNamedVars(1, 0);
bdd = OnlineGenerateBDD(MyManager.manager, &MyManager.varmap);
ivarcnt = GetVarCount(MyManager.manager);
} else {
fileheader = ReadFileHeader(arg[params.loadfile]);
switch (fileheader.filetype) {
case BDDFILE_SCRIPT:
if (params.inputfile == -1) {
printhelp(argc, arg);
fprintf(stderr, "Error: an input file is necessary for this type of "
"loading file.\n");
return -1;
}
MyManager.manager = simpleBDDinit(fileheader.varcnt);
MyManager.t = HIGH(MyManager.manager);
MyManager.f = LOW(MyManager.manager);
MyManager.varmap = InitNamedMultiVars(
fileheader.varcnt, fileheader.varstart, fileheader.bvarcnt);
if (LoadMultiVariableData(MyManager.manager, MyManager.varmap,
arg[params.inputfile]) == -1)
return -1;
start = clock();
bdd = FileGenerateBDD(MyManager.manager, MyManager.varmap, fileheader);
endc = clock();
elapsedc = ((double)(endc - start)) / CLOCKS_PER_SEC;
printf("elapsed_construction(%lf).\n", elapsedc);
ivarcnt = fileheader.varcnt;
break;
case BDDFILE_NODEDUMP:
if (params.inputfile == -1) {
printhelp(argc, arg);
fprintf(stderr, "Error: an input file is necessary for this type of "
"loading file.\n");
return -1;
}
MyManager.manager = simpleBDDinit(fileheader.varcnt);
MyManager.t = HIGH(MyManager.manager);
MyManager.f = LOW(MyManager.manager);
MyManager.varmap = InitNamedVars(fileheader.varcnt, fileheader.varstart);
bdd = LoadNodeDump(MyManager.manager, MyManager.varmap,
fileheader.inputfile);
ivarcnt = fileheader.varcnt;
break;
default:
fprintf(stderr, "Error: not a valid file format to load.\n");
return -1;
break;
}
}
#ifndef _WIN32
alarm(0);
#endif
// problem specifics
if (bdd != NULL) {
ivarcnt = RepairVarcnt(&MyManager.varmap);
code = 0;
/*
if (params.inputfile != -1) {
if (LoadVariableData(MyManager.varmap, arg[params.inputfile]) == -1)
return -1;
if (!all_loaded(MyManager.varmap, 1)) return -1;
}*/
MyManager.his = InitHistory(ivarcnt);
if (params.method != 0) {
switch (arg[params.method][0]) {
case 'g':
for (i = 0; i < MyManager.varmap.varcnt; i++) {
if (MyManager.varmap.vars[i] != NULL) {
varpattern = extractpattern(MyManager.varmap.vars[i]);
if ((varpattern == NULL) ||
(!patterncalculated(varpattern, MyManager, i))) {
tvalue = CalcGradient(MyManager, bdd,
i + MyManager.varmap.varstart, varpattern);
probability = tvalue.probability;
double factor =
sigmoid(MyManager.varmap.dvalue[i], params.sigmoid_slope) *
(1 -
sigmoid(MyManager.varmap.dvalue[i], params.sigmoid_slope)) *
params.sigmoid_slope;
if (varpattern == NULL) {
printf("query_gradient(%s,%s,%1.12f).\n", arg[params.queryid],
MyManager.varmap.vars[i], tvalue.gradient * factor);
} else {
varpattern[strlen(varpattern) - 2] = '\0';
printf("query_gradient(%s,%s,%1.12f).\n", arg[params.queryid],
varpattern, tvalue.gradient * factor);
}
ReInitHistory(MyManager.his, MyManager.varmap.varcnt);
}
if (varpattern != NULL)
free(varpattern);
} else {
fprintf(stderr, "Error: no variable name given for parameter.\n");
}
}
if (probability < 0.0) {
// no nodes, so we have to calculate probability ourself
tvalue =
CalcGradient(MyManager, bdd, 0 + MyManager.varmap.varstart, NULL);
probability = tvalue.probability;
}
printf("query_probability(%s,%1.12f).\n", arg[params.queryid],
probability);
break;
case 'l':
tvalue =
CalcGradient(MyManager, bdd, 0 + MyManager.varmap.varstart, NULL);
probability = tvalue.probability;
printf("query_probability(%s,%1.12f).\n", arg[params.queryid],
probability);
break;
case 'p':
printf("probability(%1.12f).\n", CalcProbability(MyManager, bdd));
break;
case 'o':
onlinetraverse(MyManager.manager, MyManager.varmap, MyManager.his, bdd);
break;
default:
myexpand(MyManager, bdd);
break;
}
} else {
start = clock();
// simpleNamedBDDtoDot(MyManager.manager, MyManager.varmap, bdd,
//"bdd.dot");
printf("probability(%1.12f).\n", ret_prob(MyManager, bdd));
endt = clock();
elapsedt = ((double)(endt - start)) / CLOCKS_PER_SEC;
printf("elapsed_traversing(%lf).\n", elapsedt);
// myexpand(MyManager, bdd);
}
if (params.savedfile > -1)
SaveNodeDump(MyManager.manager, MyManager.varmap, bdd,
arg[params.savedfile]);
if (params.exportfile > -1)
simpleNamedBDDtoDot(MyManager.manager, MyManager.varmap, bdd,
arg[params.exportfile]);
ReInitHistory(MyManager.his, MyManager.varmap.varcnt);
free(MyManager.his);
}
if (MyManager.manager != NULL) {
KillBDD(MyManager.manager);
exit(code);
free(MyManager.varmap.dvalue);
free(MyManager.varmap.ivalue);
free(MyManager.varmap.dynvalue);
for (i = 0; i < MyManager.varmap.varcnt; i++) {
free(MyManager.varmap.vars[i]);
free(MyManager.varmap.mvars[i].probabilities);
free(MyManager.varmap.mvars[i].booleanVars);
}
free(MyManager.varmap.vars);
free(MyManager.varmap.mvars);
free(MyManager.varmap.bVar2mVar);
}
if (params.error != NULL)
free(params.error);
return code;
}
int main(int argc, char* argv[]) {
srand(time(NULL));
std::ifstream in;
std::string outName;
bool initHarmonies = false;
if (argc == 3) {
in.open(argv[1]);
initHarmonies = in.is_open();
outName = std::string(argv[2]);
}
int const varCount = GetVarCount();
int const memorySize = 5;
float const r_accept = 0.95;
float const r_pa = 0.99;
float const r_range = 0.1;
std::vector<Harmony> init;
if (initHarmonies) {
for (int i = 0; i < memorySize; ++i) {
Harmony h;
in.ignore(1);
for (int i = 0; i < varCount; ++i) {
float weight = 0.0;
in >> weight;
h.push_back(weight);
in.ignore(1);
}
in.ignore(1);
in.ignore(1);
init.push_back(h);
}
}
in.close();
int const gameLength = 1000;
int const iterationCount = 1000;
HarmonyRanges const* ranges = GetRanges();
HarmonyFactory const factory (varCount, *ranges);
GeneratedGame generator (gameLength);
TetrisPointsEarned f (generator);
HarmonyCompareMax maxComp (f);
HarmonyCompareWrapper comp (maxComp);
HarmonySearch search (comp, factory, varCount, memorySize,
r_accept, r_pa, r_range);
if (initHarmonies)
search.InitializeHarmonies(init);
for (int i = 0; i < iterationCount; ++i) {
search.Iterate();
generator.GenerateNewGame();
search.EraseHarmonyCaches();
std::cout << "COMPLETED ITERATION " << i << std::endl;
}
delete ranges;
std::vector<Harmony const*> memory;
for (int i = 0; i < memorySize; ++i)
memory.push_back(search.GetRanked(i));
std::stringstream ss;
std::ofstream out (outName.c_str(), std::ios::app);
for (int i = 0; i < memorySize; ++i)
ss << *(memory.at(i)) << std::endl << std::endl;
ss << std::endl;
out << ss.str();
out.close();
for (int i = 0; i < memorySize; ++i)
delete memory.at(i);
std::cout << "Completed!" << std::endl;
return 0;
}
int main(int argc, char **arg) {
extmanager MyManager;
DdNode *bdd, **forest;
bddfileheader fileheader;
int code;
char yn;
code = -1;
if (argc != 2) {
fprintf(stderr, "\nUsage: %s [filename]\nGenerates and traverses a BDD from file\n", arg[0]);
fprintf(stderr, "\nUsage: %s -online\nGenerates and traverses a BDD online mode\n", arg[0]);
return code;
}
RAPIDLOADON;
if (strcmp("-online", arg[1]) == 0) {
MyManager.manager = simpleBDDinit(0);
MyManager.t = HIGH(MyManager.manager);
MyManager.f = LOW(MyManager.manager);
MyManager.varmap = InitNamedVars(1, 0);
bdd = OnlineGenerateBDD(MyManager.manager, &MyManager.varmap);
} else {
fileheader = ReadFileHeader(arg[1]);
switch(fileheader.filetype) {
case BDDFILE_SCRIPT:
MyManager.manager = simpleBDDinit(fileheader.varcnt);
MyManager.t = HIGH(MyManager.manager);
MyManager.f = LOW(MyManager.manager);
MyManager.varmap = InitNamedVars(fileheader.varcnt, fileheader.varstart);
if (fileheader.version > 1) {
forest = FileGenerateBDDForest(MyManager.manager, MyManager.varmap, fileheader);
bdd = forest[0];
} else {
forest = NULL;
bdd = FileGenerateBDD(MyManager.manager, MyManager.varmap, fileheader);
}
break;
case BDDFILE_NODEDUMP:
MyManager.manager = simpleBDDinit(fileheader.varcnt);
MyManager.t = HIGH(MyManager.manager);
MyManager.f = LOW(MyManager.manager);
MyManager.varmap = InitNamedVars(fileheader.varcnt, fileheader.varstart);
bdd = LoadNodeDump(MyManager.manager, MyManager.varmap, fileheader.inputfile);
break;
default:
fprintf(stderr, "Error: not a valid file format to load.\n");
return code;
break;
}
}
int nextbdd = 0;
while (bdd != NULL) {
printf("Do you want to load parameter values from testdata.txt [y]? "); yn = getchar(); getchar();
if (yn == 'y') {
printf("yo\n");
LoadVariableData(MyManager.varmap, "testdata.txt");
printf("yo\n");
char **a;
a = GetVariableOrder("testdata.txt", MyManager.varmap.varcnt);
int aa;
for (aa = 0; aa < MyManager.varmap.varcnt; aa++)
printf("%s\n", a[aa]);
ImposeOrder(MyManager.manager, MyManager.varmap, a);
}
code = 0;
MyManager.his = InitHistory(GetVarCount(MyManager.manager));
if (strcmp("-online", arg[1]) != 0) {
DFS(MyManager, bdd);
printf("Do you need an export [y]? "); yn = getchar(); getchar();
if (yn == 'y') simpleNamedBDDtoDot(MyManager.manager, MyManager.varmap, bdd, "SimpleCUDDExport.dot");
printf("Do you want a save [y]? "); yn = getchar(); getchar();
if (yn == 'y') SaveNodeDump(MyManager.manager, MyManager.varmap, bdd, "SimpleCUDDSave.sav");
printf("Do you want to see all true paths [y]? "); yn = getchar(); getchar();
if (yn == 'y') {
ReInitHistory(MyManager.his, GetVarCount(MyManager.manager));
getalltruepaths(MyManager, bdd, "", "");
}
} else {
onlinetraverse(MyManager.manager, MyManager.varmap, MyManager.his, bdd);
}
nextbdd++;
if (forest != NULL) bdd = forest[nextbdd]; else bdd = NULL;
}
if (MyManager.manager != NULL) KillBDD(MyManager.manager);
return code;
}
