Adds coordinate convertion methods to python lib + tests

python_if.c

@@ -28,6 +28,15 @@ static PyMethodDef RPNIterExpr_methods[] = {
 			METH_O,
 			"self, position, /",
 			"Run an IF given a position and return a new position"),
+	PYRPN_method("to_pos", rpnif_to_pos,
+			METH_FASTCALL,
+			"self, *args, /",
+			"Return a position (int) from a coordinates given as"
+			"argument."),
+	PYRPN_method("from_pos", rpnif_from_pos,
+			METH_O,
+			"self, position, /",
+			"Return a coordinates tuple from given position."),
 	PYRPN_method("__getstate__", rpnif_getstate,
 			METH_NOARGS,
 			"self, /",
@@ -165,33 +174,35 @@ int rpnif_init(PyObject *self, PyObject *args, PyObject *kwds)
 
 	//Check & convert lim
 	PyObject *tmp;
-	tmp = lim_obj;
-	if(!PyTuple_Check(tmp))
+	tmp = PySequence_Fast(lim_obj, "Sequence expected for size_lim argument");
+	if(PyErr_Occurred())
 	{
-		PyErr_SetString(PyExc_ValueError,
-			"Invalid type for size_lim argument");
 		return -1;
 	}
-	Py_ssize_t lim_obj_sz = PyTuple_Size(tmp);
+	Py_ssize_t lim_obj_sz = PySequence_Fast_GET_SIZE(tmp);
 	ndim = lim_obj_sz;
 	if(PyErr_Occurred())
 	{
+		Py_DECREF(tmp);
 		return -1;
 	}
 	if(lim_obj_sz < 1)
 	{
+		Py_DECREF(tmp);
 		PyErr_SetString(PyExc_ValueError,
 			"Size limits cannot be empty");
+		return -1;
 	}
 
 	if(pos_flag == RPN_IF_POSITION_XDIM)
 	{
-		PyObject *item = PyTuple_GET_ITEM(tmp, 0);
+		PyObject *item = PySequence_Fast_GET_ITEM(tmp, 0);
 		Py_ssize_t tmp = PyLong_AsSsize_t(item);
 		if(PyErr_Occurred())
 		{
 			PyErr_SetString(PyExc_ValueError,
 				"Unable to convert size_lim[0] to int");
+			Py_DECREF(tmp);
 			return -1;
 		}
 		if(lim_obj_sz != tmp + 1)
@@ -199,6 +210,7 @@ int rpnif_init(PyObject *self, PyObject *args, PyObject *kwds)
 			PyErr_Format(PyExc_ValueError,
 				"Xdim indicate %d size_lim but len(size_lim)=%d",
 				tmp+1, lim_obj_sz);
+			Py_DECREF(tmp);
 			return -1;
 		}
 		expt_sizes[0] = ndim = tmp;
@@ -210,6 +222,7 @@ int rpnif_init(PyObject *self, PyObject *args, PyObject *kwds)
 			PyErr_Format(PyExc_ValueError,
 				"Expected %d size_lim but len(size_lim)=%d",
 				expt_sizes[0], lim_obj_sz);
+			Py_DECREF(tmp);
 			return -1;
 		}
 	}
@@ -217,22 +230,24 @@ int rpnif_init(PyObject *self, PyObject *args, PyObject *kwds)
 	size_t sz_limits[lim_obj_sz];
 	for(Py_ssize_t i = 0; i<lim_obj_sz; i++)
 	{
-		PyObject *item = PyTuple_GET_ITEM(tmp, i);
+		PyObject *item = PySequence_Fast_GET_ITEM(tmp, i);
 		sz_limits[i] = PyLong_AsSize_t(item);
 		if(PyErr_Occurred())
 		{
 			PyErr_Format(PyExc_ValueError,
 				"Unable to convert size_lim[%d] to unsigned int",
 				i);
+			Py_DECREF(tmp);
 			return -1;
 		}
 	}
