Merge branch 'master' into sofia/transpose

Author: sofiiako

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

@@ -0,0 +1,17 @@
+type: edu
+files:
+- name: task.py
+  visible: true
+  placeholders:
+  - offset: 24
+    length: 30
+    placeholder_text: '# TODO'
+  - offset: 62
+    length: 40
+    placeholder_text: '# TODO'
+- name: tests/test_task.py
+  visible: false
+- name: __init__.py
+  visible: false
+- name: tests/__init__.py
+  visible: false

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

@@ -0,0 +1,55 @@
+## Boolean Indexing
+
+Boolean arrays used as indices are treated differently from index 
+arrays. Boolean arrays must be of the same shape as the initial dimensions of the array being indexed.
+Such boolean arrays are often referred to as **masks** and the process of indexing other arrays using them
+is called masking, or masked filtering.
+
+```python
+y = np.arange(20).reshape(5, 4)
+b = y % 2 != 0
+print(b)
+print(y[b])
+```
+Output:
+```text
+[[False  True False  True]
+ [False  True False  True]
+ [False  True False  True]
+ [False  True False  True]
+ [False  True False  True]]
+[ 1  3  5  7  9 11 13 15 17 19]
+```
+Unlike in the case of integer index arrays, in the boolean case, the result is a 1-D array 
+containing all the elements in the indexed array corresponding to all the true elements in the boolean array.
+As with index arrays, what is returned is a copy of the data, not a view as one gets with slices.
+
+
+The result will be multidimensional if `y` has more dimensions than `b`. For example, if we use a
+1-D boolean array where the second dimension agrees with that of `b` (just selecting one row from `b`),
+then the columns from `y` corresponding to the `True` values in the 1-D array will be selected:
+```python
+print(b[1, :])
+print(y[:, b[1, :]])
+```
+Output:
+```text
+[False  True False  True]
+[[ 1  3]
+ [ 5  7]
+ [ 9 11]
+ [13 15]
+ [17 19]]
+```
+The 2nd and 4th rows are selected from the indexed array and combined to make a 2-D array.
+
+In general, when the boolean array has fewer dimensions than the indexed array,
+the shape of the result is one dimension containing the number of `True` elements 
+of the boolean array, followed by the remaining dimensions of the indexed array.
+
+For further details, consult the NumPy reference documentation on [array indexing](https://numpy.org/doc/stable/reference/arrays.indexing.html#indexing).
+
+### Task 
+1. Create a 3-D array `a` with integers from 0 to 19 and shape `(2, 2, 5)`.
+2. Filter it using a 2-D boolean array `b` so that the resulting 2-D array `c` has the
+shape `(2, 5)` and contains elements `[ 0  1  2  3  4]` and `[15 16 17 18 19]`.

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

@@ -0,0 +1,10 @@
+import numpy as np
+
+a = np.arange(20).reshape(2, 2, 5)
+mask = np.array([[True, False], [False, True]])
+c = a[mask]
+
+if __name__ == '__main__':
+    print('Array a:\n', a, '\n')
+    print('Indexed array c:\n', c)
+    print(c.shape)

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

@@ -0,0 +1,15 @@
+import unittest
+import numpy as np
+
+from task import a, mask, c
+
+
+class TestCase(unittest.TestCase):
+    def test_add(self):
+        test_a = np.arange(20).reshape(2, 2, 5)
+        test_b = np.array([[True, False], [False, True]])
+        np.testing.assert_array_equal(a, test_a, err_msg='Array `a` seems off!')
+        np.testing.assert_array_equal(c, test_a[test_b], err_msg='Array `c` seems off!')
+        np.testing.assert_array_equal(mask, test_b, err_msg='Something wrong with the mask array!')
+
+

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

@@ -0,0 +1,17 @@
+type: edu
+files:
+- name: task.py
+  visible: true
+  placeholders:
+  - offset: 240
+    length: 7
+    placeholder_text: '# TODO'
+  - offset: 252
+    length: 11
+    placeholder_text: '# TODO'
+- name: tests/test_task.py
+  visible: false
+- name: __init__.py
+  visible: false
+- name: tests/__init__.py
+  visible: false

Numpy/Array Indexing and Slicing/Boolean Indexing/tests/test_task.py

@@ -0,0 +1,73 @@
+## Indexing Basics
+
+Array indexing refers to any use of the square brackets (`[]`) to index array values.
+
+### Single element indexing
+
+Single element indexing for a 1-D array works exactly like that 
+for other standard Python sequences. It is 0-based, and accepts negative indices for 
+indexing from the end of the array.
+
+Unlike lists and tuples, NumPy arrays support multidimensional indexing for multidimensional 
+arrays. That means that **it is not necessary to separate each dimension’s index into its 
+own set of square brackets**.
+
+```python
+x = np.arange(10).reshape(2, 5) # 2-dimensional
+print(x[1, 3])
+print(x[1, -1])
+print(x[0])
+```
+Output:
+```text
+8
+9
+[0, 1, 2, 3, 4]
+```
+Note that `x[0, 2]` and `x[0][2]` will produce the same result, `2`. However, the second case 
+is less efficient as a new temporary array is created after the first index that is subsequently 
+indexed by 2.
+
+### Slicing
+
+It is possible to slice arrays to extract arrays of the same number of dimensions, 
+but of different sizes than the original. The slicing works exactly the same way it 
+does for lists and tuples except that they can be applied to multiple dimensions as well.
+Basic slicing occurs when obj is a slice object (constructed by `start:stop:step` notation inside 
+of brackets), an integer, or a tuple of slice objects and integers.
+
+1-D array:
+```python
+x = np.arange(35)
+print(x[2:15])
+print(x[1:30:5])  # [start:stop:step]
+```
+Output:
+```text
+[ 2  3  4  5  6  7  8  9 10 11 12 13 14]
+[ 1  6 11 16 21 26]
+```
+2-D array:
+```python
+y = x.reshape(5, 7)
+print(y[1:5:2])
+print(y[1:5:2, ::3])  # First slicing in the first dimension, then in the second.
+```
+Output:
+```text
+[[ 7  8  9 10 11 12 13]
+ [21 22 23 24 25 26 27]]
+[[ 7 10 13]
+ [21 24 27]]
+```
+
+These examples show the use of indexing when referencing data in an array. 
+They work just as well when assigning to an array.
+Read more about this topic [here](https://numpy.org/doc/stable/user/basics.indexing.html#basics-indexing).
+
+### Task
+1. Variable `a`: use indexing on the array `x` to extract number `19` from it. Please
+   **do not** just assign `a` the value `19` :)
+2. Variable `b`: use slicing to extract every second element in every second row. The resulting array 
+should have shape `(5, 2)`.
+   

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

@@ -0,0 +1,21 @@
+import numpy as np
+
+x = np.arange(40).reshape(10, 4)
+# Array x:
+# [[ 0  1  2  3]
+#  [ 4  5  6  7]
+#  [ 8  9 10 11]
+#  [12 13 14 15]
+#  [16 17 18 19]
+#  [20 21 22 23]
+#  [24 25 26 27]
+#  [28 29 30 31]
+#  [32 33 34 35]
+#  [36 37 38 39]]
+
+a = x[4, 3]
+b = x[::2, ::2]
+
+if __name__ == '__main__':
+    print(a)
+    print(b)