Intro to Numpy and indexing in 2D arrays

# Import modules
import numpy as np
import matplotlib.pyplot as plt

# Use array() to create arrays of any dimension if you already know or have the values to put into the array.
x = np.array([5,4,3,2,1])

# Linspace inputs are start, stop, # of elements
xls = np.linspace(0,100,100)

# arange inputs are start,stop,interval
xar = np.arange(0,100,0.9999)

#print(xar.shape)
#xls.shape

# This term tells you to pull the last value of the array out
#print( xar[-1], xls[-1])

# Assembling a 2D array by concatenating 1D arrays.
x = np.array([[1,2,3],[3,4,5]])
x.ndim

# Currently this is a 1D array
y = np.array([1,2,3])

# Sometimes you need to set an array up to be 2D, so you can add data to it later.
# This should be a 2D array
y2 = np.array([1,2,3],ndmin = 2)

#print("Y has",y.ndim,"dimensions. Y2 has",y2.ndim,"dimensions")

# Examples of array manipulations.

R = np.arange(0,100,12)  # Create a vector of 9 elements

# Element-wise operation.  P is the same size as R.
P = R*R

# Impliclit element-wise operation.

Q = P.copy() - 3
Q = P*R

# Make R into a 3 x 3 matrix (2D array), and store it in S.
S = R.reshape(3,3)

# An array multiplication with broadcast operation.  
T = S*np.array([3,2,1])
#print(T)

# Object-oriented notation
#print( T.max(),np.max(T) )  #(Object-oriented notation, Functional notation)

#print( T.max(axis=0),np.max(T,axis=0) )  #Take the max along the row axis

#In general, when concatenating (merging or pasting together) arrays they must have the same shape and same dimensions 

help(np.concatenate)
np.concatenate((y,y2))  # Not permitted.

np.concatenate((y[np.newaxis,:],y2))   #Expand the dimensions of y before concatenating.

# Stack vertically.  This has same effect as concatenate
np.vstack((y,y2))   # Permitted, because arrays have the same column dimensions


# Stack horizontally.  
np.hstack((y,y2))   # Not Permitted, because y and y2 have the different row dimensions

np.hstack((y[np.newaxis,:],y2))

# Index individual row or column in 2D array
z = np.ones((100,50))


# Save a single row of z to a new variable
zr = z[9,:]

# Save a single column of z to a new variable
zc = z[:,9]

#print(zc.shape,zr.shape, z.shape)

# Make a 2D column vector of ones with 10 elements in it. 
a = np.ones([10,1])

# Copy that column vector 10 times to make a square array.
b = np.tile(a,10)


# Make a vector of 10 elements and then place them in the diagonal of a 10 x 10 square array.
c = np.ones(10)*100
d = np.diag(c)

# Use the Matplotlib spy() function to visualize the array b+d
plt.spy(b+d,precision=10,markersize=10)
plt.show()

#print(b+d)


#np.random.randn(10)

#print(d)

# Check out shape, ndim, dtype
z = d+b

#print(z.shape)

#print(z.dtype)

#print(z)

# Use boolean operators to change values.

z2 = z.copy()

# Find all the values equa1 to 1.
id1 = (z2 == 1)

# id1 now has a boolean record of which values are ==1.
#print(id1)

# Let's change all the elements equal to 1.

z2[id1] = 3.14159

#z2[z2 == 3.14159] = np.nan

#print(z2)

# Convert all the values of z2 that are > 99 into NaNs.

# Make a 2D numpy array named Arr of size 10 x 10 and fill it with random values that range between 0 and 99.  You can use numpy's random module
# np.random.randint()

# Use boolean indexing to replace all the values in Arr greater than 80 and less than 20 with NaNs.

# Use the append() or concatenate() commands in numpy to add more columns to Arr.

# We already saw that np.diag() can insert elements along the diagonal of a square array.
# Use your understanding of for loops to carry out the same operation.
# Create a 10 x 10 array of ones and then modify the center diagonal to be 101 instead of 1.
# Hint: You will need two indices, e.g i and j to specify the row and column to modify.
# Hint: You can use a boolean operator to decide which elements in the square array to modify.