Added inplace_increment function

numpy/add_newdocs.py

@@ -2231,6 +2231,59 @@ def luf(lamdaexpr, *args, **kwargs):
     30
 
     """)
+
+add_newdoc('numpy.core.multiarray', 'inplace_increment',
+    """
+    inplace_increment(a, index, inc)
+
+    Increments `a` inplace by `inc` in the locations specified by the index tuple
+	`index`. Supports advanced indexing. Repeated indexes are repeatedly
+	incremented.
+
+    Parameters
+    ----------
+    a : ndarray
+		Array to increment.
+    index : tuple of indexes
+		Supports advanced indexing.
+	inc : array_like
+		How much to increment `a`.
+
+    Returns
+    -------
+    output : None
+
+    Examples
+    --------
+	>>> a = arange(12).reshape((3,4)).astype(float64)
+	>>> index = ([1,1,2,0], [0,0,2,3])
+	>>> vals = [50,50, 30,16]
+	>>> a
+	array([[  0.,   1.,   2.,   3.],
+		   [  4.,   5.,   6.,   7.],
+		   [  8.,   9.,  10.,  11.]])
+	>>> inplace_increment(a, index, vals)
+	>>> a
+	array([[   0.,    1.,    2.,   19.],
+		   [ 104.,    5.,    6.,    7.],
+		   [   8.,    9.,   40.,   11.]])
+
+	>>> x = zeros((3,3))	   
+	>>> x
+	array([[ 0.,  0.,  0.],
+		   [ 0.,  0.,  0.],
+		   [ 0.,  0.,  0.]])
+	>>> y = arange(3*3).reshape((3,3))
+	>>> y
+	array([[0, 1, 2],
+		   [3, 4, 5],
+		   [6, 7, 8]])
+	>>> inplace_increment(x, [0,1,1], y)
+	>>> x
+	array([[  0.,   1.,   2.],
+		   [  9.,  11.,  13.],
+		   [  0.,   0.,   0.]])
+    """)
 
 
 ##############################################################################

numpy/core/bscript

@@ -427,6 +427,7 @@ def pre_build(context):
                 "src/multiarray/arraytypes.c.src",
                 "src/multiarray/nditer_templ.c.src",
                 "src/multiarray/lowlevel_strided_loops.c.src",
+                "src/multiarray/mapping.c.src",
                 "src/multiarray/einsum.c.src"]
         bld(target="multiarray_templates", source=multiarray_templates)
         if ENABLE_SEPARATE_COMPILATION:
@@ -449,7 +450,7 @@ def pre_build(context):
                 pjoin('src', 'multiarray', 'item_selection.c'),
                 pjoin('src', 'multiarray', 'iterators.c'),
                 pjoin('src', 'multiarray', 'lowlevel_strided_loops.c.src'),
-                pjoin('src', 'multiarray', 'mapping.c'),
+                pjoin('src', 'multiarray', 'mapping.c.src'),
                 pjoin('src', 'multiarray', 'methods.c'),
                 pjoin('src', 'multiarray', 'multiarraymodule.c'),
                 pjoin('src', 'multiarray', 'nditer_pywrap.c'),

numpy/core/numeric.py

@@ -10,7 +10,7 @@
            'alterdot', 'restoredot', 'roll', 'rollaxis', 'cross', 'tensordot',
            'array2string', 'get_printoptions', 'set_printoptions',
            'array_repr', 'array_str', 'set_string_function',
-           'little_endian', 'require',
+           'little_endian', 'require', 'inplace_increment',
            'fromiter', 'array_equal', 'array_equiv',
            'indices', 'fromfunction', 'isclose',
            'load', 'loads', 'isscalar', 'binary_repr', 'base_repr',
@@ -252,6 +252,7 @@ def extend_all(module):
 compare_chararrays = multiarray.compare_chararrays
 putmask = multiarray.putmask
 einsum = multiarray.einsum
+inplace_increment = multiarray.inplace_increment
 
 def asarray(a, dtype=None, order=None):
     """

numpy/core/setup.py

