いつまでも，古いママやってんじゃねえよって話(8)

これで，一応打ち止め。

いつまでも，古いママやってんじゃねえよって話(8)

https://qiita.com/yatra9/items/a4b58020ebf478b87a1e

ここに書くのも，それでも，Julia 1.7.2 での話。そのうち古くなる。

# （未）54. How to read the following file? (★★☆)

```Python.py
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)
@show Z
```

```Julia.jl
io = IOBuffer("""1, 2, 3, 4, 5\n
                6,  ,  , 7, 8\n
                 ,  , 9,10,11\n""")
using CSV, DataFrames
Matrix(CSV.read(io, DataFrame, header=0, types=Int))

3×5 Matrix{Union{Missing, Int64}}:
 1         2         3          4   5
 6          missing   missing   7   8
  missing   missing  9         10  11
```


# 56. 2次元のガウス分布(係数をのぞく)の配列を作成する (★★☆)

```Julia
X, Y = linspace(-1, 1, 10), linspace(-1, 1, 10)
σ, μ = 1.0, 0.0

# using broadcast
G = @. exp(-(abs2(X - μ) + abs2(Y' - μ)) / 2σ^2)
@show G

# using comprehension
G = [ exp(-sum(abs2, (x, y) .- μ) / 2σ^2) for x in X, y in Y]
@show G
```

linspace() は廃止。
range() を使う。または `start:step:stop`

```Julia
X, Y = range(-1, 1, length=10), range(-1, 1, length=10)
```

# 58. 配列から各行の平均値を差し引く (★★☆)

```Julia
X = rand(5, 10)
Y = X .- mean(X, 1)
```
mean() は Statistics パッケージが必要。また，dims=1 と指定する。

```Julia
using Statistics
Y = X .- mean(X, dims=1)
```


# 59. 行列の各行をn番目の列をキーとして整列する (★★☆)

```Julia
Z = rand(0:9, 5, 5)
n = 3
@show Z
@show sortrows(Z, by=row->row[n])
```

sortrows() は廃止された。
sortslices() を使う。

```Julia
sortslices(Z, dims=1, lt=(x,y)->isless(x[n],y[n]))
```

# 60. 与えられた2次元配列に、値がすべてゼロの列があるか判定する (★★☆)

```Julia
Z = rand(0:2, 3, 10)
println(any(all(iszero, Z, 1)))
```
次元は dims= で指定する。

```Julia
println(any(all(iszero, Z, dims=1)))
```


# 61. 配列から与えられた値に最も近い値を取り出す (★★☆)

```Julia
Z = rand(10, 10)
z = 0.5
m = Z[indmin(abs.(Z - z))]
```

indmin() は廃止。argmin() を使う。
また `-` ではなく，`.-` でなければならない。

```Julia
m = Z[argmin(abs.(Z .- z))]
```


# （未）62. Considering two arrays with shape (1,3) and (3,1), how to compute their sum using an iterator? (★★☆)

```Python.py
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])

[[0 1 2]
 [1 2 3]
 [2 3 4]]
```

iterator を使わなくても計算できる...

```Julia.jl
A = [0, 1, 2]
B = [0 1 2]
A .+ B

3×3 Matrix{Int64}:
 0  1  2
 1  2  3
 2  3  4
```


# （未）64. Consider a given vector, how to add 1 to each element indexed by a second vector (be careful with repeated indices)? (★★★)

```Python.py
# Author: Brett Olsen

Z = np.ones(10)
I = np.random.randint(0,len(Z),20)
Z += np.bincount(I, minlength=len(Z))
print(Z)

# Another solution
# Author: Bartosz Telenczuk
np.add.at(Z, I, 1)
print(Z)
```

```Julia.jl
Z = ones(Int, 10);
[Z[i+1] += 1 for i in I]
```

# 67. 4次元配列の後ろの2つの次元についての和を計算する (★★★)

```Julia
A = rand(1:10, 3, 4, 3, 4)
last2dims = ndims(A)-1, ndims(A)
sum2 = squeeze(sum(A, last2dims), last2dims)
```

squeeze() は廃止。
以下のように定義できるが。

