They are unused because I changed it around alot, trying to get it to
work, the problem I am having however according to me does not come
from the unused constraints but rather when I do use constraints to go
from floats to int and trying to get my root node to return an int...

The Gene1 constraints was used when I had another datatype but this
was in effect redundant and I removed it but left the constraint in
the list, so it can be disregarded. And there is idd no nil in the
int2c constraint and the functions should indeed look like,

int <- <=(float,float)
int <- >=(float,float)

Regards,
A.

On 8/24/05, Sean Luke <[log in to unmask]> wrote:
> More verification.
>
> So, your <= and >= functions must look like this?
>
> int <- <=(float,float)
> int <- >=(float,float)
>
> If so, why do you have nil in your int2c constraint?  Likewise for the
> (apparently unused) gene1 constraint?
>
> Sean
>
> On Aug 24, 2005, at 7:35 AM, Allan de Brueker wrote:
>
> > Actually it is int2c who does int <- float, float, and smallerorequal
> > and greater or equal both go from comparing floats to an integer
> > value(instead of a normal boolean like value but integers allows for
> > easier further operations). It's a typo here.
> >
> > Regards,
> > A.
> >
> > On 8/23/05, Sean Luke <[log in to unmask]> wrote:
> >> On Aug 17, 2005, at 6:48 PM, Allan de Brueker wrote:
> >>
> >>> I'm trying to go from arrays of FP numbers to single FP numbers to
> >>> integers
> >>> I would like to have operators on integers (+,-,*,/), operators on
> >>> floats(+,-,*,/),  have declared them in seperate java files, two
> >>> operators
> >>> to switch between float and int (<=, >=) and I would like for my root
> >>> to
> >>> return an integer.
> >>
> >> Let's see if I have this correct.  Your functions are (I made up some
> >> names like i+):
> >>
> >> int   <- i+(int,int)
> >> int   <- i*(int,int)
> >> int   <- i-(int,int)
> >> int   <- i/(int,int)
> >> float <- f+(float, float)
> >> float <- f*(float, float)
> >> float <- f-(float, float)
> >> float <- f/(float, float)
> >> int   <- <=(float)
> >> float <- >=(int)
> >> float <- gene()
> >>
> >> That's what it sounds like from your description above, yet your <=
> >> and
> >>> = functions are quite different below.  You're introducing a third
> >> type, 'nil', though it appears you only have two types (notionally the
> >> names 'int' and 'float').  So what's up with the constraint called
> >> 'int2c'?  What kind of function prototype is it trying to represent?
> >>
> >> Sean
> >>
> >>
> >>> So Far I have got  the following:
> >>>
> >>> #return type of the tree
> >>>
> >>> gp.tc.0.returns = int
> >>>  gp.tc.0.init = ec.gp.build.Uniform
> >>>  gp.tc.0.init.min-size = 5
> >>>  gp.tc.0.init.max-size = 15
> >>>
> >>> #3 atomic types
> >>> gp.type.a.size = 3
> >>> gp.type.a.0.name = float
> >>> gp.type.a.1.name = int
> >>> gp.type.a.2.name = nil
> >>>
> >>> #different constraints set with the different atomic types
> >>> gp.nc.size = 6
> >>>
> >>> gp.nc.0 = ec.gp.GPNodeConstraints
> >>> gp.nc.0.name = gene0
> >>> gp.nc.0.return = float
> >>> gp.nc.0.size = 0
> >>>
> >>> gp.nc.1 = ec.gp.GPNodeConstraints
> >>> gp.nc.1.name = gene1
> >>> gp.nc.1.return = nil
> >>> gp.nc.1.size = 1
> >>> gp.nc.1.child.0 = nil
> >>>
> >>>
> >>> gp.nc.2 = ec.gp.GPNodeConstraints
> >>> gp.nc.2.name = float2
> >>> gp.nc.2.return = float
> >>> gp.nc.2.size = 2
> >>> gp.nc.2.child.0 = float
> >>> gp.nc.2.child.1 = float
> >>>
> >>> gp.nc.3 = ec.gp.GPNodeConstraints
> >>> gp.nc.3.name = int2c
> >>> gp.nc.3.return = float
> >>> gp.nc.3.size = 2
> >>> gp.nc.3.child.0 = nil
> >>> gp.nc.3.child.1 = nil
> >>>
> >>> gp.nc.4 = ec.gp.GPNodeConstraints
> >>> gp.nc.4.name = int2
> >>> gp.nc.4.return = int
> >>> gp.nc.4.size = 2
> >>> gp.nc.4.child.0 = int
> >>> gp.nc.4.child.1 = int
> >>>
> >>>
> >>> # We have ... functions in the function set.  They are:
> >>> gp.fs.0.size = 11
> >>>
> >>> gp.fs.0.func.0 = ec.app.simpleclassifier.func.GetGeneFloat
> >>> gp.fs.0.func.0.nc = gene0
> >>>
> >>> gp.fs.0.func.1 = ec.app.simpleclassifier.func.Add
> >>> gp.fs.0.func.1.nc = float2
> >>>
> >>> gp.fs.0.func.2 = ec.app.simpleclassifier.func.Sub
> >>> gp.fs.0.func.2.nc = float2
> >>>
> >>> gp.fs.0.func.3 = ec.app.simpleclassifier.func.Mult
> >>> gp.fs.0.func.3.nc = float2
> >>>
> >>> gp.fs.0.func.4 = ec.app.simpleclassifier.func.Div
> >>> gp.fs.0.func.4.nc =float2
> >>>
> >>> gp.fs.0.func.5 = ec.app.simpleclassifier.func.SmallerOrEqual
> >>> gp.fs.0.func.5.nc = int2c
> >>>
> >>> gp.fs.0.func.6 = ec.app.simpleclassifier.func.GreaterOrEqual
> >>> gp.fs.0.func.6.nc = int2c
> >>>
> >>> gp.fs.0.func.7 = ec.app.simpleclassifier.func.AddInt
> >>> gp.fs.0.func.7.nc = int2
> >>>
> >>> gp.fs.0.func.8 = ec.app.simpleclassifier.func.SubInt
> >>> gp.fs.0.func.8.nc = int2
> >>>
> >>> gp.fs.0.func.9 = ec.app.simpleclassifier.func.MultInt
> >>> gp.fs.0.func.9.nc = int2
> >>>
> >>> gp.fs.0.func.10 = ec.app.simpleclassifier.func.DivInt
> >>> gp.fs.0.func.10.nc = int2
> >>
>