# Syntax for constructing a 1x1 matrix
**URL:** https://discourse.julialang.org/t/syntax-for-constructing-a-1x1-matrix/5207
**Category:** General Usage
**Created:** [August 3, 2017, 5:15pm UTC](https://discourse.julialang.org/t/syntax-for-constructing-a-1x1-matrix/5207 "2017-08-03T17:15:25Z")
**Posts on this page:** 13
**Page:** 1
### Author:  [@pablosanjose](https://discourse.julialang.org/u/pablosanjose)
#### Post date: [August 3, 2017, 5:15pm UTC](https://discourse.julialang.org/t/syntax-for-constructing-a-1x1-matrix/5207/1 "2017-08-03T17:15:25Z")
Before taking transposes seriously one could conveniently use e.g. `[5]'` to build a 1x1 matrix containing `5`. In v0.6+ this results in a `RowVector` instead. Do we have any compact syntax for building initialized 1x1 matrices now?
---
### Author:  [@kristoffer.carlsson](https://discourse.julialang.org/u/kristoffer.carlsson)
#### Post date: [August 3, 2017, 5:19pm UTC](https://discourse.julialang.org/t/syntax-for-constructing-a-1x1-matrix/5207/2 "2017-08-03T17:19:44Z")
`hcat(1)` ☹
---
### Author:  [@pablosanjose](https://discourse.julialang.org/u/pablosanjose)
#### Post date: [August 3, 2017, 5:20pm UTC](https://discourse.julialang.org/t/syntax-for-constructing-a-1x1-matrix/5207/3 "2017-08-03T17:20:44Z")
That’s not half-bad! Thanks!
---
### Author:  [@baggepinnen](https://discourse.julialang.org/u/baggepinnen)
#### Post date: [August 3, 2017, 6:09pm UTC](https://discourse.julialang.org/t/syntax-for-constructing-a-1x1-matrix/5207/4 "2017-08-03T18:09:04Z")
The following also works
```julia
julia> [5][:,:]
1×1 Array{Int64,2}:
5
```
Still ugly… 😉
---
### Author:  [@Dan](https://discourse.julialang.org/u/Dan)
#### Post date: [August 3, 2017, 6:56pm UTC](https://discourse.julialang.org/t/syntax-for-constructing-a-1x1-matrix/5207/5 "2017-08-03T18:56:04Z")
But functions can be defined for a reason (and compilers inline for a reason), so:
```julia
julia> mat(sc) = reshape([sc],1,1)
mat (generic function with 1 method)
julia> mat(5)
1×1 Array{Int64,2}:
5
```
and better yet to consider:
```julia
julia> using StaticArrays
julia> smat(sc) = @SMatrix [sc]
smat (generic function with 1 method)
julia> smat(5)
1×1 StaticArrays.SArray{Tuple{1,1},Int64,2,1}:
5
```
The little `@code_llvm` I looked at, made these methods preferable and ultimately more readable and correct.
---
### Author:  [@pablosanjose](https://discourse.julialang.org/u/pablosanjose)
#### Post date: [August 4, 2017, 1:09pm UTC](https://discourse.julialang.org/t/syntax-for-constructing-a-1x1-matrix/5207/6 "2017-08-04T13:09:49Z")
The `smat` function indeed provides an extremely compact compilation, followed by `hcat`, followed by `reshape` (which is quite suboptimal). Marked this as the best solution, thanks!
EDIT: in cases where a conventional `Matrix` instead of `SMatrix` is preferred, the function
```julia
mat(s) = Matrix(@SMatrix [s])
```
is surprisingly efficient too, better even than `hcat`
```julia
julia> @code_llvm mat(1)
define %jl_value_t addrspace(10)* @julia_mat_62521(i64) #0 !dbg !5 {
top:
%"#temp#" = alloca %SArray.10, align 8
%1 = getelementptr inbounds %SArray.10, %SArray.10* %"#temp#", i64 0, i32 0, i64 0
store i64 %0, i64* %1, align 8
%2 = addrspacecast %SArray.10* %"#temp#" to %SArray.10 addrspace(11)*
%3 = call %jl_value_t addrspace(10)* @julia_convert_62498(%jl_value_t addrspace(10)* addrspacecast (%jl_value_t* inttoptr (i64 4464354096 to %jl_value_t*) to %jl_value_t addrspace(10)*), %SArray.10 addrspace(11)* nocapture readonly %2)
ret %jl_value_t addrspace(10)* %3
```
(I just love StaticArrays.jl !)
---
### Author:  [@kristoffer.carlsson](https://discourse.julialang.org/u/kristoffer.carlsson)
#### Post date: [August 4, 2017, 1:26pm UTC](https://discourse.julialang.org/t/syntax-for-constructing-a-1x1-matrix/5207/7 "2017-08-04T13:26:31Z")
You do have a function call in there so not sure how you can say whether it is efficient or not.
Benchmarking them I found that `hcat` and your `mat` had pretty much identical performance .
---
### Author:  [@pablosanjose](https://discourse.julialang.org/u/pablosanjose)
#### Post date: [August 4, 2017, 1:36pm UTC](https://discourse.julialang.org/t/syntax-for-constructing-a-1x1-matrix/5207/8 "2017-08-04T13:36:02Z")
Oops, you’re completely right. I’m no good reading llvm 😁. Actually `hcat` is in 25% faster than `mat` in my system! Still, `smat` is way faster than both.
---
### Author:  [@baggepinnen](https://discourse.julialang.org/u/baggepinnen)
#### Post date: [August 4, 2017, 1:56pm UTC](https://discourse.julialang.org/t/syntax-for-constructing-a-1x1-matrix/5207/9 "2017-08-04T13:56:39Z")
A side note, it might be a good idea to avoid depending on the extra package `StaticArrays` if not otherwise needed.
---
### Author:  [@DNF](https://discourse.julialang.org/u/DNF)
#### Post date: [August 4, 2017, 2:05pm UTC](https://discourse.julialang.org/t/syntax-for-constructing-a-1x1-matrix/5207/10 "2017-08-04T14:05:12Z")
> [@Dan](#):
>
> reshape([sc],1,1)
```julia
using BenchmarkTools
julia> @btime reshape([1],1,1)
63.990 ns (3 allocations: 192 bytes)
1×1 Array{Int64,2}:
1
julia> @btime fill(1, (1,1))
29.674 ns (1 allocation: 96 bytes)
1×1 Array{Int64,2}:
1
julia> @btime hcat(1)
33.067 ns (1 allocation: 96 bytes)
1×1 Array{Int64,2}:
1
```
The difference between `hcat` and `fill` is small, but consistent. I also find `fill` more elegant.
---
### Author:  [@Dan](https://discourse.julialang.org/u/Dan)
#### Post date: [August 4, 2017, 2:16pm UTC](https://discourse.julialang.org/t/syntax-for-constructing-a-1x1-matrix/5207/11 "2017-08-04T14:16:55Z")
`fill` is my favorite too.
With a function:
```julia
mat(s) = begin
m = Array{typeof(s)}(1,1)
@inbounds m[1] = s
return m
end
```
another 10% can be squeezed (on my system, Julia version, and LLVM version):
```julia
julia> @btime mat(5)
26.736 ns (1 allocation: 96 bytes)
1×1 Array{Int64,2}:
5
julia> @btime fill(5,(1,1))
28.640 ns (1 allocation: 96 bytes)
1×1 Array{Int64,2}:
5
```
And the `@code_llvm` looks nice and short.
---
### Author:  [@garrison](https://discourse.julialang.org/u/garrison)
#### Post date: [August 5, 2017, 5:57am UTC](https://discourse.julialang.org/t/syntax-for-constructing-a-1x1-matrix/5207/13 "2017-08-05T05:57:30Z")
I typically use `diagm([5])`.
---
### Author:  [@olivierverdier](https://discourse.julialang.org/u/olivierverdier)
#### Post date: [June 20, 2023, 12:08pm UTC](https://discourse.julialang.org/t/syntax-for-constructing-a-1x1-matrix/5207/14 "2023-06-20T12:08:07Z")
This works, for [array literals](https://docs.julialang.org/en/v1/manual/arrays/#man-array-literals):
```julia
[5;;]
```
The number of semicolons indicate the rank of the final tensor, so for instance, `[5;;;]` is a 1x1x1 tensor.