Bugfix + tests for expression copy, len & mutations

Makefile

@@ -56,7 +56,7 @@ doc/.doxygen.stamp: $(wildcard *.c) $(wildcard *.h) Doxyfile
 
 .PHONY: clean distclean checks runtest unittest benchmark
 
-checks: runtest unittest benchmark
+checks: runtest unittest
 
 benchmark: $(LIB)
 	PYTHONPATH=`pwd` $(PYTHON) tests/benchmark.py 0x500 0x2000;  \

rpn_mutate.c

@@ -27,6 +27,7 @@ int rpn_mutation_init_params(rpn_mutation_params_t *params)
 	params->_weights[1] = to_weight(total, params->w_del);
 	params->_weights[2] = to_weight(total, params->w_mut);
 	params->_weights[3] = to_weight(total, params->w_mut_soft);
+/*
 #ifdef DEBUG
 dprintf(2, "weights : %d %d %d %d\n",
 		params->_weights[0],
@@ -34,10 +35,12 @@ dprintf(2, "weights : %d %d %d %d\n",
 		params->_weights[2],
 		params->_weights[3]);
 #endif
+*/
 	for(uint8_t i=1; i<4; i++)
 	{
 		params->_weights[i] += params->_weights[i-1];
 	}
+/*
 #ifdef DEBUG
 dprintf(2, "summed weights : %d %d %d %d\n",
 		params->_weights[0],
@@ -45,6 +48,7 @@ dprintf(2, "summed weights : %d %d %d %d\n",
 		params->_weights[2],
 		params->_weights[3]);
 #endif
+*/
 
 	total = 0;
 	for(uint8_t i=0; i<3; i++)
@@ -85,6 +89,7 @@ err:
 
 int rpn_mutation(rpn_tokenized_t *toks, rpn_mutation_params_t *params)
 {
+	//_print_params(2, params);
 	assert(toks->argc < rnd_t_max);
 
 	if(toks->tokens_sz <= params->min_len)
@@ -117,7 +122,11 @@ int rpn_mutation_add(rpn_tokenized_t *toks, rpn_mutation_params_t *params)
 	rpn_token_t *new_toks, new_token;
 	size_t position;
 
-	if(rpn_rand_limit(toks->tokens_sz-1, &position) < 0)
+	if(toks->tokens_sz == 0)
+	{
+		position = 0;
+	}
+	else if(rpn_rand_limit(toks->tokens_sz, &position) < 0)
 	{
 		return -1;
 	}
@@ -347,3 +356,17 @@ int rpn_rand_limit(size_t max, size_t *res)
 	//*res = max - 1;
 	return 0;
 }
+
+void _print_params(int fd, rpn_mutation_params_t *params)
+{
+	dprintf(fd, "Minlen = %ld w[add=%.2f del=%.2f mut=%.2f msf=%.2f]\n",
+			params->min_len, params->w_add, params->w_del,
+			params->w_mut, params->w_mut_soft);
+	dprintf(fd, "w_add_elt [op=%.2f const=%.2f var=%.2f]\n",
+			params->w_add_elt[0], params->w_add_elt[1],
+			params->w_add_elt[2]);
+	dprintf(fd, "w_mut_elt [op=%.2f const=%.2f var=%.2f]\n",
+			params->w_mut_elt[0], params->w_mut_elt[1],
+			params->w_mut_elt[2]);
+}
+

rpn_mutate.h

@@ -98,4 +98,7 @@ int rpn_rand_limit(size_t max, size_t *res);
 int _rpn_random_choice(size_t sz, rnd_t *weights, size_t *res);
 void __rpn_random_choice(size_t sz, rnd_t *weights, rnd_t rand, size_t *res);
 
+// Debugging function
+void _print_params(int fd, rpn_mutation_params_t *params);
+
 #endif

tests/tests_pyrpn.py

@@ -1,7 +1,7 @@
 #!/usr/bin/python3
-# Copyright 2020 Weber Yann
+# Copyright 2020, 2023 Weber Yann
 #
-# This file is part of geneifs.
+# This file is part of rpnifs.
 #
 #        geneifs is free software: you can redistribute it and/or modify
 #        it under the terms of the GNU General Public License as published by
@@ -17,6 +17,7 @@
 #        along with geneifs.  If not, see <http://www.gnu.org/licenses/>.
 #
 
+import copy
 import sys
 import random
 import math
@@ -34,28 +35,6 @@ except (ImportError, NameError) as e:
           file=sys.stderr)
     raise e
 
