# check version
np.__version__

# read about signature and docstring 
np.ndarray?

# or use help()

help(np.mean)

# a vector: the argument to the array function is a Python list
# more generally, 1D array
lst = [1,2,3,4.0]
v = np.array(lst, dtype=np.int32)

v

# get its datatype
v.dtype

# a matrix: the argument to the array function is a nested Python list (can also be a tuple of tuples)
# more generally, a 2D array
list_of_lists = [[1, 2], [3, 4]]
M = np.array(list_of_lists)

M

# a row vector

row_vec = v[np.newaxis, :]  # v[None, :]
row_vec

# a column vector
col_vec = v[:, np.newaxis]  # v[:, None]
col_vec

# read more about newaxis here: https://stackoverflow.com/questions/29241056/how-does-numpy-newaxis-work-and-when-to-use-it

# when using linspace, both end points ARE included
np.linspace(0, 10)

np.logspace(0, 5, 10, base=np.e)

# a 3D array
# a random array where the values come from a standard Normal distribution
gaussian = np.random.randn(2 * 3 * 4)

# reshape the array to desired shape.
# only the number of dimensions can be altered 
# the number of elements CANNOT be changed during a reshape operation

gaussian = gaussian.reshape(2, 3, 4)
gaussian

# an array full of zero values
# one can also specify a desired datatype

zero_arr = np.zeros((3, 4))
zero_arr

# an array full of ones
# one can also specify datatype

ones_arr = np.ones((3, 4), dtype=np.float32)
ones_arr

# a 4x4 identity (matrix) array

iden = np.identity(3, dtype=np.float128)  # np.eye(4, dtype=np.float128)
iden

# a diagonal array

diag = np.diag([1, 2, 3, 4.0])
diag

# get the list of all supported data types
np.sctypes

# get number of dimensions of the array
gaussian.ndim
print("total dimensions of the array is: ", gaussian.ndim)

# get the shape of the array
gaussian.shape
print("the shape of the array is: ", gaussian.shape)

# get the total number of elements in the array
gaussian.size
print("total number of items is: ", gaussian.size)

# get memory consumed by each item in the array
gaussian.itemsize
print("memory consumed by each item is: ", gaussian.itemsize)

# get memory consumed by the array
gaussian.nbytes
print("total memory consumed by the whole array is: ", gaussian.nbytes)

# 1D array of random integers
# get 10 integers from 0 to 23

num_samples = 10
integers = np.random.randint(23, size=num_samples)
integers

# indexing 1D array needs only one index
# get 3rd element (remember: NumPy unlike MATLAB is 0 based indexing)
integers[2]

twoD_arr = np.arange(1, 46).reshape(3, -1)
twoD_arr

# indexing 2D array needs only two indices.
# then it returns a scalar value

# value at last row and last column
twoD_arr[-1, -1]

# however, if we use only one (valid) index then it returns a 1D array

# get all elments in the last row
twoD_arr[-1]  # or twoD_arr[-1, ] or twoD_arr[-1, :]

# remember `gaussian` is a 3D array. 
gaussian

# So, a 2D array is returned when using one index

# return last slice
gaussian[-1]

# a 1D array is returned when using a pair of indices

# return first row from last slice
gaussian[-1, 0]

# return last row from last slice
gaussian[-1, -1]

# return last element of row of last slice
idx = (-1, -1, -1)
gaussian[idx]

# updating the array by assigning values
# truncation will happen if there's a datatype mismatch
#print(integers)
integers[2] = 99.21
integers

integers

# slice a portion of the array
# similar to Python iterator slicing
# x[start:stop:step]

# get last 5 elements
integers[-5:]

# if `stop` is omitted then it'll be sliced till the end of the array
# by default, step is 1

# get alternative elements (every other element) from the array
# equivalently step = 2

integers[::2]

# reversing the array
integers[::-1]

# forward traversal of array
integers[3::]

# reverse travesal of array (starting from 4th element)
integers[3::-1]

integers

# assign new values to the last two elements
integers[-2:] = [-23, -46]

integers

# a 2D array
twenty = (np.arange(4 * 5)).reshape(4, 5)
twenty

# slice first 2 rows and 3 columns
twenty[:2, :3]

# slice and get only the corner elements
# three "jumps" along dimension 0
# four "jumps" along dimension 1
twenty[::3, ::4]

# reversing the order of elements along columns (i.e. along dimension 0)
twenty[::-1, ...]

# reversing the order of elements along rows (i.e. along dimension 1)
twenty[..., ::-1]

# reversing the rows and columns (i.e. along both dimensions)
twenty[::-1, ::-1]

# or more intuitively
np.flip(twenty, axis=(0, 1))

# or equivalently
np.flipud(np.fliplr(twenty))
np.fliplr(np.flipud(twenty))

# a 2D array
twenty

# get 2nd, 3rd, and 4th rows
row_indices = [1, 2, 3]
twenty[row_indices]

col_indices = [1, 2, -1] # remember, index -1 means the last element
twenty[row_indices, col_indices]

# 1D array
integers