+	Py_DECREF(tmp);
+	tmp = NULL;
 
 	expr_self->ndim = ndim;
 
 	//Check & convert const values
 	Py_ssize_t values_obj_sz = 0;
-	tmp = NULL;
 	if(expt_sizes[1] > 0)
 	{
 		tmp = const_values_obj;
@@ -280,6 +295,12 @@ with given arguments");
 
 	// Creating rif with a new memory map
 	expr_self->rif = rpn_if_new(rif_params, NULL);
+	if(!expr_self->rif)
+	{
+		PyErr_Format(PyExc_RuntimeError,
+				"Error initalizing if : %s", strerror(errno));
+		return -1;
+	}
 
 	// Creating the tuple holding RPNExpr instances of expressions
 	expr_self->expr = PyTuple_New(expr_self->rif->params->rpn_sz);
@@ -369,10 +390,10 @@ PyObject *rpnif_get_params(PyObject *self)
 	return res;
 }
 
-
 PyObject *rpnif_step(PyObject *self, PyObject* opos)
 {
 	PyRPNIterExpr_t *expr_self = (PyRPNIterExpr_t*)self;
+	/** @todo allow tuple as argument !!!!! */
 	if(!PyLong_Check(opos))
 	{
 		PyErr_SetString(PyExc_TypeError, "Expected position to be an int");
@@ -390,6 +411,100 @@ PyObject *rpnif_step(PyObject *self, PyObject* opos)
 }
 
 
+PyObject *rpnif_to_pos(PyObject *self, PyObject** argv, Py_ssize_t argc)
+{
+	PyRPNIterExpr_t *expr_self = (PyRPNIterExpr_t*)self;
+	rpn_if_default_data_t *rif_data = (rpn_if_default_data_t*)expr_self->rif->params->data;
+	const short idx_off = rif_data->pos_flag == RPN_IF_POSITION_XDIM?1:0;
+	long long value;
+	
+	if(argc != rif_data->ndim)
+	{
+		PyErr_Format(PyExc_IndexError,
+				"Expression expect %lu dimentions coordinates,"
+				" but %ld arguments given.",
+				rif_data->ndim, argc);
+		return NULL;
+	}
+
+	rpn_value_t result=0;
+	size_t cur_dim_sz = 1;
+
+	for(Py_ssize_t i=0; i<rif_data->ndim; i++)
+	{
+		if(!PyLong_Check(argv[i]))
+		{
+			PyErr_SetString(PyExc_TypeError,
+					"coordinates must be integers");
+			return NULL;
+		}
+		value = PyLong_AsLongLong(argv[i]);
+		value = value >= 0?value:(-(rpn_value_t)-value)%rif_data->size_lim[i+idx_off];
+		if(value >= rif_data->size_lim[i+idx_off])
+		{
+			PyErr_Format(PyExc_IndexError,
+					"Coordinate %ld overflows : %R/%lu",
+					i, argv[i],
+					rif_data->size_lim[i+idx_off]);
+			return NULL;
+		}
+		result += value * cur_dim_sz;
+		cur_dim_sz *= rif_data->size_lim[i+idx_off];
+	}
+
+	return PyLong_FromUnsignedLongLong(result);
+}
+
+
+PyObject *rpnif_from_pos(PyObject *self, PyObject* _pos)
+{
+	PyRPNIterExpr_t *expr_self = (PyRPNIterExpr_t*)self;
+	rpn_if_default_data_t *rif_data = (rpn_if_default_data_t*)expr_self->rif->params->data;
+	const short idx_off = rif_data->pos_flag == RPN_IF_POSITION_XDIM?1:0;
+
+	if(!PyLong_Check(_pos))
+	{
+		PyErr_SetString(PyExc_TypeError,
+				"Expected position to be an integer");
+		return NULL;
+	}
+
+	size_t pos = PyLong_AsUnsignedLong(_pos);
+	if(PyErr_Occurred())
+	{
+		return NULL;
+	}
+
+	PyObject *res = PyTuple_New(rif_data->ndim);
+	if(PyErr_Occurred())
+	{
+		return NULL;
+	}
+	
+	for(size_t i=0; i<rif_data->ndim; i++)
+	{
+		size_t val;
+		size_t lim = rif_data->size_lim[i+idx_off];
+
+		val = pos % lim;
+		pos /= lim;
+
+		PyObject *elt = PyLong_FromUnsignedLong(val);
+		if(PyErr_Occurred())
+		{
+			goto err;
+		}
+		PyTuple_SET_ITEM(res, i,  elt);
+	}
+
+	return res;
+
+err:
+	Py_DECREF(res);
+	return NULL;
+}
+
+
 PyObject *rpnif_keys(PyObject *self)
 {
 	PyRPNIterExpr_t *expr_self = (PyRPNIterExpr_t*)self;
@@ -719,7 +834,7 @@ int rpnif_ass_subscript(PyObject *self, PyObject *key, PyObject *elt)
 	if(idx < 0)
 	{
 		PyErr_Format(PyExc_IndexError,
-				"Cannot set expression '%s' that do not exists with this parameters",
+				"Cannot set expression '%U' that do not exists with this parameters",
 				key);
 		return -1;
 	}

python_if.h

@@ -132,6 +132,21 @@ PyObject *rpnif_get_params(PyObject *self);
  */
 PyObject *rpnif_step(PyObject *self, PyObject* pos);
 
+/**@brief Convert given arguments coordinates to position
+ * @param self RPNIterExpr instance
+ * @param argv Pointer on the array of arguments
+ * @param argc Argument count
+ * @return An integer
+ */
+PyObject *rpnif_to_pos(PyObject *self, PyObject** argv, Py_ssize_t argc);
+
+/**@brief Convert given position to coordinates tuple
+ * @param self RPNIterExpr instance
+ * @param pos Position, as integer, to convert
+ * @return A tuple
+ */
+PyObject *rpnif_from_pos(PyObject *self, PyObject* pos);
+
 /**@brief RPNIterExpr __getstate__ method for pickling
  * @param cls RPNIterExpr type object
  * @param noargs Not an argument...

rpn_if.c

@@ -71,6 +71,7 @@ rpn_if_t* rpn_if_new(const rpn_if_param_t *params, rpn_value_t *memmap)
 		#endif
 		goto rpn_malloc_err;
 	}
+
 	res->rpn_args = &(res->rpn_res[params->rpn_sz]);
 
 	res->rpn = malloc(sizeof(rpn_expr_t) * params->rpn_sz);

rpn_if.h

@@ -113,7 +113,7 @@ struct rpn_if_s
 /**@brief Macro fetching a memory pointer given a position
  * @return rpn_value_t* values
  */
-#define rpn_if_getitem(rif, pos) (rif->mem + ((rif->params->value_sz) * pos))
+#define rpn_if_getitem(rif, pos) (rpn_value_t*)(((unsigned char*)rif->mem + ((rif->params->value_sz) * pos)))
 
 /**@brief Alloc a new @ref rpn_if_s using given parameters
  * @param params IF parameters

rpn_if_default.c

@@ -435,7 +435,7 @@ int rpn_if_argf_xdim(rpn_if_t *rif, size_t pos, rpn_value_t *args)
 	curpos = pos;
 	for(i=0; i<*(data->size_lim)-1; i++)
 	{
-		curdim_sz *= data->size_lim[i+1];
+		curdim_sz = data->size_lim[i+1];
 		args[i] = curpos % curdim_sz;
 		curpos /= curdim_sz;
 	}
@@ -454,7 +454,7 @@ int rpn_if_argf_xdim(rpn_if_t *rif, size_t pos, rpn_value_t *args)
 int rpn_if_resf_xdim(rpn_if_t *rif, size_t *pos, rpn_value_t *_data)
 {
 	rpn_if_default_data_t *data;
-	size_t i, res, cur, curlim, prevlim;
+	size_t i, res, cur, curlim, dim_sz;
 
 	data = (rpn_if_default_data_t*)rif->params->data;
 	res = 0;
@@ -469,20 +469,10 @@ int rpn_if_resf_xdim(rpn_if_t *rif, size_t *pos, rpn_value_t *_data)
 	}
 	/**@todo check if *(data->size_lim) overflow rif->params->rpn_argc */
 
-	res = rif->rpn_res[0];
-	if(res >= data->size_lim[1])
-	{
-		if(data->pos_flag & RPN_IF_POSITION_OF_ERR)
-		{
-			return -1;
-		}
-		res %= data->size_lim[1];
-	}
-
-	for(i=1; i < *(data->size_lim); i++)
+	dim_sz = 1;
+	for(i=0;  i < *(data->size_lim); i++)
 	{
 		cur = rif->rpn_res[i];
-		prevlim = data->size_lim[i];
 		curlim = data->size_lim[i+1];
 		if(cur >= curlim)
 		{
@@ -492,7 +482,8 @@ int rpn_if_resf_xdim(rpn_if_t *rif, size_t *pos, rpn_value_t *_data)
 			}
 			cur %= curlim;
 		}
-		res += cur * prevlim;
+		res += cur * dim_sz;
+		dim_sz *= curlim;
 	}
 	*pos = res;
 	return 0;

rpn_jit.c

@@ -400,7 +400,7 @@ int _rpn_expr_compile_tokens(rpn_expr_t* expr)
 unsigned long rpn_expr_eval(rpn_expr_t *expr, unsigned long *args)
 {
 	rpn_run_f expr_run;
-	unsigned long int res;
+	rpn_value_t res;
 	if(expr->state == RPN_ERROR)
 	{
 		return 0;

tests/tests_rpn_compile.py

@@ -34,6 +34,8 @@ except (ImportError, NameError) as e:
           file=sys.stderr)
     raise e
 
+from utils import Progress, VERBOSE
+
 class TestRpnCompile(unittest.TestCase):
 
     def test_basic(self):
@@ -55,11 +57,9 @@ class TestRpnCompile(unittest.TestCase):
 
     def test_long_code(self):
         """ Compile longs expressions (from 256 to 65536 op )"""
-        for i in range(0x100,0x10000,0x500):
+        for i in Progress(range(0x100,0x10000,0x500)):
             with self.subTest('Testing expression with %X ops' % i):
                 for argc in range(1,32, 8):
-                    sys.stderr.write('.')
-                    sys.stderr.flush()
                     args = [random.randint(0,IMAX) for _ in range(argc)]
                     expr = pyrpn.RPNExpr(pyrpn.random_expr(argc, i), argc)
                     del(expr)
@@ -69,16 +69,19 @@ class TestRpnCompile(unittest.TestCase):
         argc = 4
         codelen = 0x50000
         import time
-        for i in range(3):
+        for i in Progress(3):
             args = [random.randint(0,IMAX) for _ in range(argc)]
-            sys.stderr.write('Generate')
-            sys.stderr.flush()
+            if VERBOSE:
+                sys.stderr.write('Generate')
+                sys.stderr.flush()
             expr_str = pyrpn.random_expr(argc, codelen)
-            sys.stderr.write('d Compile')
-            sys.stderr.flush()
+            if VERBOSE:
+                sys.stderr.write('d Compile')
+                sys.stderr.flush()
             expr = pyrpn.RPNExpr(expr_str, argc)
-            sys.stderr.write('d ')
-            sys.stderr.flush()
+            if VERBOSE:
+                sys.stderr.write('d ')
+                sys.stderr.flush()
             del(expr)
 
     def test_pickling(self):  

tests/tests_rpn_eval.py

@@ -34,6 +34,8 @@ except (ImportError, NameError) as e:
           file=sys.stderr)
     raise e
 
+from utils import Progress
+
 class TestRpnEval(unittest.TestCase):
 
     def test_arithm(self):
@@ -50,10 +52,8 @@ class TestRpnEval(unittest.TestCase):
             #('l', '<<'),
             #('r', '>>')
         ]
