Add auto steps + correcting fractdim target

Now turmit can run to limit fractdim (when it stop raising)
The fractdim score is calculated given the target

gte/__main__.py

 parser_evolve = subparsers.add_parser('evolve', help='evolving help')
 
 parser_evolve.add_argument('--steps', '-s', type=int, metavar='N',
-                           default=30000, help="Number of steps")
+                           default=None, help="Number of steps")
 
 parser_evolve.add_argument('--repeat-eval', '-R', type=int, metavar='N',
                            default=5)
         # Displaying eval results
         logger.info('Generation evaluating ended in %.2fs' % (genstop - genstart))
 
-        if args.target is None:
-            scores = sorted(scores, key=lambda x: x[0], reverse=True)
-        else:
-            scores = sorted(scores, key=lambda x: abs(x[0] - args.target),)
+        scores = sorted(scores, key=lambda x: x[0], reverse=True)
+
         for i, (score, prog, sinfo) in enumerate(scores):
             logger.info('P%d %.3f:(D:%.3f,F:%.3f) : "%s"' % (i, score,
                                                              sinfo['D'],

gte/world.py

         steps = args.steps
     else:
         steps = args.steps - int((args.steps / 1.5) // (args.repeat_eval - trynum))
-    for step in range(steps):
-        for turmit in turmits:
-            turmit()
+    
+    if not steps: # 0 or None
+        pfdim = 0
+        dfdim = 1
+        steps = 0
+        lim_reach = 0
+        retry_lim = 0
+        while lim_reach < 2:
+            for _ in range(3000):
+                for turmit in turmits:
+                    turmit()
+            steps += 0x1000
+            cfdim = w.fractdim() # delta fdim on not targeted dim
+            dfdim = cfdim - pfdim
+            pfdim = cfdim
+            if abs(dfdim) < 0.001:
+                lim_reach += 1
+            else:
+                retry_lim += 1
+                if retry_lim < 3:
+                    lim_reach = 0
+    else:
+        for step in range(steps):
+            for turmit in turmits:
+                turmit()
     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_fract, raw_fract = w.fractdim_target(args.target)
     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,Dtr:%.3f) in %.3fs (%dus per step)\t%s'
+        msg = 'G%d P%d R%d: %d steps scores %.3f:(D:%.3f,F:%.3f,'
         msg %= (generation, progid, trynum, steps, score, score_dir,
-                score_fract, score_deter, tall,
-                ((stop - start)*1000000)//steps//len(turmits),
-                str(prog))
+                score_fract)
+        if args.target:
+            msg += 'RawF:%.3f,' % raw_fract
+        msg += 'Dtr:%.3f) in %.3fs (%dus per step)\t%s'
+        msg %= (score_deter, tall,
+                ((stop - start)*1000000)//steps//len(turmits), str(prog))
         logger.info(msg)
     return progid, score, sinfo
 
         ''' @brief Save as an image '''
         scipy.misc.imsave(filename, self._val)
     
+    def fractdim_target(self, target, threshold=None):
+        res = self.fractdim(threshold)
+        if target:
+            ret = (2.0 - (abs(target - res))*5)
+            if ret < 0:
+                ret = 0.0
+            return (ret, res)
+        else:
+            return (res, res)
+
     def fractdim(self, threshold=None):
         ''' @return Minkowski–Bouligand dimension (computed) '''
         if not self._gray: