Hi all again.

I added the restrinctions that i needed (see bellow). I this thread will be
useful to somebody.

Regards.


*gp.nc.size = 16*
*
*
*gp.nc.7 = ec.gp.GPNodeConstraints*
*gp.nc.7.name = ncAND_or_rule*
*gp.nc.7.returns = and*
*gp.nc.7.size = 2*
*gp.nc.7.child.0 = or*
*gp.nc.7.child.1 = rule*
*
*
*gp.nc.8 = ec.gp.GPNodeConstraints*
*gp.nc.8.name = ncAND_and_rule*
*gp.nc.8.returns = and*
*gp.nc.8.size = 2*
*gp.nc.8.child.0 = and*
*gp.nc.8.child.1 = rule*
*
*
*gp.nc.9 = ec.gp.GPNodeConstraints*
*gp.nc.9.name = ncAND_rule_rule*
*gp.nc.9.returns = and*
*gp.nc.9.size = 2*
*gp.nc.9.child.0 = rule*
*gp.nc.9.child.1 = rule*
*
*
*gp.nc.10 = ec.gp.GPNodeConstraints*
*gp.nc.10.name = ncOR_or_rule*
*gp.nc.10.returns = or*
*gp.nc.10.size = 2*
*gp.nc.10.child.0 = or*
*gp.nc.10.child.1 = rule*
*
*
*gp.nc.11 = ec.gp.GPNodeConstraints*
*gp.nc.11.name = ncOR_and_rule*
*gp.nc.11.returns = or*
*gp.nc.11.size = 2*
*gp.nc.11.child.0 = and*
*gp.nc.11.child.1 = rule*
*
*
*##Not used*
*#gp.nc.12 = ec.gp.GPNodeConstraints*
*#gp.nc.12.name = ncOR_rule_rule*
*#gp.nc.12.returns = or*
*#gp.nc.12.size = 2*
*#gp.nc.12.child.0 = rule*
*#gp.nc.12.child.1 = rule*
*
*
*gp.nc.13 = ec.gp.GPNodeConstraints*
*gp.nc.13.name = ncAND_and_and*
*gp.nc.13.returns = and*
*gp.nc.13.size = 2*
*gp.nc.13.child.0 = and*
*gp.nc.13.child.1 = and*
*
*
*##Not used*
*#gp.nc.14 = ec.gp.GPNodeConstraints*
*#gp.nc.14.name = ncOR_and_and*
*#gp.nc.14.returns = or*
*#gp.nc.14.size = 2*
*#gp.nc.14.child.0 = and*
*#gp.nc.14.child.1 = and*
*
*
*gp.nc.15 = ec.gp.GPNodeConstraints*
*gp.nc.15.name = ncRule*
*gp.nc.15.returns = rule*
*gp.nc.15.size = 0*
*
*
*
*
*gp.fs.0.size = 7*
*
*
*gp.fs.0.func.0 = ec.app.gp.ossimRuleGeneration.func.And*
*gp.fs.0.func.0.nc = ncAND_or_rule*
*
*
*gp.fs.0.func.1 = ec.app.gp.ossimRuleGeneration.func.And*
*gp.fs.0.func.1.nc = ncAND_and_rule*
*
*
*gp.fs.0.func.2 = ec.app.gp.ossimRuleGeneration.func.And*
*gp.fs.0.func.2.nc = ncAND_rule_rule*
*
*
*gp.fs.0.func.3 = ec.app.gp.ossimRuleGeneration.func.Or*
*gp.fs.0.func.3.nc = ncOR_or_rule*
*
*
*gp.fs.0.func.4 = ec.app.gp.ossimRuleGeneration.func.Or*
*gp.fs.0.func.4.nc = ncOR_and_rule*
*
*
*gp.fs.0.func.5 = ec.app.gp.ossimRuleGeneration.func.Or*
*gp.fs.0.func.5.nc = ncOR_rule_rule*
*
*
*gp.fs.0.func.6 = ec.app.gp.ossimRuleGeneration.func.rule*
*gp.fs.0.func.6.nc = ncRule*






