Add a score to evaluate the use of variable in direction calculation

gte/rpnlib.py

 _var_list['g'] = 0
 _var_list['b'] = 0
 
-def RpnOp(method):
+def RpnOpNoMod(method):
+    return RpnOp(method, True)
+
+def RpnOp(method, nomod = False):
     ''' @brief Decorator for RPN operation that autodetect argument count
         
         Autodetect argument count and pop them from the stack. Then attempt
     narg = len(inspect.signature(method).parameters)-1
     def wrapped(self):
         args = [ self._pop() for _ in range(narg) ]
+        determinist = True
+        if not nomod:
+            for arg in args:
+                if isinstance(arg, IntVar):
+                    determinist = False
+                    break
         args.reverse()
         try:
             res = method(self, *args)
         except ZeroDivisionError:
             res = None
         if res is None:
-            return None
+            return determinist
         try:
             for topush in res:
                 if not isinstance(topush, int):
                 raise ValueError('Turmit.%s() returned a list containing a\
 %s : %s' % (method.__name__, type(res), res))
             self._push(res)
-        return res
+        return determinist
     _op_list[method.__name__] = (method, wrapped)
     return wrapped
 
         ''' @return Random value '''
         return cls.random(cls.VALUE)
 
+
+class IntVar(int):
+    pass

gte/turmit.py

         if self._prog is None:
             self._prog = RpnExpr.random(self._prog_sz)
 
-        self.__expr_fun = lambda *args, **kwargs: (0,)
+        self._determin_score = 5
+
+        self.__expr_fun = lambda *args, **kwargs: (0, True, None)
 
     def __call__(self, **context):
         ''' @brief Exec the RPN expression and return the stack head
             @param context dict : dict with variable values (see @ref rpnlib._var_list)
             @return stack head after RPN
         '''
-        context = {k:int(context[k]) % self._max_int for k in context}
+        context = {k:IntVar(context[k]) % self._max_int for k in context}
 
         if self.__expr_fun is None:
             self._compile()
         ret = self.__expr_fun(self, **context)
-        if isinstance(ret, int):
+
+        determinist = ret[1]
+
+        if len(ret) == 2:
+            ret = ret[0]
             return ret
+        #if len(ret) == 3 -> returned a continuation address in RPN expr
 
         #self.__ip = 0
         self.__ip = ret[0]
             if sym.optype == RpnSymbol.VALUE:
                 self._push(sym.value)
             elif sym.optype == RpnSymbol.VARIABLE:
-                self._push(context[sym.value.lower()])
+                self._push(IntVar(context[sym.value.lower()]))
             elif sym.optype == RpnSymbol.OPERATION:
-                getattr(self, sym.value.lower())()
+                op = getattr(self, sym.value.lower())
+                if determinist:
+                    if not op():
+                        determinist = False
+                else:
+                    op()
             self.__ip += 1
+
+        self._determin_score += 0 if determinist else 1
         return self.shead
 
     def _compile(self):
-        code = 'def expr_fun(self, x, y, r, g, b):\n'
+        code = '''def expr_fun(self, x, y, r, g, b):
+
+    determinist = True'''
+
+        op2_head = '''a = self._stack[self._cur]
+    self._cur = (self._cur - 1) if self._cur > 0 else (len(self._stack) - 1)
+    if isinstance(a, IntVar) or isinstance(self._stack[self._cur], IntVar):
+        determinist = False
+'''
         for ip, sym in enumerate(self._prog):
             if sym.optype == RpnSymbol.VALUE:
                 code += '''
 ''' % sym.value.lower()
             elif sym.value == 'add':
                 code += '''
-    a = self._stack[self._cur]
-    self._cur = (self._cur - 1) if self._cur > 0 else (len(self._stack) - 1)
+    %s
     self._stack[self._cur] += a
     self._stack[self._cur] %= self._max_int
-'''
+''' % op2_head
             elif sym.value == 'sub':
                 code += '''
-    a = self._stack[self._cur]
-    self._cur = (self._cur - 1) if self._cur > 0 else (len(self._stack) - 1)
+    %s
     self._stack[self._cur] = self._stack[self._cur] - a
     if self._stack[self._cur] < 0:
         self._stack[self._cur] += self._max_int
-'''
+''' % op2_head
             elif sym.value == 'mul':
                 code += '''
-    a = self._stack[self._cur]
-    self._cur = (self._cur - 1) if self._cur > 0 else (len(self._stack) - 1)
+    %s
     self._stack[self._cur] *= a
     self._stack[self._cur] %= self._max_int
-'''
+''' % op2_head
             elif sym.value == 'div':
                 code += '''
-    a = self._stack[self._cur]
-    self._cur = (self._cur - 1) if self._cur > 0 else (len(self._stack) - 1)
+    %s
     if a != 0:
         self._stack[self._cur] = self._stack[self._cur] // a
-'''
+''' % op2_head
             elif sym.value == 'mod':
                 code += '''
