NAIAHD

numpy 100제

76. Consider a one-dimensional array Z, build a two-dimensional array whose first row is (Z[0],Z[1],Z[2]) and each subsequent row is shifted by 1 (last row should be (Z[-3],Z[-2],Z[-1])

#hint: from numpy.lib import stride_tricks
from numpy.lib import stride_tricks
def rolling(a, window):
    shape = (a.size - window +1, window)
    strides = (a.itemsize, a.itemsize)
    return stride_tricks.as_strided(a, shape = shape, strides = strides)

data = rolling(np.arange(10),3)
print(data)

77. How to negate a boolean, or to change the sign of a float inplace?

#hint: np.logical_not, np.negative
data = np.random.randint(0,2,100)
print(data)

print(np.logical_not(data, out = data))

data = np.random.uniform(-1.0, 1.0, 100)
print(data)

print(np.negative(data, out = data))

78. Consider 2 sets of points P0,P1 describing lines (2d) and a point p, how to compute distance from p to each line i (P0[i],P1[i])? 

#No hints provided...
def distance(P0, P1, p):
    T = P1 - P0
    L = (T**2).sum(axis=1)
    U = -((P0[:,0]-p[...,0])*T[:,0] + (P0[:,1]-p[...,1])*T[:,1]) / L
    U = U.reshape(len(U), 1)
    D = P0 + U*T - p
    return np.sqrt((D **2).sum(axis = 1))
P0 = np.random.uniform(-10,10,(10,2))
P1 = np.random.uniform(-10,10,(10,2))
p  = np.random.uniform(-10,10,( 1,2))

print(distance(P0, P1, p))

79. Consider 2 sets of points P0,P1 describing lines (2d) and a set of points P, how to compute distance from each point j (P[j]) to each line i (P0[i],P1[i])?

#No hints provided..
P0 = np.random.uniform(-10,10,(10,2))
P1 = np.random.uniform(-10,10,(10,2))
p  = np.random.uniform(-10,10,( 10,2))
print(np.array([distance(P0,P1, p_i) for p_i in p]))

80. Consider an arbitrary array, write a function that extract a subpart with a fixed shape and centered on a given element (pad with a fill value when necessary)

#hint: minimum maximum
Z = np.random.randint(0, 10, (10,10))
print(Z)
shape = (5,5)
fill = 0
position = (1,1)
R = np.ones(shape)
P = np.array(list(position)).astype(int)
Rs = np.array(list(R.shape)).astype(int)
Zs = np.array(list(Z.shape)).astype(int)

R_start = np.zeros((len(shape),)).astype(int)
R_stop = np.array(list(shape)).astype(int)
Z_start = (P-Rs//2)
Z_stop = (P+Rs//2) + Rs%2

R_start = (R_start-np.minimum(Z_start,0)).tolist()
Z_start = (np.maximum(Z_start,0)).tolist()
R_stop = (np.maximum(R_start,(R_stop-np.maximum(Z_stop-Zs,0)))).tolist()
Z_stop = (np.minimum(Z_stop, Zs)).tolist()

r = [slice(start,stop) for start,stop in zip(R_start,R_stop)]
z = [slice(start,stop) for start,stop in zip(Z_start,Z_stop)]
R[r] = Z[z]
print(Z)
print(R)

81. Consider an array Z = [1,2,3,4,5,6,7,8,9,10,11,12,13,14], how to generate an array R = [[1,2,3,4], [2,3,4,5], [3,4,5,6], ..., [11,12,13,14]]?

#hint: stride_tricks.as_strided
from numpy.lib import stride_tricks
Z = np.arange(1,15, dtype = np.uint32)
print(Z)
R = stride_tricks.as_strided(Z, (11,4), (4,4))
print(R)

82. Compute a matrix rank 

#hint: np.linalg.svd
Z = np.random.uniform(0,1,(10,10))
U,S, V = np.linalg.svd(Z)
rank = np.sum(S > 1e-10)
print(rank)

83. How to find the most frequent value in an array?

#hint: np.bincount, argmax
data = np.random.randint(0,10,50)
print(data)
print(np.bincount(data))
print(np.bincount(data).argmax())

84. Extract all the contiguous 3x3 blocks from a random 10x10 matrix

#hint: stride_tricks.as_strided
data = np.random.randint(0,5,(10,10))
n = 3
i = 1 + (data.shape[0]-3)
j = 1 + (data.shape[1]-3)
C = stride_tricks.as_strided(data, shape= (i,j,n,n), strides = data.strides+ data.strides)
print(C)

85. Create a 2D array subclass such that Z[i,j] == Z[j,i] 

#hint: class method
class Symetric(np.ndarray):
    def __setitem__(self, index, value):
        i,j = index
        super(Symetric, self).__setitem__((i,j), value)
        super(Symetric, self).__setitem__((j,i), value)
        
def symetric(Z):
    return np.asarray(Z+Z.T-np.diag(Z.diagonal())).view(Symetric)

S= symetric(np.random.randint(0,10,(5,5)))
S[2,3]  = 42
print(S)

86. Consider a set of p matrices wich shape (n,n) and a set of p vectors with shape (n,1). How to compute the sum of of the p matrix products at once? (result has shape (n,1))

#hint: np.tensordot
p, n = 10,20
M = np.ones((p,n,n))
V = np.ones((p,n,1))
S = np.tensordot(M,V, axes = [[0,2],[0,1]])
print(S)

87. Consider a 16x16 array, how to get the block-sum (block size is 4x4)?

#hint: np.add.reduceat
Z = np.ones((16,16))
print(Z)
k = 4
S = np.add.reduceat(np.add.reduceat(Z, np.arange(0,Z.shape[0],k), axis = 0), np.arange(0,Z.shape[1], k), axis = 1)
print(S)

88. How to implement the Game of Life using numpy arrays?

#No hints provided...
def iterate(Z):
    N = (Z[0:-2, 0:-2] + Z[0:-2, 1:-1] + Z[0:-2, 2:]+ Z[1:-1, 0:-2] + Z[1:-1, 2:]+Z[2:,0:-2]+ Z[2:, 1:-1]+ Z[2:,2:])

    birth = (N == 3) * (Z[1:-1, 1:-1] ==0)
    survive = ((N == 2)|(N ==3))& (Z[1:-1, 1:-1]==1)
    Z[...] = 0
    Z[1:-1, 1:-1][birth | survive] =1
    return Z

Z = np.random.randint(0,2, (50,50))
for i in range(100):
    Z = iterate(Z)
print(Z)

89. How to get the n largest values of an array

#hint: np.argsort | np.argpartitio
data = np.arange(10000)
print(data)
np.random.shuffle(data)
n = 5
print(data[np.argsort(data)[-n:]])
print(data[np.argpartition(-data,n )[:n]])

90. Given an arbitrary number of vectors, build the cartesian product (every combinations of every item)

#hint: np.indices
def cartesian(arrays):
    arrays = [np.asarray(a) for a in arrays]
    shape = (len(x) for x in arrays)
    ix = np.indices(shape, dtype = int)
    ix = ix.reshape(len(arrays), -1).T
    
    for n, arr in enumerate(arrays):
        ix[:,n ] = arrays[n][ix[:,n]]
    return ix
print(cartesian(([1,2,3],[4,5],[6,7])))

91. How to create a record array from a regular array?

#hint: np.core.records.fromarrays
data = np.array([("Hello", 2.5, 3),("World", 3.6, 2)])
R = np.core.records.fromarrays(data.T, names='col1, col2, col3', formats='S8, f8, i8')
print(R)

92. Consider a large vector Z, compute Z to the power of 3 using 3 different methods

#hint: np.power, *, np.einsum
x = np.random.rand(int(5e1))

%timeit np.power(x,3)
%timeit x*x*x
%timeit np.einsum('i,i,i->i',x,x,x)

93. Consider two arrays A and B of shape (8,3) and (2,2). How to find rows of A that contain elements of each row of B regardless of the order of the elements in B?

#hint: np.where
A = np.random.randint(0, 5, (8,3))
B = np.random.randint(0, 5, (2,2))

C = (A[..., np.newaxis, np.newaxis] == B)
rows = np.where(C.any((3,1)).all(1))[0]
print(rows)

94. Considering a 10x3 matrix, extract rows with unequal values (e.g. [2,2,3])

#No hints provided...
data = np.random.randint(0,5,(10,3))
print(data)
E = np.all(data[:,1:] == data[:,:-1], axis = 1)
print(E)
U = data[~E]
print(U)

U = data[data.max(axis=1) != data.min(axis =1),:]
print(U)

95. Convert a vector of ints into a matrix binary representation

#hint: np.unpackbits
I = np.array([0,1,2,3,15,16,32,64,128])
print(I)
B = ((I.reshape(-1, 1) & (2 ** np.arange(8))) != 0).astype(int)
print(B[:,::-1])

I = np.array([0,1,2,3,15,16,32,64,128], dtype = np.uint8)
print(np.unpackbits(I[:, np.newaxis], axis = 1))

96. Given a two dimensional array, how to extract unique rows?

#hint: np.ascontiguousarray | np.uniqu
data = np.random.randint(0,2,(6,3))
T = np.ascontiguousarray(data).view(np.dtype((np.void, data.dtype.itemsize * data.shape[1])))
_, idx = np.unique(T, return_index = True)
uZ = Z[idx]
print(uZ)

uZ = np.unique(Z, axis = 0)
print(uZ)

97. Considering 2 vectors A & B, write the einsum equivalent of inner, outer, sum, and mul function

#hint: np.einsum
A = np.random.uniform(0,1 , 10)
print(A)
B = np.random.uniform(0,1,10)
print(B)

print(np.einsum('i->', A)) #np.sum(A)
print(np.einsum('i,i->i', A,B))# A * B
print(np.einsum('i,i', A,B))# np.inner(A, B)
print(np.einsum('i,j->ij', A,B))#np.outer(A, B)

A = [1,2,3]
B = [4,5,6]
print(np.inner(A, B))
# 1* 4+ 2* 5 + 3* 6
print(np.outer(A,B))
# 1   4, 5, 6 
# 2   4, 5, 6 
# 3   4, 5, 6 

np.diff() : 차분 

98. Considering a path described by two vectors (X,Y), how to sample it using equidistant samples

#hint: np.cumsum, np.interp
phi = np.arange(0, 10 * np.pi, 0.1)
a = 1
x = a* phi * np.cos(phi)
y = a* phi * np.sin(phi)
print(x)
dr = (np.diff(x) ** 2 + np.diff(y) ** 2) **.5
r = np.zeros_like(x)
r[1:] = np.cumsum(dr)
r_int = np.linspace(0, r.max(), 200)
x_int = np.interp(r_int, r, x)
y_int = np.interp(r_int, r, y)
print(r_int)
print(x_int)
print(y_int)

x = [1,3,6]
np.diff(x)  # (3-1, 6 - 3)

99. Given an integer n and a 2D array X, select from X the rows which can be interpreted as draws from a multinomial distribution with n degrees, i.e., the rows which only contain integers and which sum to n.

#hint: np.logical_and.reduce, np.mod
X = np.asarray([[1.0, 0.0, 3.0, 8.0],
                [2.0, 0.0, 1.0, 1.0],
                [1.5, 2.5, 1.0, 0.0]])
n = 4
M = np.logical_and.reduce(np.mod(X,1)==0, axis = -1)
print(M)
M &= (X.sum(axis = -1) == n)
print(X[M])

100. Compute bootstrapped 95% confidence intervals for the mean of a 1D array X (i.e., resample the elements of an array with replacement N times, compute the mean of each sample, and then compute percentiles over the means).

#hint: np.percentile
X = np.random.randn(100)
print(x)
N = 1000
idx = np.random.randint(0, X.size, (N, X.size))
print(idx)
means = X[idx].mean(axis = 1)
print(means)
confint = np.percentile(means, [2.5, 97.5])
print(confint)