Ejemplo n.º 1
0
 public GPTreeConstraints Constraints(GPInitializer initializer)
 {
     if (ConstraintsIndex < 0 || ConstraintsIndex > initializer.TreeConstraints.Count - 1)
     {
         throw new InvalidOperationException("ConstraintsIndex is outside of the allowable range: [0, initializer.TreeConstraints.Length - 1]");
     }
     return(initializer.TreeConstraints[ConstraintsIndex]);
 }
Ejemplo n.º 2
0
        public override bool CompatibleWith(GPInitializer initializer, GPType t)
        {
            // if the type is me, then I'm compatible with it
            if (t.Type == Type)
            {
                return(true);
            }

            // if the type an atomic type, then return false
            if (t.Type < initializer.NumAtomicTypes)
            {
                return(false);
            }

            // if the type is < 0 (it's a set type), then I'm compatible
            // if I'm contained in it.  Use its sparse array.
            return(((GPSetType)t).TypesSparse[Type]);
        }
Ejemplo n.º 3
0
        public override bool CompatibleWith(GPInitializer initializer, GPType t)
        {
            // if the type is me, then I'm compatible with it.
            if (t.Type == Type)
            {
                return(true);
            }

            // if the type is an atomic type, then I'm compatible with it if I contain it.
            // Use the sparse array.
            if (t.Type < initializer.NumAtomicTypes)
            {
                // atomic type, faster than doing instanceof
                return(TypesSparse[t.Type]);
            }

            // else the type is a set type.  I'm compatible with it if we contain
            // an atomic type in common.   Use the sorted packed array.

            var s = (GPSetType)t;
            var x = 0;
            var y = 0;

            for (; x < TypesPacked.Length && y < s.TypesPacked.Length;)
            {
                if (TypesPacked[x] == s.TypesPacked[y])
                {
                    return(true);
                }
                if (TypesPacked[x] < s.TypesPacked[y])
                {
                    x++;
                }
                else
                {
                    y++;
                }
            }
            return(false);
        }
Ejemplo n.º 4
0
 /// <summary>
 /// Am I compatible with ("fit" with) <i>t</i>?  For two atomic
 /// types, this is done by direct pointer equality.  For
 /// two set types, this is done by determining if the intersection
 /// is nonempty.  A set type is compatible with an atomic type
 /// if it contains the atomic type in its set.
 /// </summary>
 public abstract bool CompatibleWith(GPInitializer initializer, GPType t);