@@ -691,6 +691,7 @@ def generate_multiarray_templated_sources(ext, build_dir):
                    join(local_dir, subpath, 'arraytypes.c.src'),
                    join(local_dir, subpath, 'nditer_templ.c.src'),
                    join(local_dir, subpath, 'lowlevel_strided_loops.c.src'),
+                   join(local_dir, subpath, 'mapping.c.src'),
                    join(local_dir, subpath, 'einsum.c.src')]
 
         # numpy.distutils generate .c from .c.src in weird directories, we have
@@ -776,7 +777,7 @@ def generate_multiarray_templated_sources(ext, build_dir):
             join('src', 'multiarray', 'item_selection.c'),
             join('src', 'multiarray', 'iterators.c'),
             join('src', 'multiarray', 'lowlevel_strided_loops.c.src'),
-            join('src', 'multiarray', 'mapping.c'),
+            join('src', 'multiarray', 'mapping.c.src'),
             join('src', 'multiarray', 'methods.c'),
             join('src', 'multiarray', 'multiarraymodule.c'),
             join('src', 'multiarray', 'nditer_templ.c.src'),

numpy/core/src/multiarray/mapping.c → numpy/core/src/multiarray/mapping.c.src

@@ -2056,6 +2056,193 @@ PyArray_MapIterArray(PyArrayObject * a, PyObject * index)
 #undef SOBJ_TOOMANY
 #undef SOBJ_LISTTUP
 
