Look at MoveIteratorFactory, that allows you to select those moves JIT (so without creating all of them like in MoveListFactory).
Also see JUST_IN_TIME vs caching explanation in docs.

Let's continue further questions/discussions on the new mailing list
   http://www.optaplanner.org/community/forum.html


hth

On 27-06-14 14:05, DwProd . wrote:
Thanks a lot, yeah nearBySelection is probably what I would need, too bad it's not out yet :(

As for the custom MoveListFactory, I found out what I'm trying to do has an off the charts complexity. It basically has to find all subsets of planning variables of a given size (combinations with repetition) which is the number of entities I want to move at once... Worst case has a complexity of something like O(4^n/sqrt(pi n))... It gets unmanagable pretty soon unfortunately.

I'm not sure what I'll be doing but it seems like I'll have to do without those constraints at first... Thanks again for your help however !

Best regards,

Woody


2014-06-25 13:18 GMT+02:00 Geoffrey De Smet <ge0ffrey.s...@gmail.com <mailto:ge0ffrey.s...@gmail.com>>:


    On 25-06-14 12:58, DwProd . wrote:
    Thanks a lot for your answer !

    1) I don't think pillar based moves are what I'm looking for,
    except if I can select a pillar based on a Problem Fact (its
    service in my case) and then spread the different entities of the
    pillar on the available hosts (basically setting possibly
    different planning variables for the entities of the pillar).

    2) cartesianProductMoveSelector seem more like it, but the number
    of moves to combine is somewhat static is it not ? I can't for
    instance specify in a Planning Entity (using a property) that its
    move should be combined with n other moves of processes of the
    same type ?
    That would be nearBySelection... (note: the name might change
    before I implement).
    You need to be able to tell optaplanner that processes of the same
    type are "near" (~related) to each other and should be moved together.
    As stated before, I am working on this for 6.2.


    3) I feel like my usecase is complicated enough to have to resort
    to that if there is no built in way to handle it... Does this
    work by implementing a MoveListFactory, or a CompositeMove ? I
    don't think I quite get the difference to be honest...
    If you write a custom MoveListFactory (or MoveIteratorFactory),
    you could still opt to go with the build-in moves (such as
    ChangeMove) or combinations of those with CompositeMove. However,
    because those build-in moves require reflection stuff
    (VariableDescriptor etc), it's probably easier to just to write a
    domain-specific Move.
    See the examples that have custom moves.


    Thanks again for your time,

    Cheers,

    Woody


    2014-06-25 9:37 GMT+02:00 Geoffrey De Smet
    <ge0ffrey.s...@gmail.com <mailto:ge0ffrey.s...@gmail.com>>:

        1) There's 2 course grained moves out of the box in
        6.1.0.CR1: pillarChangeMove and pillarSwapMove.
        And in 6.1.0.CR1 they also include subpillars (which is
        important).
        
http://docs.jboss.org/drools/release/latest/optaplanner-docs/html_single/index.html#pillarChangeMoveSelector
        Start with trying those.

        2) Then look into cartesianProduct selection and mimic
        selection (see docs).
        The <cartesianProductMoveSelector> allows you to combine to
        existing moves into a new one.
        The mimic selection allows you to make sure that those 2
        moves change the same entity (if needed), but a different
        variable of course.
        I am working on nearBySelection for 6.2 to allow it to select
        2 entities that are somehow "nearBy" to each other (for
        example in the same service etc).

        3) If the above don't help enough, there's always custom
        moves (see docs): total freedom, but the devil is in the
        details :)


        On 24-06-14 01:58, DwProd . wrote:
        Hello there,

        I'm pretty new to OptaPlanner, and I must say I'm really
        impressed with the maturity of it all. Great software with a
        great documentation !

        I've been working on a variation of the Cloud Balancing
        example, with a few differences, which make it look like the
        Machine Reassignment problem as well :

        - Some processes are already placed and are immovable (using
        a Selection Filter checking a boolean property of the
        planning entity)
        - The Computer (the planning variable) is nullable
        (basically this is Multiple Muti-Dimensional Knapsack
        problem) which means I added a soft constraint penalty for
        processes with a null host.
        - Processes can only be of a few classes (which I called
        services, a Problem Fact). Processes of a given service type
        have a certain amount of required cpu and ram.

        Taking these elements into account, I do get very good
        results with OptaPlanner. However, the following constraints
        always put me into a score trap :

        - For some services, processes work in groups. For instance,
        if groups are of size 3, having 7 processes is not any
        better than having 6 processes. If there were already 2
        processes (immovable and placed), I should only add 4
        processes and not 5, even if there are enough resources. For
        this constraint, I have tried using a rule (medium
        constraint) accumulating processes of that service and using
        the modulo operator with the group size.
        - Some services are dependant on one another. For instance,
        I know that if I have n1 groups of processes of the service
        1, I require Math.ceil(2.5*n1) groups of processes of the
        service 2. I have implemented this similarly with a medium
        constraint...

        With any (or both) of these constraints, little to no
        processes of the concerned services are added and I fail to
        reach a good solution. I have tried benchmarking with
        several local search methods and various parameters, but all
        give the same results...

        I feel like the next logical step would be to used the often
        mentioned in the documentation "Coarse Grained Moves" but I
        fail to locate any simple example. The Nurse Rostering
        example seems to use that technique to some extent but it
        seems like an overly complicated example, is it not.

        Thank you very much for reading this far, if you have any
        question, guideline, or just a trick, I'd be absolutely
        delighted to hear from you !

        Cheers,

        Woody


        _______________________________________________
        rules-users mailing list
        rules-users@lists.jboss.org  <mailto:rules-users@lists.jboss.org>
        https://lists.jboss.org/mailman/listinfo/rules-users


        _______________________________________________
        rules-users mailing list
        rules-users@lists.jboss.org <mailto:rules-users@lists.jboss.org>
        https://lists.jboss.org/mailman/listinfo/rules-users




    _______________________________________________
    rules-users mailing list
    rules-users@lists.jboss.org  <mailto:rules-users@lists.jboss.org>
    https://lists.jboss.org/mailman/listinfo/rules-users


    _______________________________________________
    rules-users mailing list
    rules-users@lists.jboss.org <mailto:rules-users@lists.jboss.org>
    https://lists.jboss.org/mailman/listinfo/rules-users




_______________________________________________
rules-users mailing list
rules-users@lists.jboss.org
https://lists.jboss.org/mailman/listinfo/rules-users

_______________________________________________
rules-users mailing list
rules-users@lists.jboss.org
https://lists.jboss.org/mailman/listinfo/rules-users

Reply via email to