choco-users Mailing List for choco

On 15/10/2007, at 7:48 PM, Hadrien Cambazard wrote:

> Yes, I would say that this code is safe.
> You can remove value while iterating just like for Integer  
> variables if I remember well.
> Did you got any problems while doing that ?

I was just checking. Many java iterators are not safe to use in this  
way. (Or perhaps that was just true in older versions of the JDK.)

> Please, keep in mind that SetVar just like RealVar are more  
> examples of how to extend choco than real kernels for set and  
> continous variables. We are typically not using them ourselves yet.  
> This should change soon for continous variables but set variables  
> are not the next priority.

Does that mean that they have not been thoroughly tested, or just  
that they haven't been highly optimised?

I'm in the process of writing constraints representing the subset  
relationship and set partitioning.

> I hope, you manage to reach your goals with choco despite our lack  
> of reactivity !

Thanks, but I sadly think I'm going to need to look for a better  
documented system, or else I'm going to spend all my time trying to  
decipher your code rather than working on my problem. Are there any  
other constraint programming systems you would recommend? The  
features I particularly need are:

1) Integer variables, with equality and comparison and basic arithmetic
2) Set variables over integers, with membership, subset,  
intersection, union etc
3) Boolean combinations of constraints, (disjuction, equivalence,  
implication, negation)

I'm looking for a system that is not too much of a nightmare to  
debug. I've tried ECLiPSe prolog, but visualisation and debugging in  
Prolog is pretty awful. Java is my programming language of choice.

Malcolm

--
"The modern man in revolt has become
           practically useless for all purposes of revolt.
By rebelling against everything
           he has lost his right to rebel against anything."
                                                    - G.K.Chesterton,  
Orthodoxy

On 10/10/2007, at 9:24 PM, Guillaume Rochart wrote:

> Hi all,
>
> 1/ isConsistent should return if there exist or not a support  
> satisfying the constraint (it should say true if there exists one  
> but say true too if we do not really know)
> 2/ isSatisfed should return if the constraint is satisfied when all  
> variables are instantiated
> 3/ isEntailed should return true if the constraint is satisfied  
> (whatever value is chosen in current domains), false if it not  
> satisfied (already violated whateter value we choose), null otherwise.

So when would isConsistent return anything other than (isEntailed !=  
Boolean.FALSE)?

How often are these methods called? Does it matter much how efficient  
they are?

Malcolm
--
Many clever men like you have trusted to civilisation.
Many clever Babylonians, many clever Egyptians,
Many clever men at the end of Rome.
                               - G.K.Chesterton, The Napoleon of  
Notting Hill

Hi,

I'm trying to write a constraint which represents the partitioning of  
a set into a collection of disjoint subsets. To make sure that the  
subsets are disjoint, it is useful to keep track of how many subsets  
have each element in their kernel or envelope. It is more efficient  
to store this information and update it as we are notified of  
additions and removals, rather than to scan all the sets on every  
pass. I have written code which uses a HashMap for this purpose, but  
it just occured to me that this will not work with backtracking. Is  
there an appropriate alternative structure which will respond to  
backtracking appropriately?

Thanks,
Malcolm

--
"If there is one thing worse than the modern weakening of major morals
    it is the modern strengthening of minor morals.
Thus it is considered more withering to accuse a man
    of bad taste than of bad ethics."    -- G.K.Chesterton, On Lying  
in Bed

Is it safe to remove an element from the domain of a SetVar while  
iterating over it?

That is: is the following code legal?

for (IntIterator it0 = set.getDomain().getEnvelopeIterator();  
it0.hasNext();) {
    int x = it0.next();

    if (test(x)) set.remFromEnvelope(x, 0);
}

Malcolm

--
      "Progress should mean that we are always changing the world to fit
       the vision, instead we are always changing the vision."
                - G.K.Chesterton, Orthodoxy

Hi all,

1/ isConsistent should return if there exist or not a support satisfying the
constraint (it should say true if there exists one but say true too if we do
not really know)
2/ isSatisfed should return if the constraint is satisfied when all
variables are instantiated
3/ isEntailed should return true if the constraint is satisfied (whatever
value is chosen in current domains), false if it not satisfied (already
violated whateter value we choose), null otherwise.

Regards,


Guillaume

