Hi I want to generate an array `A`

in which each element is a 2\times 2 matrix. And I want to initialize this array such that each element is `[1/2 0; 0 1/2]`

. Later I want to replace some element by different matrices like `A[i] = [a b; c d]`

and I want to be able to get each element, ,like `temp = A[j]`

for further computation. What is the efficient way to do this? Thanks.

Edit: No, `fill`

fills the array with addresses to the same matrix, my bad. Here’s how to do it:

```
A = [[0.5 0; 0 0.5] for i=1:10]
A[2] .= [1 1;1 0]
B = A[5]
```

Yes this works. Thank you!

For 2x2 matrices I would use StaticArrays:

```
using StaticArrays
A = fill(SA[0.5 0.0; 0.0 0.5], 10)
A[2] = SA[1.0 1.0;1.0 0.0]
```

SArrays are immutable, so you cannot use dot-assignment in the last line, but you *can* use `fill`

.

This will be much more efficient than regular arrays.

Sorry, I can’t see why `fill`

doesn’t work. I tried the previous version `A = fill([1/2 0; 0 1/2],10)`

and it gives me an array of matrices. I can also change the elements like `A[1] = [1 2;3 4]`

. Could you please explain why `fill`

fails? Thank you.

The problem is that every element of the vector `A`

refers to the same object.

```
julia> A = fill([1/2 0; 0 1/2], 4)
4-element Vector{Matrix{Float64}}:
[0.5 0.0; 0.0 0.5]
[0.5 0.0; 0.0 0.5]
[0.5 0.0; 0.0 0.5]
[0.5 0.0; 0.0 0.5]
julia> A[1][1,1] = 123
123
julia> A
4-element Vector{Matrix{Float64}}:
[123.0 0.0; 0.0 0.5]
[123.0 0.0; 0.0 0.5]
[123.0 0.0; 0.0 0.5]
[123.0 0.0; 0.0 0.5]
```

Basically you have the same matrix several times! I don’t think you want that.

Oh I see. Thank you!

Hi guys. I have one more question. Suppose I need to replace one element of the array to be a complex matrix like ` A[i] = [1+im 0;0 1-im]`

, then I need to use `[1/2+0*im 0; 0 1/2+0*im]`

when I initialize the array, right?

Just to be clear for those who don’t know, `fill`

has the exact same semantics in both cases, it’s just that if the array is immutable (like a `StaticArray`

) then there’s no difference between `n`

references to the same object and a `n`

distinct objects. But if you are doing the same operations with both types (without errors), you should get the same results. Maybe that’s pedantic but to me it feels confusing to describe the behavior as depending on the mutability of the object. That said, I agree `fill`

is often more useful when there’s no danger of mutating, which you get with `StaticArray`

s.

Yeah, you need to do that, or you could specify the type when creating the matrices directly, like

```
A = [Complex{Float64}[0.5 0; 0 0.5] for i=1:10]
```

Got it. Thanks