+typedef void (*inplace_map_binop)(PyArrayMapIterObject *, PyArrayIterObject *);
+
+/**begin repeat
+* #type  = npy_int8, npy_int16, npy_int32, npy_int64, npy_int128, npy_int256,
+           npy_uint8, npy_uint16, npy_uint32, npy_uint64, npy_uint128, npy_uint256, 
+           npy_float16, npy_float32, npy_float64, npy_float80, npy_float96, npy_float128, npy_float256#
+
+* #typen = NPY_INT8, NPY_INT16, NPY_INT32, NPY_INT64, NPY_INT128, NPY_INT256,
+           NPY_UINT8, NPY_UINT16, NPY_UINT32, NPY_UINT64, NPY_UINT128, NPY_UINT256, 
+           NPY_FLOAT16, NPY_FLOAT32, NPY_FLOAT64, NPY_FLOAT80, NPY_FLOAT96, NPY_FLOAT128, NPY_FLOAT256#
+*/
+#if defined(@typen@)
+static void @type@_inplace_add(PyArrayMapIterObject *mit, PyArrayIterObject *it)
+{
+    int index = mit->size;
+    while (index--) {
+        ((@type@*)mit->dataptr)[0] = ((@type@*)mit->dataptr)[0] + ((@type@ *)it->dataptr)[0];
+
+        PyArray_MapIterNext(mit);
+        PyArray_ITER_NEXT(it);
+    }
+}
+#endif
+/**end repeat**/
+
+/**begin repeat
+* #type  = npy_complex32, npy_complex64, npy_complex128, npy_complex160, npy_complex192, npy_complex512#
+* #typen = NPY_COMPLEX32, NPY_COMPLEX64, NPY_COMPLEX128, NPY_COMPLEX160, NPY_COMPLEX192, NPY_COMPLEX512#
+*/
+#if defined(@typen@)
+static void @type@_inplace_add(PyArrayMapIterObject *mit, PyArrayIterObject *it)
+{
+    int index = mit->size;
+    while (index--) {
+        ((@type@*)mit->dataptr)[0].real = ((@type@*)mit->dataptr)[0].real + ((@type@ *)it->dataptr)[0].real;
+        ((@type@*)mit->dataptr)[0].imag = ((@type@*)mit->dataptr)[0].imag + ((@type@ *)it->dataptr)[0].imag;
+
+        PyArray_MapIterNext(mit);
+        PyArray_ITER_NEXT(it);
+    }
+}
+#endif
+/**end repeat**/
+
+inplace_map_binop addition_funcs[] = {
+/**begin repeat
+* #type  = npy_int8, npy_int16, npy_int32, npy_int64, npy_int128, npy_int256,
+           npy_uint8, npy_uint16, npy_uint32, npy_uint64, npy_uint128, npy_uint256, 
+           npy_float16, npy_float32, npy_float64, npy_float80, npy_float96, npy_float128, npy_float256,
+           npy_complex32, npy_complex64, npy_complex128, npy_complex160, npy_complex192, npy_complex512#
+
+* #typen = NPY_INT8, NPY_INT16, NPY_INT32, NPY_INT64, NPY_INT128, NPY_INT256,
+           NPY_UINT8, NPY_UINT16, NPY_UINT32, NPY_UINT64, NPY_UINT128, NPY_UINT256, 
+           NPY_FLOAT16, NPY_FLOAT32, NPY_FLOAT64, NPY_FLOAT80, NPY_FLOAT96, NPY_FLOAT128, NPY_FLOAT256,
+           NPY_COMPLEX32, NPY_COMPLEX64, NPY_COMPLEX128, NPY_COMPLEX160, NPY_COMPLEX192, NPY_COMPLEX512#
+*/
+#if defined(@typen@)
+@type@_inplace_add,
+#endif
+/**end repeat**/
+NULL}; 
+
+int type_numbers[] = {
+/**begin repeat
+* #typen = NPY_INT8, NPY_INT16, NPY_INT32, NPY_INT64, NPY_INT128, NPY_INT256,
+           NPY_UINT8, NPY_UINT16, NPY_UINT32, NPY_UINT64, NPY_UINT128, NPY_UINT256, 
+           NPY_FLOAT16, NPY_FLOAT32, NPY_FLOAT64, NPY_FLOAT80, NPY_FLOAT96, NPY_FLOAT128, NPY_FLOAT256,
+           NPY_COMPLEX32, NPY_COMPLEX64, NPY_COMPLEX128, NPY_COMPLEX160, NPY_COMPLEX192, NPY_COMPLEX512#
+*/
+#if defined(@typen@)
+@typen@,
+#endif
+/**end repeat**/
+-1000}; 
+
+static int
+map_increment(PyArrayMapIterObject *mit, PyObject *op, inplace_map_binop add_inplace)
+{
+    PyArrayObject *arr = NULL;
+    PyArrayIterObject *it;
+    PyArray_Descr *descr;
+
+    if (mit->ait == NULL) {
+        return -1;
+    }
+    descr = PyArray_DESCR(mit->ait->ao);
+    Py_INCREF(descr);
+    arr = (PyArrayObject *)PyArray_FromAny(op, descr,
+                                0, 0, NPY_ARRAY_FORCECAST, NULL);
+    if (arr == NULL) {
+        return -1;
+    }
+
+    if ((mit->subspace != NULL) && (mit->consec)) {
+        if (mit->iteraxes[0] > 0) {  
+            _swap_axes(mit, (PyArrayObject **)&arr, 0);
+            if (arr == NULL) {
+                return -1;
+            }
+        }
+    }
+
+    if ((it = (PyArrayIterObject *)\
+            PyArray_BroadcastToShape(arr, mit->dimensions, mit->nd)) == NULL) {
+        Py_DECREF(arr);	
+
+        return -1;
+    }
+
+
+
+    PyArray_MapIterReset(mit);
+
+    (*add_inplace)(mit, it);
+
+    Py_DECREF(arr);
+    Py_DECREF(it);
+    return 0;
+}
+
+
+static PyObject *
+inplace_increment(PyObject *dummy, PyObject *args)
+{
+    PyObject *arg_a = NULL, *index=NULL, *inc=NULL;
+    PyArrayObject *a;
+    inplace_map_binop add_inplace = NULL; 
+    int type_number = -1;
+    int i =0;
+    PyArrayMapIterObject * mit;
+
+    if (!PyArg_ParseTuple(args, "OOO", &arg_a, &index,
+            &inc)) { 
+        return NULL;
+    }
+    if (!PyArray_Check(arg_a)) {
+         PyErr_SetString(PyExc_ValueError, "needs an ndarray as first argument");
+         return NULL;
+    }
+    a = (PyArrayObject *) arg_a;
+
+    if (PyArray_FailUnlessWriteable(a, "input/output array") < 0) {
+        return NULL;
+    }   
+
+    if (PyArray_NDIM(a) == 0) {
+        PyErr_SetString(PyExc_IndexError, "0-d arrays can't be indexed.");
+        return NULL; 
+    }
+    type_number = PyArray_TYPE(a);
+
+
+
+
+    while (type_numbers[i] >= 0 && addition_funcs[i] != NULL){    
+        if (type_number == type_numbers[i]) {
+            add_inplace = addition_funcs[i];
+            break;
+        }
+        i++ ;
+    }
+
+    if (add_inplace == NULL) {
+        PyErr_SetString(PyExc_TypeError, "unsupported type for a"); 
+        return NULL;
+    }
+
+    mit = (PyArrayMapIterObject *) PyArray_MapIterNew(index, 0, 1);
+    if (mit == NULL) {
+        goto fail;
+    }
+    PyArray_MapIterBind(mit, a);
+    if (map_increment(mit, inc, add_inplace) != 0) {
+        goto fail;
+    }
+
+    Py_DECREF(mit);
+
+    Py_INCREF(Py_None);
+    return Py_None;
+
+fail:
+    Py_XDECREF(mit);
+
+    return NULL;
+}
+
 static void
 arraymapiter_dealloc(PyArrayMapIterObject *mit)
 {

numpy/core/src/multiarray/mapping.h

@@ -59,4 +59,7 @@ PyArray_MapIterBind(PyArrayMapIterObject *, PyArrayObject *);
 NPY_NO_EXPORT PyObject*
 PyArray_MapIterNew(PyObject *, int, int);
 
+static PyObject *
+inplace_increment(PyObject *dummy, PyObject *args);
+
 #endif

numpy/core/src/multiarray/multiarraymodule.c

@@ -3677,6 +3677,9 @@ static struct PyMethodDef array_module_methods[] = {
     {"test_interrupt",
         (PyCFunction)test_interrupt,
         METH_VARARGS, NULL},
+	{"inplace_increment",
+        (PyCFunction)inplace_increment,
+        METH_VARARGS, NULL},	
     {NULL, NULL, 0, NULL}                /* sentinel */
 };
 

numpy/core/tests/test_inplace_increment.py

@@ -0,0 +1,49 @@
+import numpy as np
+from numpy.testing import *
+from numpy.testing.utils import WarningManager
+import warnings
+
+
+class TestInplaceIncrement(TestCase):
+	def test_dtypes(self):
+		def testdt(dt):
+			a = np.arange(12).reshape((3,4)).astype(dt)
+			index = ([1,1,2,0], [0,0,2,3])
+			inc = [50,50, 30,16]
+
+			np.inplace_increment(a, index, inc)
+
+			assert_array_almost_equal(a, np.array([[   0,    1,    2,   19],
+											[ 104,    5,    6,    7],
+											[   8,    9,   40,   11]]).astype(dt))
+
+		testdt(np.float)
+		testdt(np.int)
+		testdt(np.complex)
+
+	def test_slice(self):
+		a = np.arange(12).reshape((3,4)).astype(float)
+		index = (1, slice(None, None))
+		inc = [50,50, 30,16]
+
+		np.inplace_increment(a, index, inc)
+
+		assert_array_almost_equal(a, np.array([[   0,    1,    2,   3],
+											[ 54,    55,    36,  23],
+											[   8,    9,   10,   11]]).astype(float))
+
+	def test_boolean(self):
+		a = np.arange(12).reshape((3,4)).astype(float)
+		index = (1, np.array([ False, True, False, True], dtype = bool))
+		inc = [30,16]
+
+		np.inplace_increment(a, index, inc)
+
+		assert_array_almost_equal(a, np.array([[   0,    1,    2,   3],
+											[   4,   35,    6,  23],
+											[   8,    9,   10,   11]]).astype(float))
+
+
+
+if __name__ == "__main__":
+	run_module_suite()