int main (int argc, char** argv) {
std::string line;
int limit = 100;
int elements = 4;
std::vector<std::vector<int>> v;
for(int i = 0 ; i < elements - 1; ++i) {
v = generateAll(limit, v);
}
// For the last generation iteration we just want to print out the max value
generateAll(limit, v, true);
}
int main(int argc, char **argv)
{
if(argc < 2) return EXIT_FAILURE;
int stage = atoi(argv[1]);
char *state = argv[2];
if(!isValidState(state)) return EXIT_FAILURE;
if(stage == 1){
//char *state = argv[2];
char *movelist = argv[3];
//if(!isValidState(state)) return EXIT_FAILURE;
if(!isValidMoveList(movelist)) return EXIT_FAILURE;
//printf("processing...\n");
processMoveList(state, movelist);
}
else if(stage == 2){
int n_moves = atoi(argv[3]);
if(n_moves < 0 || n_moves > 9) return EXIT_FAILURE;
MoveTree *generate = generateAll(state, n_moves);
MoveTree_print(generate);
free(generate);
}
else if(stage == 3){
char *solution = solve(state);
printf("%s\n", solution);
free(solution);
}
return EXIT_SUCCESS;
}
MyWidget::MyWidget(QGLWidget *parent)
: QGLWidget(QGLFormat(), parent)
{
setMouseTracking(true);
setPaletteBackgroundColor(QColor(255,255,255));
setstatus();
menu = new QMenuBar(this, "Menu bar");
file = new QPopupMenu( this , "file");
save = new QPopupMenu( this , "save");
placement = new QPopupMenu( this , "placement");
options = new QPopupMenu( this , "options");
view = new QPopupMenu( this , "viewing");
save->insertItem( "Save &eps file", this, SLOT(savedepsfile()), CTRL+Key_E );
save->insertItem( "Save &stl file", this, SLOT(savedstlfile()), CTRL+Key_S );
file->insertItem( "&Load", this, SLOT(openedfile()), CTRL+Key_L );
generate_id = placement->insertItem( "&Generate", &p, SLOT(generate()), CTRL+Key_G );
generatefirst_id = placement->insertItem( "Generate &First", &p, SLOT(generateFirst()), CTRL+Key_F );
generatenext_id = placement->insertItem( "Generate &Next", &p, SLOT(generateNext()), CTRL+Key_N );
generateten_id = placement->insertItem( "Next &ten streamlines", &p, SLOT(generateTen()), CTRL+Key_T );
generateresume_id = placement->insertItem( "&Resume the placement", &p, SLOT(generateAll()), CTRL+Key_C );
clear_id = placement->insertItem( "&Clear", &p, SLOT(purge()), CTRL+Key_M );
drawstl_id = view->insertItem( "&Draw streamlines", &p, SLOT(draw_stl()), CTRL+Key_D );
drawpq_id = view->insertItem( "Draw &queue elements", &p, SLOT(draw_pq()), CTRL+Key_Q );
drawtr_id = view->insertItem( "Draw t&riangulation", &p, SLOT(draw_tr()), CTRL+Key_R );
drawbc_id = view->insertItem( "Draw &biggest circle", &p, SLOT(draw_bc()), CTRL+Key_B );
addimage_id = placement->insertItem( "&Image", this, SLOT(openedimage()), CTRL+Key_I );
options->insertItem( "Density...", &p, SLOT(density()));
options->insertItem( "Saturation ration...", &p, SLOT(ratio()));
options->insertItem( "Sampling step...", &p, SLOT(sampling()));
options->insertItem( "Integrating step...", &p, SLOT(integrating()));
placement->insertItem( "&Options ", options );
save_id = file->insertItem( "&Save", save );
menu->insertItem( "&File", file );
menu->insertItem( "&Placement", placement );
view_id = menu->insertItem( "&View ", view );
file->insertItem( "&Quit", qApp, SLOT(quit()), ALT+Key_F4 );
// desable all generator menu items
placement->setItemEnabled(generate_id, false);
placement->setItemEnabled(generatefirst_id, false);
placement->setItemEnabled(generatenext_id, false);
placement->setItemEnabled(generateten_id, false);
placement->setItemEnabled(generateresume_id, false);
placement->setItemEnabled(clear_id, false);
menu->setItemEnabled(view_id, false);
placement->setItemEnabled(addimage_id, false);
file->setItemEnabled(save_id, false);
connect(this, SIGNAL(fileloaded(const QString &)), &p, SLOT(load(const QString &)));
connect(this, SIGNAL(imageloaded(const QString &)), &p, SLOT(image(const QString &)));
connect(&p, SIGNAL(optionschanged()), this, SLOT(updatestatus()));
}
char *solve(char * state)
{
MoveTree *tree = generateAll(state,MAX_SEARCH_DEPTH);
MoveTree *answer = MoveTree_find(tree, FINAL_STATE);
char *moves = NULL;
if(answer != NULL){
moves = strdup(answer -> moves);
}
MoveTree_destroy(tree);
return moves;
}
MainWindow::MainWindow(QWidget* parent) : QWidget(parent)
{
setupUi(this);
connect(bSave, SIGNAL(clicked()), this, SLOT(generateAll()));
loadConfiguration ( gen_driver_container () );
loadExistConfiguration ( existingProjectFolders() );
fillUi();
connect(tabWidget, SIGNAL(currentChanged(int)), this, SLOT(onTabChanged(int)));
onTabChanged(0);
}
void generateAll(vector<PNoeud>& l,bool elseOther=true) {
PNoeud& n= *this;
Pion pion = n.max?n.computer:!n.computer;
for(size_t i=0;i<n.plat.pions.size();i++) {
for(size_t j=0;j<n.plat.pions[i].size();j++) {
try {
Case tmpc((int)i,(int)j);
l.push_back(PNoeud(n.plat,tmpc,pion,n.computer,!n.max));
} catch (othelloException&) {
}
}
}
if(l.empty() && elseOther) {
n.max = !n.max;
generateAll(l,false);
}
}
Matrix GenSetBase::pllMesh(int P, ColumnVector& xc, ColumnVector& xn, double r)
// P : num points we want ( ~ num of processors)
// xc: the current point;
// xn: the "newton" point, tells the dir in which the mesh is grown
// r: ||xc-xn||, if known.
//
// return matrix M with genset generated at y_k = xc+k(xn-xc)
// with radius r_k = k^n*r_0, r_0=||xc-xn||/2
//
// *** current implementation not optimized for efficiency ***
//
{
int k = 0;
ColumnVector xk;
double rk;
Matrix M, A, B, C;
ColumnVector ns = xn - xc; // newton step
int m = Vdim;
int n = Size;
// return at least the base point
M = xn;
int nump = P-1;
//--
// main loop:
//--
if (r <= 0) r = Norm2(ns);
double r0 = 0.25*r;
double pert = r0*.05;
while (nump > 0) {
// generate points xc + k*newton_step + r^k*d(i), i=1..size()
++k;
xk = xc + k*ns;
rk = k*r0;
A = generateAll(xk,rk);
// perturbation to avoid potential overlaps
int RAND_HALF = RAND_MAX / 2;
for (int i=1; i<=n; i++)
for (int j=1; j<=m; j++) {
int sig = (std::rand() > RAND_HALF)? 1 : -1;
double amp = std::rand() / RAND_MAX * pert;
A(j,i) = A(j,i) + sig * amp ;
}
// after the first iteration want to add xk to M
if (k>1) {
B = M | xk;
M = B;
--nump;
}
// addd to M as many columns as we can afford
if (nump > n) {
B = M | A;
}
else if (nump>0) {
C = A.SubMatrix(1,m,1,nump);
B = M | C;
}
M = B;
nump = nump - n;
}
return M;
}
int main(int argc, char * * argv)
{
if (argc < 3)
{
fprintf(stderr, "Invalid arguments, please refer to "
"the README file, or read the source for "
"pa11.c\n");
return EXIT_FAILURE;
}
char * state = argv[2];
if(!isValidState(state))
{
fprintf(stderr, "Invalid state: %s\n", state);
return EXIT_FAILURE;
}
if (strcmp(argv[1], "1") == 0)
{
if (argc < 4)
{
fprintf(stderr, "Invalid arguments for cmd=1\n");
return EXIT_FAILURE;
}
const char * movelist = argv[3];
if(!isValidMoveList(movelist))
{
fprintf(stderr, "Invalid movelist: %s\n",
movelist);
return EXIT_FAILURE;
}
processMoveList(state, movelist);
}
if (strcmp(argv[1], "2") == 0)
{
if (argc < 4)
{
fprintf(stderr, "Invalid arguments for cmd=2\n");
return EXIT_FAILURE;
}
int nummove = (int) strtol(argv[3], NULL, 10);
if ((nummove < 0) || (nummove > 9))
{
fprintf(stderr, "Expected n=[0..9], but got %d\n",
nummove);
return EXIT_FAILURE;
}
MoveTree * tree = generateAll(state, nummove);
MoveTree_print(tree);
MoveTree_destroy(tree);
}
if (strcmp(argv[1], "3") == 0)
{
char * movelist = solve(state);
if(movelist == NULL) {
printf("No solution within %d steps\n",
MAX_SEARCH_DEPTH);
} else {
printf("%s\n", movelist);
}
free(movelist);
}
return EXIT_SUCCESS;
}
