How we should create an object whose type is Array not Vector or Matrix which are aliases of Arrays

For example if I can create an Array

```
x = ["random", 1, "test", 3.1455]
y = ["Hello" 1 ; "test" "random"]
```

then typeof output for

```
typeof(x)
typeof(y)
```

Results in

Vector{Any} (alias for Array{Any, 1})

Matrix{Any} (alias for Array{Any, 2})

What is the problem with one- and two-dimensional `Array`

types having shorter equivalent names?

Anyway, if you absolutely want to create an object of an `Array`

type which doesn’t happen to have a shorter alias, you can do

```
julia> z = ["Hello" ;;; 1]
1×1×2 Array{Any, 3}:
[:, :, 1] =
"Hello"
[:, :, 2] =
1
julia> typeof(z)
Array{Any, 3}
```

1 Like

Thanks, this is slightly confusing when coming from Python, I am checking when we have Vector, Matrices and Arrays

They are all the same thing. `Vector`

is a synonym for a 1d `Array`

and `Matrix`

is a synonym for a 2d `Array`

. The short names are just to make it easier to type and talk about.

7 Likes

Just to make this abundantly clear, `Vector{T}`

is a type alias (see the docs here and here) for `Array{T,1}`

, and `Matrix{T}`

is a type alias for `Array{T,2}`

. Type aliases are just new names for types that are exactly equivalent to the old names:

```
julia> Vector{Int} === Array{Int,1}
true
julia> Matrix{Int} === Array{Int,2}
true
```

You can even define your own type aliases using regular assignment (usually to a `const`

variable):

```
julia> struct LongName{S,T} end
julia> const LN = LongName{S,T} where {S,T};
julia> LN === LongName
true
julia> const LN2{S} = LongName{S,Int} where S
LN2 (alias for LongName{S, Int64} where S)
julia> LN2{String} === LongName{String, Int}
true
```

1 Like

`Array`

(e.g. `Array{Any, 2}`

) is the general name for a collection of some type (e.g. `Any`

) across some number of dimensions (e.g. `2`

). The most common number of dimensions are 1-dimensional arrays (also called vectors) and 2-dimensional arrays (also called matrices). We just don’t give special names to any of the arrays with dimensions larger than 2.

```
x = ["random", 1, "test", 3.1455] # 4-element Vector{Any}
y = ["Hello" 1 ; "test" "random"] # 2×2 Matrix{Any}
x isa Array # true
y isa Array # true
x isa Vector # true
y isa Vector # false
x isa Matrix # false
y isa Matrix # true
Vector{Any} === Array{Any, 1} # true
Matrix{Any} === Array{Any, 2} # true
```

2 Likes