Ejemplo n.º 1
0
//-----------------------------------------------------------------------------------------------
// Called by Ipopt when finished
//-----------------------------------------------------------------------------------------------
void BonminInterfaceGradients::finalize_solution(TMINLP::SolverReturn status,
                               Index n, const Number* x, Number obj_value)
{


    cout << "IPOPT returned a status indicating ";

    if ( status == Ipopt::SUCCESS ) cout << "SUCCESS";
    else if ( status == Ipopt::MAXITER_EXCEEDED ) cout << "MAXITER_EXCEEDED";
    else if ( status == Ipopt::CPUTIME_EXCEEDED ) cout << "CPUTIME_EXCEEDED";
    else if ( status == Ipopt::STOP_AT_TINY_STEP ) cout << "STOP_AT_TINY_STEP";
    else if ( status == Ipopt::STOP_AT_ACCEPTABLE_POINT ) cout << "STOP_AT_ACCEPTABLE_POINT";
    else if ( status == Ipopt::LOCAL_INFEASIBILITY ) cout << "LOCAL_INFEASIBILITY";
    else if ( status == Ipopt::USER_REQUESTED_STOP ) cout << "USER_REQUESTED_STOP";
    else if ( status == Ipopt::FEASIBLE_POINT_FOUND ) cout << "FEASIBLE_POINT_FOUND";
    else if ( status == Ipopt::DIVERGING_ITERATES ) cout << "DIVERGING_ITERATES";
    else if ( status == Ipopt::RESTORATION_FAILURE ) cout << "RESTORATION_FAILURE";
    else if ( status == Ipopt::ERROR_IN_STEP_COMPUTATION ) cout << "ERROR_IN_STEP_COMPUTATION";
    else if ( status == Ipopt::INVALID_NUMBER_DETECTED ) cout << "INVALID_NUMBER_DETECTED";
    else if ( status == Ipopt::TOO_FEW_DEGREES_OF_FREEDOM ) cout << "TOO_FEW_DEGREES_OF_FREEDOM";
    else if ( status == Ipopt::INVALID_OPTION ) cout << "INVALID_OPTION";
    else if ( status == Ipopt::OUT_OF_MEMORY ) cout << "OUT_OF_MEMORY";
    else if ( status == Ipopt::INTERNAL_ERROR ) cout << "INTERNAL_ERROR";
    else cout << "UNKNOWN_ERROR";

    cout << endl;

    cout << "Writing the final solution to the summary file..." << endl;
    Case *c = generateCase(n,x);
    c->setObjectiveValue(-obj_value);

    p_optimizer->sendBestCaseToRunner(c);

}
Ejemplo n.º 2
0
void    SfBall::_initNewGame() {
    for (std::list<Ball*>::iterator it = _balls.begin(); it != _balls.end(); ++it)
        delete *it;
    _balls.clear();
    _map->reset(22, 26);
    _resetMousePosition();

    Ball* ball = new Ball(sf::Vector2f(5.5, 5.5), 0.15, _gameWorld);
    ball->setName("Ball_1");
    ball->setSpeed(sf::Vector2f(1, 5) * 0.5f);
    *_scene << ball;
    _balls.push_back(ball);
    Case* current;

    for (int i = 0; i < 22; ++i) {
        current = new StandardCase(sf::Vector2f(i, 10), _gameWorld);
        current->setColor(sf::Color::Yellow);
        *_scene << current;
        *_map << current;
    }
    for (int i = 6; i < 22; ++i) {
        current = new StandardCase(sf::Vector2f(i, 5), _gameWorld);
        current->setColor(sf::Color::Yellow);
        *_scene << current;
        *_map << current;
    }
    sf::View view = _window->getView();

    _playerBar->setPosition(sf::Vector2f(view.getCenter().x, 1));
}
Ejemplo n.º 3
0
int main(int argc, char **argv){
	DBR reasoner = DBR(argv[1],argv[2]);
	int choice = 0;
	Case prob = Case();
	Dish sol = Dish();
	while((choice = mainMenu()) != 3){
		switch(choice){
			case 1:
				reasoner.addDish(constructDish());
				break;
			case 2:
				prob = constructProblem();
				sol = reasoner.query(prob);
				cout << "You should try ";
				cout << sol.getName() <<endl;
				if(goodSuggestion()){
					reasoner.addCase(Case(prob.getLikes(), prob.getDislikes(), sol));
				}
				break;
			default:
				cout << "Unrecognized input!" <<endl;
				break;
		}
	}
	cout << "Bye!" <<endl;
	reasoner.save(argv[1],argv[2]);
	return 0;
}
Ejemplo n.º 4
0
void SfBall::PreSolve(b2Contact *contact, const b2Manifold *oldManifold) {
    Object* objA = (Object*)contact->GetFixtureA()->GetBody()->GetUserData();
    Object* objB = (Object*)contact->GetFixtureB()->GetBody()->GetUserData();
    Ball* currentBall = dynamic_cast<Ball*>(objA);
    Object* currentObject = NULL;

    if (!currentBall) {
        currentBall = dynamic_cast<Ball*>(objB);
        currentObject = objA;
    } else {
        currentObject = objB;
    }
    if (!currentBall || !currentObject)
        return ;
    Case*   currentCase = NULL;
    Wall*   currentWall = NULL;
    Bar*    currentBar = NULL;
    if ((currentCase = dynamic_cast<Case*>(currentObject)) != NULL) {
        currentCase->contact(this);
    } else if ((currentWall = dynamic_cast<Wall*>(currentObject)) != NULL) {
        if (currentWall == _bottomWall)
            std::cout << "LOOOOSE" << std::endl;
    } else if ((currentBar = dynamic_cast<Bar*>(currentObject)) != NULL) {

    } else {
        contact->SetEnabled(false);
        return ;
    }
}
Ejemplo n.º 5
0
Sort* PartieClient::getSort(Position* position, int id_sort)
{
    Case* caseCible = this->getCase(position);
    if(caseCible == NULL)
    {
        return NULL;
    }
    return caseCible->getSortId(id_sort);
}
Ejemplo n.º 6
0
bool GestionnaireCollision::collisionMur(const Fantome& fantome, const Case& mur)
{
    if(fantome.estSorti())
    {
        if(mur.getType() != 0 && mur.getType() != 4 && mur.getType() != 5)
        {
            return fantome.getSprite().getGlobalBounds().intersects(mur.getRectangle().getGlobalBounds());
        }
        else
        {
            return false;
        }
    }
    else
    {
        if(mur.getType() != 0 && mur.getType() != 3 && mur.getType() != 4 && mur.getType() != 5)
        {
            return fantome.getSprite().getGlobalBounds().intersects(mur.getRectangle().getGlobalBounds());
        }
        else
        {
            return false;
        }
    }
}
Ejemplo n.º 7
0
Case * AngeAleatoire::choisirUneCase() {
	int x = 0;
	int y = 0;
	int t = maPartie->monDamier->taille;
	int i, j, n, r;
	Case * c;
	// le programme choisit un coup
	n = 0; // on compte le nombre de coups possibles.
	for (i=0; i<t; i++) {
		for (j=0; j<t; j++) {
			c = maPartie->monDamier->mesCases[i][j];
			if ((c->distance(maCase)<=puissance) && !(c->estBouchee()) && (!c->estAnge()))
				n++;
		}
	}
	r = Alea::engendrer(n);
	n = 0; // on selectionne un coup aleatoire dans les coups possibles.
	for (i=0; i<t; i++) {
		for (j=0; j<t; j++) {
			c = maPartie->monDamier->mesCases[i][j];
			if ((c->distance(maCase)<=puissance) && !(c->estBouchee()) && (!c->estAnge()))
				if (++n == r) {
					x = c->getX() + 1;
					y = c->getY() + 1;
				}
			}
	}
	return c;
}
Ejemplo n.º 8
0
int main()
{
	int moveNum = 0;
	

	freopen("input.txt", "r", stdin);

	for (int y = 0; y < 8; y++)
	{
		scanf("%s", map[y]);
	}

	for (int y = 0; y < 8; y++)
	{
		for (int x = 0; x < 8; x++)
		{
			if (map[y][x] == WHITE)
			{
				setBit(&nowCase.m_State, x, y, 1);
			}

			if (map[y][x] == GOAL)
			{
				goalX.push_back(x);
				goalY.push_back(y);
			}
		}
	}

	

	for (;;)
	{
		printBoard();
		char key = getch();

		switch (key)
		{
		case 'a':
			nowCase = nowCase.getNextCase(LEFT);
			break;
		case 'w':
			nowCase = nowCase.getNextCase(UP);
			break;
		case 's':
			nowCase = nowCase.getNextCase(DOWN);
			break;
		case 'd':
			nowCase = nowCase.getNextCase(RIGHT);
			break;
		}
	}
	return 0;
}
Ejemplo n.º 9
0
void Unite::attaquer(Case c) {
    if (getJoueur()->getPtAction()<m_AttaqueParDefaut->getPtAction()) {
        ManquePtAction ex;
        throw ex;
    }
    Case cE = *(getPosition()[0]);
    if ((abs(c.getX() - cE.getX()) + abs(c.getY() - cE.getY())) <= m_AttaqueParDefaut->getPortee()) {
        ManquePortee ex;
        throw ex;
    }
    m_AttaqueParDefaut->lancerAttaque(&c);
}
Ejemplo n.º 10
0
void Unite::attaquer(Case c, Attaque* attaque) {
    if (getJoueur()->getPtAction()<attaque->getPtAction()) {
        ManquePtAction ex;
        throw ex;
    }
    Case cE = *(getPosition()[0]);
    if ((abs(c.getX() - cE.getX()) + abs(c.getY() - cE.getY())) <= attaque->getPortee()) {
        ManquePortee ex;
        throw ex;
    }
    attaque->lancerAttaque(&c);
}
Ejemplo n.º 11
0
bool Classifier::eval(Case &c,PredicateNode &pred)
{
  int attribute=pred.getAttribute();
  switch(schema[attribute]->getType())
    {
    case DISCRETE:
      return c.getDiscrete(attribute)==pred.getIntValue();
    case CONTINUOUS:
      return c.getContinuous(attribute)<=
	pred.getFloatValue();
    }
}
Ejemplo n.º 12
0
bool GestionnaireCollision::collisionMur(const Pacman& pacman, const Case& mur)
{
    // 0 et 4 représente les tile ou l'on peut passer
    if(mur.getType() != 0 && mur.getType() != 4 && mur.getType() != 5)
    {
        return pacman.getSprite().getGlobalBounds().intersects(mur.getRectangle().getGlobalBounds());
    }
    else
    {
        return false;
    }
}
Ejemplo n.º 13
0
//-----------------------------------------------------------------------------------------------
// evaluates the model
//-----------------------------------------------------------------------------------------------
bool LshNomadEvaluator::eval_x(NOMAD::Eval_Point &x, const NOMAD::Double &h_max, bool &count_eval) const
{
    // generating a case from the evaluation point
    Case *c = generateCase(x);
    CaseQueue *cq = new CaseQueue();

    cq->push_back(c);

    // sending the case off for evaluation
    p_optimizer->sendCasesToOptimizer(cq);

    ///p_optimizer->runCase(c);

    // extracting the objective
    x.set_bb_output(0, -c->objectiveValue());





    // extracting the constraint values
    // the constraints in NOMAD must be on the form: c <= 0

    for(int i = 0; i < c->numberOfConstraints(); ++i)
    {
        double val_input;
        double val = c->constraintValue(i);
        double max = p_optimizer->runner()->model()->constraints().at(i)->max();
        double min = p_optimizer->runner()->model()->constraints().at(i)->min();


        if(val > max) val_input = val - max;

        else if(val < min) val_input = min - val;
        else
        {
            double u_slack = max - val;
            double l_slack = val - min;

            val_input = (u_slack > l_slack) ? -u_slack : -l_slack;
        }

        x.set_bb_output(i+1, val_input);
    }

    // deleting the case from the heap
    delete c;
    delete cq;

    return true;


}
Ejemplo n.º 14
0
int Case::FinishUpdateLoadedTexturesStatic(void *pData)
{
    UpdateLoadedTexturesParameters *pParams = reinterpret_cast<UpdateLoadedTexturesParameters *>(pData);

    Case *pThis = pParams->pCase;
    string newLocationId = pParams->newLocationId;

    delete pParams;

    pThis->FinishUpdateLoadedTextures(newLocationId);

    return 0;
}
Ejemplo n.º 15
0
void ReceptionClient::traitementInfoSort()
{
    char* argument[6] = {NULL};
    Sort* sort = NULL;
    Case* caseCible = NULL;
    Joueur* proprietaire = NULL;
    int x = -1, y = -1, duree = -1;
    unsigned int id = 0;
    for(int i = 0; i < 6; i++)
    {
        argument[i] = strtok (NULL, SEPARATEUR_ELEMENT);
    }
    for(int i = 0; i < 6; i++)
    {
        if(argument[i] == NULL)
        {
            //Info fausse
            return;
        }
    }
    x = atoi(argument[4]);
    y = atoi(argument[5]);
    duree = atoi(argument[3]);
    id = atoi(argument[1]);

    sort = this->partie->getSort(Position::fabriquePosition(x, y), id);
    //Sort inexistant sur la case
    if(sort == NULL)
    {
        sort = UsineSort::fabriqueSort(argument[0]);
        //Pas de sort de ce nom
        if(sort == NULL)
        {
            return;
        }
        proprietaire = this->partie->getJoueur((argument[2]));
        //Pas de joueur de ce nom
        if(proprietaire == NULL)
        {
            return;
        }
        sort->setProprietaire(proprietaire);
        sort->setId(id);
        caseCible = this->partie->getCase(Position::fabriquePosition(x, y));
        //Pas de case à cette position
        if(caseCible != NULL)
        {
            caseCible->ajouterSort(sort, duree);
        }
    }
}
Ejemplo n.º 16
0
Partie::Partie(int t, char a, char d) {
  monDamier = new Damier(t);
  gagnee = false;
  
  if (a=='h') monAnge = new AngeHumain(this, 1);
  if (a=='a') monAnge = new AngeAleatoire(this, 1);   
  Case * c = monDamier->mesCases[monDamier->taille/2][monDamier->taille/2];
  c->setAnge(monAnge);
  monAnge->setCase(c);
  if (d=='h') monDiable = new DiableHumain(this);
  if (d=='a') monDiable = new DiableAleatoire(this);

  trait = monAnge;
}
Ejemplo n.º 17
0
void Partie::initialiser() {
  cout << "\tAnge Humain ou Aleatoire ? (h/a)" << endl;
  char r;
  cin >> r;
  if (r=='h') monAnge = new AngeHumain(this, 1);
  if (r=='a') monAnge = new AngeAleatoire(this, 1);   
  Case * c = monDamier->mesCases[monDamier->taille/2][monDamier->taille/2];
  c->setAnge(monAnge);
  monAnge->setCase(c);
  cout << "\tDiable Humain ou Aleatoire ? (h/a)" << endl;
  cin >> r;
  if (r=='h') monDiable = new DiableHumain(this);
  if (r=='a') monDiable = new DiableAleatoire(this);
  trait = monAnge;
}
Ejemplo n.º 18
0
void				Graphics::printRessources(Map *map)
{
  Case				*currentCase;
  std::map<t_ressource, int>	currentMap;
  t_ressource			currentRes;

  for (size_t i = 0; (currentCase = map->getCase(i)) != NULL; i++)
    {
      currentMap = currentCase->getRessources();
      for (int j = 0; j != 7; j++)
	{
	  currentRes = (t_ressource)j;
	  if (currentMap[currentRes] > 0)
	    printThisRessourceAtPos(currentRes, currentCase->getPos());
	}
    }
}
Ejemplo n.º 19
0
int main()
{
   clrscr();
   Timer t;
   int index;
   Case C;
   C.input();
   t.start();index = C.Horspool_Machine();t.stop();

   if(index == -1) cout << "\nMatch couldn't be found\n";
   else cout << "\nMatch found at position "<< (index + 1) <<"\n";
   
   cout << "\nTime taken for this is : "<< t.time() <<" seconds\n";

   getch();
   return 0;
}
Ejemplo n.º 20
0
//-----------------------------------------------------------------------------------------------
// generates a case with the starting point variable values for int  and bin types
//-----------------------------------------------------------------------------------------------
Case* IpoptOptimizer::generateStartingPoint()
{
    Case *c = new Case();

    // integer variables
    for(int i = 0; i < runner()->model()->integerVariables().size(); ++i)
    {
        c->addIntegerVariableValue(runner()->model()->integerVariableValue(i));
    }

    // binary variables
    for(int i = 0; i < runner()->model()->binaryVariables().size(); ++i)
    {
        c->addBinaryVariableValue(runner()->model()->binaryVariableValue(i));
    }

    return c;
}
Ejemplo n.º 21
0
//-----------------------------------------------------------------------------------------------
// generates a case from an Eval_Point
//-----------------------------------------------------------------------------------------------
Case* LshNomadEvaluator::generateCase(const NOMAD::Eval_Point &x) const
{
    Case *c = new Case();

    int var_num = 0;

    for(int i = 0; i < p_optimizer->runner()->model()->realVariables().size(); ++i)
    {
        c->addRealVariableValue(x[var_num].value());
        ++var_num;
    }




    return c;

}
void GameForm::updateCaseDisplay(int caseId)
{
	Case* currentCase = Game::getInstance()->getCase(caseId);
	int value = currentCase->getValue();

	Osp::Base::String label= "";

	if(value >0 && value <= _valueMax)
	{
		if(currentCase->isFixed())
			_buttons[caseId]->SetTextColor(Osp::Graphics::Color::COLOR_RED);
		else
			_buttons[caseId]->SetTextColor(Osp::Graphics::Color::COLOR_BLUE);

		label.Insert(value,0);
	}
	_buttons[caseId]->SetText(label);
}
Ejemplo n.º 23
0
bool DiableHumain::verifier(int x,int y){
	bool ok=true;
	Case * c;
	if ((x>0) && (y>0) &&
		(x<=maPartie->monDamier->taille)&&
		(y<=maPartie->monDamier->taille)) {
			ok = true;
			c = maPartie->monDamier->mesCases[x-1][y-1];
			if (c->estBouchee()){
				cout << "Erreur: case bouchee." << endl; ok = false;
			}
			if (c->estAnge()) {
				cout << "Erreur: case occupee par l'ange." << endl; ok = false;
			}
		}
		else ok = false;
	return ok;
}
Ejemplo n.º 24
0
Case* CaseBuilder::construct()
{
    Q_ASSERT(m_executable);
    QFileInfo exeLocation(m_executable->location().toLocalFile());

    QString cazeName = m_executable->name();
    if (!m_suite.isEmpty() && cazeName.startsWith(m_suite + '-')) {
        QStringList spl = cazeName.split('-');
        Q_ASSERT(spl.count() > 1);
        spl.removeFirst();
        cazeName = spl.join("-");
    }

    Case* caze = new Case(cazeName, exeLocation);
    caze->setExecutable( m_executable );
    Executable* exe = m_executable;
    //exe->setLocation(KUrl(exeLocation.absoluteFilePath()));
    m_executable->setCase(caze);
    exe->setOutputParser( new OutputParser);
    QStringList exeFunctionOut = m_executable->fetchFunctions();
    bool success = false;
    foreach(QString line, exeFunctionOut) { //krazy:exclude=foreach
        if (line.endsWith(QLatin1String("()")) &&
                !line.contains(QLatin1String(" "))) {
            // recognize this as a legit qtest function output line
            line.chop(2); // remove "()"
            Command* foo = new Command(line, caze);
            caze->addChild(foo);
            success = true;
        } else { // garbage
            if (!line.isEmpty()) {
                kDebug() << "Garbage line:\n" << line;
            }
        }
    }
    if (success) {
        return caze;
    } else {
        delete caze;
        return 0;
    }
}
Ejemplo n.º 25
0
void Unite::deplacer(Case c) {
    Case nouveau = deplacement(c);
    if (c.getX()!=nouveau.getX() && c.getY()!=nouveau.getY() && !nouveau.isOccupee())
    {
        nouveau.setCase(this);
        //Rajout de void setCase(Unite unite); -> Test de si la case n'est pas occup�, puis mettre a jour la case
                                // appel d'une exception si la case est occup� (Pour saut� l'instruction suivante)
                                // ou avec un booleen, je ne sais pas
                                // Nicolas :-D
        c.setCase(NULL);
        // mettre a 0 la case
    }
    else
    {
        cout << "case prise"<<endl;
    }
}
Ejemplo n.º 26
0
void Etat::interaction(Case& c){
  switch(c.getInteraction()){
  case 1:{
    interface->setEtat(&interface->ainvs);
    interface->affichage();
    break;
  }
  case 2:{
    cout << "La porte est fermée" << endl;
    break;
  }
  case 3:{
    interface->setEtat(&interface->adial);
    interface->affichage();
    break;
  }
  }
}
Ejemplo n.º 27
0
void Jeu::tourJoueur(Joueur* j){
    pair<Joueur*,int> pairetmp;


    cout << "debut du tour." << endl;
    Case* ct;
    Case* tmp;
    //on rajoute un au compteur de jouer du joueur
    j->setJouer(j->getJouer()+1);
    //s'il peut jouer et qu'il n'a pas gagné, on lance son tour
    while((j->getJouer())>0 && !joueurAGagne(j)){
        int choix = j->choixPions();
        pairetmp = make_pair(j,choix);
        //Le joueur fait son choix de pions et on vérifie que c'est vraiment un pion et qu'il n'est pas en fin
        //Ici, le joueur peut choisir 0 s'il veut choisir après le lancer de dé
        while(choix<0 || choix>j->getNombrePions() || (choix!=0 && plateau.estEnFin(placementpions.find(pairetmp)->second))){
            choix = j->choixPions();
            pairetmp = make_pair(j,choix);
        }
        int lancer = j->choixDeplacement();
        cout << "le lancer vaut " << lancer << endl;
        //Si le joueur n'a toujours pas fait son choix, on lui redemande de choisir
        while(choix<1 || choix>j->getNombrePions() || plateau.estEnFin(placementpions.find(pairetmp)->second)){
            choix = j->choixPions();
            pairetmp = make_pair(j,choix);
        }

        ct = placementpions.find(pairetmp)->second;
        //une fois la case du pions trouvée, on fait avancer le pion
        tmp = j->avancerPion(ct, lancer);
        //on enlève un pion à l'ancienne case
        ct->setNombrePions(ct->getNombrePions()-1);
        //on supprime le lien entre pion et case pour créer le nouveau lien
        placementpions.erase(placementpions.find(pairetmp));
        placementpions.insert(make_pair(pairetmp,tmp));
        //on rajoute un pion à la nouvelle case
        tmp->setNombrePions(tmp->getNombrePions()+1);
        cout << "le pion est à la case " << tmp->getNumeroCase() << endl;
        cout << "peut-il rejouer ? " << j->getJouer() << endl;

        string k;
        afficher();
        getline(cin,k);

    }
}
void BruteForceFinder::Worker::solution_found(size_t insert_place, const Case& _case) {
    Insertion& insertion = this->solving_step.back();
    insertion.insert_place = insert_place;
    auto insert_place_mask = insertion.skeleton.get_insert_place_mask(insert_place);
    for (const Algorithm& algorithm: _case.algorithm_list()) {
        Insertion& insertion = this->solving_step.back();
        insertion.insertion = &algorithm;
        if (!insertion.skeleton.is_worthy_insertion(
            algorithm, insert_place,
            insert_place_mask,
            this->finder.fewest_moves
        )) {
            continue;
        }
        this->solving_step.push_back({
            insertion.skeleton.insert(algorithm, insert_place).first,
        });
        this->update_fewest_moves();
        this->solving_step.pop_back();
    }
}
Ejemplo n.º 29
0
 void visitSwitchStatement(SwitchStatement *node) override {
   prefix();
   fprintf(fp_, "[ SwitchStatement\n");
   indent();
   node->expression()->accept(this);
   for (size_t i = 0; i < node->cases()->length(); i++) {
     Case *c = node->cases()->at(i);
     c->expression()->accept(this);
     if (c->others()) {
       for (size_t j = 0; j < c->others()->length(); j++)
         c->others()->at(j)->accept(this);
     }
     indent();
     c->statement()->accept(this);
     unindent();
   }
   if (node->defaultCase())
     node->defaultCase()->accept(this);
   unindent();
 }
Ejemplo n.º 30
0
void Case::copy(const Case kase){//DONE
    setTouche(kase.getTouche());
    setBateau(kase.getBateau());
}