Merge pull request #5 from jetbrains-academy/sofia/integer_array_indexing

Added Integer Array Indexing task to section Array Indexing ans Slici…

Author: sofiiako

Numpy/Array Indexing and Slicing/Integer Array Indexing/__init__.py

@@ -0,0 +1,26 @@
+type: edu
+files:
+- name: task.py
+  visible: true
+  placeholders:
+  - offset: 63
+    length: 28
+    placeholder_text: '# TODO: use a 1-D numpy array for indexing'
+  - offset: 96
+    length: 52
+    placeholder_text: '# TODO: use a 2-D numpy array for indexing'
+  - offset: 155
+    length: 22
+    placeholder_text: '# TODO: use a 1-D numpy array for indexing'
+  - offset: 182
+    length: 43
+    placeholder_text: '# TODO: use two 1-D arrays for indexing'
+  - offset: 230
+    length: 25
+    placeholder_text: '# TODO: use a 1-D numpy array and a scalar for indexing'
+- name: tests/test_task.py
+  visible: false
+- name: __init__.py
+  visible: false
+- name: tests/__init__.py
+  visible: false

Numpy/Array Indexing and Slicing/Integer Array Indexing/task-info.yaml

@@ -0,0 +1,90 @@
+## Integer array indexing
+
+NumPy arrays may be indexed with other arrays.
+For all cases of index arrays, what is returned is a copy of the original data, not a view as one gets for slices.
+
+Index arrays must be of integer type. Each value in the array indicates which value in the array 
+to use in place of the index. Negative values are permitted and work as they do with single indices or slices.
+
+```python
+x = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
+a = np.array([0, 3, 5, 2])
+print(x[a])
+```
+Output:
+```text
+[1 4 6 3]
+```
+
+When index arrays are used, what is returned is an array with the same shape as the index 
+array, but with the type and values of the array being indexed:
+```python
+b = np.array([[9, 9], [0, 1]])
+c = x[b]
+print(c)
+```
+Output:
+```text
+[[10 10]
+ [ 1  2]]
+```
+
+### Indexing multidimensional arrays
+Things become more complex when multidimensional arrays are indexed, particularly with multidimensional index arrays.
+Let's consider this:
+
+```python
+x = np.arange(15).reshape(5, 3)
+print(x)
+print(x[np.array([0, 1, 4])])  # 1
+print(x[np.array([0, 1, 4]), np.array([0, 0, 1])])  # 2
+```
+Output:
+```text
+[[ 0  1  2]
+ [ 3  4  5]
+ [ 6  7  8]
+ [ 9 10 11]
+ [12 13 14]]
+ 
+[[ 0  1  2]
+ [ 3  4  5]
+ [12 13 14]]
+ 
+[ 0  3 13]
+```
+You can see that in the first case, a new array is constructed where 
+each value of the index array selects one row from the indexed array and the resulting 
+array has the shape `(number_of_index_elements, size_of_row)`.
+
+In the second case, the resulting array has the same shape as the index arrays, and the values 
+correspond to the index set for each position in the index arrays. In this example, the first 
+index value is `0` for both index arrays, and thus the first value of the resulting array is `x[0, 0]`. 
+The next value is `y[1, 0]`, and the last is `y[4, 1]`.
+
+If the index arrays do not have the same shape, there is an attempt to broadcast them to the same shape. 
+If they cannot be broadcast to the same shape, an exception is raised.
+
+The broadcasting mechanism permits index arrays to be combined with scalars for other indices. 
+The scalar value is used for all the corresponding values of the index arrays:
+
+```python
+print(x[np.array([0, 2, 3, 4]), 1])
+```
+Output:
+```text
+[ 1  7 10 13]
+```
+You can read more about integer indexing [here](https://numpy.org/doc/stable/reference/arrays.indexing.html#integer-array-indexing).
+
+### Task
+1. Using integer array indexing create an array `a` that contains elements with 
+   indices `[7, 13, 28, 33]` from the array `x`.
+   Then create a 2-D array `b` with shape `(3, 3)` that contains elements with indices
+   `[0, 1, 2], [10, 11, 12], [28, 29, 30]` from the array `x`.
+   
+2. Based on the 2-D array `y`:
+   - Create an array `c` containing rows number `0`, `2` and `4`.
+   - Create a 1-D array `d`, containing elements `0`, `1` and `2` from the rows `0`, `2` and `4`, respectively.
+   - Create a 1-D array `e`, containing elements with index `6` from rows `1`, `2` and `4`.
+    

Numpy/Array Indexing and Slicing/Integer Array Indexing/task.md

@@ -0,0 +1,21 @@
+import numpy as np
+
+x = np.arange(35)
+y = x.reshape(5, 7)
+
+a = x[np.array([7, 13, 28, 33])]
+b = x[np.array([[0, 1, 2], [10, 11, 12], [28, 29, 30]])]
+
+
+c = y[np.array([0, 2, 4])]
+d = y[np.array([0, 2, 4]), np.array([0, 1, 2])]
+e = y[np.array([1, 2, 4]), 6]
+
+
+if __name__ == '__main__':
+    print(y)
+    print('\n', a.shape)
+    print('\n', b.shape)
+    print('\n', c.shape)
+    print('\n', d.shape)
+    print('\n', e.shape)

Numpy/Array Indexing and Slicing/Integer Array Indexing/task.py

@@ -0,0 +1,19 @@
+import unittest
+import numpy as np
+
+from task import x, y, a, b, c, d, e
+
+class TestCase(unittest.TestCase):
+    def test_shape(self):
+        self.assertEqual(a.shape, (4,), msg='Wrong shape of array a!')
+        self.assertEqual(b.shape, (3, 3), msg='Wrong shape of array b!')
+        self.assertEqual(c.shape, (3, 7), msg='Wrong shape of array c!')
+        self.assertEqual(d.shape, (3,), msg='Wrong shape of array d!')
+        self.assertEqual(e.shape, (3,), msg='Wrong shape of array e!')
+
+    def test_arrays(self):
+        np.testing.assert_array_equal(a, x[np.array([7, 13, 28, 33])], err_msg='Array a is not what we expected!')
+        np.testing.assert_array_equal(b, x[np.array([[0, 1, 2], [10, 11, 12], [28, 29, 30]])], err_msg='Array b is not what we expected!')
+        np.testing.assert_array_equal(c, y[np.array([0, 2, 4])], err_msg='Array c is not what we expected!')
+        np.testing.assert_array_equal(d, y[np.array([0, 2, 4]), np.array([0, 1, 2])], err_msg='Array d is not what we expected!')
+        np.testing.assert_array_equal(e, y[np.array([1, 2, 4]), 6], err_msg='Array e is not what we expected!')

Numpy/Array Indexing and Slicing/Integer Array Indexing/tests/__init__.py

@@ -1,2 +1,3 @@
 content:
 - Indexing Basics
+- Integer Array Indexing