- Notifications
You must be signed in to change notification settings - Fork 50
100 narray exercises
Masahiro TANAKA edited this page Mar 10, 2017 · 40 revisions
This is Ruby/Numo::NArray version of 100 numpy exercises (Repository)
# 100 numpy exercises This is a collection of exercises that have been collected in the numpy mailing list, on stack overflow and in the numpy documentation. I've also created some to reach the 100 limit. The goal of this collection is to offer a quick reference for both old and new users but also to provide a set of exercices for those who teach. If you find an error or think you've a better way to solve some of them, feel free to open an issue at <https://github.com/rougier/numpy-100> Python:
import numpy as npRuby:
require "numo/narray"Python:
print(np.__version__) np.show_config()Ruby:
p Numo::NArray::VERSIONPython:
Z = np.zeros(10) print(Z)Ruby:
z = Numo::DFloat.zeros(10) p zPython:
Z = np.zeros((10,10)) print("%d bytes" % (Z.size * Z.itemsize))Ruby:
z = Numo::DFloat.zeros(10,10) printf "%d bytes", z.byte_sizePython:
$ python -c "import numpy; numpy.info(numpy.add)"
Ruby:
$ ri 'Numo::DFloat#+'
Python:
Z = np.zeros(10) Z[4] = 1 print(Z)Ruby:
z = Numo::DFloat.zeros(10) z[4] = 1 p zPython:
Z = np.arange(10,50) print(Z)Ruby:
z = Numo::DFloat[10..49] p zPython:
Z = np.arange(50) Z = Z[::-1] print(Z)Ruby:
z = Numo::Int32.new(50).seq z = z.reverse # or z = z[(-1..0).step(-1)]Python:
Z = np.arange(9).reshape(3,3) print(Z)Ruby:
z = Numo::Int32.new(3,3).seq p zPython:
nz = np.nonzero([1,2,0,0,4,0]) print(nz)Ruby:
nz = Numo::NArray[1,2,0,0,4,0].ne(0).where p nzPython:
Z = np.eye(3) print(Z)Ruby:
z = Numo::DFloat.eye(3) p zPython:
Z = np.random.random((3,3,3)) print(Z)Ruby:
z = Numo::DFloat.new(3,3,3).rand p zPython:
Z = np.random.random((10,10)) Zmin, Zmax = Z.min(), Z.max() print(Zmin, Zmax)Ruby:
z = Numo::DFloat.new(10,10).rand zmin, zmax = z.minmax p zmin, zmaxPython:
Z = np.random.random(30) m = Z.mean() print(m)Ruby:
z = Numo::DFloat.new(30).rand m = z.mean p mPython:
Z = np.ones((10,10)) Z[1:-1,1:-1] = 0 print(Z)Ruby:
z = Numo::DFloat.ones(10,10) z[1..-2,1..-2] = 0 p zPython:
Z = np.ones((5,5)) Z = np.pad(Z, pad_width=1, mode='constant', constant_values=0) print(Z)Ruby:
# todo: padPython:
print(0 * np.nan) print(np.nan == np.nan) print(np.inf > np.nan) print(np.nan - np.nan) print(0.3 == 3 * 0.1)Ruby:
0 * Float::NAN Float::NAN == Float::NAN Float::INFINITY > Float::NAN Float::NAN - Float::NAN 0.3 == 3 * 0.1Python:
Z = np.diag(1+np.arange(4),k=-1) print(Z)Ruby:
z = Numo::Int32.zeros(5,5) z.diagonal(-1)[] = Numo::Int32[1..4] p zPython:
Z = np.zeros((8,8),dtype=int) Z[1::2,::2] = 1 Z[::2,1::2] = 1 print(Z)Ruby:
z = Numo::Int32.zeros(8,8) z[(1..-1).step(2),(0..-1).step(2)] = 1 z[(0..-1).step(2),(1..-1).step(2)] = 1 p z # z = (Numo::Int32.new(1,8).seq + Numo::Int32.new(8,1).seq) % 2 # p zPython:
print(np.unravel_index(100,(6,7,8)))Ruby:
# NArray allows unraveled index access z = Numo::Int32.new(6,7,8).seq p z[100]Python:
Z = np.tile( np.array([[0,1],[1,0]]), (4,4)) print(Z)Ruby:
z = Numo::NArray[[0,1],[1,0]].tile(4,4) p zPython:
Z = np.random.random((5,5)) Zmax, Zmin = Z.max(), Z.min() Z = (Z - Zmin)/(Zmax - Zmin) print(Z)Ruby:
z = Numo::DFloat.new(5,5).rand zmin, zmax = z.minmax z = (z - zmin)/(zmax - zmin) p zPython:
color = np.dtype([("r", np.ubyte, 1), ("g", np.ubyte, 1), ("b", np.ubyte, 1), ("a", np.ubyte, 1)])Ruby:
# todo: record color = Numo::Struct.new do uint8 "r" uint8 "g" uint8 "b" uint8 "a" endPython:
Z = np.dot(np.ones((5,3)), np.ones((3,2))) print(Z)Ruby:
x = Numo::DFloat.ones(5,3) y = Numo::DFloat.ones(3,2) z = x.dot y p zPython:
# Author: Evgeni Burovski Z = np.arange(11) Z[(3 < Z) & (Z <= 8)] *= -1 print(Z)Ruby:
z = Numo::Int32.new(11).seq z[(3 < z) & (z <= 8)] *= -1 p zPython:
# Author: Jake VanderPlas print(sum(range(5),-1)) from numpy import * print(sum(range(5),-1))Ruby:
p [*0...5,-1].inject(:+) p Numo::Int32[0...5].sum(-1)Python:
Z = np.arange(5) Z**Z 2 << Z >> 2 Z <- Z 1j*Z Z/1/1 Z<Z>ZRuby:
z = Numo::Int32.new(5).seq z**z 2 << z >> 2 z <- z 1i*z z/1/1 z<z>zPython:
print(np.array(0) / np.array(0)) print(np.array(0) // np.array(0)) print(np.array([np.nan]).astype(int).astype(float))Ruby:
p Numo::Int32[0] / Numo::Int32[0] p Numo::DFloat[Float::NAN].cast_to(Numo::Int32).cast_to(Numo::DFloat)Python:
# Author: Charles R Harris Z = np.random.uniform(-10,+10,10) print (np.trunc(Z + np.copysign(0.5, Z)))Ruby:
z = Numo::DFloat.new(10).seq(-10,2.1) #rand(-10,+10) p (z + Numo::DFloat[0.5].copysign(z)).truncPython:
Z1 = np.random.randint(0,10,10) Z2 = np.random.randint(0,10,10) print(np.intersect1d(Z1,Z2))Ruby:
# todo: intersect1dPython:
# Suicide mode on defaults = np.seterr(all="ignore") Z = np.ones(1)/0 # Back to sanity _ = np.seterr(**defaults)Ruby:
# ?Python:
np.sqrt(-1) == np.emath.sqrt(-1)Ruby:
# NAPython:
yesterday = np.datetime64('today', 'D') - np.timedelta64(1, 'D') today = np.datetime64('today', 'D') tomorrow = np.datetime64('today', 'D') + np.timedelta64(1, 'D')Ruby:
# use built-in class require "date" yesterday = Date.today - 1 today = Date.today tomorrow = Date.today + 1Python:
Z = np.arange('2016-07', '2016-08', dtype='datetime64[D]') print(Z)Ruby:
# use built-in class require "date" z = *Date.new(2016,7)..Date.new(2016,8) p zPython:
A = np.ones(3)*1 B = np.ones(3)*2 np.add(A,B,out=B) np.divide(A,2,out=A) np.negative(A,out=A) np.multiply(A,B,out=A)Ruby:
a = Numo::DFloat.new(3).fill(1) b = Numo::DFloat.new(3).fill(2) p (a+b)*(-a/2) (a+b.inplace)*(-a.inplace/2) p bPython:
Z = np.random.uniform(0,10,10) print (Z - Z%1) print (np.floor(Z)) print (np.ceil(Z)-1) print (Z.astype(int)) print (np.trunc(Z))Ruby:
z = Numo::DFloat.new(10).rand(10) p z - z%1 p z.floor p z.ceil - 1 p z.cast_to(Numo::Int32) p z.truncPython:
Z = np.zeros((5,5)) Z += np.arange(5) print(Z)Ruby:
z = Numo::DFloat.zeros(5,5) z += Numo::Int32.new(5).seq p zPython:
def generate(): for x in range(10): yield x Z = np.fromiter(generate(),dtype=float,count=-1) print(Z)Ruby:
# no method: fromiter generate = Enumerator.new do |y| 10.times{|x| y << x} end z = Numo::DFloat[*generate] p zPython:
Z = np.linspace(0,1,12,endpoint=True)[1:-1] print(Z)Ruby:
z = Numo::DFloat.linspace(0,1,12)[1..-2] p zPython:
Z = np.random.random(10) Z.sort() print(Z)Ruby:
z = Numo::DFloat.new(10).rand z = z.sort p zPython:
# Author: Evgeni Burovski Z = np.arange(10) np.add.reduce(Z)Ruby:
z = Numo::Int32.new(10).seq z.sum # speed?Python:
A = np.random.randint(0,2,5) B = np.random.randint(0,2,5) equal = np.allclose(A,B) print(equal)Ruby:
a = Numo::Int32.new(5).rand(2) b = Numo::Int32.new(5).rand(2) equal = a.eq(b).all? p equalPython:
Z = np.zeros(10) Z.flags.writeable = False Z[0] = 1Ruby:
z = Numo::DFloat.zeros(10) z.freeze z[0] = 144. Consider a random 10x2 matrix representing cartesian coordinates, convert them to polar coordinates (★★☆)
Python:
Z = np.random.random((10,2)) X,Y = Z[:,0], Z[:,1] R = np.sqrt(X**2+Y**2) T = np.arctan2(Y,X) print(R) print(T)Ruby:
z = Numo::DFloat.new(10,2).rand x,y = z[true,0], z[true,1] r = Numo::NMath.sqrt(x**2+y**2) t = Numo::NMath.atan2(y,x) p r p tPython:
Z = np.random.random(10) Z[Z.argmax()] = 0 print(Z)Ruby:
z = Numo::DFloat.new(10).rand z[z.max_index] = 0 p zPython:
Z = np.zeros((5,5), [('x',float),('y',float)]) Z['x'], Z['y'] = np.meshgrid(np.linspace(0,1,5), np.linspace(0,1,5)) print(Z)Ruby:
# todo: meshgridPython:
# Author: Evgeni Burovski X = np.arange(8) Y = X + 0.5 C = 1.0 / np.subtract.outer(X, Y) print(np.linalg.det(C))Ruby:
# todo: linalg.detPython:
for dtype in [np.int8, np.int32, np.int64]: print(np.iinfo(dtype).min) print(np.iinfo(dtype).max) for dtype in [np.float32, np.float64]: print(np.finfo(dtype).min) print(np.finfo(dtype).max) print(np.finfo(dtype).eps)Ruby:
# todo: Int32::MIN/MAX, etcPython:
np.set_printoptions(threshold=np.nan) Z = np.zeros((16,16)) print(Z)Ruby:
Numo::NArray.inspect_cols = nil Numo::NArray.inspect_rows = nil z = Numo::DFloat.zeros(25,25) p zPython:
Z = np.arange(100) v = np.random.uniform(0,100) index = (np.abs(Z-v)).argmin() print(Z[index])Ruby:
z = Numo::Int32.new(100).seq v = rand*100 index = (z-v).abs.min_index p z[index]Python:
Z = np.zeros(10, [ ('position', [ ('x', float, 1), ('y', float, 1)]), ('color', [ ('r', float, 1), ('g', float, 1), ('b', float, 1)])]) print(Z)Ruby:
# todo: record52. Consider a random vector with shape (100,2) representing coordinates, find point by point distances (★★☆)
Python:
Z = np.random.random((10,2)) X,Y = np.atleast_2d(Z[:,0]), np.atleast_2d(Z[:,1]) D = np.sqrt( (X-X.T)**2 + (Y-Y.T)**2) print(D) # Much faster with scipy import scipy # Thanks Gavin Heverly-Coulson (#issue 1) import scipy.spatial Z = np.random.random((10,2)) D = scipy.spatial.distance.cdist(Z,Z) print(D)Ruby:
# todo: cdistPython:
Z = np.arange(10, dtype=np.int32) Z = Z.astype(np.float32, copy=False) print(Z)Ruby:
# NArray does not support in-place type conversionPython:
from io import StringIO # Fake file s = StringIO("""1, 2, 3, 4, 5\n 6, , , 7, 8\n , , 9,10,11\n""") Z = np.genfromtxt(s, delimiter=",", dtype=np.int) print(Z)Ruby:
require "stringio" s = StringIO.new("1, 2, 3, 4, 5 6, , , 7, 8 , , 9,10,11") z = Numo::NArray[*s.readlines.map{|l| l.split(",").map{|x| x.strip.empty? ? Float::NAN : x.to_f}}]Python:
Z = np.arange(9).reshape(3,3) for index, value in np.ndenumerate(Z): print(index, value) for index in np.ndindex(Z.shape): print(index, Z[index])Ruby:
z = Numo::Int32.new(3,3).seq z.each_with_index{|x,*i| p [i,x]}Python:
X, Y = np.meshgrid(np.linspace(-1,1,10), np.linspace(-1,1,10)) D = np.sqrt(X*X+Y*Y) sigma, mu = 1.0, 0.0 G = np.exp(-( (D-mu)**2 / ( 2.0 * sigma**2 ) ) ) print(G)Ruby:
x = Numo::DFloat.linspace(-1,1,10) y = Numo::DFloat.linspace(-1,1,10).expand_dims(1) d = Numo::NMath.sqrt(x*x+y*y) sigma, mu = 1.0, 0.0 g = Numo::NMath.exp(-( (d-mu)**2 / ( 2.0 * sigma**2 ) ) ) p gPython:
# Author: Divakar n = 10 p = 3 Z = np.zeros((n,n)) np.put(Z, np.random.choice(range(n*n), p, replace=False),1) print(Z)Ruby:
# todo: choisePython:
# Author: Warren Weckesser X = np.random.rand(5, 10) # Recent versions of numpy Y = X - X.mean(axis=1, keepdims=True) # Older versions of numpy Y = X - X.mean(axis=1).reshape(-1, 1) print(Y)Ruby:
x = Numo::DFloat.new(5, 10).rand y = x - x.mean(1).expand_dims(1)Python:
# Author: Steve Tjoa Z = np.random.randint(0,10,(3,3)) print(Z) print(Z[Z[:,1].argsort()])Ruby:
z = Numo::Int32.new(3,3).rand(10) p z p z[z[true,1].sort_index,true]Python:
# Author: Warren Weckesser Z = np.random.randint(0,3,(3,10)) print((~Z.any(axis=0)).any())Ruby:
z = Numo::Int32.new(3,10).rand(3) (~z.ne(0).any?(0)).any?Python:
Z = np.random.uniform(0,1,10) z = 0.5 m = Z.flat[np.abs(Z - z).argmin()] print(m)Ruby:
z = Numo::DFloat.new(10).rand x = 0.5 m = z[(z - x).abs.min_index] p m62. Considering two arrays with shape (1,3) and (3,1), how to compute their sum using an iterator? (★★☆)
Python:
A = np.arange(3).reshape(3,1) B = np.arange(3).reshape(1,3) it = np.nditer([A,B,None]) for x,y,z in it: z[...] = x + y print(it.operands[2])Ruby:
# no iteratorPython:
class NamedArray(np.ndarray): def __new__(cls, array, name="no name"): obj = np.asarray(array).view(cls) obj.name = name return obj def __array_finalize__(self, obj): if obj is None: return self.info = getattr(obj, 'name', "no name") Z = NamedArray(np.arange(10), "range_10") print (Z.name)Ruby:
module NamedArray attr_accessor :name end def NamedArray(array,name) obj = array.extend(NamedArray) obj.name = name return obj end z = NamedArray(Numo::NArray[0...10], "range_10") p z.name # todo: asarray64. Consider a given vector, how to add 1 to each element indexed by a second vector (be careful with repeated indices)? (★★★)
Python:
# Author: Brett Olsen Z = np.ones(10) I = np.random.randint(0,len(Z),20) Z += np.bincount(I, minlength=len(Z)) print(Z)Ruby:
z = Numo::Int32.ones(10) i = Numo::Int32.new(20).rand(0,z.size) z += i.bincount(minlength:z.size)Python:
# Author: Alan G Isaac X = [1,2,3,4,5,6] I = [1,3,9,3,4,1] F = np.bincount(I,X) print(F)Ruby:
x = [1,2,3,4,5,6] i = [1,3,9,3,4,1] f = Numo::NArray[*i].bincount(x) p fPython:
# Author: Nadav Horesh w,h = 16,16 I = np.random.randint(0,2,(h,w,3)).astype(np.ubyte) F = I[...,0]*256*256 + I[...,1]*256 +I[...,2] n = len(np.unique(F)) print(np.unique(I))Ruby:
# todo: unique w,h = 16,16 i = Numo::UInt32.new(h,w,3).rand(2) f = i[false,0]*256*256 + i[false,1]*256 +i[false,2] p f.flatten.sort.to_a.uniqPython:
A = np.random.randint(0,10,(3,4,3,4)) sum = A.reshape(A.shape[:-2] + (-1,)).sum(axis=-1) print(sum)Ruby:
a = Numo::Int32.new(3,4,3,4).rand(10) sum = a.sum(-2,-1) p sum68. Considering a one-dimensional vector D, how to compute means of subsets of D using a vector S of same size describing subset indices? (★★★)
Python:
# Author: Jaime Fernández del Río D = np.random.uniform(0,1,100) S = np.random.randint(0,10,100) D_sums = np.bincount(S, weights=D) D_counts = np.bincount(S) D_means = D_sums / D_counts print(D_means)Ruby:
d = Numo::DFloat.new(100).rand(0,1) s = Numo::Int32.new(100).rand(0,10) d_sums = s.bincount(d) d_counts = s.bincount d_means = d_sums / d_counts p d_meansPython:
# Author: Mathieu Blondel A = np.random.uniform(0,1,(5,5)) B = np.random.uniform(0,1,(5,5)) # Slow version np.diag(np.dot(A, B)) # Fast version np.sum(A * B.T, axis=1) # Faster version np.einsum("ij,ji->i", A, B)Ruby:
a = Numo::DFloat.new(3,3).seq b = Numo::DFloat.new(3,3).seq p a.mulsum(b.transpose,1) # speed?70. Consider the vector [1, 2, 3, 4, 5], how to build a new vector with 3 consecutive zeros interleaved between each value? (★★★)
Python:
# Author: Warren Weckesser Z = np.array([1,2,3,4,5]) nz = 3 Z0 = np.zeros(len(Z) + (len(Z)-1)*(nz)) Z0[::nz+1] = Z print(Z0)Ruby:
z = Numo::NArray[1,2,3,4,5] nz = 3 z0 = Numo::Int32.zeros(z.size + (z.size-1)*(nz)) z0[(0..-1).step(nz+1)] = z p z071. Consider an array of dimension (5,5,3), how to mulitply it by an array with dimensions (5,5)? (★★★)
Python:
A = np.ones((5,5,3)) B = 2*np.ones((5,5)) print(A * B[:,:,None])Ruby:
a = Numo::Int32.ones(5,5,3) b = Numo::Int32.new(5,5).fill(2) p a * b[:*,:*,:-]Python:
# Author: Eelco Hoogendoorn A = np.arange(25).reshape(5,5) A[[0,1]] = A[[1,0]] print(A)Ruby:
a = Numo::Int32.new(5,5).seq a[[0,1],true] = a[[1,0],true].copy p a # todo: identity check between read/write array73. Consider a set of 10 triplets describing 10 triangles (with shared vertices), find the set of unique line segments composing all the triangles (★★★)
Python:
# Author: Nicolas P. Rougier faces = np.random.randint(0,100,(10,3)) F = np.roll(faces.repeat(2,axis=1),-1,axis=1) F = F.reshape(len(F)*3,2) F = np.sort(F,axis=1) G = F.view( dtype=[('p0',F.dtype),('p1',F.dtype)] ) G = np.unique(G) print(G)Ruby:
# todo: roll74. Given an array C that is a bincount, how to produce an array A such that np.bincount(A) == C? (★★★)
Python:
# Author: Jaime Fernández del Río C = np.bincount([1,1,2,3,4,4,6]) A = np.repeat(np.arange(len(C)), C) print(A)Ruby:
a = Numo::NArray[1,1,2,3,4,4,6] c = a.bincount a = a.seq.repeat(c) p aPython:
# Author: Jaime Fernández del Río def moving_average(a, n=3) : ret = np.cumsum(a, dtype=float) ret[n:] = ret[n:] - ret[:-n] return ret[n - 1:] / n Z = np.arange(20) print(moving_average(Z, n=3))Ruby:
def moving_average(a, n=3) ret = a.cumsum ret[n..-1] = ret[n..-1] - ret[0..-n-1] ret[n-1..-1] / n end z = Numo::DFloat.new(20).seq p moving_average(z, 3)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]) (★★★)
Python:
# Author: Joe Kington / Erik Rigtorp 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) Z = rolling(np.arange(10), 3) print(Z)Ruby:
# no module: stride_tricksPython:
# Author: Nathaniel J. Smith Z = np.random.randint(0,2,100) np.logical_not(Z, out=Z) Z = np.random.uniform(-1.0,1.0,100) np.negative(Z, out=Z)Ruby:
# todo: logical_not z = Numo::Int32.new(100).rand(2) p z z.inplace ^ 1 p z z = Numo::DFloat.new(100).rand(-1,1) p z -z.inplace p z78. 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])? (★★★)
Python:
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))Ruby:
def distance(p0, p1, p) t = p1 - p0 l = (t**2).sum(1) u = -((p0[true,0]-p[false,0])*t[true,0] + (p0[true,1]-p[false,1])*t[true,1]) / l u = u.reshape(u.size,1) d = p0 + u*t - p return Numo::NMath.sqrt((d**2).sum(1)) end p0 = Numo::DFloat.new(10,2).rand(-10,10) p1 = Numo::DFloat.new(10,2).rand(-10,10) p = Numo::DFloat.new( 1,2).rand(-10,10) p 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])? (★★★)
Python:
# Author: Italmassov Kuanysh # based on distance function from previous question 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]))Ruby:
p0 = Numo::DFloat.new(10,2).rand(-10,10) p1 = Numo::DFloat.new(10,2).rand(-10,10) p = Numo::DFloat.new(10,2).rand(-10,10) p Numo::NArray[*(0...p.shape[0]).map{|i| distance(p0, p1, p[i,true])}]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) (★★★)
Python:
# Author: Nicolas Rougier Z = np.random.randint(0,10,(10,10)) shape = (5,5) fill = 0 position = (1,1) R = np.ones(shape, dtype=Z.dtype)*fill 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)Ruby:
# todo: minimum, maximum81. 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? (★★★)
Python:
# Author: Stefan van der Walt Z = np.arange(1,15,dtype=np.uint32) R = stride_tricks.as_strided(Z,(11,4),(4,4)) print(R)Ruby:
# no moudle: stride_tricksPython:
# Author: Stefan van der Walt Z = np.random.uniform(0,1,(10,10)) U, S, V = np.linalg.svd(Z) # Singular Value Decomposition rank = np.sum(S > 1e-10) print(rank)Ruby:
# todo: svdPython:
Z = np.random.randint(0,10,50) print(np.bincount(Z).argmax())Ruby:
z = Numo::Int32.new(50).rand(0,10) z.bincount.max_indexPython:
# Author: Chris Barker Z = np.random.randint(0,5,(10,10)) n = 3 i = 1 + (Z.shape[0]-3) j = 1 + (Z.shape[1]-3) C = stride_tricks.as_strided(Z, shape=(i, j, n, n), strides=Z.strides + Z.strides) print(C)Ruby:
# no module: stride_tricksPython:
# Author: Eric O. Lebigot # Note: only works for 2d array and value setting using indices 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)Ruby:
module Symetric def []=(i,j,value) super(i,j,value) super(j,i,value) if i != j end end def symetric(z) y = z + z.transpose y.diagonal.store(z.diagonal) y.extend(Symetric) end s = symetric(Numo::Int32.new(5,5).rand(10)) s[2,3] = 42 p s86. 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)) (★★★)
Python:
# Author: Stefan van der Walt 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) # It works, because: # M is (p,n,n) # V is (p,n,1) # Thus, summing over the paired axes 0 and 0 (of M and V independently), # and 2 and 1, to remain with a (n,1) vector.Ruby:
p, n = 10, 20 m = Numo::DFloat.ones(p,n,n) v = Numo::DFloat.ones(p,n,1) s = m.transpose(0,2,1).mulsum(v,0,1) p s # todo: tensordot?Python:
# Author: Robert Kern Z = np.ones((16,16)) 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)Ruby:
n, k = 16, 4 z = Numo::DFloat.ones(n,n) s = z.reshape(n/k,k,n/k,k).sum(1,3) # todo: reduceat?Python:
# Author: Nicolas Rougier def iterate(Z): # Count neighbours 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:]) # Apply rules 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)Ruby:
def iterate(z) # Count neighbours n = z[0..-3,0..-3] + z[0..-3,1..-2] + z[0..-3,2..-1] + z[1..-2,0..-3] + z[1..-2,2..-1] + z[2..-1,0..-3] + z[2..-1,1..-2] + z[2..-1,2..-1] # Apply rules birth = n.eq(3) & z[1..-2,1..-2].eq(0) survive = (n.eq(2) | n.eq(3)) & z[1..-2,1..-2].eq(1) z[] = 0 #z[1..-2,1..-2][birth | survive] = 1 y = z[0..-3,0..-3].copy y[birth | survive] = 1 z[1..-2,1..-2] = y end z = Numo::Int32.new(50,50).rand(2) 100.times{ iterate(z) } p zPython:
Z = np.arange(10000) np.random.shuffle(Z) n = 5 # Slow print (Z[np.argsort(Z)[-n:]]) # Fast print (Z[np.argpartition(-Z,n)[:n]])Ruby:
z = Numo::DFloat.new(10000).rand n = 5 p z[z.sort_index[-n..-1]] # todo: shuffle, argpartition90. Given an arbitrary number of vectors, build the cartesian product (every combinations of every item) (★★★)
Python:
# Author: Stefan Van der Walt 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])))Ruby:
def cartesian(*arrays) arrays = arrays.map{|a| Numo::Int32.cast(a)} shape = arrays.map{|x| x.size} asz = arrays.size ix = Numo::Int32.zeros(*shape, asz) arrays.each_with_index do |arr,n| s = [1]*asz s[n] = arr.size ix[false,n] = arr.reshape(*s) end return ix.reshape(ix.size/asz,asz) end p cartesian([1, 2, 3], [4, 5], [6, 7])Python:
Z = np.array([("Hello", 2.5, 3), ("World", 3.6, 2)]) R = np.core.records.fromarrays(Z.T, names='col1, col2, col3', formats = 'S8, f8, i8') print(R)Ruby:
# todo: recordPython:
# Author: Ryan G. x = np.random.rand(5e7) %timeit np.power(x,3) %timeit x*x*x %timeit np.einsum('i,i,i->i',x,x,x)Ruby:
x = Numo::DFloat.new(5e7).rand x**3 # probably fast93. 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? (★★★)
Python:
# Author: Gabe Schwartz A = np.random.randint(0,5,(8,3)) B = np.random.randint(0,5,(2,2)) C = (A[..., np.newaxis, np.newaxis] == B) rows = (C.sum(axis=(1,2,3)) >= B.shape[1]).nonzero()[0] print(rows)Ruby:
a = Numo::Int32.new(8,3).rand(5) b = Numo::Int32.new(2,2).rand(5) c = a[false,:new,:new].eq b rows = (c.count_true(1,2,3) >= b.shape[1]).where p rowsPython:
# Author: Robert Kern Z = np.random.randint(0,5,(10,3)) E = np.logical_and.reduce(Z[:,1:] == Z[:,:-1], axis=1) U = Z[~E] print(Z) print(U)Ruby:
z = Numo::Int32.new(10,3).rand(5) e = (z[true,1..-1].eq z[true,0..-2]).all?(1) u = z[(~e).where,true] p z p uPython:
# Author: Warren Weckesser I = np.array([0, 1, 2, 3, 15, 16, 32, 64, 128]) B = ((I.reshape(-1,1) & (2**np.arange(8))) != 0).astype(int) print(B[:,::-1]) # Author: Daniel T. McDonald I = np.array([0, 1, 2, 3, 15, 16, 32, 64, 128], dtype=np.uint8) print(np.unpackbits(I[:, np.newaxis], axis=1))Ruby:
i = Numo::NArray[0, 1, 2, 3, 15, 16, 32, 64, 128] b = Numo::Int32.cast((i[true,:new] & (2**Numo::Int32.new(8).seq)).ne 0) p b.reverse(1) i = Numo::UInt8[0, 1, 2, 3, 15, 16, 32, 64, 128] p Numo::Bit.from_binary(i.to_binary,[i.size,8]).reverse(1)Python:
# Author: Jaime Fernández del Río Z = np.random.randint(0,2,(6,3)) T = np.ascontiguousarray(Z).view(np.dtype((np.void, Z.dtype.itemsize * Z.shape[1]))) _, idx = np.unique(T, return_index=True) uZ = Z[idx] print(uZ)Ruby:
# todo: unique row97. Considering 2 vectors A & B, write the einsum equivalent of inner, outer, sum, and mul function (★★★)
Python:
# Author: Alex Riley # Make sure to read: http://ajcr.net/Basic-guide-to-einsum/ A = np.random.uniform(0,1,10) B = np.random.uniform(0,1,10) np.einsum('i->', A) # np.sum(A) np.einsum('i,i->i', A, B) # A * B np.einsum('i,i', A, B) # np.inner(A, B) np.einsum('i,j', A, B) # np.outer(A, B)Ruby:
# no method: einsum a = Numo::DFloat.new(10).rand(0,1) b = Numo::DFloat.new(10).rand(0,1) a.sum # np.sum(A) a*b # A * B a.mulsum(b) # np.inner(A, B) a[false,:new]*b # np.outer(A, B)98. Considering a path described by two vectors (X,Y), how to sample it using equidistant samples (★★★)?
Python:
# Author: Bas Swinckels phi = np.arange(0, 10*np.pi, 0.1) a = 1 x = a*phi*np.cos(phi) y = a*phi*np.sin(phi) dr = (np.diff(x)**2 + np.diff(y)**2)**.5 # segment lengths r = np.zeros_like(x) r[1:] = np.cumsum(dr) # integrate path r_int = np.linspace(0, r.max(), 200) # regular spaced path x_int = np.interp(r_int, r, x) # integrate path y_int = np.interp(r_int, r, y)Ruby:
# todo: interp99. 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. (★★★)
Python:
# Author: Evgeni Burovski 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) M &= (X.sum(axis=-1) == n) print(X[M])Ruby:
x = Numo::NArray[[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 = (x%1).eq(0).all?(-1) m &= x.sum(-1).eq(n) p x[m.where,true]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). (★★★)
Python:
# Author: Jessica B. Hamrick X = np.random.randn(100) # random 1D array N = 1000 # number of bootstrap samples idx = np.random.randint(0, X.size, (N, X.size)) means = X[idx].mean(1) confint = np.percentile(means, [2.5, 97.5]) print(confint)Ruby:
x = Numo::DFloat.new(100).rand_norm n = 1000 # number of bootstrap samples idx = Numo::Int32.new(n, x.size).rand(x.size) means = x[idx].mean(1) confint = means[means.sort_index[means.size/100.0*Numo::DFloat[2.5, 97.5]]] p confint # todo: percentile