-## TODO : move this function somewhere or implement it in C
-def decode_state(state):
-    """ Return a dict containing rpn state dump fields
-    """
-    res = dict()
-    res['real_sz'] = len(state)
-    res['total_sz'] = int.from_bytes(state[0:8], byteorder="little")
-    res['argc'] =  int.from_bytes(state[8:16], byteorder="little")
-    res['stack_sz_bytes'] = state[16:24]
-    res['stack_sz'] = state[16]
-    res['token_sz'] = int.from_bytes(state[24:32], byteorder="little", signed=True)
-    res['stack'] = [int.from_bytes(state[i:i+8], byteorder="little")
-                    for i in range(32, 32 + (8*res['stack_sz']),8)]
-    res['tokens_off'] = 32 + (8*res['stack_sz'])
-    res['tokens_real_sz'] = res['real_sz'] - res['tokens_off']
-    res['tokens'] = [state[i:i+24]
-                      for i in range(res['tokens_off'],
-                                     res['tokens_off'] + (24*res['token_sz']),
-                                     24)]
-    return res
-    pass
-
 
 class Test0RpnModule(unittest.TestCase):
 
@@ -113,6 +92,15 @@ class Test0RpnModule(unittest.TestCase):
             self.assertIn(long, known_ops)
             self.assertEqual(short, known_ops[long])
 
+    def testing_rand_expr_len(self):
+        """ Testing if RPNExpr.random_expr() returns expected expression """
+        for _ in range(100):
+            elen = random.randint(1, 50)
+            rnd_expr = pyrpn.random_expr(20, elen)
+            spl = [s for s in rnd_expr.split(' ') if len(s.strip())]
+            with self.subTest(expected_tokens=elen, tokens_count=len(spl), expr=rnd_expr):
+                self.assertEqual(len(spl), elen)
+
     def test_rand_expr(self):
         """ Testing RPNExpr.random_expr() """
         result = {}
@@ -142,27 +130,6 @@ class Test0RpnModule(unittest.TestCase):
         entropy = 1-sum([(n/all_count)**2
                           for _, n in counters.items()])
         self.assertGreater(entropy, 1-(1/all_ops), "Low entropy !")
-    
-    def test_pickle_state(self):
-        """ Testing pickling/unpickling """
-        e = pyrpn.RPNExpr('0x42 + A0', 2)
-        e2 = pickle.loads(pickle.dumps(e))
-        ds_e = decode_state(e.__getstate__())
-        ds_e2 = decode_state(e2.__getstate__())
-        self.assertEqual(e.__getstate__(), e2.__getstate__(),
-                         msg="EXPR: %r != %r (%r != %r)" % (e, e2, ds_e, ds_e2))
-        for i in range(100):
-            e = pyrpn.RPNExpr(pyrpn.random_expr(0), 2)
-
-            e2 = pickle.loads(pickle.dumps(e))
-
-            self.assertEqual(e.__getstate__(), e2.__getstate__(),
-                             msg="EXPR#%d : %r != %r" % (i,e, e2))
-
-            e3 = pickle.loads(pickle.dumps(e2))
-
-            self.assertEqual(e.__getstate__(), e3.__getstate__(), msg=e)
-            self.assertEqual(e2.__getstate__(), e3.__getstate__(), msg=e)
-
+   
 if __name__ == '__main__':
     unittest.main()

tests/tests_rpn_compile.py

@@ -67,7 +67,7 @@ class TestRpnCompile(unittest.TestCase):
     def test_very_long(self):
         """ Compile 3 very long expression (5242K op) """
         argc = 4
-        codelen = 0x500000
+        codelen = 0x50000
         import time
         for i in range(3):
             args = [random.randint(0,IMAX) for _ in range(argc)]

tests/tests_rpn_copy.py