-        for rpn_op, pyop in ops:
+        for rpn_op, pyop in Progress(ops):
             with self.subTest('Testing op %s (%s)' % (rpn_op, pyop)):
-                sys.stderr.write('.')
-                sys.stderr.flush()
                 for i in range(0x1000):
                     op1, op2 = random.randint(0,IMAX), random.randint(1,IMAX)
                     pyexpr = '%d %s %d' % (op1, pyop, op2)

tests/tests_rpniter.py

@@ -26,11 +26,13 @@ import unittest
 
 try:
     import pyrpn
-except (importerror, nameerror) as e:
+except (ImportError, NameError) as e:
     print("error importing pyrpn. try to run make.",
           file=sys.stderr)
     raise e
 
+from utils import Progress
+
 
 class TestRpnExprCopy(unittest.TestCase):
     """ Testing RPNExpr sequence method """
@@ -124,7 +126,7 @@ class TestRPNIterInit(unittest.TestCase):
     
     @skipIfNoNumpy()
     def test_buffer(self):
-        """ Test the buffer interface using numpy """
+        """ Test the len on buffer interface using numpy """
         args = [((pyrpn.const.POS_XY,
                   pyrpn.const.RESULT_COUNT,
                   (640,480)), 640*480),
@@ -171,6 +173,280 @@ class TestRPNIterInit(unittest.TestCase):
             str_repr = repr(rif)
 
 
+class TestRPNIterCoordinates(unittest.TestCase):
+    """ Testing methods for coordinates <-> position convertions """
+
+    def test_position_linear(self):
+        """ Testing linear coordinate convertion methods """
+        rif = pyrpn.RPNIterExpr(pyrpn.const.POS_LINEAR,
+                    pyrpn.const.RESULT_CONST,
+                    (256,), (42,))
+
+        for pos in range(256):
+            with self.subTest(rif=rif, position=pos, expt=(pos,)):
+                res = rif.from_pos(pos)
+                self.assertEqual(res, (pos,))
+            with self.subTest(rif=rif, expt=pos, coord=(pos,)):
+                res = rif.to_pos(pos)
+                self.assertEqual(res, pos)
+
+    def test_position_xy(self):
+        """ Testing XY coordinate convertion methods """
+        for _ in Progress(5):
+            sz = (random.randint(32,128), random.randint(32,128))
+            rif = pyrpn.RPNIterExpr(pyrpn.const.POS_XY,
+                    pyrpn.const.RESULT_CONST,
+                    sz, (42,))
+            for pos in range(sz[0]*sz[1]):
+                coord = rif.from_pos(pos)
+                expt = (pos % sz[0], pos // sz[0])
+                with self.subTest(sz=sz, pos=pos, expt=expt, result=coord):
+                    self.assertEqual(expt, coord)
+                result = rif.to_pos(*coord)
+                with self.subTest(sz=sz, coord=coord, expt=pos, result=result):
+                    self.assertEqual(result, pos)
+
+    def test_position_xy_neg(self):
+        """ Testing XY coordinates with negative values """
+        sz = (100,200)
+        rif = pyrpn.RPNIterExpr(pyrpn.const.POS_XY,
+                pyrpn.const.RESULT_CONST,
+                sz, (42,))
+        
+        for _ in range(1000):
+            ny = random.randint(-0x1000000, sz[1])
+            nx = random.randint(0,sz[0]-1)
+            pos = rif.to_pos(nx, ny)
+            coord = rif.from_pos(pos)
+            self.assertEqual(coord, (nx, (ny%(1<<64))%sz[1]))
+
+    def test_position_xy_random(self):
+        """ Testing XY coordinate convertion methods (random samples)"""
+        for _ in Progress(256):
+            sz = (random.randint(32,4096), random.randint(32,4096))
+            rif = pyrpn.RPNIterExpr(pyrpn.const.POS_XY,
+                    pyrpn.const.RESULT_CONST,
+                    sz, (42,))
+            for _ in range(500):
+                pos = random.randint(0, (sz[0]*sz[1])-1)
+                coord = rif.from_pos(pos)
+                expt = (pos % sz[0], pos // sz[0])
+                with self.subTest(sz=sz, pos=pos, expt=expt, result=coord):
+                    self.assertEqual(expt, coord)
+                result = rif.to_pos(*coord)
+                with self.subTest(sz=sz, coord=coord, expt=pos, result=result):
+                    self.assertEqual(result, pos)
+
+    def test_position_xdim(self):
+        """ Testing XDIM coordinate convertion methods """
+        ndim = 5
+        resol = [8 for _ in range(ndim)]
+        sz = [ndim]+resol
+        linear_size = 1
+        for e in resol:
+            linear_size *= e
+        rif = pyrpn.RPNIterExpr(pyrpn.const.POS_XDIM,
+                pyrpn.const.RESULT_CONST,
+                sz, (42,))
+        for pos in range(linear_size):
+            coord = rif.from_pos(pos)
+            expt = []
+            cur = pos
+            for dim in resol:
+                elt = cur % dim
+                cur //= dim
+                expt.append(elt)
+            expt = tuple(expt)
+            with self.subTest(sz=sz, pos=pos, expt=expt, result=coord):
+                self.assertEqual(expt, coord)
+            result = rif.to_pos(*coord)
+            with self.subTest(sz=sz, coord=coord, expt=pos, result=result):
+                self.assertEqual(result, pos)
+
+    def test_position_xdim_neg(self):
+        """ Testing XDIM negative position convertion """
+        # TODO test negativ for other coordinate systems
+        ndim = 4
+        szlim = (ndim, 10,20,30,40)
+        rif = pyrpn.RPNIterExpr(pyrpn.const.POS_XDIM,
+                pyrpn.const.RESULT_CONST,
+                szlim, (42,))
+
+        pos = rif.to_pos(0,0,-5,0)
+        self.assertEqual(rif.from_pos(pos), (0,0,(-5%(1<<64))%30, 0))
+
+    def test_position_xdim(self):
+        """ Testing XDIM coordinate convertion methods (random sampling)"""
+        for _ in Progress(16):
+            ndim = random.randint(3,8)
+            resol = [random.randint(2, 16) for _ in range(ndim)]
+            sz = [ndim]+resol
+            linear_size = 1
+            for e in resol:
+                linear_size *= e
+            rif = pyrpn.RPNIterExpr(pyrpn.const.POS_XDIM,
+                    pyrpn.const.RESULT_CONST,
+                    sz, (42,))
+            for _ in range(2000):
+                pos = random.randint(0, linear_size-1)
+                coord = rif.from_pos(pos)
+                expt = []
+                cur = pos
+                for dim in resol:
+                    elt = cur % dim
+                    cur //= dim
+                    expt.append(elt)
+                expt = tuple(expt)
+                with self.subTest(sz=sz, pos=pos, expt=expt, result=coord):
+                    self.assertEqual(expt, coord)
+                result = rif.to_pos(*coord)
+                with self.subTest(sz=sz, coord=coord, expt=pos, result=result):
+                    self.assertEqual(result, pos)
+
+
+class TestRPNIterConst(unittest.TestCase):
+    """ Testing various coordinate systems with constant result value """
+
+    @skipIfNoNumpy()
+    def test_simple_linear_const(self):
+        """ Testing a simple constant result on linear coord  """
+        rif = pyrpn.RPNIterExpr(pyrpn.const.POS_LINEAR,
+                                pyrpn.const.RESULT_CONST,
+                                (512,), (42,))
+
+        data = np.frombuffer(rif, dtype=np.uint64)
+        for elt in data:
+            self.assertEqual(elt, 0)
+
+        rif['X'] = 'A0 A1 +'
+        pos = rif.step(0)
+        self.assertEqual(pos, 0)
+        self.assertEqual(data[0], 42)
+
+        data = np.frombuffer(rif, dtype=np.uint64)
+        self.assertEqual(data[0], 42)
+        for elt in data[1:]:
+            self.assertEqual(elt, 0)
+
+
+
+        pos = rif.step(0)
+        self.assertEqual(pos, 42)
+
+        data = np.frombuffer(rif, dtype=np.uint64)
+        for i, elt in enumerate(data):
+            with self.subTest(cur_pos=i):
+                if i in (0, 42):
+                    self.assertEqual(elt, 42)
+                else:
+                    self.assertEqual(elt, 0)
+
+
+        pos = rif.step(1)
+        self.assertEqual(pos, 1)
+        pos = rif.step(pos)
+        self.assertEqual(pos, 43)
+
+        newpos = 512 - 40
+        pos = rif.step(newpos)
+        self.assertEqual(pos, newpos)
+        pos = rif.step(pos)
+        self.assertEqual(pos, 2)
+
+    def test_random_linear_const(self):
+        """ Testing linear coord with const with random expressions """
+        for _ in range(200):
+            const_val = random.randint(0,0xFFFF)
+            rif = pyrpn.RPNIterExpr(pyrpn.const.POS_LINEAR,
+                                    pyrpn.const.RESULT_CONST,
+                                    (512,), (const_val,))
+            rif['X'].mutate(n_mutations=random.randint(10,100))
+            pos=0
+            all_pos=[]
+            for  _ in range(100):
+                pos = rif.step(pos)
+                all_pos.append(pos)
+                data = np.frombuffer(rif, dtype=np.uint64)
+                self.assertEqual(data[pos], const_val)
+            for i, elt in enumerate(np.frombuffer(rif, dtype=np.uint64)):
+                if i in all_pos:
+                    self.assertEqual(elt, const_val)
+                else:
+                    self.assertEqual(elt, 0)
+
+    def test_simple_xy_const(self):
+        """ Testing xy coord with const value """
+        sz = (1024,256)
+
+        rif = pyrpn.RPNIterExpr(pyrpn.const.POS_XY,
+                                pyrpn.const.RESULT_CONST,
+                                sz, (42,))
+        
+        rif['X'] = 'A0 A1 +'
+        rif['Y'] = 'A2'
+
+        pos = rif.step(0)
+        self.assertEqual(pos, 0)
+
+        pos = rif.step(0)
+        self.assertEqual(rif.from_pos(pos), (0,42))
+
+        pos = rif.step(rif.to_pos(1,1))
+        self.assertEqual(rif.from_pos(pos), (2,0))
+
+        pos = rif.step(rif.to_pos(1,1))
+        self.assertEqual(rif.from_pos(pos), (2,0))
+
+        pos = rif.step(rif.to_pos(2,0))
+        self.assertEqual(rif.from_pos(pos), (2,42))
+
+    def test_random_xy_const(self):
+        """ Testing xy coord with const with random expressions """
+        for _ in Progress(200):
+            const_val = random.randint(0,0xFFFF)
+            rif = pyrpn.RPNIterExpr(pyrpn.const.POS_XY,
+                                    pyrpn.const.RESULT_CONST,
+                                    (1024,1024,), (const_val,))
+            rif['X'].mutate(n_mutations=random.randint(10,100))
+            rif['Y'].mutate(n_mutations=random.randint(10,100))
+            pos=0
+            all_pos=[]
+            for  _ in range(100):
+                sys.stdout.flush()
+                pos = rif.step(pos)
+                all_pos.append(pos)
+                data = np.frombuffer(rif, dtype=np.uint64)
+                self.assertEqual(data[pos], const_val)
+            expt = np.zeros(len(data), dtype=np.uint64)
+            for p in all_pos:
+                expt[p] = const_val
+            self.assertTrue((expt == data).all())
+
+    def test_simple_xdim_const(self):
+        """ Testing xdim coord with const """
+        rif = pyrpn.RPNIterExpr(pyrpn.const.POS_XDIM,
+                                pyrpn.const.RESULT_CONST,
+                                (4,100,200,300,400), (42,))
+        rif['D0'] = 'A1'
+        rif['D1'] = 'A0 A2 +'
+        rif['D2'] = 'A0 A1 -'
+        rif['D3'] = 'A3 A4 +'
+
+        pos = rif.step(0)
+        self.assertEqual(pos, 0)
+        pos = rif.step(0)
+        self.assertEqual(rif.from_pos(pos), (0,0,0,42))
+
+        pos = rif.step(5)
+        self.assertEqual(rif.from_pos(pos), (0,5,5,0))
+        pos = rif.step(rif.to_pos(0,5,5,0))
+        self.assertEqual(rif.from_pos(pos), (5,5,(-5%(1<<64))%300,42))
+        expt = (5,5,-5,42)
+        expt_pos = rif.to_pos(*expt)
+        self.assertEqual(pos, expt_pos)
+
+
+
 if __name__ == '__main__':
     unittest.main()
 

tests/tests_rpniter_seq.py

@@ -26,7 +26,7 @@ import unittest
 
 try:
     import pyrpn
-except (importerror, nameerror) as e:
+except (ImportError, NameError) as e:
     print("error importing pyrpn. try to run make.",
           file=sys.stderr)
     raise e

tests/tests_tokens.py

@@ -23,7 +23,7 @@ import unittest
 
 try:
     import pyrpn
-except (importerror, nameerror) as e:
+except (ImportError, NameError) as e:
     print("error importing pyrpn. try to run make.",
           file=sys.stderr)
     raise e

tests/utils.py

@@ -0,0 +1,81 @@
+#!/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 sys
+import math
+
+try:
+    import pyrpn
+except (ImportError, NameError) as e:
+    print("error importing pyrpn. try to run make.",
+          file=sys.stderr)
+    raise e
+
+
+VERBOSE = '-v' in sys.argv or '--verbose' in sys.argv
+
+class Progress:
+
+    STYLE = '|/-\\'
+
+    def __init__(self, iterator, count=None):
+        if isinstance(iterator, int):
+            self.__iter = range(iterator)
+            self.__count = iterator
+        else:
+            self.__iter = iterator
+            try:
+                self.__count = len(iterator) if count is None else count
+            except Exception:
+                self.__count = None
+        self.__iter = iter(self.__iter)
+
+        self.__cur = 0
+        if self.__count is not None:
+            count_sz = math.floor(math.log10(self.__count)+1)
+            self.__fmt = '%%%dd/%%%dd' % (count_sz, count_sz)
+    
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        return self.next()
+
+    def next(self):
+        if not VERBOSE or self.__count is None:
+            clean_len = 1
+            if VERBOSE and self.__count == 0:
+                sys.stderr.write('\b')
+            sys.stderr.write(self.STYLE[self.__cur%len(self.STYLE)])
+            sys.stderr.write('\b')
+        else:
+            msg = self.__fmt % (self.__cur+1, self.__count)
+            clean_len = len(msg)
+            msg += '\b' * clean_len
+            sys.stderr.write(msg)
+        sys.stderr.flush()
+        self.__cur += 1
+        try:
+            return next(self.__iter)
+        except Exception as expt:
+            sys.stderr.write(' '*clean_len + '\b'  *  clean_len)
+            raise expt
+
+
+