On Tue, Dec 15, 2009 at 5:32 PM, alibaba <[log in to unmask]> wrote:

> Hi All,
>
> Thanks for keep on reading.
>
> I have found what I was looking for on this thread: The "nil" GPType in
> GPNodeConstraints<http://listserv.gmu.edu/cgi-bin/wa?A2=ind0804&L=ecj-interest-l&D=0&X=4753654B9C0978582B&P=855>.
> I am indeed trying to add the constraints that my model needs and I'm coming
> across some troubles.
>
> Let me *contextualize *the problem. I'm generating a tree of *AND *and *OR
> *non-terminal nodes and a *RULE*-function as terminal nodes. I want to add
> some constrains so the generated tree follows this two rules:
>  *1)* The root of the tree must be an AND function.
>  *2)* At least one of the childs of the non-terminal nodes must be or a
> terminal-node (RULE) or an AND node.
>
> I'm trying to add the described constrains like this:
>
> First, I define the GPTypes as follows:
>
> gp.type.a.size = 4
>
> gp.type.a.0.name = nil   # This one might not be necessary
>
> gp.type.a.1.name = rule
>
> gp.type.a.2.name = and
>
> gp.type.a.3.name = or
>
> gp.type.s.size = 0
>
>
> *To fulfill 1)* I added the follow tree constrain:
>
> gp.tc.0.returns = and
>
>
> *To fulfill 2)* I added the follow node constrains:
>
> gp.nc.size = 10
>
> #--------------------#
>
> gp.nc.7 = ec.gp.GPNodeConstraints
>
> gp.nc.7.name = ncAND
>
> gp.nc.7.returns = and
>
> gp.nc.7.size = 2
>
> gp.nc.7.child.0 = rule
>
> *gp.nc.7.child.1 = or*
>
> #--------------------#
>
> gp.nc.8 = ec.gp.GPNodeConstraints
>
> gp.nc.8.name = ncRULE
>
> gp.nc.8.returns = rule
>
> gp.nc.8.size = 0
>
> #--------------------#
>
> gp.nc.9 = ec.gp.GPNodeConstraints
>
> gp.nc.9.name = ncOR
>
> gp.nc.9.returns = or
>
> gp.nc.9.size = 2
>
> gp.nc.9.child.0 = rule
>
> *gp.nc.9.child.1 = and*
>
>
>
> Then I add each constrains to the functions of the function set:
>
> gp.fs.0.func.0 = ec.app.gp.ossimRuleGeneration.func.Or
>
> gp.fs.0.func.0.nc = *ncOR*
>
>
>> gp.fs.0.func.1 = ec.app.gp.ossimRuleGeneration.func.rule
>
> gp.fs.0.func.1.nc = *ncRULE*
>
>
>> gp.fs.0.func.2 = ec.app.gp.ossimRuleGeneration.func.And
>
> gp.fs.0.func.2.nc = *ncAND*
>
>
>
> *Note *that with this constrains I am being more restrictive that what I
> have defined in 2), and actually* it doesn't work *because, as it is
> obvious, it never finish due there is always a non-terminal node as child
> in gp.nc.8.child.1 and gp.nc.9.child.1. The problem here is that I need gp.nc.8.child.1
> and gp.nc.9.child.1 to be some times *AND *and some others *RULE*, so the
> GP program will eventually finish.
>
> And I will like to set gp.nc.8.child.0 and gp.nc.9.child.0 some times to *RULE
> *and some others to *AND *to fully satisfy 2)
>
> Is there any way? How can I do such things.
>
> Thanks in advance.
>
>
>
> On Tue, Dec 15, 2009 at 10:08 AM, alibaba <[log in to unmask]> wrote:
>
>>
>> Hello!
>>
>> First of all, thanks for reading.
>>
>> I need to add some Constraints to my GP program so each function that I
>> have can only accept a specific subset of children. For this, should specify
>> this on the params files or I have to add some checks on the
>> checkConstraints method for each GPNode.
>>
>> Does anybody know an example on the web about this that I can follow?
>>
>> Thanks in advance.
>>
>>
>