@@ -0,0 +1,109 @@
+#!/usr/bin/python3
+# Copyright 2023 Weber Yann
+#
+# This file is part of rpnifs.
+#
+#        geneifs is free software: you can redistribute it and/or modify
+#        it under the terms of the GNU General Public License as published by
+#        the Free Software Foundation, either version 3 of the License, or
+#        (at your option) any later version.
+#
+#        geneifs is distributed in the hope that it will be useful,
+#        but WITHOUT ANY WARRANTY; without even the implied warranty of
+#        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#        GNU General Public License for more details.
+#
+#        You should have received a copy of the GNU General Public License
+#        along with geneifs.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+import copy
+import pickle
+import sys
+
+import unittest
+
+
+try:
+    import pyrpn
+except (ImportError, NameError) as e:
+    print("Error importing pyrpn. Try to run make.",
+          file=sys.stderr)
+    raise e
+
+
+## TODO : move this function somewhere or implement it in C
+def decode_state(state):
+    """ Return a dict containing rpn state dump fields
+    """
+    res = dict()
+    res['real_sz'] = len(state)
+    res['total_sz'] = int.from_bytes(state[0:8], byteorder="little")
+    res['argc'] =  int.from_bytes(state[8:16], byteorder="little")
+    res['stack_sz_bytes'] = state[16:24]
+    res['stack_sz'] = state[16]
+    res['token_sz'] = int.from_bytes(state[24:32], byteorder="little", signed=True)
+    res['stack'] = [int.from_bytes(state[i:i+8], byteorder="little")
+                    for i in range(32, 32 + (8*res['stack_sz']),8)]
+    res['tokens_off'] = 32 + (8*res['stack_sz'])
+    res['tokens_real_sz'] = res['real_sz'] - res['tokens_off']
+    res['tokens'] = [state[i:i+24]
+                      for i in range(res['tokens_off'],
+                                     res['tokens_off'] + (24*res['token_sz']),
+                                     24)]
+    return res
+
+
+
+class TestRpnExprState(unittest.TestCase):
+    """ Testing RPNExpr "state" related methods (__copy__, __get/setstate__)
+    """
+
+    def test_pickle_state(self):
+        """ Testing pickling/unpickling """
+        e = pyrpn.RPNExpr('0x42 + A0', 2)
+        e2 = pickle.loads(pickle.dumps(e))
+        ds_e = decode_state(e.__getstate__())
+        ds_e2 = decode_state(e2.__getstate__())
+        self.assertEqual(e.__getstate__(), e2.__getstate__(),
+                         msg="EXPR: %r != %r (%r != %r)" % (e, e2, ds_e, ds_e2))
+        for i in range(100):
+            e = pyrpn.RPNExpr(pyrpn.random_expr(0), 2)
+
+            e2 = pickle.loads(pickle.dumps(e))
+
+            self.assertEqual(e.__getstate__(), e2.__getstate__(),
+                             msg="EXPR#%d : %r != %r" % (i,e, e2))
+
+            e3 = pickle.loads(pickle.dumps(e2))
+
+            self.assertEqual(e.__getstate__(), e3.__getstate__(), msg=e)
+            self.assertEqual(e2.__getstate__(), e3.__getstate__(), msg=e)
+
+
+
+    def test_copy(self):
+        """ Basic copy test based on pickling """
+        e = pyrpn.RPNExpr('0x42 + A0', 2)
+        e2 = copy.copy(e)
+        ds_e = decode_state(e.__getstate__())
+        ds_e2 = decode_state(e2.__getstate__())
+        self.assertEqual(e.__getstate__(), e2.__getstate__(),
+                         msg="EXPR: %r != %r (%r != %r)" % (e, e2, ds_e, ds_e2))
+        for i in range(100):
+            e = pyrpn.RPNExpr(pyrpn.random_expr(0), 2)
+
+            e2 = copy.copy(e)
+
+            self.assertEqual(e.__getstate__(), e2.__getstate__(),
+                             msg="EXPR#%d : %r != %r" % (i,e, e2))
+
+            e3 = pickle.loads(pickle.dumps(e2))
+
+            self.assertEqual(e.__getstate__(), e3.__getstate__(), msg=e)
+            self.assertEqual(e2.__getstate__(), e3.__getstate__(), msg=e)
+
+
+if __name__ == '__main__':
+    unittest.main()
+

tests/tests_rpn_mutate.py

