Elegant way to turn a Array{T,N} to a Array{Array{T,M},N-M} - multidimensional-array

Let's say I'm starting with:
x = collect(reshape(1:24, (3,4,2)))
3×4×2 Array{Int64,3}:
[:, :, 1] =
1 4 7 10
2 5 8 11
3 6 9 12
[:, :, 2] =
13 16 19 22
14 17 20 23
15 18 21 24
I want to get to this:
3×2 Array{Array{Int64,1},2}:
[1, 4, 7, 10] [13, 16, 19, 22]
[2, 5, 8, 11] [14, 17, 20, 23]
[3, 6, 9, 12] [15, 18, 21, 24]
It's sort of what eachslice does, except I need to iterate across more than 1 dimension. So far, I can accomplish this for this particular array with broadcasting getindex and very awkward reshaping of axes:
y = getindex.(Ref(x), axes(x,1), Ref(:),
reshape(axes(x,3), 1, length(axes(x,3)) )
)
But it's obviously very cumbersome to adjust for different array shapes. The main hangup is having to reshape the axes for broadcasting, it's not as clean as getindex(x,:,1,:) where the axes are presumed orthogonal.


In addition to the solutions already discussed this can be achieved using mapslices:
julia> mapslices(a -> [a], x; dims=(2,))
3×1×2 Array{Vector{Int64}, 3}:
[:, :, 1] =
[1, 4, 7, 10]
[2, 5, 8, 11]
[3, 6, 9, 12]
[:, :, 2] =
[13, 16, 19, 22]
[14, 17, 20, 23]
[15, 18, 21, 24]
the result is in this case an 3x1x2 Array but we can easily create a function that also drops the singleton dimension:
reslice(a, dims) = dropdims(mapslices(x -> [x], x; dims); dims)
julia> reslice(x, (2,))
3×2 Matrix{Vector{Int64}}:
[1, 4, 7, 10] [13, 16, 19, 22]
[2, 5, 8, 11] [14, 17, 20, 23]
[3, 6, 9, 12] [15, 18, 21, 24]
This solution is not as efficient as the "getindex" solution but may better capture the intention.

Related

How can I recode a variable in R, so that the lowest value will be 1, the second lowest will be 2 etc

Imagine I have a tidy dataset with 1 variable and 10 observations. The values of the variable are e.g. 3, 5, 7, 9, 13, 17, 29, 33, 34, 67. How do I recode it so that the 3 will be 1, the 5 will be 2 (...) and the 67 will be 10?

