julia> display([i*j for i=1:3, j=1:3])
3×3 Array{Int64,2}:
1 2 3
2 4 6
3 6 9
julia> display([i*j for i=1:3, j=1:3 i>=j])
6-element Array{Int64,1}:
1
2
3
4
6
9
not a surprise. what i'd like is:
3×3 Array{Int64,2}:
1
2 4
3 6 9
i suppose a for loop is needed. what i don't want is to generate the entire array and then filter out or replace the ones.
while the example is symmetric, it not really relevant to the q. any f(i,j) could be substituted for i*j. (symmetric or not)
I suppose you wanted to write [i*j for i=1:3, j=1:3 if i>=j]. The if condition will always make your result a vector.
What you can do to avoid generating an entire array is e.g.:
x = Matrix{Int}(3,3)
for i in 1:3, j in 1:i
x[i,j] = i*j
end
y = LowerTriangular(x)
Related
That's it. My program generates a vector of Int64s, and each time I need to stack each Vector into a M by N Matrix
Everything. e.g.
Push, Append, hcat [], (), {}, even ¯_(ツ)_/¯
If this is a new matrix use hcat:
julia> hcat([1,2,3],[4,5,6])
3×2 Matrix{Int64}:
1 4
2 5
3 6
This will also work with vector of vectors:
julia> vecs = [[1,2,3],[4,5,6],[7,8,9]];
julia> a = hcat(vecs...)
3×3 Matrix{Int64}:
1 4 7
2 5 8
3 6 9
If performance is an issue reduce combined with hcat will be more verbose but much faster:
reduce(hcat, vecs)
To put data into a column use broadcasted assignment:
julia> a[:,2] .= [40,50,60];
julia> a
3×3 Matrix{Int64}:
1 40 7
2 50 8
3 60 9
I have a 4: 3 matrix and I would like to take only 2: 3.
Is it possible to delimit using the DelimitedFiles command?
How should I use it?
Q = convert(Matrix, ACT[2:3])#I would like to omit the 2:3
Suppose you have the following Matrix:
julia> a = collect(reshape(1:12,(4,3)))
4×3 Array{Int64,2}:
1 5 9
2 6 10
3 7 11
4 8 12
You can select a subarray in two ways - either making a copy of the desired part or creating a view.
Making a copy (a new object is created and Array's data is copied:
julia> a[1:2,:]
2×3 Array{Int64,2}:
1 5 9
2 6 10
Creating a view. This is in many scenarios much faster because the data is not copied:
julia> view(a, 1:2, :)
2×3 view(::Array{Int64,2}, 1:2, :) with eltype Int64:
1 5 9
2 6 10
For creating the view you can also use a macro - in this case your code will be more similar to the one that copies the data:
julia> #view a[1:2,:]
2×3 view(::Array{Int64,2}, 1:2, :) with eltype Int64:
1 5 9
2 6 10
Each of those views can be shown using the command display and this is the standard way to handle showing them.
However if you want to use DelmitedFiles you can, for example:
julia> using DelimitedFiles;writedlm(stdout, #view a[1:2,:])
1 5 9
2 6 10
Given the array:
arr = [1 2; 3 4; 5 6]
3×2 Array{Int64,2}:
1 2
3 4
5 6
which is flattened flat_arr = collect(Iterators.flatten(arr))
6-element Array{Int64,1}:
1
3
5
2
4
6
I sometimes need to go between both index formats. For example, if I got the sorted indices of flat_arr, I may want to iterate over arr using these sorted indices. In Python, this is typically done with np.unravel_index. How is this done in Julia? Do I just need to write my own function?
vec() creates a 1-d view of the array. Hence you can have both pointers to the array in the memory and use whichever one you need in any minute (they point to the same array):
julia> arr = [1 2; 3 4; 5 6]
3×2 Array{Int64,2}:
1 2
3 4
5 6
julia> arr1d = vec(arr)
6-element Array{Int64,1}:
1
3
5
2
4
6
julia> arr1d[4] = 99
99
julia> arr
3×2 Array{Int64,2}:
1 99
3 4
5 6
Note that in Julia arrays are stored in column major order and hence the fourth value is the first value in the second column
This can be accomplished using CartesianIndices.
c_i = CartesianIndices(arr)
flat_arr[2] == arr[c_i[2]]) == 3
If I want to create 2D array with 1 row by 5 columns.
I could do this
julia> a = [1 2 3 4 5]
1×5 Array{Int64,2}:
1 2 3 4 5
But to create 2D array with 5 rows by 1 column. I have tried
julia> b = [1; 2; 3; 4; 5]
5-element Array{Int64,1}:
1
2
3
4
5
But I got back a 1D array which is NOT what I wanted
The only way to get it to work is
julia> b=reshape([1 2 3 4 5],5,1)
5×1 Array{Int64,2}:
1
2
3
4
5
Perhaps I am missing some crucial information here.
You could also do a = [1 2 3 4 5]'.
On a side note, for Julia versions > 0.6 the type of a wouldn't be Array{Int64, 2} but a LinearAlgebra.Adjoint{Int64,Array{Int64,2}} as conjugate transpose is lazy in this case. One can get <= 0.6 behavior by a = copy([1 2 3 4 5]').
AFAIK there is no syntactic sugar for it.
I usually write:
hcat([1, 2, 3, 4, 5])
which is short and I find it easy to remember.
If you use reshape you can replace one dimension with : which means you do not have to count (it is useful e.g. when you get an input vector as a variable):
reshape([1 2 3 4 5], :, 1)
Finally you could use:
permutedims([1 2 3 4 5])
If the two Int arrays are, a = [1;2;3] and b = [4;5;6], how do we concatenate the two arrays in both the dimensions? The expected outputs are,
julia> out1
6-element Array{Int64,1}:
1
2
3
4
5
6
julia> out2
3x2 Array{Int64,2}:
1 4
2 5
3 6
Use the vcat and hcat functions:
julia> a, b = [1;2;3], [4;5;6]
([1,2,3],[4,5,6])
help?> vcat
Base.vcat(A...)
Concatenate along dimension 1
julia> vcat(a, b)
6-element Array{Int64,1}:
1
2
3
4
5
6
help?> hcat
Base.hcat(A...)
Concatenate along dimension 2
julia> hcat(a, b)
3x2 Array{Int64,2}:
1 4
2 5
3 6
Square brackets can be used for concatenation:
julia> a, b = [1;2;3], [4;5;6]
([1,2,3],[4,5,6])
julia> [a; b]
6-element Array{Int64,1}:
1
2
3
4
5
6
julia> [a b]
3×2 Array{Int64,2}:
1 4
2 5
3 6
You can use the cat function to concatenate any number of arrays along any dimension. The first input is the dimension over which to perform the concatenation; the remaining inputs are all of the arrays you wish to concatenate together
a = [1;2;3]
b = [4;5;6]
## Concatenate 2 arrays along the first dimension
cat(1,a,b)
6-element Array{Int64,1}:
1
2
3
4
5
6
## Concatenate 2 arrays along the second dimension
cat(2,a,b)
3x2 Array{Int64,2}:
1 4
2 5
3 6
## Concatenate 2 arrays along the third dimension
cat(3,a,b)
3x1x2 Array{Int64,3}:
[:, :, 1] =
1
2
3
[:, :, 2] =
4
5
6
when encountered Array{Array,1}, the grammer is a little bit different, like this:
julia> a=[[1,2],[3,4]]
2-element Array{Array{Int64,1},1}:
[1, 2]
[3, 4]
julia> vcat(a)
2-element Array{Array{Int64,1},1}:
[1, 2]
[3, 4]
julia> hcat(a)
2×1 Array{Array{Int64,1},2}:
[1, 2]
[3, 4]
julia> vcat(a...)
4-element Array{Int64,1}:
1
2
3
4
julia> hcat(a...)
2×2 Array{Int64,2}:
1 3
2 4
ref:
... combines many arguments into one argument in function definitions
In the context of function definitions, the ... operator is used to combine many different arguments into a single argument. This use of ... for combining many different arguments into a single argument is called slurping
Functional way to concatanate 2 arrays is to use reduce function.
a = rand(10, 1)
b = rand(10, 1)
c = reduce(hcat, [ a, b])