@@ -0,0 +1,100 @@
+#!/usr/bin/python3
+# Copyright 2020, 2023 Weber Yann
+#
+# This file is part of rpnifs.
+#
+#        geneifs is free software: you can redistribute it and/or modify
+#        it under the terms of the GNU General Public License as published by
+#        the Free Software Foundation, either version 3 of the License, or
+#        (at your option) any later version.
+#
+#        geneifs is distributed in the hope that it will be useful,
+#        but WITHOUT ANY WARRANTY; without even the implied warranty of
+#        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#        GNU General Public License for more details.
+#
+#        You should have received a copy of the GNU General Public License
+#        along with geneifs.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+import random
+import unittest
+
+
+try:
+    from tqdm import tqdm
+except (ImportError, NameError) as e:
+    tqdm = lambda i, *args, **kwargs:iter(i)
+
+try:
+    import pyrpn
+except (ImportError, NameError) as e:
+    print("Error importing pyrpn. Try to run make.",
+          file=sys.stderr)
+    raise e
+
+## TODO : test w_add_elt and w_mut_elt
+
+class TestRpnExprMutation(unittest.TestCase):
+
+    def test_base_mutation(self):
+        """ Testing mutation without parameters """
+        expr = pyrpn.RPNExpr("", 3)
+        expr.mutate()
+        expr.mutate(n_mutations=10)
+
+    def test_mutation_params_len(self):
+        """ Testing some value for parameters checking resulting expr len """
+
+        tests = (
+            ([1,1,0,0,0,(0,0,0),(0,0,0)], [1,0,100]),
+            ([1,2,1,0,0,(0,0,0),(0,0,0)], [1/3]),
+            ([1,2,0,1,0,(0,0,0),(0,0,0)], [2/3]),
+            ([1,3,1,2,0,(0,0,0),(0,0,0)], [2/6]),
+        )
+
+        for p_args, f_args in tests:
+            params = pyrpn.RPNMutationParamsTuple(p_args)
+            with self.subTest(params=params):
+                self._generic_mutation_params_lentest(params, *f_args)
+
+    def test_random_int_mutation_params(self):
+        """ Testing int random values for parameters checking resulting expr len """
+        for _ in range(50):
+            m_params = [random.randint(0,20) for _ in range(4)]
+            expt_len = (m_params[0]-m_params[1])/sum(m_params)
+            expt_len = 0 if expt_len < 0 else expt_len
+            params = [1] + m_params + [(0,0,0),(0,0,0)]
+            params = pyrpn.RPNMutationParamsTuple(params)
+            with self.subTest(params=params):
+                self._generic_mutation_params_lentest(params, expt_len)
+
+    def test_random_float_mutation_params(self):
+        """ Testing float random values for parameters checking resulting expr len """
+        for _ in range(50):
+            m_params = [random.randint(0,20)/20 for _ in range(4)]
+            expt_len = (m_params[0]-m_params[1])/sum(m_params)
+            expt_len = 0 if expt_len < 0 else expt_len
+            params = [1] + m_params + [(0,0,0),(0,0,0)]
+            params = pyrpn.RPNMutationParamsTuple(params)
+            with self.subTest(params=params):
+                self._generic_mutation_params_lentest(params, expt_len)
+
+    def _generic_mutation_params_lentest(self, params, expt_len, percent_error=.05,n_mut=5000):
+
+        expt_len = int(expt_len*n_mut)
+
+        expr = pyrpn.RPNExpr("", 3)
+        expr.mutate(params, n_mutations=n_mut)
+        msg = "Expected a len of %d ( [%d..%d] with %.1f%% error) but got %d"
+        self.assertTrue(abs(len(expr) - expt_len) <= n_mut*percent_error,
+                msg=msg % (expt_len,
+                           expt_len + n_mut*percent_error,
+                           expt_len - n_mut*percent_error,
+                           percent_error*100,
+                           len(expr)))
+
+
+if __name__ == '__main__':
+    unittest.main()
+

tests/tests_rpn_sequence.py

@@ -0,0 +1,66 @@
+#!/usr/bin/python3
+# Copyright 2023 Weber Yann
+#
+# This file is part of rpnifs.
+#
+#        geneifs is free software: you can redistribute it and/or modify
+#        it under the terms of the GNU General Public License as published by
+#        the Free Software Foundation, either version 3 of the License, or
+#        (at your option) any later version.
+#
+#        geneifs is distributed in the hope that it will be useful,
+#        but WITHOUT ANY WARRANTY; without even the implied warranty of
+#        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#        GNU General Public License for more details.
+#
+#        You should have received a copy of the GNU General Public License
+#        along with geneifs.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+import copy
+import pickle
+import random
+import sys
+
+import unittest
+
+try:
+    import pyrpn
+except (ImportError, NameError) as e:
+    print("Error importing pyrpn. Try to run make.",
+          file=sys.stderr)
+    raise e
+
+
+class TestRpnExprCopy(unittest.TestCase):
+    """ Testing RPNExpr sequence method """
+
+
+    def test_len(self):
+        """ Testing __len__ on some expressions """
+
+        tests = (
+            (['0x42 + A0', 2], 3),
+            (['A0', 10], 1),
+            (['', 1], 0),
+        )
+
+        for args, elen in tests:
+            e = pyrpn.RPNExpr(*args)
+            with self.subTest(expr=e, expected_len=elen):
+                self.assertEqual(len(e), elen)
+
+
+    def test_rand_len(self):
+        """ Testing __len__ with random expressions """
+        for _ in range(100):
+            elen = random.randint(1,50)
+            rexpr = pyrpn.random_expr(30,elen)
+            expr = pyrpn.RPNExpr(rexpr, 30)
+            with self.subTest(expr=expr, expected_len=elen):
+                self.assertEqual(len(expr), elen)
+
+
+if __name__ == '__main__':
+    unittest.main()
+