```Julia
function squeeze( A :: AbstractArray )
         keepdims = Tuple(i for i in size(A) if i != 1);
         return reshape( A, keepdims );
end;
sum2 = squeeze(sum(A, dims=last2dims))

3×4 Matrix{Int64}:
 71  68  69  62
 72  65  69  74
 63  80  56  45
```

reshape() を使おう。

```Julia
sum2 = reshape(sum(A, dims=last2dims), last2dims)

3×4 Matrix{Int64}:
 71  68  69  62
 72  65  69  74
 63  80  56  45
 ```
または，dropdims() を使う。

```Julia
dropdims(sum(A, dims=last2dims), dims=last2dims)
```

# （未）68. 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.py
# 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)

# Pandas solution as a reference due to more intuitive code
import pandas as pd
print(pd.Series(D).groupby(S).mean())
```

```Julia.jl
using DataFrames
df = DataFrame(D=D, S=S);
combine(groupby(df, :S), :D => mean)
```


# 70. ベクトル [1, 2, 3, 4, 5]から、各要素の間に3個のゼロを挿入した新しいベクトルを作成する (★★★)

```Julia
Z = [1, 2, 3, 4, 5]
nz = 3
Z0 = zeros(eltype(Z), length(Z) + (length(Z)-1)*nz)
Z0[1:nz+1:end] = Z
@show Z0

# 以下は動かない repmat() は廃止された
# another solution
Z0 = reshape([Z repmat(zero(Z), 1, nz)]', :)
```

repeat() を使おう。

``` Julia
Z0 = reshape([Z repeat(zero(Z), 1, nz)]', :)
```


# （未）72. How to swap two rows of an array? (★★★)

```Python.py
# Author: Eelco Hoogendoorn

A = np.arange(25).reshape(5,5)
A[[0,1]] = A[[1,0]]
print(A)
```

```Julia.jl
A =  Matrix(reshape(0:24, 5, :)) # reshape() だけではちょっと癖が強い

5×5 Matrix{Int64}:
 0  5  10  15  20
 1  6  11  16  21
 2  7  12  17  22
 3  8  13  18  23
 4  9  14  19  24

A[[1,2], :] .= A[[2,1], :]
A

5×5 Matrix{Int64}:
 1  6  11  16  21
 0  5  10  15  20
 2  7  12  17  22
 3  8  13  18  23
 4  9  14  19  24
```


# 73. それぞれ3点で構成される10個の三角形を考える。全ての三角形を構成する線分を重複をのぞいて得る (★★★)

```Julia
faces = rand(1:100, 10, 3)
F = circshift(repeat(faces, inner=(1,2)), (0,-1))
F = reshape(F', 2, :)
G = unique(extrema(F, 1))
```

MethodError になる。
dims はキーワード引数になった。

```Julia
G = unique(extrema(F, dims=1))
```

# 83. 配列に最も多く出現する値を得る

```Julia
Z = rand(1:10, 50)

# Slow
print(indmax(count(Z .== v) for v in 1:maximum(Z)))
# --> UndefVarError: indmax not defined

print(argmax(count(Z .== v) for v in 1:maximum(Z)))

# Fast
F = zero(1:maximum(Z))
foreach(v -> F[v] += 1, Z)
print(indmax(F))
# --> UndefVarError: indmax not defined
```

indmax() は廃止された。
argmax() を使う。

```Julia
print(argmax(F))
```

# 87. 16x16の行列の、4x4の小行列毎の和を計算する (★★★)

```Julia
using Base.Iterators
Z = ones(16,16);
k = 4
S = [sum(Z[i,j]) for i in partition(indices(Z,1), k), j in partition(indices(Z,1), k)]
display(S)
```

indices() は廃止された。
axes() を使う。

```Julia
S = [sum(Z[i,j]) for i in partition(axes(Z,1), k), j in partition(axes(Z,1), k)]
```

# （未）89. How to get the n largest values of an array (★★★)

```Python.py
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]])
```

```Julia.jl
a = Z[partialsortperm(Z, 1:n, rev=true)] # np.argpartition に相当
```




# 96. 2次元配列から、重複のない行を取り出す。(★★★)

```Julia
Z = rand(0:1, 6, 3)
Z[unique(i->Z[i,:], indices(Z,1)), :]
```

indices() は廃止された。
axes() を使う。

```Julia
Z[unique(i->Z[i,:], axes(Z,1)), :]
```