gecoder-with-gecode 0.9.0 → 0.9.1

data/ext/gecode-2.2.0/contribs/qecode/myspace.hh

@@ -0,0 +1,68 @@
+/*****************************************************************[myspace.hh]
+Copyright (c) 2007, Universite d'Orleans - Jeremie Vautard, Marco Benedetti,
+Arnaud Lallouet.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*****************************************************************************/
+#ifndef __QECODE_MYSPACE__
+#define __QECODE_MYSPACE__
+
+#include "qecode.hh"
+#include <vector>
+#include "gecode/minimodel.hh"
+#include "vartype.hh"
+
+using namespace Gecode;
+using namespace Gecode::Int;
+
+/** \brief A simple extension of Gecode::Space class
+*
+*  A simple extension of the Space class from Gecode, in order to have access to the variables it contains.
+*/
+
+class QECODE_VTABLE_EXPORT MySpace : public Space {
+    
+protected :
+    unsigned int n;
+    
+public:
+    /** \brief This array contains all the variables this space contains.
+    */
+    void** v;
+    
+    
+    /** \brief This array indicates the type of each variable
+    */
+    VarType* type_of_v;
+    
+    /** \brief Constructor of a space with a fixed number of variables
+        *
+        * Builds a space which will contain  nv variables (the variables themselves are however not declared).
+        *  @param nv the number of variable the space must contain.
+        */
+    QECODE_EXPORT MySpace(unsigned int nv);
+    QECODE_EXPORT int nbVars() {return n;}
+    QECODE_EXPORT MySpace(bool share,MySpace& ms);
+    QECODE_EXPORT virtual MySpace* copy(bool share);
+    QECODE_EXPORT virtual ~MySpace();
+};
+
+
+
+#endif

data/ext/gecode-2.2.0/contribs/qecode/qsolver.cc

@@ -0,0 +1,268 @@
+/****   , [ QSolver.cc ], 
+Copyright (c) 2008 Universite d'Orleans - Jeremie Vautard 
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+ *************************************************************************/
+
+#include "qsolver.hh"
+#include <climits>
+
+QSolver::QSolver(Implicative* sp) {
+    this->sp = sp;
+    nbRanges=new int;
+}
+
+Strategy QSolver::solve(unsigned long int& nodes) {
+    vector<int> plop;
+    plop.clear();
+    return rSolve(sp,0,plop,nodes);
+}
+
+Strategy QSolver::rSolve(Implicative* qs,int scope, vector<int> assignments, unsigned long int& nodes) {
+    nodes++;
+//    cout<<"rSolve for scope "<<scope<<" with assignments ";
+//    for (int i=0;i<assignments.size();i++) cout<<assignments[i]<<" ";
+//    cout<<endl;
+    //////////////////////////////////////////////////////////////////////////////////////////
+    // First case : we reached the goal, we just have to check it                           //
+    //////////////////////////////////////////////////////////////////////////////////////////
+    if (scope == qs->spaces()) {
+//        cout<<"First case"<<endl;
+        MySpace* g = qs->getGoal();
+        if (g == NULL) {/*cout<<"the goal was null"<<endl;*/return Strategy(StrategyNode::SFalse());}
+        for (int i=0;i<g->nbVars();i++) {
+            switch (g->type_of_v[i]) {
+                case VTYPE_INT : 
+                    post(g,*(static_cast<IntVar*>(g->v[i])) == assignments[i]);
+                    break;
+                case VTYPE_BOOL :
+                    post(g,*(static_cast<BoolVar*>(g->v[i])) == assignments[i]);
+                    break;
+                default :
+                    cout<<"1Unknown variable type"<<endl;
+                    abort();
+            }
+        }
+        if (g->status() == SS_FAILED) {
+//            cout<<"goal failed after assignments"<<endl;
+            delete g;
+            return Strategy(StrategyNode::SFalse());
+        }
+//        cout<<"goal OK"<<endl;
+        delete g;
+        return Strategy(StrategyNode::STrue());
+    }
+    
+    /////////////////////////////////////////////////////////////////////////////////////////
+    // Second case : we are in the middle of the problem...                                //
+    /////////////////////////////////////////////////////////////////////////////////////////
+    else {
+//        cout<<"second case "<<endl;
+        MySpace* espace = qs->getSpace(scope);
+        if (espace == NULL) cout<<"I caught a NULL for scope "<<scope<<". I will crash..."<<endl;
+//        cout<<"size of assignments "<<assignments.size()<<endl;
+        for (int i=0;i<assignments.size();i++) {
+//            cout<<"I assign variable "<<i<<" with value "<<assignments[i]<<endl; cout.flush();
+            switch (espace->type_of_v[i]) {
+                case VTYPE_INT : 
+                    post(espace,*(static_cast<IntVar*>(espace->v[i])) == assignments[i]);
+                    break;
+                case VTYPE_BOOL :
+                    post(espace,*(static_cast<BoolVar*>(espace->v[i])) == assignments[i]);
+                    break;
+                default :
+                    cout<<"2Unknown variable type"<<endl;
+                    abort();
+            }
+        }
+        
+        // Second case, first subcase : current scope is universal
+        /////////////////////////////////////////////////////////
+        if (qs->quantification(scope)) {
+//            cout<<"universal"<<endl;
+            
+            if (espace->status() == SS_FAILED) {
+//                cout<<"the scope is failed"<<endl;
+                delete espace;
+                return Strategy(StrategyNode::STrue());
+            }
+            
+            DFS<MySpace> solutions(espace);
+            MySpace* sol = solutions.next();
+            if (sol == NULL) {
+//                cout<<"first sol is null"<<endl;
+                delete espace;
+                return Strategy(StrategyNode::STrue());
+            }
+            
+            Strategy retour = StrategyNode::Dummy();
+            while (sol != NULL) {
+//                cout<<"a solution"<<endl;
+                vector<int> assign;
+                for (int i = 0; i<sol->nbVars();i++) {
+                    switch (sol->type_of_v[i]) {
+                        case VTYPE_INT : 
+                            assign.push_back( (static_cast<IntVar*>(sol->v[i]))->val() );
+                            break;
+                        case VTYPE_BOOL : 
+                            assign.push_back( (static_cast<BoolVar*>(sol->v[i]))->val() );
+                            break;
+                        default :
+                            cout<<"3Unknown variable type"<<endl;
+                            abort();
+                    }
+                }
+                
+                int vmin = ( (scope==0)? 0 : (qs->nbVarInScope(scope-1)) );
+                int vmax = (qs->nbVarInScope(scope))-1;
+                vector<int> zevalues;
+                for (int i = vmin; i<=vmax;i++) {
+                    switch (sol->type_of_v[i]) {
+                        case VTYPE_INT : 
+                            zevalues.push_back( (static_cast<IntVar*>(sol->v[i]))->val() );
+                            break;
+                        case VTYPE_BOOL : 
+                            zevalues.push_back( (static_cast<BoolVar*>(sol->v[i]))->val() );
+                            break;
+                        default :
+                            cout<<"4Unknown variable type"<<endl;
+                            abort();
+                    }
+                }
+                Strategy toAttach(true,vmin,vmax,scope,zevalues);
+                
+                Strategy son = rSolve(qs,scope+1,assign,nodes);
+                if (son.isFalse()) {
+//                    cout<<"the son is false"<<endl;
+                    delete sol;
+                    delete espace;
+                    return Strategy(StrategyNode::SFalse());
+                }
+//                cout<<"the son is true"<<endl;
+                toAttach.attach(son);
+                retour.attach(toAttach);
+                delete sol;
+                sol = solutions.next();
+            } // end of while
+            delete espace;
+            return retour;
+        } // end of if(universal)
+        
+        // Second case, second subcase : current scope is existential
+        ////////////////////////////////////////////////////////////
+        else {
+//            cout<<"existential"<<endl;
+            if ((espace->status()) == SS_FAILED) {
+//                cout<<"the Espace is failed"<<endl;
+                delete espace;
+                return Strategy(StrategyNode::SFalse());
+            }
+            
+            DFS<MySpace> solutions(espace);
+            MySpace* sol =solutions.next();
+            if (sol == NULL) {
+//                cout<<"the first sol is null"<<endl;
+                delete espace;
+                return Strategy(StrategyNode::SFalse());
+            }
+            
+            OptVar* opt = qs->getOptVar(scope);
+            int opttype = qs->getOptType(scope);
+            Strategy retour(StrategyNode::SFalse());
+            int score= ( (opttype == 1) ? INT_MAX : INT_MIN );
+            while (sol != NULL) {
+//                cout<<"une solution"<<endl;
+                vector<int> assign;
+                for (int i = 0; i<sol->nbVars();i++) {
+                    switch (sol->type_of_v[i]) {
+                        case VTYPE_INT : 
+                            assign.push_back( (static_cast<IntVar*>(sol->v[i]))->val() );
+                            break;
+                        case VTYPE_BOOL : 
+                            assign.push_back( (static_cast<BoolVar*>(sol->v[i]))->val() );
+                            break;
+                        default :
+                            cout<<"5Unknown variable type"<<endl;
+                            abort();
+                    }
+                } // end for
+
+                int vmin = ( (scope==0)?0 : qs->nbVarInScope(scope-1) );
+                int vmax = qs->nbVarInScope(scope)-1;
+                vector<int> zevalues;
+                for (int i = vmin; i<=vmax;i++) {
+                    switch (sol->type_of_v[i]) {
+                        case VTYPE_INT : 
+                            zevalues.push_back( (static_cast<IntVar*>(sol->v[i]))->val() );
+                            break;
+                        case VTYPE_BOOL : 
+                            zevalues.push_back( (static_cast<BoolVar*>(sol->v[i]))->val() );
+                            break;
+                        default : 
+                            cout<<"6unknown Variable type"<<endl;
+                            abort();
+                    }
+                }
+                Strategy candidate(false,vmin,vmax,scope,zevalues);
+
+                Strategy son_of_candidate = rSolve(qs,scope+1,assign,nodes);
+                if (son_of_candidate.isFalse()) candidate = Strategy::SFalse();
+                else candidate.attach(son_of_candidate);
+                
+                int score_of_candidate;
+                if (candidate.isFalse()) score_of_candidate = ( (opttype == 1) ? INT_MAX : INT_MIN );
+                else score_of_candidate = opt->getVal(candidate);
+//                cout<<"score of candidate is "<<score_of_candidate<<endl;
+//                cout<<"Opt type is";
+                switch (opttype) {
+                    case 0 : // ANY
+//                        cout<<"ANY"<<endl;
+                        if (!candidate.isFalse()) {
+                            delete sol;
+                            delete espace;
+                            return candidate;
+                        }
+                        break;
+                    case 1 : // MIN
+//                        cout<<"MIN"<<endl;
+                        if (score_of_candidate < score) {
+                            retour=candidate;
+                            score=score_of_candidate;
+                        }
+                        break;
+                    case 2 : // MAX
+//                        cout<<"MAX"<<endl;
+                        if (score_of_candidate > score) {
+                            retour=candidate;
+                            score=score_of_candidate;
+                        }
+                        break;
+                    default : 
+                        cout<<"Unknown opt type : "<<opttype<<endl;
+                        abort();
+                        break;
+                } // end switch
+                delete sol;
+                sol=solutions.next();
+            } // end while 
+            delete espace;
+            return retour;
+        } // end if..else (existential)
+    }// end "Second case"
+}

