Best way to extend the size and add terms to a SparseArray without expanding

Question

Let's say I have a "small" SparseArray of any size, in the example $2\times2$

MatrixForm[
    m2 = SparseArray[{{i_,i_}->1,{1,2}->a},2]
]

I want to expand it to a "Large"m any size larger than the previous, for example, $4\times4$ SparseArray without rewriting it.

let's say

m4test = SparseArray[{{i_,i_}->1,{1,2}->a, {3,4}->b },4]

How do I efficiently (not expanding and contracting) do I transform m2 into m4 by increasing the size and adding new terms?

Due diligence

I didn't find a similar question on the site, and ChatGPT doesn't seem to understand how to program for general cases.

I have tried this,

extendSparseArray[sa_, rules_] := SparseArray[
    Join[rules, ArrayRules[sa]]
    , Max[Join[Dimensions[sa],Flatten@rules[[All,1]] ] ]
]

MatrixForm[
    extendSparseArray[m2, {{3,4}->b}]
]

Which does part of the job. Notice it conserves the default value, because

ArrayRules[SparseArray[{{i_,i_}->1}, 4, x]]
(* {{1, 1} -> 1, {2, 2} -> 1, {3, 3} -> 1, {4, 4} -> 1, {_, _} -> x} *)

which includes the rule {_, _} -> x. Unfortunately, it misses the other general rule {i_,i_}->1.

Another problem is that it doesn't work with further patterns. This fails, because Max[4, i_] doesn't make sense.

extendSparseArray[m2, {{i_,i_}->1,  {3,4}->b}]

Furthermore, it all seems too cumbersome, and I'm hoping I'm missing something more fundamental.

Perhaps it's not reasonable to expect to recover the pattern rule, in that case at least the default value (in this case zero, but not necessarily) should be conserved.

What are simple and idiomatic ways to achieve this and which one performs the best?

The examples are meant to be minimal to facilitate the discussion, I will use this with larger and more complex SparseArray expressions.

---

It seems from the comments that I'm not explaining myself clearly.

SparseArray[SparseArray[{},n],m] with $m>n$ does part of the job, it manipulates a small SparseArray to make it larger, but the issue is how do I add the rules that define some of the new terms in a short robust and idiomatic form?

Answer 1

I think ArrayFlatten is your best friend here.

A = SparseArray[{{i_, i_} -> 1, {1, 2} -> a}, 2];
B = SparseArray[{{i_, i_} -> 1, {1, 2} -> b}, 2];

AB = ArrayFlatten[{{A,0},{0,B}}]

$$ \left( \begin{array}{cccc} 1 & a & 0 & 0 \\ 0 & 1 & 0 & 0 \\ 0 & 0 & 1 & b \\ 0 & 0 & 0 & 1 \\ \end{array} \right) $$

In this case, ArrayFlatten is even clever enough to replace the two 0s by the according 0-block matrices. This is not always possible, e.g., when you want to stack A and B on top of each other and if you still want to get a $4 \times 4$ matrix. Then you have to give at least one 0-block explicitly:

ArrayFlatten[{{A, SparseArray[{}, {2, 2}]}, {B, 0}}]

Beware that all sparse matrices that show up here should be SparseArrays; otherwise ArrayFlatten will produce a dense matrix. Moreover, all the default values of the SparseArrays have to coincide, too (and 0 is considered different from 0. in this regards); otherwise, a dense matrix is creates.

Answer 2

I'd probably create a helper function and then use the built in matrix-related functions.

specialMatrix[val_] := SparseArray[{{i_, i_} -> 1, {1, 2} -> val}, 2];
BlockDiagonalMatrix[{specialMatrix[a], specialMatrix[b]}]

In "normal" form this gives

{{1, a, 0, 0}, 
 {0, 1, 0, 0}, 
 {0, 0, 1, b}, 
 {0, 0, 0, 1}}

The basic problem with your approach is that, while the SparseArray constructor takes pattern arguments, the SparseArray structure that results uses the concrete rules that the patterns specified. So you can't just take the ArrayRules and expect them to be still patterns.

You might also be able to use DiagonalMatrix and/or IdentityMatrix. DiagonalMatrix lets you specify the values for any particular diagonal, so if your rules can be formulated rigorously (I'm assuming that the simple a and b aren't totally faithful to your actual problem) it might work nicely.