How do I retrieve an array of arrays of arrays in Julia? - arrays

Question

I am new in Julia, so don't judge me please (ha ha)
This is my situation: I needed to save several 2x2x2 matrices whose elements were vectors of 4 elements, but now when I try to retrieve them from a file, I can't !!!
This is what I did:
To create these matrices I made this function
function InitialConf(L_=2,S_=2,T_=2,Dim_=4)
Conf_=Array{Array{Float64,1}}(L_,S_,T_)
for i_ = 1:L_, j_=1:S_,k_=1:T_
Conf_[i_,j_,k_]=RanUniVec(Dim_)
end
return Conf_
end
Where RanUniVec(Dim_) is the function that creates these vectors of 4 dimentions with special characteristics that are not important for this discussion:
function RanUniVec(Dim_)
vector_=Array{Float64}(Dim_)
while true
for i_ in 1:Dim_
vector_[i_]=UniformRand(-1,1)
end
if norm(vector_)<1 && norm(vector_)>0.5
break
end
end
vector_=normalize(vector_) # 2-norm
return vector_
end
function UniformRand(a_,b_)
rand_=(b_-a_)*rand()+a_
return rand_
end
I needed two of these matrices (for example) so I did the next:
States=[]
Conf1=InitialConf()
Conf2=InitialConf()
push!(States,Conf1)
push!(States,Conf2)
f=open("Info.txt","w") do f
write(f,"$States")
end
This made the Info.txt file where is my information, but when I try to get the States array again from this file, Julia tells me that it can't
f=readlines("Info.txt")
States=parse(f)
ERROR: MethodError: no method matching parse(::Array{String,1})
Closest candidates are:
parse(::Type{IPv4}, ::AbstractString) at socket.jl:167
parse(::Type{IPv6}, ::AbstractString) at socket.jl:218
parse(::Type{DateTime}, ::AbstractString, ::DateFormat{Symbol("yyyy-mm-dd\\THH:MM:SS.s"),Tuple{Base.Dates.DatePart{'y'},Base.Dates.Delim{Char,1},Base.Dates.DatePart{'m'},Base.Dates.Delim{Char,1},Base.Dates.DatePart{'d'},Base.Dates.Delim{Char,1},Base.Dates.DatePart{'H'},Base.Dates.Delim{Char,1},Base.Dates.DatePart{'M'},Base.Dates.Delim{Char,1},Base.Dates.DatePart{'S'},Base.Dates.Delim{Char,1},Base.Dates.DatePart{'s'}}}) at dates/parse.jl:202
...
Do you know how I can get again my State array?

Answer 1

In general you should use Colin's recommendation from the comment in the long run. Here is what you can do if you actually have those text files already generated. I will use a smaller example.
Assume your original array is consisting of two 2x2x2 arrays. Here is an example I will use:
julia> z
2-element Array{Array{Int64,3},1}:
[1 2; 3 4]
[10 20; 30 40]
[1 2; 3 4]
[10 20; 30 40]
julia> z[1]
2×2×2 Array{Int64,3}:
[:, :, 1] =
1 2
3 4
[:, :, 2] =
10 20
30 40
julia> z[2]
2×2×2 Array{Int64,3}:
[:, :, 1] =
1 2
3 4
[:, :, 2] =
10 20
30 40
Now it will get saved to a file as the following string:
julia> repr(z)
"Array{Int64,3}[[1 2; 3 4]\n\n[10 20; 30 40], [1 2; 3 4]\n\n[10 20; 30 40]]"
And parsing this string will clearly fail. What you have to do is to edit your files to add cat method invocation on each entry of a big array and pass dimension 3 as the one on which you want to cat them.
This means that from the original contents of the save file:
Array{Int64,3}[[1 2; 3 4]
[10 20; 30 40], [1 2; 3 4]
[10 20; 30 40]]
You have to make this file contain:
Array{Int64,3}[cat(3, [1 2; 3 4], [10 20; 30 40]),
cat(3, [1 2; 3 4], [10 20; 30 40])]
Those changes can be done either by hand or you could write a program to perform the transformation (you have to replace , by ), cat(3,; \n\n by ,; make sure that first cat and last ) are added as they will not be caught by the first two rules).
Now if you read it in it as a string you can evaluate result of parsing it:
julia> s = """Array{Int64,3}[cat(3, [1 2; 3 4], [10 20; 30 40]),
cat(3, [1 2; 3 4], [10 20; 30 40])]"""
"Array{Int64,3}[cat(3, [1 2; 3 4], [10 20; 30 40]),\ncat(3, [1 2; 3 4], [10 20; 30 40])]"
julia> eval(parse(s))[2]
2×2×2 Array{Int64,3}:
[:, :, 1] =
1 2
3 4
[:, :, 2] =
10 20
30 40
Note, however, that all this is not recommended - it is better to use the packages that Colin recommended to do this.

Answer 2

Not directly an answer to your specific question, but a general recommendation for future development. To save data to disk, and reload later, give preference to formats such as JLD2.jl.
You save with
#save "filename.jld2" ARRAY
and load with
#load "filename.jld2" ARRAY
without having to figure out what was the format you chose in the past. Saves a lot of headache with complex data structures.