data/ext/gecode-2.2.0/contribs/qecode/qsolver.hh

@@ -0,0 +1,46 @@
+/****   , [ qsolver.hh ], 
+Copyright (c) 2008 Universite d'Orleans - Jeremie Vautard 
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+ *************************************************************************/
+#ifndef __QECODE_QSOLVER_OPT__
+#define __QECODE_QSOLVER_OPT__
+
+#include "Implicative.hh"
+#include <iostream>
+#include <cstdlib>
+#include "gecode/minimodel.hh"
+#include "gecode/search.hh"
+#include "Strategy.hh"
+#include "qecode.hh"
+
+using namespace Gecode;
+class QECODE_VTABLE_EXPORT QSolver {
+    
+private:
+    int n;
+    Implicative* sp;
+    int* nbRanges;
+    Strategy rSolve(Implicative* qs,int scope,vector<int> assignments,unsigned long int& nodes);
+public:
+    QECODE_EXPORT QSolver(Implicative* sp);
+    QECODE_EXPORT Strategy solve(unsigned long int& nodes);
+};
+
+#endif

data/ext/gecode-2.2.0/doxygen/doxygen.hh.in

@@ -0,0 +1,1112 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2005
+ *     Guido Tack, 2005
+ *
+ *  Last modified:
+ *     $Date: 2008-07-11 10:17:28 +0200 (Fri, 11 Jul 2008) $ by $Author: tack $
+ *     $Revision: 7320 $
+ *
+ *  This file is part of Gecode, the generic constraint
+ *  development environment:
+ *     http://www.gecode.org
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining
+ *  a copy of this software and associated documentation files (the
+ *  "Software"), to deal in the Software without restriction, including
+ *  without limitation the rights to use, copy, modify, merge, publish,
+ *  distribute, sublicense, and/or sell copies of the Software, and to
+ *  permit persons to whom the Software is furnished to do so, subject to
+ *  the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be
+ *  included in all copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ *  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ *  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ *  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ *  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+/*
+ * No code, just contains the group definitions of the
+ * Doxygen-generated documentation
+ */
+
+
+/**
+ * \defgroup Task Functionality by programming task
+ */
+
+/**
+ * \defgroup TaskModel Programming models
+ * \ingroup Task
+ */
+
+/**
+ * \defgroup TaskModelScript Setting up scripts
+ *
+ * Scripts (or models) are programmed by inheriting from the class
+ * Gecode::Space. For many examples see \ref Example.
+ *
+ * \ingroup TaskModel
+ */
+
+/**
+ * \defgroup TaskModelInt Using finite domain integers
+ * \ingroup TaskModel
+ */
+
+/**
+ * \defgroup TaskModelIntVars Integer variables
+ * \ingroup TaskModelInt
+ */
+
+/**
+ * \defgroup TaskModelSearch Search engines
+ *
+ * Defines search engines. All search engines (but Gecode::LDS, where
+ * it is not needed) support recomputation. The behaviour of recomputation
+ * is controlled by a passing a search option object (see the class 
+ * Gecode::Search::Options).
+ *
+ * Requires \code #include "gecode/search.hh" \endcode
+ * \ingroup TaskModel
+ */
+
+/**
+ * \defgroup TaskModelSet Using finite integer sets
+ * \ingroup TaskModel
+ */
+
+/**
+ * \defgroup TaskModelSetVars Set variables
+ * \ingroup TaskModelSet
+ */
+
+/**
+ * \defgroup TaskModelCpltSet Using finite integer sets with complete domain representation
+ * \ingroup TaskModel
+ */
+
+/**
+ * \defgroup TaskModelCpltSetVars Set variables with complete domain representation
+ * \ingroup TaskModelCpltSet
+ */
+
+/**
+ * \defgroup TaskModelMiniModel Direct modelling
+ * \ingroup TaskModel
+ */
+
+/**
+ * \defgroup TaskSearch Programming search engines
+ * \ingroup Task
+ */
+
+/**
+ * \defgroup TaskActor Programming actors
+ * \ingroup Task
+ */
+
+/**
+ * \defgroup TaskActorInt Programming integer actors
+ * \ingroup TaskActor
+ */
+
+/**
+ * \defgroup TaskActorSet Programming set actors
+ * \ingroup TaskActor
+ */
+
+/**
+ * \defgroup TaskActorCpltSet Programming CpltSet actors
+ * \ingroup TaskActor
+ */
+
+/**
+ * \defgroup TaskVar Programming variables
+ * \ingroup Task
+ */
+
+/**
+ * \defgroup TaskVarView Programming views for variables
+ * \ingroup TaskVar
+ */
+
+/**
+ * \defgroup TaskTest Testing
+ * \ingroup Task
+ */
+
+/**
+ * \defgroup TaskReflSer Reflection and serialization
+ * \ingroup Task
+ *
+ * Reflection allows you to query a Space object for the propagators, 
+ * branchings, and variables that it contains.
+ *
+ * Serialization provides methods for producing a text or binary 
+ * representation of a space that can be used to recreate a copy of the space.
+ */
+
+/**
+ * \defgroup TaskReflection Reflection API
+ *
+ * The reflection API provides information about the propagators, branchings,
+ * and variables in a space. More detailed, step-by-step information can be 
+ * found in the \ref PageReflection "reflection tutorial".
+ *
+ * Requires \code #include "gecode/kernel.hh" \endcode
+ *
+ * \ingroup TaskReflSer
+ */
+
+#include "doxygen/reflection.hh"
+
+/**
+ * \defgroup TaskSerialization Serialization
+ *
+ * The serialization API lets you produce text or binary representations of a 
+ * space, and recreate a copy of the original space from that representation.  
+ * It provides funcionality for creating variables and posting propagators in 
+ * a space using the specifications obtained through reflection.
+ *
+ * Requires \code #include "gecode/serialization.hh" \endcode
+ *
+ * \ingroup TaskReflSer
+ */
+
+/**
+ * \defgroup Func Common functionality
+ */
+
+/**
+ * \defgroup FuncMem Memory management
+ * \ingroup Func
+ */  
+
+/**
+ * \defgroup FuncThrow Gecode exceptions
+ * \ingroup Func
+ */
+
+/**
+ * \defgroup FuncSupport Support algorithms and datastructures
+ *
+ * These are some common datastructures used in the implementation of
+ * %Gecode. Maybe they can be also useful to others.
+ *
+ * In order to use them, one needs to include the appropriate header-file
+ * as described in the class and function documentation.
+ * \ingroup Func
+ */  
+
+/**
+ * \defgroup FuncIter Range and value iterators
+ *
+ * Both range and value iterators have a rather simple interface
+ * for controlling iteration (which deviates from what you might be
+ * used to from other iterators).
+ *
+ * The application operator (if \c i is an iterator, it is invoked by \c i() )
+ * tests whether an iterator has not yet reached
+ * its end (in this case, \c true is returned). The prefix
+ * increment operator (if \c i is an iterator, this is invoked as \c ++i)
+ * moves the iterator to the next element (either next value or next range).
+ *
+ * Value iterators provide access to the value by the member function
+ * \c val(). Range iterators provide access to the smallest, largest, and
+ * width of the current range by \c min(), \c max(), and \c width()
+ * respectively.
+ * 
+ * Requires \code #include "gecode/iter.hh" \endcode
+ * \ingroup Func
+ */
+
+/**
+ * \defgroup FuncIterRanges Range iterators
+ *
+ * A range iterator provides incremental access to a sequence of increasing
+ * ranges.
+ *
+ * Requires \code #include "gecode/iter.hh" \endcode
+ * \ingroup FuncIter
+ */
+
+/**
+ * \defgroup FuncIterRangesVirt Range iterators with virtual member functions
+ *
+ * A range iterator provides incremental access to a sequence of increasing
+ * ranges. Iterators with virtual member functions have to be used when
+ * they are combined dynamically, and the actual types hence cannot be
+ * specified as template arguments.
+ *
+ * Requires \code #include "gecode/iter.hh" \endcode
+ * \ingroup FuncIterRanges
+ */
+
+/**
+ * \defgroup FuncIterValues Value iterators
+ *
+ * A value iterator provides incremental access to a sequence of increasing
+ * values. 
+ *
+ * Requires \code #include "gecode/iter.hh" \endcode
+ * \ingroup FuncIter
+ */
+
+/**
+ * \defgroup FuncIterValuesVirt Value iterators with virtual member functions
+ *
+ * A value iterator provides incremental access to a sequence of increasing
+ * values. Iterators with virtual member functions have to be used when
+ * they are combined dynamically, and the actual types hence cannot be
+ * specified as template arguments.
+ *
+ * Requires \code #include "gecode/iter.hh" \endcode
+ * \ingroup FuncIterValues
+ */
+
+/**
+ * \defgroup Other Other available functionality
+ *
+ */
+
+/**
+ * \defgroup FuncIntProp Integer propagators
+ *
+ * This module contains a description of all predefined integer 
+ * propagators. They can be reused, for example, for rewriting
+ * newly defined integer propagators into already available
+ * propagators.
+ * \ingroup Other
+ */
+
+/**
+ * \defgroup FuncIntSelView Integer view selection for branching
+ *
+ * Contains a description of view selection strategies on integer
+ * views that can be used together with the generic view/value
+ * branching class Gecode::ViewValBranching (argument \a ViewSel).
+ *
+ * All view selection classes require 
+ * \code #include "gecode/int/branch.hh" \endcode
+ * \ingroup Other
+ */
+
+/**
+ * \defgroup FuncIntSelVal Integer value selection for branching
+ *
+ * Contains a description of value selection strategies on integer
+ * views that can be used together with the generic view/value
+ * branching class Gecode::ViewValBranching (argument \a ValSel).
+ *
+ * All value selection classes require 
+ * \code #include "gecode/int/branch.hh" \endcode
+ * \ingroup Other
+ */
+
+/**
+ * \defgroup FuncSetProp Set propagators
+ *
+ * This module contains a description of all predefined finite set
+ * propagators. They can be reused, for example, for rewriting
+ * newly defined finite set propagators into already available
+ * propagators.
+ * \ingroup Other
+ */
+
+/**
+ * \defgroup FuncSetSelView Set view selection for branching
+ *
+ * Contains a description of view selection strategies on set
+ * views that can be used together with the generic view/value
+ * branching class Gecode::ViewValBranching (argument \a ViewSel).
+ *
+ * All view selection classes require 
+ * \code #include "gecode/set/branch.hh" \endcode
+ * \ingroup Other
+ */
+
+/**
+ * \defgroup FuncSetSelVal Set value selection for branching
+ *
+ * Contains a description of value selection strategies on set
+ * views that can be used together with the generic view/value
+ * branching class Gecode::ViewValBranching (argument \a ValSel).
+ *
+ * All value selection classes require 
+ * \code #include "gecode/set/branch.hh" \endcode
+ * \ingroup Other
+ */
+
+/**
+ * \defgroup FuncCpltSetProp CpltSet propagators
+ *
+ * This module contains a description of all predefined
+ * propagators for CpltSet variables. They can be reused, for example, for 
+ * rewriting newly defined CpltSet propagators into already available
+ * propagators.
+ * \ingroup Other
+ */
+
+/**
+ * \defgroup FuncCpltSetSelView CpltSet view selection for branching
+ *
+ * Contains a description of view selection strategies on CpltSet
+ * views that can be used together with the generic view/value
+ * branching class Gecode::ViewValBranching (argument \a ViewSel).
+ *
+ * All view selection classes require 
+ * \code #include "gecode/cpltset/branch.hh" \endcode
+ * \ingroup Other
+ */
+
+/**
+ * \defgroup FuncCpltSetSelVal CpltSet value selection for branching
+ *
+ * Contains a description of value selection strategies on CpltSet
+ * views that can be used together with the generic view/value
+ * branching class Gecode::ViewValBranching (argument \a ValSel).
+ *
+ * All value selection classes require 
+ * \code #include "gecode/cpltset/branch.hh" \endcode
+ * \ingroup Other
+ */
+
+/**
+ * \defgroup Example Example scripts (models)
+ *
+ * All scripts are compiled into simple standalone programs. All
+ * programs understand the several generic and problem-specific
+ * commandline options. An overview of the options is available
+ * by invoking the standalone programs with the <code>-help</code>
+ * commandline option.
+ *
+ */
+
+/**
+ * \defgroup ExProblem Scripts for problems
+ * \ingroup Example
+ *
+ * These scripts are for small problems that exemplify how to model
+ * with %Gecode.
+ *
+ */
+
+/**
+ * \defgroup ExStress Scripts for stress tests
+ * \ingroup Example
+ *
+ * These scripts are for stressing certain system features, typically
+ * the implementation of a particular constraint.
+ *
+ */
+
+/*
+ * Collect some definitions for which no reasonable place exists
+ *
+ */
+
+/**
+ * \namespace Gecode::Support 
+ * \brief %Support algorithms and datastructures
+ */
+
+/**
+ * \mainpage Gecode Reference Documentation
+ *
+ * This document provides reference information about
+ * <A HREF="http://www.gecode.org">%Gecode</A>.
+ * The documentation is structured into three major groups: 
+ * getting started, common programming tasks, and  
+ * available functionality.
+ *
+ * This document corresponds to %Gecode version @VERSION@, please consult
+ * the changelog for \ref SectionChangeList "recent changes".
+ *
+ * \section SecStart Getting started
+ *
+ * For your first steps with %Gecode, the following pages may be of interest:
+ *  - \ref PageComp
+ *  - \ref PageUsage
+ *  - \ref PageNotation
+ *  - \ref PageGlossary
+ *
+ * To get started with modelling in %Gecode, you may also want to have a look 
+ * at our \ref Example.
+ *
+ * \section SecByTask Programming tasks
+ *
+ * Documentation is available for the following tasks:
+ *  - \ref TaskModel
+ *  - \ref TaskSearch
+ *  - \ref TaskActor "Programming propagators and branchings"
+ *  - \ref TaskVar
+ *  - \ref TaskTest
+ *  - \ref TaskReflSer
+ *
+ * \section SecByFunc Available functionality
+ *
+ * The most important functionality is:
+ *  - \ref FuncMem
+ *  - \ref FuncThrow
+ *
+ * The complete functionality can be found \ref Func "here".
+ *
+ * The part \ref Other documents existing propagators, variable 
+ * implementations, and so on which serves as documentation of examples.
+ *
+ * \section SecIndex List and index content
+ *
+ * Additionally, the documentation also features the following parts:
+ *  - \ref PageLic
+ *  - \ref PageChange
+ *
+ * The following lists and indices are available
+ *  - \ref PageCodeStat
+ *  - <a class="el" href="modules.html">List of all modules</a> 
+ *  - <a class="el" href="annotated.html">List of all classes including brief documentation</a>
+ *  - <a class="el" href="namespaces.html">List of all namespaces including brief documentation</a>
+ *  - <a class="el" href="files.html">List of all files</a>
+ *  - <a class="el" href="hierarchy.html">Class hierarchy</a>
+ *  - <a class="el" href="classes.html">Alphabetical class index</a>
+ *  - <a class="el" href="namespacemembers.html">Namespace members</a>
+ *  - <a class="el" href="functions.html">Class members</a>
+ *  - <a class="el" href="globals.html">File members</a>
+ */
+
+/**
+ * \page PageNotation Notational conventions
+ *
+ * Throughout this reference documentation we use some notational conventions
+ * designed to keep the documentation concise yet understandable. Please
+ * read the following carefully.
+ *
+ * \section NotationArray Array notation
+ *
+ * We allow ourselves to refer to the \f$i\f$-th element of an array \f$x\f$ 
+ * by \f$x_i\f$. The size of an array \f$x\f$ (either provided by a member 
+ * function \c %size() or clear from context) is denoted \f$|x|\f$.
+ *
+ * \section NotationHome The home space
+ *
+ * Many functions and member functions take an argument \a home of 
+ * type \c Space*. The home space serves as manager to many
+ * operations used by variables, views, propagators, spaces, and so
+ * on. It provides
+ * services such as failure management, propagation control, 
+ * memory management, and so on. To keep the documentation concise
+ * the home space is not documented for functions
+ * and member functions.
+ *
+ * \section NotationShare Sharing in update and copy
+ *
+ * In member functions that either copy or update an object during
+ * cloning, an argument \a share of type \c bool is available. This
+ * Boolean value controls whether during cloning the data structure at
+ * hand will be shared among the newly created cloned space and the original
+ * or whether two independent copies are created. Some functions (such
+ * as \c copy for spaces (Gecode::Space) or \c copy for propagators
+ * (Gecode::Propagator) also feature this argument. Here it is used
+ * to pass on the Boolean value to other datastructures used inside spaces
+ * or propagators.
+ *
+ * The actual value the \a share argument has is defined by the search
+ * engine: when a search engine uses the \a clone member function of
+ * a space it decides whether sharing is to be used in the cloning of
+ * the space or not. If the search engine is single-threaded, it will
+ * use full sharing (\a share will be true). Only if the search engine
+ * uses concurrency or parallelism with more than a single thread,
+ * it will pass false as value. This means that by not sharing data structures
+ * among spaces which are to be used in different threads, all parts of
+ * %Gecode but the actual search engine do not need to provide concurrency
+ * control.
+ *
+ * As examples for data structures which are sensitive to sharing, consider
+ * Gecode::SharedArray, Gecode::IntSet, and Gecode::DFA.
+ */
+
+/**
+  \page PageGlossary Brief glossary
+
+This page gives brief explanations about some of the most
+frequently occurring terms (currently limited to important
+entities manifest in the implementation) used in the %Gecode
+reference documentation.
+
+\section GlossaryActor Actor
+
+An actor is a branching (\ref GlossaryBranching), a propagator
+(\ref GlossaryPropagator), or an advisor (\ref
+GlossaryAdvisor). Actors provide common functionality such as
+member functions for copying during cloning, memory allocation,
+and so on. Actors are implemented by the class
+Gecode::Actor. More on programming actors can be found in the
+module \ref TaskActor.
+
+\section GlossaryBranching Branching
+
+A branching defines the shape of the search tree. Branchings are
+also known as labelings or distributors, and a branching creates
+a series of choice points. Branchings are implemented by the
+class Gecode::Branching. A common abstraction for defining
+branchings based on view and value selection is provided by the
+class Gecode::ViewValBranching.
+
+\section GlossaryBranchingDesc Branching description
+
+A branching description speeds up recomputation by providing
+batch recomputation. It is created by a branching (\ref
+GlossaryBranching) and allows to replay the effect of that
+branching without the need to first perform constraint
+propagation. The base-class for branching descriptions is
+Gecode::BranchingDesc. An example for a branching description
+that works together with branchings based on view and value
+selection is Gecode::PosValDesc.
+
+\section GlossarySpace Computation space
+
+A computation space (space for short) comprises all entities for
+a constraint problem to be solved, including all actors (\ref
+GlossaryActor) and variables (\ref GlossaryVariable). A space can
+be seen as corresponding to a node in the search tree. It
+organizes constraint propagation, the branching process,
+exploration, and memory management. Spaces are implemented by the
+class Gecode::Space. They provide functionality for \ref
+TaskModelScript, \ref TaskSearch, and \ref FuncMemSpace.
+
+\section GlossaryME Modification event
+
+A modification event describes how a view (\ref GlossaryView) or
+variable implementation (\ref GlossaryVarImp) is changed by an
+update operation performed on the view or variable. Each variable
+domain defines its own modification events (see \ref
+TaskActorIntMEPC and \ref TaskActorSetMEPC). However modification
+events that describe generic events such as failure, no
+modification, or assignment to a single value are predefined (see
+\ref TaskVarMEPC).
+
+\section GlossaryPropCond Propagation condition
+
+A propagation condition defines when a propagator requires to be
+re-executed. Re-execution is controlled by the modification events
+that occur on the variables the propagator depends on (see \ref
+GlossaryPropagator). Propagation conditions and the relation
+between propagation conditions and modification events depends on
+the variable domain (see \ref TaskActorIntMEPC and \ref
+TaskActorSetMEPC). However, the propagation conditions that
+states re-execution when a variable becomes assigned is generic
+(see \ref TaskVarMEPC).
+
+\section GlossaryPropagator Propagator
+
+A propagator implements a constraint (actually, a constraint can
+be implemented by a collection of propagators). Execution by a
+propagator is defined by its dependencies: the views (referring to
+some variables) together with their propagation conditions. A
+propagator is implemented by inheriting from the class
+Gecode::Propagator. Common abstractions for propagators are also
+available (see \ref TaskPropPat, \ref TaskPropRePat, and \ref
+TaskPropSetPat).
+
+\section GlossaryAdvisor Advisor
+
+An advisor supports a single propagator. An advisor is executed
+whenever the view it has subscribed to is modified. Execution of
+an advisor amounts to executing the advise member function of the
+advisor's propagator where the advisor and delta information
+(\ref GlossaryDelta) are passed as arguments. An advisor is
+implemented by inheriting from the class Gecode::Advisor.
+
+\section GlossaryDelta Delta information
+
+Delta information is implemented as an object which is a subclass
+of Gecode::Delta. A Delta object describes how the domain of a
+variable has been changed by an operation on the variable. Delta
+objects are passed together with advisors to the advise member
+function of a propagator.
+
+\section GlossaryMED Modification event delta
+
+A propagator maintains a delta of modification events for all
+variable types. A modification event delta is available to the
+propagate and cost member functions of a propagator and describes
+the modification events that have occurred since the last execution of a
+propagator.  A modification event delta is highly abstract: it
+does not reveal for which variable a particular modification
+event occurred, it only reveals that a certain modification event
+has occurred for any variable of a given variable
+type. Modification events for a particular variable type can be
+extracted from a modification event delta through the respective
+view or variable implementation (see for example \ref
+TaskActorIntView or \ref TaskActorSetView).
+
+\section GlossaryVariable Variable
+
+A variable is used for modeling problems, be it for direct
+modeling or for modeling through some interface. A variable
+provides only those operations useful for modeling and excludes
+in particular operations that can modify the variable domain
+directly. A variable is implemented by a variable implementation
+(see below).
+
+\section GlossaryVarImp Variable implementation
+
+A variable implementation is implemented by inheriting from
+Gecode::Variable. It implements the variable domain and provides
+operations to access and modify the domain. Examples of variable
+implementations are Gecode::Int::IntVarImp and
+Gecode::Set::SetVarImp.
+
+\section GlossaryView View
+
+A view offers essentially the same interface as a variable
+implementation and allows both domain access and
+modification. Typically, several views exist for the same
+variable implementation to obtain several constraints from the
+same propagator. Examples of views are \ref TaskActorIntView and
+\ref TaskActorSetView.
+
+*/
+ 
+/**
+ * \page PageUsage Compiling and linking against Gecode
+ *
+ * \section SecUsageInclude Including header files
+ *
+ * Deciding which header files must be included when using %Gecode is
+ * quite straightforward. There are the following header files for inclusion:
+ *  - gecode/support.hh must always included (support.hh header is 
+ *    included from kernel.hh)
+ *  - gecode/kernel.hh must always be included (the header files below
+ *    also always include kernel.hh).
+ *  - gecode/search.hh must be included, if search engines are used 
+ *    (see for example \ref TaskModelSearch).
+ *  - gecode/int.hh must be included, if any integer functionality is used
+ *    (see for example \ref TaskModelInt and \ref TaskActorInt).
+ *  - gecode/set.hh must be included, if any finite set functionality is used
+ *    (see for example \ref TaskModelSet and \ref TaskActorSet).
+ *  - gecode/cpltset.hh must be included, if any complete finite set 
+ *    functionality is used
+ *    (see for example \ref TaskModelCpltSet and \ref TaskActorCpltSet).
+ *  - gecode/minimodel.hh must be included, if direct modelling support
+ *    is used (see for example \ref TaskModelMiniModel).
+ *  - gecode/serialization.hh must be included, if support for serialization
+ *    is used.
+ *
+ * Other functionality is available through a set of header files. For example
+ * to access the implementation of particular propagators, a particular header
+ * file must be included. The header file to be included is always mentioned
+ * in the documentation of the class or function.
+ *
+ * \section SecUsageLink Linking libraries
+ *
+ * Setting the exact name for a library on a particular platform aside,
+ * inclusion of header files basically coincides with against which
+ * library must be linked. That is:
+ *  - If gecode/support.hh is included, linking againg the support library is 
+ *    required.
+ *  - If gecode/kernel.hh is included, linking against the kernel library is
+ *    required.
+ *  - If gecode/search.hh is included, linking against the search library is
+ *    required.
+ *  - If gecode/int.hh is included, linking against the integer library is
+ *    required.
+ *  - If gecode/set.hh is included, linking against the set library is
+ *    required.
+ *  - If gecode/cpltset.hh is included, linking against the cpltset library is
+ *    required.
+ *  - If gecode/minimodel.hh is included, linking against the minimodel
+ *    library is required.
+ *  - If gecode/serialization.hh is included, linking against the 
+ *    serialization library is required.
+ *
+ * The functionality in \ref FuncIter requires no
+ * library for linking. Reusing integer or set propagators of course
+ * require the integer or set library.
+ *
+ * If there is a difference between library and DLL (such as on Windows)
+ * linking must be done against the appropriate library and the
+ * corresponding DLL must be available for execution (such as in the
+ * PATH environment variable).
+ *
+ * The libraries contain code that is executed at link time (for registering
+ * part of the reflection functionality).  If you create static libraries,
+ * this code will not be linked into your executable as it is not directly
+ * referenced. You will have to tell your linker to include all symbols from 
+ * the library (e.g. using -Wl,--whole-archive on Linux). Please refer to your
+ * linker documentation.
+ *
+ * \section SecUsageLibraries Library names
+ *
+ * \subsection SULA Windows with Visual Studio
+ *
+ *  - Support library and DLL: GecodeSupport.lib and GecodeSupport.dll
+ *  - Kernel library and DLL: GecodeKernel.lib and GecodeKernel.dll
+ *  - Search library and DLL: GecodeSearch.lib and GecodeSearch.dll
+ *  - Integer library and DLL: GecodeInt.lib and GecodeInt.dll
+ *  - Set library and DLL: GecodeSet.lib and GecodeSet.dll
+ *  - CpltSet library and DLL: GecodeCpltSet.lib and GecodeCpltSet.dll
+ *  - Minimodel library and DLL: GecodeMiniModel.lib and GecodeMiniModel.dll
+ *  - Serialization library and DLL: GecodeSerialization.lib and 
+ *    GecodeSerialization.dll
+ *
+ * \subsection SULB Unix (Linux, MacOS X)
+ *
+ * Depending on whether %Gecode was compiled as a static or as a dynamic
+ * library, different filename suffixes are used on different Unix platforms.
+ * All library names follow the following scheme:
+ *
+ *  - Support library: libgecodesupport.&lt;EXT&gt;
+ *  - Kernel library: libgecodekernel.&lt;EXT&gt;
+ *  - Search library: libgecodesearch.&lt;EXT&gt;
+ *  - Integer library: libgecodeint.&lt;EXT&gt;
+ *  - Set library: libgecodeset.&lt;EXT&gt;
+ *  - CpltSet library: libgecodecpltset.&lt;EXT&gt;
+ *  - Minimodel library: libgecodeminimodel.&lt;EXT&gt;
+ *  - Serialization library: libgecodeserialization.&lt;EXT&gt;
+ *
+ * where &lt;EXT&gt; depends on the library type and platform:
+ *
+ *  - libgecode[...].a for static libaries on all Unix flavors
+ *  - libgecode[...].so for shared libraries on Linux
+ *  - libgecode[...].dylib for shared libraries on MacOS X
+ *
+ * You can use for example
+ * 
+ * <code>gcc -L$GPREFIX/lib -lgecodekernel</code>
+ *
+ * to link the kernel library, if the libraries are found in
+ * <code>$GPREFIX/lib</code>.
+ */
+ 
+/**
+ * \page PageComp Compiling and installing Gecode
+ *
+ * The %Gecode library, including examples and documentation, can be built
+ * on all recent versions of Windows, Linux, and MacOS X. Porting to other
+ * Unix flavors should be easy, if any change is necessary at all.
+ *
+ * \section Prerequisites
+ *
+ * In order to compile %Gecode, you need a standard Unix toolchain including
+ * the following programs:
+ *
+ *  - a bash-compatible shell
+ *  - GNU make
+ *  - sed
+ *  - cp
+ *  - diff
+ *  - tar
+ *  - perl
+ *
+ * These are available in all standard installations of Linux. On MacOS X,
+ * you need to install the Apple developer tools. For
+ * Windows, we require the
+ * <a href="http://www.cygwin.com/">Cygwin environment</a> that provides
+ * all necessary tools.
+ *
+ * We currently support
+ *   - the Microsoft Visual C++ compilers for Windows. The Microsoft
+ *     Visual C++ 2005 Express Edition is available free of charge from
+ *     <a href="http://msdn.microsoft.com/vstudio/express/visualc/">the MSDN
+ *     web pages</a>. 
+ *   - the GNU Compiler Collection (gcc) for Windows and Unix flavors such as
+ *     Linux and MacOS X. The GNU gcc is open source software and available
+ *     from <a href="http://gcc.gnu.org/">the GCC home page</a>. It is included
+ *     in all Linux distributions and the Apple MacOS X developer tools.
+ *     %Gecode requires at least version 3.4 of gcc. We recommend using version
+ *     4.2 or higher. Very unfortunately, the parser used in versions of gcc
+ *     before 3.4 is broken and hence cannot compile %Gecode.
+ *
+ * The Intel C++ compiler is currently not supported.
+ *
+ * \section CompConf Configuring the sources
+ *
+ * %Gecode uses GNU autoconf to acquire information about the system it is
+ * compiled on. Typically, you need to run the <code>configure</code>
+ * script in the toplevel directory.
+ *
+ * To setup %Gecode for your particular system, you may need to add one or
+ * more of the following options to <code>configure</code>:
+ *
+ *  - When using the GNU compiler gcc on Windows instead of the Microsoft
+ *    compiler, add
+ *    <code>CC=gcc CXX=g++</code> to your
+ *    invocation of <code>configure</code>
+ *  - To install %Gecode somewhere else than the default
+ *    <code>/usr/local</code>, use the <code>--prefix=[...]</code> switch
+ *  - You can enable and disable the individual modules %Gecode consists of
+ *    using <code>--enable-[MODULE]</code> and <code>--disable-[MODULE]</code>
+ *
+ * You can get a list of all supported configuration options by calling 
+ * <code>configure</code> with the <code>--help</code> switch.
+ *
+ * \subsection CompConfExamples Example configurations
+ *
+ * To compile %Gecode on a <b>Windows machine using the GNU compiler</b>, use
+ *
+ * <code>./configure CC=gcc CXX=g++</code>
+ *
+ * To compile only the %Gecode library <b>without examples</b> on a Unix machine, use
+ *
+ * <code>./configure --disable-examples</code>
+ *
+ * To compile on a <b>Unix machine</b> using a different than the default
+ * <code>gcc</code> compiler, and install under <code>/opt/gecode</code>, use
+ *
+ * <code>./configure --prefix=/opt/gecode CC=gcc-4.0 CXX=g++-4.0</code>
+ *
+ * To compile a <b>debug build</b> on Unix, turning on all assertions and not
+ * inlining anything, use
+ *
+ * <code>./configure --enable-debug</code>
+ *
+ * To compile on <b>Cygwin</b>, but linking against the <b>Windows libraries</b> instead
+ * of the Cygwin libraries, use
+ *
+ * <code>./configure CC="gcc -mno-cygwin" CXX="g++ -mno-cygwin"</code>
+ * Note that we only support building static libraries on Cygwin.
+ *
+ * To compile on a system using a different than the default compiler,
+ * and a <code>/bin/sh</code> that is not bash compatible (e.g. a
+ * <b>Solaris machine</b>), use
+ *
+ * <code>./configure --with-host-os=linux \ </code><br>
+ * <code>&nbsp;&nbsp;&nbsp;CC="gcc-4.0" CXX="g++-4.0" \ </code><br>
+ * <code>&nbsp;&nbsp;&nbsp;SHELL="/bin/bash"</code><br>
+ * <code>make SHELL="/bin/bash"</code>
+ *
+ * You can compile as <b>"universal binary" on a Mac OS
+ * machine</b>. Configure with
+ *
+ * <code>./configure --with-architectures=i386,ppc</code>
+ *
+ * For building universal binaries on a PowerPC machine, you have to supply
+ * the path to the universal SDK (which is the default on Intel based Macs):
+ * 
+ * <code>./configure --with-architectures=i386,ppc</code>
+ * <code>&nbsp;&nbsp;&nbsp;--with-sdk=/Developer/SDKs/MacOSX10.4u.sdk</code>
+ *
+ * \subsection CompConfUsr Passing options for compilation
+ *
+ * Additional options for compilation can be passed to the compiler
+ * from the make commandline via the variable <code>CXXUSR</code>. For
+ * example, to pass to gcc the additional option "-mtune=i686" the following
+ * can be used:
+ *
+ * <code>make CXXUSR="-mtune=i686"</code>
+ *
+ * \subsection CompConfSepDir Compiling in a separate directory
+ *
+ * The %Gecode library can be built in a separate directory. This is useful
+ * if you do not want to clutter the source tree with all the object files
+ * and libraries.
+ *
+ * Configuring %Gecode in a separate directory is easy. Assume that the
+ * sources can be found in directory <code>$GSOURCEDIR</code>, change to
+ * the directory where you want to compile %Gecode and call
+ *
+ * <code>$GSOURCEDIR/configure [options]</code>
+ *
+ * This will generate all necessary files in the new build directory.
+ *
+ * \section CompComp Compiling the sources
+ *
+ * After successful configuration, simply invoking
+ *
+ * <code>make</code>
+ *
+ * in the toplevel %Gecode directory will compile the whole library.
+ *
+ * \section CompExamples Running the examples
+ *
+ * After compiling the examples, they can be run directly from the command
+ * line. For instance, try the %Golomb Rulers Problem:
+ *
+ * <code>./examples/golomb</code>
+ *
+ * or (when running Windows):
+ *
+ * <code>./examples/golomb.exe</code>
+ * 
+ * On some platforms, you may need to set environment variables like
+ * <code>LD_LIBRARY_PATH</code> (Linux) or <code>DYLD_LIBRARY_PATH</code>
+ * (Mac OS) to the toplevel compile directory (where the dynamic libraries
+ * are placed after compilation).
+ *
+ * For more information on example scripts see \ref Example.
+ *
+ * \section Installation Installation
+ *
+ * After a successful compilation, you can install the %Gecode library
+ * and all header files necessary for compiling against it by invoking
+ *
+ * <code>make install</code>
+ *
+ * in the build directory.
+ *
+ * \section DepMngmt Dependency management
+ *
+ * The dependencies between source files are not handled automatically. If you
+ * are using a Gecode version from our subversion repository or if you
+ * modified any of the source files, you will have to call
+ * <code>make depend</code> before compilation in order to determine the
+ * source dependencies.
+ *
+ * Dependency management is only needed for recompiling Gecode after changing
+ * something. In an unmodified version (or after a <code>make clean</code>)
+ * all files are compiled anyway.
+ *
+ * \section UnsupPlatfrms Compiling for unsupported platforms
+ *
+ * If you want to try compiling Gecode on a platform that we do not
+ * mention, you can override the platform tests during
+ * <code>configure</code>. There are two options to specify the type of
+ * platform:
+ *
+ *  - <code>--with-host-os=[linux|darwin|windows]</code>
+ *  - <code>--with-compiler-vendor=[gnu|microsoft]</code>
+ *
+ * Using the first option, you can state that your platform should behave like
+ * Linux, Darwin (which is actually BSD), or Windows. This affects mainly
+ * the filenames and the tools used to generate shared and static libraries.
+ *
+ * The second option says
+ * that your compiler can be used very much like the gnu compiler
+ * <code>gcc</code>, or the Microsoft compiler <code>cl</code>.
+ * Please let us know of any successfull attempt at
+ * compiling Gecode on other platforms.
+ *
+ * \section MakeTargets Useful Makefile targets
+ *
+ * The main %Gecode Makefile supports the following useful targets:
+ *
+ *  - <code>all</code> compiles all parts of the library that were enabled
+ *                     during <code>configure</code>, and the examples if
+ *                     enabled
+ *  - <code>install</code> installs library, headers and examples (if enabled)
+ *                         into the <code>prefix</code> given at
+ *                         <code>configure</code>
+ *  - <code>clean</code> removes object files
+ *  - <code>veryclean</code> removes object files, libraries, and all files 
+ +                           generated during <code>make</code>
+ *  - <code>distclean</code> removes object files, libraries, and all
+ *                           generated files
+ *  - <code>depend</code> generates dependencies between source files
+ *  - <code>test</code> compiles the test suite
+ *  - <code>doc</code> generates this reference documentation using doxygen
+ *  - <code>installdoc</code> installs the documentation
+ *  - <code>dist</code> creates a source distribution as a tgz archive, not 
+ *    including the contributions found in the <code>contribs</code> directory
+ *  - <code>distdir</code> creates a source distribution in a directory, not 
+ *    including the contributions found in the <code>contribs</code> directory
+ *  - <code>distdoc</code> creates tgz and zip archives of the documentation
+ *  - <code>distzip</code> creates a binary distribution as a zip archive
+ *  - <code>disttgz</code> creates a binary distribution as a tgz archive
+ *
+ * \section CompileGist Compilation with Gist
+ *
+ * The %Gecode Interactive Search Tool (Gist) is a graphical search engine for 
+ * %Gecode, built on top of the
+ * <a href="http://trolltech.com/products/qt">Qt GUI toolkit</a>.
+ *
+ * In order to compile %Gecode with Gist, you need an installation of the Qt 
+ * library including the development header files.  The source code for Qt is 
+ * <a href="http://trolltech.com/downloads/opensource">available from 
+ * Trolltech under the GPL license.</a>
+ *
+ * <b>
+ * Please note that if you want to develop closed-source software with %Gecode
+ * and Gist, you will need to get a commercial license for Qt from Trolltech!
+ * </b>
+ *
+ * If you are developing on Windows using the Microsoft Visual C++ compiler, 
+ * make sure to compile the Qt library with the same compiler (this is 
+ * possible with Qt version 4.3.2, even if the download page does not say so).
+ *
+ * If the <code>qmake</code> tool is in your shell path, all you need to do to 
+ * enable Gist is to configure %Gecode with the switch 
+ * <code>--enable-gist</code>.
+ */
+
+
+/**
+ * \page PageHowToChange_2 How to Change from Gecode 1.3.1 to Gecode 2.0.x
+ *
+
+As Gecode 2.0.0 is a major revision of Gecode, your programs that are written
+for Gecode 1.3.1 are likely to require some modifications before they work
+again. All modifications are straightforward, though.
+
+This short summary shows how to adapt your models and linker invocation, for
+changes to propagator implementations, etc, please consult the changelog.
+
+\section SecChange2IntBool IntVar and BoolVar
+
+Boolean variables (BoolVar) are not any longer integer variables
+(IntVar). The same holds for variable arrays (BoolVarArray,
+IntVarArray). So, you can not mix Boolean and integer variables
+in the same array (use two different arrays) and you can not cast
+between them. If you want to link the value of a BoolVar to the
+value of an IntVar you have to use a \ref TaskModelIntChannel
+"channel constraint".  Posting constraints remains unchanged, as
+all constraints offer two overloaded versions (one for IntVar,
+one for BoolVar).
+
+\section SecChange2Regular Regular constraint
+
+The regular constraint has been renamed to extensional (after
+all, it is an extensionally specified constraint). The old name
+is still available in the MiniModel module. 
+
+If you want to use regular expressions, you have to add
+   \code #include "gecode/int/minimodel.hh" \endcode
+to your file as they moved to the MiniModel module.
+
+\section SecChange2Bool Boolean constraints
+
+In order to make the interface to Boolean constraints more
+regular and similar to set constraints, Boolean constraints are
+available as rel constraints. That is, instead of
+   \code bool_and(home, x, y, z); \endcode
+you have to write
+   \code rel(home, x, BOT_AND, y, z); \endcode
+Likewise, for arrays you have to write
+   \code rel(home, BOT_AND, x, y); \endcode
+instead of
+   \code bool_and(home, x, y); \endcode
+More information is available \ref TaskModelIntRelBool "here".
+
+\section SecChange2Branching Branching
+
+Values and types for selecting how to branch have been made uniform. 
+Replace BVAL_* by INT_VAL_*, BVAR_* by INT_VAR_*, and so on.
+
+\section SecChange2GCC Global cardinality constraint
+
+The interface for the global cardinality constraint has been
+simplified.  The constraint is now called count. Please check the
+documentation for \ref TaskModelIntCard "details".
+
+\section SecChange2Sorted Sortedness constraint
+
+The sortedness constraint has been renamed to sorted.
+
+\section Linking
+
+Some generic functionality has been put into its own library (\code
+libgecodesupport \endcode on Unix systems, \code GecodeSupport.dll \endcode on
+Windows). You have to link against this library now.
+
+*/