# mask has to be of the same shape as the array to be indexed; else IndexError would be thrown
# mask for indexing alternate elements in the array
row_mask = np.array([True, False, True, False, True, False, True, False, True, False])

integers[row_mask]

# alternatively
row_mask = np.array([1, 0, 1, 0, 1, 0, 1, 0, 1, 0], dtype=np.bool)

integers[row_mask]

range_arr = np.arange(0, 10, 0.5)
range_arr

mask = (range_arr > 5) * (range_arr < 7.5)
mask

range_arr[mask]

# or equivalently

mask = (5 < range_arr) & (range_arr < 7.5)
range_arr[mask]

a = np.arange(10)
a

# create a slice view
s1 = a[1::3]
s1

a

a[7] = 77
s1

b = np.arange(10, dtype='int16')
b

b32 = b.view(np.int32)
b32 += 1

# check array b and see the changes reflected
b

b8 = b.view(np.int8)
b8

# toy data
arr = np.arange(5 * 7).reshape(5, 7)
arr

# randomly shuffle the array along axis 0
# NOTE: this is an in-place operation
np.random.shuffle(arr)
arr

# compute argmax
amax = np.argmax(arr, axis=None)
idx = np.unravel_index(amax, arr.shape)
idx

# retrieve element
arr[idx]

# however, `max` would simply do that job
np.max(arr)

arr

# compute `mean` along an axis;
# should never use a `for` loop to do this
# use the standard ufunc `np.mean()`

## Signature: np.mean(a, axis=None, dtype=None, out=None, keepdims=<no value>)
avg = np.mean(arr, axis=0, keepdims=True)     # `keepdims` kwarg would return the result as an array of same dimension as input array.
avg

# conditional check
idxs = np.where(arr > 10)
idxs

# we can get the actual elements with the above mask
greater10 = arr[idxs]
greater10

# note that this would give us a copy of array.

greater10[-1] = 0
arr

random_arr = np.random.randn(2, 3, 4)
np.save("persist/random-array.npy", random_arr)

# The exclamation mark means that this line should be run through `bash` as though it were run on the terminal
!file persist/random-array.npy

vec = np.arange(0, 5)

vec

# note that original `vec` still remains unaffected since we haven't assigned the new array to it.
vec * 2

vec + 2

arr = np.arange(4 * 5).reshape(4, 5)
arr

np.matmul(arr, (arr.T))

print(vec.shape, arr.shape)

# shape has to match
vec * arr

# else no broadcasting will happen and an error is thrown
#print(vec[:, None].shape)

vec[:, None] * arr

# however, this would work
vec[:4, None] * arr

# matrix-matrix product
print(arr.T.shape, arr.shape)
np.dot(arr.T, arr)

# matrix-vector product
print("shapes: ", arr.shape, vec.shape)
np.dot(arr, vec)   # but not this: np.dot(vec, arr)

col_vec = vec[:, None]
print("shapes: ", (col_vec).T.shape, (col_vec).shape)

# inner product
(col_vec.T) @ (col_vec)

a = np.array([[1, 2], [3, 4]])
a

# repeat each element 3 times
np.repeat(a, 3)

# tile the matrix 3 times 
np.tile(a, 3)

b = np.array([[5, 6]])
b

# concatenate a and b along axis 0
np.concatenate((a, b), axis=0)

# concatenate a and b along axis 1
np.concatenate((a, b.T), axis=1)

np.vstack((a,b))

np.hstack((a,b.T))

A = np.array([[1, 2], [3, 4]])

A

# now array B is referring to the same array data as A 
B = A
B

# changing B affects A
B[0,0] = 10

A

# now, if we modify B, A is not affected
B[0,0] = -5

A

v1 = np.array([-3,-2,-1,0,1,2,3])

Theta(v1)

Theta_vec(v1)

Theta(v1)

# it even works with scalar input
Theta(-1.2), Theta(2.6)

axis_visual = "https://i.stack.imgur.com/p2PGi.png"
Image(url=axis_visual)

arr_visual = "https://www.oreilly.com/library/view/elegant-scipy/9781491922927/assets/elsp_0105.png"
Image(url=arr_visual)

arr = np.arange(5 * 6).reshape(5, 6)
arr

arr.mean(axis=0, keepdims=True)

bcast_visual = "https://jakevdp.github.io/PythonDataScienceHandbook/figures/02.05-broadcasting.png"
Image(url=bcast_visual, width=720, height=480)

rng = np.random.RandomState(seed=42)
data = rng.randint(-1, 5, (3, 6))
data

# for reproducibility
rng = np.random.RandomState(seed=42)

std_normal_dist = rng.standard_normal(size=(3, 4, 2))
std_normal_dist

# if reproducibility matters ...
rng = np.random.RandomState(seed=42)

# an array of 10 points randomly sampled from a normal distribution
# loc=mean, scale=std deviation
rng.normal(loc=0.0, scale=1.0, size=(3, 4, 2))

# uniform distribution
rng = np.random.RandomState(seed=42)

rng.uniform(low=0, high=1.0, size=(3, 4, 2))