One possibility is to use rank: in a ´dplyr` setting it could look like this:
library(dplyr)
tibble(x = c(3, 5, 7, 9, 13, 17, 29, 33, 34, 67)) %>%
mutate(y = rank(x))

Here is one way -
x <- c(3, 5, 7, 9, 13, 17, 29, 33, 67, 34)
x1 <- sort(x)
y <- match(x1, unique(x1))
y
#[1] 1 2 3 4 5 6 7 8 9 10
Changed the order of last 2 values so that it also works when the data is not in order.

Another way:
x <- c(3, 5, 7, 9, 13, 17, 29, 33, 67, 34)
x <- sort(x)
seq_along(x)
# 1 2 3 4 5 6 7 8 9 10

How the "undefined var" error in a set can be solved?

would you please help me how can I solve the undefined var error in the following code:
Beta
6×3×3 Array{Array{Int64,1},3}:
[:, :, 1] =
[4, 2, 5, 3, 6] [4, 2, 5, 3, 6] [4, 2, 5, 3, 6]
[5, 3, 6] [5, 3, 6] [5, 3, 6]
[6] [6] [6]
[2, 5, 3, 6] [2, 5, 3, 6] [2, 5, 3, 6]
[3, 6] [3, 6] [3, 6]
[1, 4, 2, 5, 3] [1, 4, 2, 5, 3] [1, 4, 2, 5, 3]
[:, :, 2] =
[4, 2, 5, 3, 6] [4, 2, 5, 3, 6] [4, 2, 5, 3, 6]
[5, 3, 6] [5, 3, 6] [5, 3, 6]
[6] [6] [6]
[2, 5, 3, 6] [2, 5, 3, 6] [2, 5, 3, 6]
[3, 6] [3, 6] [3, 6]
[1, 4, 2, 5, 3] [1, 4, 2, 5, 3] [1, 4, 2, 5, 3]
[:, :, 3] =
[4, 2, 5, 3, 6] [4, 2, 5, 3, 6] [4, 2, 5, 3, 6]
[5, 3, 6] [5, 3, 6] [5, 3, 6]
[6] [6] [6]
[2, 5, 3, 6] [2, 5, 3, 6] [2, 5, 3, 6]
[3, 6] [3, 6] [3, 6]
[1, 4, 2, 5, 3] [1, 4, 2, 5, 3] [1, 4, 2, 5, 3]
Beta is an array matrix and d matrix as follow:
d=[ 0.0 105.0 119.0 55.0 123.0 44.0
105.0 0.0 76.0 135.0 42.0 81.0
119.0 76.0 0.0 170.0 42.0 76.0
55.0 135.0 170.0 0.0 164.0 97.0
123.0 42.0 42.0 164.0 0.0 86.0
44.0 81.0 76.0 97.0 86.0 0.0];
sum(d[i,j]*x[i,j,k,t] for i in 1:6,j in Set(Beta[i,k,t]), t in 1:3, k in 1:3 )
ERROR: UndefVarError: i not defined
Stacktrace:
[1] macro expansion at C:\Users\admin\AppData\Local\JuliaPro-0.6.4.
1\pkgs-0.6.4.1\v0.6\Atom\src\repl.jl:118 [inlined]
[2] anonymous at .\<missing>:?
why this error is happened? if you don't mind please help me about that error . thanks

The required functionality is explained in Generator Expressions section of the Julia manual:
Ranges in generators and comprehensions can depend on previous ranges by writing multiple for keywords:
julia> [(i,j) for i=1:3 for j=1:i]
6-element Array{Tuple{Int64,Int64},1}:
(1, 1)
(2, 1)
(2, 2)
(3, 1)
(3, 2)
(3, 3)
In such cases, the result is always 1-d.

How to generate sequence with exclusions in R

I need 4 functions that generate some numbers (each)
First function generates sequence from n odd numbers except 5, 15, 25, etc...
example with n=2: 1, 1, 3, 3, 7, 7, 9, 9, 11, 11, 13, 13, 17, 17,...
Second function generates sequence from n even numbers except 10, 20, 30, etc...
example witn n=2: 2, 2, 4, 4, 6, 6, 8, 8, 12, 12, 14, 14, 16, 16,...
Third function generates sequence from n numbers from 5 by 10
example witn n=2: 5, 5, 15, 15, 25, 25,...
Fourth function generates sequence from n numbers from 10 by 10
example witn n=2: 10, 10, 20, 20, 30, 30,...
Each function has to get vector 1: N and n as inputs.
For example,
f1(1:10, 3)
> 1, 1, 1, 3, 3, 3, 7, 7, 7, 9
f2(1:5, 10)
> 2, 2, 2, 2, 2
f3(1:15, 5)
> 5, 5, 5, 5, 5, 15, 15, 15, 15, 15, 25, 25, 25, 25, 25
f4(1:2, 1)
> 10, 20
I have some decision for first two functions but I don`t know how to exclude some numbers:
f1 <- function(x) 2*((x-1) %/% 10) + 1 # goes 1, 3, 5, etc for n = 10
f2 <- function(x) 2*((x-1) %/% 10 + 1) # goes 2, 4, 6, etc for n = 10

why not use seq and rep ?
n = 25
nrep = 2 # number of repetitions
by5 <- sort(rep(seq(5, n, by = 10), nrep )) # numbers from 5 by 10
by5
by10 <- sort(rep(seq(10, n, by = 10), nrep )) # numbers from 10 by 10
by10
odd <- sort(rep(seq(1, n, by = 2), nrep )) # odd number
odd[!odd %in% by5] # remove all the by5 values
even <- sort(rep(seq(2, n, by = 2), nrep )) # Even numbers
even[!even %in% by10] # remove all the by 10 values
output
> [1] 5 5 15 15 25 25
> [1] 10 10 20 20
> [1] 1 1 3 3 7 7 9 9 11 11 13 13 17 17 19 19 21 21 23 23
> [1] 2 2 4 4 6 6 8 8 12 12 14 14 16 16 18 18 22 22 24 24.

