[gecode-users] Extending Integer Variable

[Vincent Barichard]

Dear Christian,

Thank you very much for your useful information and advices.

My purpose is to design some search algorithms which deal with values and 
domains. In fact, I need at the same time the _min and _max value of the 
variable domain and the _current value that I try to instantiate.
As In Gecode, an instantiation makes the domain to reduce  to a single value 
(_min == _max), I need another "int" member to store the _current value 
without reducing the domain.

I am not sure that other people will absolutely need that, but It can be 
usefull to add its own data structure to an existing Gecode variable. Maybe a 
pointer to an object (NULL by default) given to the constructor. If a user 
wants to deal with this object, he must design a View which tackles the 
object.

As a conclusion, I will follow your advice and do the experiment first :-)

Thank you again,

Cheers,
Vincent

Le jeudi 3 avril 2008, Christian Schulte a écrit :
> Dear Vincent,
>
> let me first elaborate a little bit how Gecode's variables and propagators
> are structured before I actually attempt to give an answer.
>
> Gecode has three important concepts regarding variables:
>  - variables: they are used for modeling, and the only operations they
> provide are good for modeling. In particular,
>    variables to not provide operations to update their domain. Examples are
> IntVar, BoolVar, etc. Variables are
>    hence provide nothing but an interface to variable implementations
> (actually, variables are implemented as
>    a pointer to variable implementations).
>  - variable implementations: they are the real objects storing the domain
> and which propagators and advisors must be
>    executed when the domain changes. They themselves are constructed in two
> steps: a domain independent stub that is
>    automatically generated from a simple description (just a few lines).
> The stub is concerned with events, how
>    propagators can be subscribed to, and linking the variable
> implementations to the Gecode kernel etc. The real
>    variable implementation then inherits from the generated stub and adds
> the variable domain and so on.
>  - views: like variables they are nothing but an interface for variable
> implementations. However, views are used
>    by propagators and branching and provide operations to update variable
> domains, subscribe propagators to changes,
>    and so on. More importantly, for the same variable implementation
> several views exist: a MinusView for a variable
>    implementation x, for example, provides an interface that behaves as if
> the operations on the MinusView are executed
>    on -x rather than x. Examples are IntView, BoolView, MinusView,
> OffsetView, ... For more on views there is paper
>    on the Gecode webpage.
>
> Propagators themselves have two parts: a post function and the actual
> propagator. A post function (such as rel, distinct, linear, etc.) is used
> for modeling and hence takes variables as arguments. It then chooses the
> right propagator and the right views (converting variables to views by
> passing the underlying reference to the variable implementation).
>
> Propagators are typically parametric (as templates in C++) with respect to
> the view they are using: for example, the Max propagator is instantiated
> for the max posting function with an IntView whereas it is also
> instantiated with a MinusView for the min posting function.
>
> Sorry for the long blurb, let's move to the answer: as Gecode is designed,
> you can reuse propagators provided that you implement: a variable
> implementation by yourself (that's what you want to do), variables for them
> (so that you can model), and views for them (so that you can reuse the
> propagators), post functions (because they talk about your variables).
>
> This is a lot of effort! If you want to make something that is used (rather
> than an experiment), then one could also make views and variables
> parametric wrt the variable implementation used. That is easy but requires
> intimate Gecode knowledge. Then, in principal, one could also make the post
> functions parametric but this is almost impossible in reality as they
> should provide simple static linkage as they constitute the basic interface
> to Gecode.
>
> So it really depends on what you want to do. For an experiment, hack the
> variable implementation. For something, first do the experiment ;-)
>
> What do you want to do? Do you think it me be generally useful to be
> included in Gecode anyway?
>
> All the best
> Christian
>
> --
> Christian Schulte, www.ict.kth.se/~cschulte/
>
>
> -----Original Message-----
> From: users-bounces at gecode.org [mailto:users-bounces at gecode.org] On Behalf
> Of Vincent Barichard
> Sent: Wednesday, April 02, 2008 4:08 PM
> To: gecode list
> Subject: [gecode-users] Extending Integer Variable
>
> Hi,
>
> I am trying to extend IntVar in order to use it in my self(-made
> algorithms. I would like to use an unaltered Gecode, but I need to add an
> "int" member in
> the IntVar implementation. I don't want to make my own Integer Variable
> class
> because I also need to use the algorithms designed in Gecode.
> Is there a clean way to extend this class (by inheritance maybe ....) and
> add
> a member without altering Gecode ?
>
> Thank you for your assistance.
> Best regards,
>
> Vincent



-- 
Vincent Barichard        Université d'Angers (LERIA)
Tel: 02 41 73 52 06      Département Informatique
Fax: 02 41 73 50 73      H203