On 10/10/07, Malcolm Ryan <mal...@cs...> wrote:
>
> On 10/10/2007, at 11:25 AM, Malcolm Ryan wrote:
>
> > What are the correct semantics of the isConsistent() method on
> > Propagator?
>
> And what is the semantics of isEntailed()? Am I correct in thinking
> that it should return false only if the constraint is contradicted,
> and return null if it neither entailed nor contradicted? The
> description doesn't make this clear.
>
> Malcolm
>
> --
>       "The act of defending any of the cardinal virtues has today all
>        the exhilaration of a vice."
>                                      - G.K.Chesterton A Defense of
> Humility
>
>
>
>
> -------------------------------------------------------------------------
> This SF.net email is sponsored by: Splunk Inc.
> Still grepping through log files to find problems?  Stop.
> Now Search log events and configuration files using AJAX and a browser.
> Download your FREE copy of Splunk now >> http://get.splunk.com/
> _______________________________________________
> Choco-users mailing list
> Cho...@li...
> https://lists.sourceforge.net/lists/listinfo/choco-users
>

On 10/10/2007, at 11:25 AM, Malcolm Ryan wrote:

> What are the correct semantics of the isConsistent() method on
> Propagator?

And what is the semantics of isEntailed()? Am I correct in thinking  
that it should return false only if the constraint is contradicted,  
and return null if it neither entailed nor contradicted? The  
description doesn't make this clear.

Malcolm

--
      "The act of defending any of the cardinal virtues has today all
       the exhilaration of a vice."
                                     - G.K.Chesterton A Defense of  
Humility

What are the correct semantics of the isConsistent() method on  
Propagator?

Malcolm

--
"The modern man in revolt has become
           practically useless for all purposes of revolt.
By rebelling against everything
           he has lost his right to rebel against anything."
                                                    - G.K.Chesterton,  
Orthodoxy

On 09/10/2007, at 5:44 PM, Narendra Jussien wrote:

> Yes, the Problem.post() method introduces a backtrackable  
> constraint in the network.

Does it make sense for a constraint to post new subconstraints during  
the propagation process? For example, would the attached Java code  
work? Or is there a better way to do this?

> We are aware of the documentation issue in choco and we are happy  
> to announce that we hired some permanent staff for the choco  
> project. This staff will start in November so we plan a real  
> documentation by mid-2008.

That's excellent news.

Malcolm

--
      "The act of defending any of the cardinal virtues has today all
       the exhilaration of a vice."
                                     - G.K.Chesterton A Defense of  
Humility

Yes, the Problem.post() method introduces a backtrackable constraint =20
in the network.


We are aware of the documentation issue in choco and we are happy to =20
announce that we hired some permanent staff for the choco project. =20
This staff will start in November so we plan a real documentation by =20
mid-2008.

Narendra

Le 8 oct. 07 =E0 08:42, Malcolm Ryan a =E9crit :

> Poking around in the source, it looks like this might be possible.
> The documentation for Problem.post() seems to indicate that it is
> possible to post a new constraint which will be retracted on
> backtracking. Is that correct?
>
> A lot of the internals of Choco are very sparsely documented. Do you
> plan on fixing that soon?
>
> Malcolm
>
> On 08/10/2007, at 1:07 PM, Malcolm Ryan wrote:
>
>> I then have a bunch of different constraints which apply to all
>> elements in the list (and only those). So essentially, for each such
>> constraint C(V), I form a list of 100 constraints which state whether
>> the constraint applies to each element, depending on the length
>> variable:
>>
>> L > 0 =3D> C(V_0)
>> L > 1 =3D> C(V_1)
>> ...
>> L > 99 =3D> C(V_99)
>>
>> It seems to me that introducing 100 constraints like this is
>> inefficient. I'd much rather have a single constraint which watched
>> as the lower bound of L increased and added individual element
>> constraints on the fly. So when L is foung to be greater than 2, C
>> (V_0), C(V_1) and C(V_2) are added to the problem.
>>
>> The apparent difficulty with this is the backtracking behaviour. If
>> on backtracking we determine that L is less than 2, then we need to
>> retract C(V_2) from the constraint store. Is there any easy way to do
>> this in Choco?
>>
>> Malcolm
>>
>> --
>> Many clever men like you have trusted to civilisation.
>> Many clever Babylonians, many clever Egyptians,
>> Many clever men at the end of Rome.
>>                                - G.K.Chesterton, The Napoleon of
>> Notting Hill
>>
>>
>>
>>
>> ---------------------------------------------------------------------=20=