-    a = self._stack[self._cur]
-    self._cur = (self._cur - 1) if self._cur > 0 else (len(self._stack) - 1)
+    %s
     if a != 0:
         self._stack[self._cur] = self._stack[self._cur] % a
-'''
+''' % op2_head
             elif sym.value == 'bin_and':
                 code += '''
-    a = self._stack[self._cur]
-    self._cur = (self._cur - 1) if self._cur > 0 else (len(self._stack) - 1)
+    %s
     self._stack[self._cur] &= a
-'''
+''' % op2_head
             elif sym.value == 'bin_or':
                 code += '''
-    a = self._stack[self._cur]
-    self._cur = (self._cur - 1) if self._cur > 0 else (len(self._stack) - 1)
+    %s
     self._stack[self._cur] |= a
-'''
+''' % op2_head
             elif sym.value == 'bin_xor':
                 code += '''
-    a = self._stack[self._cur]
-    self._cur = (self._cur - 1) if self._cur > 0 else (len(self._stack) - 1)
+    %s
     self._stack[self._cur] ^= a
-'''
+''' % op2_head
             elif sym.value == 'lshift':
                 code += '''
-    a = self._stack[self._cur]
-    self._cur = (self._cur - 1) if self._cur > 0 else (len(self._stack) - 1)
+    %s
     self._stack[self._cur] = (self._stack[self._cur] << a) % self._max_int
-'''
+''' % op2_head
             elif sym.value == 'rshift':
                 code += '''
-    a = self._stack[self._cur]
-    self._cur = (self._cur - 1) if self._cur > 0 else (len(self._stack) - 1)
+    %s
     self._stack[self._cur] = self._stack[self._cur] >> a
-'''
+''' % op2_head
             elif sym.value == 'dup':
                 code += '''
     a = self._stack[self._cur]
+    if isinstance(a, IntVar):
+        determinist = False
     self._cur += 1
     self._cur %= len(self._stack)
     self._stack[self._cur] = a
 '''
             else:
                 code += '''
-    return (%d,)
+    return (%d,determinist, None)
 ''' % ip
         code += '''
-    return self._stack[self._cur]
+    return (self._stack[self._cur], determinist)
 '''
         g = {}
         l = {}
             @param val int : integer to transform
             @return integer
         '''
+        intvar = isinstance(val, IntVar)
         val = int(val)
         if self._max_int is not None:
             val %= self._max_int
             if not self._signed_int and val < 0:
                 val = self._max_int - val
-        return val
+        return IntVar(val) if intvar else val
 
     @RpnOp
     def mem_sz(self, new_sz):
         '''
         return a & b
 
-    @RpnOp
+    @RpnOpNoMod
     def dup(self, a):
         ''' @brief Duplicates stack head
             @param a int : value
         '''
         return a ^ b
 
-    @RpnOp
+    @RpnOpNoMod
     def pop(self, a):
         ''' @brief Pops a, head of the stack
             @param a int : value
         '''
         pass
 
-    @RpnOp
+    @RpnOpNoMod
     def swp(self, a, b):
         ''' @brief Swap the two values on top of the stack
             @param a int : v1

gte/world.py

     stop = time.time()
 
     score_dir = sum([t.dirvar() for t in turmits]) / len(turmits)
+    score_deter = sum([t.determinist() for t in turmits]) / len(turmits)
     score_fract = w.fractdim()
-    score = score_dir * score_fract
+    score = (score_dir * score_fract) * (score_deter * 0.2 + 0.8)
     sinfo = {'F':score_fract, 'D':score_dir}
     #score = sum([score_fract] + [score_dir] * 4) / 5
     if not args.quiet:
         tall = time.time() - startall
-        msg = 'G%d P%d R%d: %d steps scores %.3f:(D:%.3f,F:%.3f) in %.3fs (%dus per step)\t%s'
+        msg = 'G%d P%d R%d: %d steps scores %.3f:(D:%.3f,F:%.3f,Dtr:%.3f) in %.3fs (%dus per step)\t%s'
         msg %= (generation, progid, trynum, steps, score, score_dir,
-                score_fract, tall,
+                score_fract, score_deter, tall,
                 ((stop - start)*1000000)//steps//len(turmits),
                 str(prog))
         logger.info(msg)
         self._dirvar_cnt -= 1
         self._steps += 1
 
+    def determinist(self):
+        ''' @brief Process a determinit score : determinist_expr / total expr
+            @return float in [0.0..1.0]
+        '''
+        return (self._determin_score + 1) / self._steps
+
     def dirvar(self):
         ''' @brief Process @ref _dirvar to return a direction variation
             score