Combinations of two arrays with ordering in Julia

If I have
a=[1,3,5,7,9]
b=[2,4,6,8,10]
and I want to create every combination of length 5 of the two lists with ordering.
So far I can get every possible combination through:
ab=hcat(a,b)
collect(combinations(ab,5))
but I want to receive only the 32 (in this case) ordered combinations.
A function similar to what I am looking for would be the Tuples[Transpose#{a,b}] function in Mathematica.
EDIT:
Mathematica output would be as follows
a = {1, 3, 5, 7, 9};
b = {2, 4, 6, 8, 10};
combin = Tuples[Transpose#{a, b}]
Length[combin]
Out[1]:= {{1, 3, 5, 7, 9}, {1, 3, 5, 7, 10}, {1, 3, 5, 8, 9}, {1, 3, 5, 8,
10}, {1, 3, 6, 7, 9}, {1, 3, 6, 7, 10}, {1, 3, 6, 8, 9}, {1, 3, 6,
8, 10}, {1, 4, 5, 7, 9}, {1, 4, 5, 7, 10}, {1, 4, 5, 8, 9}, {1, 4,
5, 8, 10}, {1, 4, 6, 7, 9}, {1, 4, 6, 7, 10}, {1, 4, 6, 8, 9}, {1,
4, 6, 8, 10}, {2, 3, 5, 7, 9}, {2, 3, 5, 7, 10}, {2, 3, 5, 8,
9}, {2, 3, 5, 8, 10}, {2, 3, 6, 7, 9}, {2, 3, 6, 7, 10}, {2, 3, 6,
8, 9}, {2, 3, 6, 8, 10}, {2, 4, 5, 7, 9}, {2, 4, 5, 7, 10}, {2, 4,
5, 8, 9}, {2, 4, 5, 8, 10}, {2, 4, 6, 7, 9}, {2, 4, 6, 7, 10}, {2,
4, 6, 8, 9}, {2, 4, 6, 8, 10}}
Out[2]:= 32

Here's a v0.5 solution using Base.product.
With
a = [1,3,5,7,9]
b = [2,4,6,8,10]
To create an array of tuples
julia> vec(collect(Base.product(zip(a, b)...)))
32-element Array{Tuple{Int64,Int64,Int64,Int64,Int64},1}:
(1,3,5,7,9)
(2,3,5,7,9)
(1,4,5,7,9)
(2,4,5,7,9)
(1,3,6,7,9)
(2,3,6,7,9)
(1,4,6,7,9)
(2,4,6,7,9)
(1,3,5,8,9)
(2,3,5,8,9)
⋮
(2,4,6,7,10)
(1,3,5,8,10)
(2,3,5,8,10)
(1,4,5,8,10)
(2,4,5,8,10)
(1,3,6,8,10)
(2,3,6,8,10)
(1,4,6,8,10)
(2,4,6,8,10)
and to collect that result into a matrix
julia> hcat((collect(row) for row in ans)...)
5×32 Array{Int64,2}:
1 2 1 2 1 2 1 2 1 2 1 2 1 … 2 1 2 1 2 1 2 1 2
3 3 4 4 3 3 4 4 3 3 4 4 3 4 3 3 4 4 3 3 4 4
5 5 5 5 6 6 6 6 5 5 5 5 6 6 5 5 5 5 6 6 6 6
7 7 7 7 7 7 7 7 8 8 8 8 8 7 8 8 8 8 8 8 8 8
9 9 9 9 9 9 9 9 9 9 9 9 9 10 10 10 10 10 10 10 10 10

There is a package Iterators.jl. By using it (First you should install it by Pkg.add("Iterators")) you can do the following:
using Iterators
for p in product([1,2],[3,4],[5,6],[7,8],[9,10])
#show p
end
Output:
p = (1,3,5,7,9)
p = (2,3,5,7,9)
p = (1,4,5,7,9)
p = (2,4,5,7,9)
p = (1,3,6,7,9)
p = (2,3,6,7,9)
p = (1,4,6,7,9)
p = (2,4,6,7,9)
p = (1,3,5,8,9)
p = (2,3,5,8,9)
p = (1,4,5,8,9)
p = (2,4,5,8,9)
p = (1,3,6,8,9)
p = (2,3,6,8,9)
p = (1,4,6,8,9)
p = (2,4,6,8,9)
p = (1,3,5,7,10)
p = (2,3,5,7,10)
p = (1,4,5,7,10)
p = (2,4,5,7,10)
p = (1,3,6,7,10)
p = (2,3,6,7,10)
p = (1,4,6,7,10)
p = (2,4,6,7,10)
p = (1,3,5,8,10)
p = (2,3,5,8,10)
p = (1,4,5,8,10)
p = (2,4,5,8,10)
p = (1,3,6,8,10)
p = (2,3,6,8,10)
p = (1,4,6,8,10)
p = (2,4,6,8,10)
EDIT
To get the results as array of arrays or matrix you can do :
arr = Any[]
for p in product([1,2],[3,4],[5,6],[7,8],[9,10])
push!(arr,[y for y in p])
end
# now arr is array of arrays. If you want matrix:
hcat(arr...)

Probably the simplest solution is to simply filter out the unsorted elements; filter(issorted, …) should do the trick. This yields 26 elements, though, so perhaps I'm misunderstanding your intention:
julia> collect(filter(issorted, combinations(ab,5)))
26-element Array{Array{Int64,1},1}:
[1,3,5,7,9]
[1,3,5,7,8]
⋮

Another nested loop in R

I have the following data and nested for loop:
x <- c(12, 27, 21, 16, 12, 21, 18, 16, 20, 23, 21, 10, 15, 26, 21, 22, 22, 19, 26, 26)
y <- c(8, 10, 7, 7, 9, 5, 7, 7, 10, 4, 10, 3, 9, 6, 4, 2, 4, 2, 3, 6)
a <- c(20,25)
a.sub <- c()
df <- c()
for(j in 1:length(a)){
a.sub <- which(x >= a[j])
for(i in 1:length(a.sub)){
df[i] <- y[a.sub[i]]
}
print(df)
}
I'd like the loop to return values for df as:
[1] 10 6 3 6 4 10 6 4 2 4 3 6
[1] 10 6 3 6
As I have it, however, the loop returns the same values twice of df for a <- 20 but not a <- 25:
[1] 10 7 5 10 4 10 6 4 2 4 3 6
[1] 10 6 3 6 4 10 6 4 2 4 3 6

for(i in 1:length(a.sub)){
df[i] <- y[a.sub[i]]
}
can become
df <- y[a.sub]
neither a.sub nor df need to be predefined then and thus...
x <- c(12, 27, 21, 16, 12, 21, 18, 16, 20, 23, 21, 10, 15, 26, 21, 22, 22, 19, 26, 26)
y <- c(8, 10, 7, 7, 9, 5, 7, 7, 10, 4, 10, 3, 9, 6, 4, 2, 4, 2, 3, 6)
a <- c(20,25)
for(j in 1:length(a)){
a.sub <- which(x >= a[j])
df <- y[a.sub]
print(df)
}
It could be made shorter. df is unnecessary if you're just printing the subset of y anyway. Just print it directly. And the selector is so short it wouldn't make a single line confusing. Furthermore, why use length of a and index.. loop through a directly. So, it could be...
a <- c(20,25)
for(ax in a){
print( y[ which(x >= ax) ] )
}

Not sure if this is a simplified version of a more complex problem, but I'd probably solve this using some direct indexing and an apply function. Something like this:
z <- cbind(x,y)
sapply(c(20,25), function(x) z[z[, 1] >= x, 2])
[[1]]
[1] 10 7 5 10 4 10 6 4 2 4 3 6
[[2]]
[1] 10 6 3 6

Resources