>> -
>> ---
>> This SF.net email is sponsored by: Splunk Inc.
>> Still grepping through log files to find problems?  Stop.
>> Now Search log events and configuration files using AJAX and a
>> browser.
>> Download your FREE copy of Splunk now >> http://get.splunk.com/
>> _______________________________________________
>> Choco-users mailing list
>> Cho...@li...
>> https://lists.sourceforge.net/lists/listinfo/choco-users
>
> --
>        "An inconvenience is only an adventure wrongly considered;
>         an adventure is an inconvenience rightly considered."
>                  - G.K.Chesterton, On Running After Ones Hat
>
>
>
>
> ----------------------------------------------------------------------=20=

> ---
> This SF.net email is sponsored by: Splunk Inc.
> Still grepping through log files to find problems?  Stop.
> Now Search log events and configuration files using AJAX and a =20
> browser.
> Download your FREE copy of Splunk now >> http://get.splunk.com/
> _______________________________________________
> Choco-users mailing list
> Cho...@li...
> https://lists.sourceforge.net/lists/listinfo/choco-users
>
>

Poking around in the source, it looks like this might be possible.  
The documentation for Problem.post() seems to indicate that it is  
possible to post a new constraint which will be retracted on  
backtracking. Is that correct?

A lot of the internals of Choco are very sparsely documented. Do you  
plan on fixing that soon?

Malcolm

On 08/10/2007, at 1:07 PM, Malcolm Ryan wrote:

> I then have a bunch of different constraints which apply to all
> elements in the list (and only those). So essentially, for each such
> constraint C(V), I form a list of 100 constraints which state whether
> the constraint applies to each element, depending on the length
> variable:
>
> L > 0 => C(V_0)
> L > 1 => C(V_1)
> ...
> L > 99 => C(V_99)
>
> It seems to me that introducing 100 constraints like this is
> inefficient. I'd much rather have a single constraint which watched
> as the lower bound of L increased and added individual element
> constraints on the fly. So when L is foung to be greater than 2, C
> (V_0), C(V_1) and C(V_2) are added to the problem.
>
> The apparent difficulty with this is the backtracking behaviour. If
> on backtracking we determine that L is less than 2, then we need to
> retract C(V_2) from the constraint store. Is there any easy way to do
> this in Choco?
>
> Malcolm
>
> --
> Many clever men like you have trusted to civilisation.
> Many clever Babylonians, many clever Egyptians,
> Many clever men at the end of Rome.
>                                - G.K.Chesterton, The Napoleon of
> Notting Hill
>
>
>
>
> ---------------------------------------------------------------------- 
> ---
> This SF.net email is sponsored by: Splunk Inc.
> Still grepping through log files to find problems?  Stop.
> Now Search log events and configuration files using AJAX and a  
> browser.
> Download your FREE copy of Splunk now >> http://get.splunk.com/
> _______________________________________________
> Choco-users mailing list
> Cho...@li...
> https://lists.sourceforge.net/lists/listinfo/choco-users

--
       "An inconvenience is only an adventure wrongly considered;
        an adventure is an inconvenience rightly considered."
                 - G.K.Chesterton, On Running After Ones Hat

I'm trying to make a constraint based representation of a list of  
variable length. Basically, I have an array of, say, 100 element  
variables V_0, ..., V_99, plus a length variable L in [0,100].  
Semantically, the first L of the element variables are in the list,  
the others are irrelevant.

I then have a bunch of different constraints which apply to all  
elements in the list (and only those). So essentially, for each such  
constraint C(V), I form a list of 100 constraints which state whether  
the constraint applies to each element, depending on the length  
variable:

L > 0 => C(V_0)
L > 1 => C(V_1)
...
L > 99 => C(V_99)

It seems to me that introducing 100 constraints like this is  
inefficient. I'd much rather have a single constraint which watched  
as the lower bound of L increased and added individual element  
constraints on the fly. So when L is foung to be greater than 2, C 
(V_0), C(V_1) and C(V_2) are added to the problem.

The apparent difficulty with this is the backtracking behaviour. If  
on backtracking we determine that L is less than 2, then we need to  
retract C(V_2) from the constraint store. Is there any easy way to do  
this in Choco?

Malcolm

--
Many clever men like you have trusted to civilisation.
Many clever Babylonians, many clever Egyptians,
Many clever men at the end of Rome.
                               - G.K.Chesterton, The Napoleon of  
Notting Hill

Is the Choco project still being actively developed and supported?

Malcolm

--
       "An inconvenience is only an adventure wrongly considered;
        an adventure is an inconvenience rightly considered."
                 - G.K.Chesterton, On Running After Ones Hat

hi
this is to let you know that we are using choco in an extension of jpf 
tool (see http://javapathfinder.sourceforge.net/)
we are mostly interested in constraints for reals.
regards
corina