ArrayFlatten
ArrayFlatten[{{m11,m12,…},{m21,m22,…},…}]
creates a single flattened matrix from a matrix of matrices mi j.
ArrayFlatten[a,r]
flattens out r pairs of levels in the array a.
Details
- ArrayFlatten requires that the blocks it flattens have dimensions that fit together.
- ArrayFlatten can be used to form block matrices from arrays of blocks.
- For a matrix of matrices, ArrayFlatten[a] yields a matrix whose elements are in the same order as in MatrixForm[a].
- ArrayFlatten[a] is normally equivalent to Flatten[a,{{1,3},{2,4}}]. »
- ArrayFlatten[a,r] is normally equivalent to Flatten[a,{{1,r+1},{2,r+2},…,{r,2r}}].
- For a tensor with rank 2r, ArrayFlatten[a,r] gives a tensor with rank r.
- In ArrayFlatten[{{m11,m12,…},{m21,m22,…},…}], all the matrices mi j in the same row must have the same first dimension, and matrices mi j in the same column must have the same second dimension.
- In general, in ArrayFlatten[a,r], all the k
dimensions of a[[i1,i2,…,
]] must be equal for each possible value of ik . - Elements at level r whose array depth is less than r are treated as scalars, and are replicated to fill out a rank-r array of the appropriate dimensions.
- ArrayFlatten works with SparseArray objects. »
Examples
open all close allBasic Examples (2)
Create a block matrix by flattening out a matrix of matrices:
m = {{1, 2}, {3, 4}};ArrayFlatten[{{m, m, m}, {m, m, m}}]Use 0s to represent zero matrices:
m = {{1, 2}, {3, 4}};ArrayFlatten[{{0, 0, m}, {m, m, 0}}]Scope (4)
Flatten a rank-4 array to rank 2:
ArrayFlatten[Array[a, {1, 2, 3, 4}]]//DimensionsFlatten only the first four levels of a rank-6 array:
ArrayFlatten[Array[a, {1, 2, 3, 4, 5, 6}]]//DimensionsFlatten a rank 6 array to rank 3:
ArrayFlatten[Array[a, {1, 2, 3, 4, 5, 6}], 3]//DimensionsArrayFlatten works with SparseArray objects:
s = SparseArray[{i_, i_, j_, k_} -> i / (j + k - 1), {3, 3, 2, 2}]m = ArrayFlatten[s]MatrixForm[m]Make a sparse matrix from a block matrix of SparseArray objects:
s1 = SparseArray[{i_, i_} -> i, {2, 2}];
s2 = SparseArray[{i_, j_} /; Abs[i - j] == 1 -> i - j, {3, 3}]m = ArrayFlatten[{{0, s1}, {-s2, 0}}]MatrixForm[m]Applications (5)
Put together many copies of a "tile":
ArrayPlot[ArrayFlatten[Table[{{2, 0, 0, 1}, {1, 0, 2, 1}, {0, 1, 2, 2}}, {10}, {10}]]]Iterate a 2D substitution system:
NestList[ArrayFlatten[# /. 1 -> {{1, 0}, {1, 1}}]&, {{1}}, 3]ArrayPlot[#, ImageSize -> Tiny]& /@ %Iterate a 3D substitution system:
NestList[ArrayFlatten[# /. 1 -> {{{1, 0}, {0, 0}}, {{1, 0}, {1, 1}}}, 3]&, {{{1}}}, 3];Graphics3D[Cuboid /@ Position[#, 1], ImageSize -> Tiny]& /@ %Form an involutory matrix 
, such that 
:
involutoryMatrix[A_ ? MatrixQ, B_] := Block[{n, k}, {n, k} = Dimensions[A];ArrayFlatten[| | |
| ----------------------- | ----------------------- |
| IdentityMatrix[k] - B.A | B |
| 2 A - A.B.A | A.B - IdentityMatrix[n] |] /; Dimensions[B] == {k, n}]L = involutoryMatrix[RandomInteger[{-5, 5}, {3, 2}], RandomInteger[{-5, 5}, {2, 3}]]Check that the resulting matrix is involutory:
L.L//MatrixFormForm a block matrix semidiscretization of the wave equation 
with n spatial points:
n = 100;h = 1. / n;Differentiation matrix for second-order approximation of 
with periodic boundary conditions:
dm = SparseArray[{{i_, i_} -> -2 / h ^ 2, {i_, j_} /; Abs[i - j] == 1 -> 1 / h ^ 2, {n, 1} -> 1 / h ^ 2, {1, n} -> 1 / h ^ 2}, {n, n}, 0.]im = IdentityMatrix[n, SparseArray, WorkingPrecision -> MachinePrecision]Form block matrix a for system 
where 
:
a = ArrayFlatten[{{0., im}, {dm, 0.}}]im2 = IdentityMatrix[2 n, SparseArray, WorkingPrecision -> MachinePrecision]Set up an initial condition vector for 
:
ic = Join[Table[Exp[-100(i h - .5) ^ 2], {i, n}], ConstantArray[0., n]];Approximate the solution at 
using the backward Euler method with time step k:
k = h / 100;lsf = LinearSolve[im2 - k a];solt = ic;Do[solt = lsf[solt], {Round[0.25 / k]}];
ListPlot[{Take[solt, n], Take[solt, -n]}, DataRange -> {0, 1}, PlotRange -> All]Properties & Relations (3)
MatrixForm displays matrices of matrices in the same order as ArrayFlatten:
m = {{1, 2}, {3, 4}}; b = {{m, m, m}, {m, m, m}};MatrixForm[b]MatrixForm[ArrayFlatten[b]]ArrayFlatten is a special case of Flatten:
m = {{1, 2}, {3, 4}}; b = {{m, 2m}, {3m, 4m}};MatrixForm[b]Flatten[b, {{1, 3}, {2, 4}}] == ArrayFlatten[b]KroneckerProduct is defined as ArrayFlatten of an Outer product:
m1 = Array[a, {2, 2}]; m2 = Array[b, {2, 2}];KroneckerProduct[m1, m2] == ArrayFlatten[Outer[Times, m1, m2]]
An Elementary Introduction to the Wolfram LanguageText
Wolfram Research (2007), ArrayFlatten, Wolfram Language function, https://reference.wolfram.com/language/ref/ArrayFlatten.html.
CMS
Wolfram Language. 2007. "ArrayFlatten." Wolfram Language & System Documentation Center. Wolfram Research. https://reference.wolfram.com/language/ref/ArrayFlatten.html.
APA
Wolfram Language. (2007). ArrayFlatten. Wolfram Language & System Documentation Center. Retrieved from https://reference.wolfram.com/language/ref/ArrayFlatten.html