243 lines
5.8 KiB
Markdown
243 lines
5.8 KiB
Markdown
# Extending an existing matrix
|
||
{:.no_toc}
|
||
|
||
<nav markdown="1" class="toc-class">
|
||
* TOC
|
||
{:toc}
|
||
</nav>
|
||
|
||
## The goal
|
||
|
||
|
||
|
||
Questions to [David Rotermund](mailto:davrot@uni-bremen.de)
|
||
|
||
## [numpy.tile](https://numpy.org/doc/stable/reference/generated/numpy.tile.html)
|
||
|
||
```python
|
||
numpy.tile(A, reps)
|
||
```
|
||
|
||
> Construct an array by repeating A the number of times given by reps.
|
||
>
|
||
> If reps has length d, the result will have dimension of max(d, A.ndim).
|
||
>
|
||
> If A.ndim < d, A is promoted to be d-dimensional by prepending new axes. So a shape (3,) array is promoted to (1, 3) for 2-D replication, or shape (1, 1, 3) for 3-D replication. If this is not the desired behavior, promote A to d-dimensions manually before calling this function.
|
||
>
|
||
> If A.ndim > d, reps is promoted to A.ndim by pre-pending 1’s to it. Thus for an A of shape (2, 3, 4, 5), a reps of (2, 2) is treated as (1, 1, 2, 2).
|
||
>
|
||
> Note : Although tile may be used for broadcasting, it is strongly recommended to use numpy’s broadcasting operations and functions.
|
||
|
||
**You might want to first use numpy.newaxis to create the required additional axis and then use tile.**
|
||
|
||
Adding a new dimension makes a copy:
|
||
|
||
```python
|
||
import numpy as np
|
||
|
||
a = np.arange(1, 5)
|
||
|
||
print(a) # -> [1 2 3 4]
|
||
print(a.shape) # -> (4,)
|
||
|
||
b = a[np.newaxis, :]
|
||
print(b.shape) # -> (1, 4)
|
||
print(np.may_share_memory(a, b)) # -> True (View)
|
||
|
||
c = np.tile(a, (1, 1))
|
||
print(c.shape) # -> (1, 4)
|
||
print(np.may_share_memory(a, c)) # -> False (Copy)
|
||
```
|
||
|
||
Examples:
|
||
|
||
```python
|
||
import numpy as np
|
||
|
||
a = np.arange(1, 5)[np.newaxis, :]
|
||
|
||
print(a) # -> [[1 2 3 4]]
|
||
print(a.shape) # -> (1, 4)
|
||
|
||
c = np.tile(a, (1, 1))
|
||
print(c) # -> [[1 2 3 4]]
|
||
print(c.shape) # -> (1, 4)
|
||
|
||
c = np.tile(a, (4, 1))
|
||
print(c)
|
||
print(c.shape) # -> (4, 4)
|
||
|
||
c = np.tile(a, (1, 4))
|
||
print(c) # -> [[1 2 3 4 1 2 3 4 1 2 3 4 1 2 3 4]]
|
||
print(c.shape) # -> (1, 16)
|
||
```
|
||
|
||
Output:
|
||
|
||
```python
|
||
[[1 2 3 4]
|
||
[1 2 3 4]
|
||
[1 2 3 4]
|
||
[1 2 3 4]]
|
||
```
|
||
|
||
Be very careful if you haven’t newaxis-ed...
|
||
|
||
```python
|
||
import numpy as np
|
||
|
||
a = np.arange(1, 5)
|
||
|
||
print(a) # -> [1 2 3 4]
|
||
print(a.shape) # -> (4,)
|
||
|
||
c = np.tile(a, (4))
|
||
print(c) # -> [1 2 3 4 1 2 3 4 1 2 3 4 1 2 3 4]
|
||
print(c.shape) # -> (16,)
|
||
|
||
c = np.tile(a, (1, 4))
|
||
print(c) # -> [[1 2 3 4 1 2 3 4 1 2 3 4 1 2 3 4]]
|
||
print(c.shape) # -> (1, 16)
|
||
|
||
c = np.tile(a, (4, 1))
|
||
print(c)
|
||
print(c.shape) # -> (4, 4)
|
||
print()
|
||
|
||
c = np.tile(a, (4, 1, 1))
|
||
print(c)
|
||
print(c.shape) # -> (4, 1, 4)
|
||
print()
|
||
|
||
c = np.tile(a, (1, 4, 1))
|
||
print(c)
|
||
print(c.shape) # -> (1, 4, 4)
|
||
print()
|
||
|
||
c = np.tile(a, (1, 1, 4))
|
||
print(c) # -> [[[1 2 3 4 1 2 3 4 1 2 3 4 1 2 3 4]]]
|
||
print(c.shape) # -> (1, 1, 16)
|
||
```
|
||
|
||
Output:
|
||
|
||
```python
|
||
[[1 2 3 4]
|
||
[1 2 3 4]
|
||
[1 2 3 4]
|
||
[1 2 3 4]]
|
||
|
||
[[[1 2 3 4]]
|
||
|
||
[[1 2 3 4]]
|
||
|
||
[[1 2 3 4]]
|
||
|
||
[[1 2 3 4]]]
|
||
|
||
[[[1 2 3 4]
|
||
[1 2 3 4]
|
||
[1 2 3 4]
|
||
[1 2 3 4]]]
|
||
```
|
||
|
||
## [numpy.repeat](https://numpy.org/doc/stable/reference/generated/numpy.repeat.html#numpy-repeat)
|
||
|
||
**Don’t confuse tile() with repeat()!**
|
||
|
||
```python
|
||
numpy.repeat(a, repeats, axis=None)[source]
|
||
```
|
||
|
||
> Repeat each element of an array after themselves
|
||
|
||
```python
|
||
import numpy as np
|
||
|
||
a = np.arange(1, 5)
|
||
print(a) # -> [1 2 3 4]
|
||
print(a.shape) # -> (4,)
|
||
|
||
b = np.repeat(a, (4))
|
||
print(b) # -> [1 1 1 1 2 2 2 2 3 3 3 3 4 4 4 4]
|
||
print(b.shape) # -> (16,)
|
||
```
|
||
|
||
## [numpy.pad](https://numpy.org/doc/stable/reference/generated/numpy.pad.html)
|
||
|
||
```python
|
||
numpy.pad(array, pad_width, mode='constant', **kwargs)
|
||
```
|
||
|
||
> Pad an array.
|
||
|
||
> **pad_width** : {sequence, array_like, int}
|
||
>
|
||
> Number of values padded to the edges of each axis. ((before_1, after_1), ... (before_N, after_N)) unique pad widths for each axis. (before, after) or ((before, after),) yields same before and after pad for each axis. (pad,) or int is a shortcut for before = after = pad width for all axes.
|
||
|
||
> **constant_values** : sequence or scalar, optional
|
||
>
|
||
> Used in ‘constant’. The values to set the padded values for each axis.
|
||
>
|
||
> ((before_1, after_1), ... (before_N, after_N)) unique pad constants for each axis.
|
||
>
|
||
> (before, after) or ((before, after),) yields same before and after constants for each axis.
|
||
>
|
||
> (constant,) or constant is a shortcut for before = after = constant for all axes.
|
||
>
|
||
> Default is 0.
|
||
|
||
```python
|
||
import numpy as np
|
||
|
||
a = np.arange(1, 5)
|
||
print(a) # -> [1 2 3 4]
|
||
print(a.shape) # -> (4,)
|
||
|
||
|
||
print(np.pad(a, 2)) # -> [0 0 1 2 3 4 0 0]
|
||
print(np.pad(a, [2, 3])) # -> [0 0 1 2 3 4 0 0 0]
|
||
print(np.pad(a, [2, 3], constant_values=-1)) # -> [-1 -1 1 2 3 4 -1 -1 -1]
|
||
```
|
||
|
||
```python
|
||
import numpy as np
|
||
|
||
a = np.arange(1, 5).reshape((1, 4))
|
||
print(a) # -> [[1 2 3 4]]
|
||
print(a.shape) # -> (1, 4)
|
||
|
||
|
||
print(np.pad(a, [[2, 3], [1, 1]]))
|
||
```
|
||
|
||
Output:
|
||
```python
|
||
[[0 0 0 0 0 0]
|
||
[0 0 0 0 0 0]
|
||
[0 1 2 3 4 0]
|
||
[0 0 0 0 0 0]
|
||
[0 0 0 0 0 0]
|
||
[0 0 0 0 0 0]]
|
||
```
|
||
|
||
### Pad can do more complex padding patterns than just pad with constant values!
|
||
|
||
> **mode** : str or function, optional
|
||
>
|
||
> One of the following string values or a user supplied function.
|
||
|
||
|||
|
||
|---|---|
|
||
|‘constant’ (default)|Pads with a constant value.|
|
||
|‘edge’|Pads with the edge values of array.|
|
||
|‘linear_ramp’|Pads with the linear ramp between end_value and the array edge value.|
|
||
|‘maximum’|Pads with the maximum value of all or part of the vector along each axis.|
|
||
|‘mean’|Pads with the mean value of all or part of the vector along each axis.|
|
||
|‘median’|Pads with the median value of all or part of the vector along each axis.|
|
||
|‘minimum’|Pads with the minimum value of all or part of the vector along each axis.|
|
||
|‘reflect’|Pads with the reflection of the vector mirrored on the first and last values of the vector along each axis.|
|
||
|‘symmetric’|Pads with the reflection of the vector mirrored along the edge of the array.|
|
||
|‘wrap’|Pads with the wrap of the vector along the axis. The first values are used to pad the end and the end values are used to pad the beginning.|
|
||
|‘empty’|Pads with undefined values.|
|
||
|<function>|Padding function, see Notes.|
|