How do I map individual data elements to the csc form of A?

[kirkrudolph]

Can anyone give me advice for how to create an index map for where each data element ends up in the csc array of A? I have a lot of data I'm trying to update in A and can't figure out a way to map the data to the final index.

I initially setup the problem for a 3 state MPC problem with a lot of custom constraints. If I want to iterate and try a different problem by adding or removing constraints, the data in the A update array shifts depending on the new constraint(s). At runtime, I can't use the same sparse functions I originally used to setup the problem so I need to have the indices/data map predetermined.

Thank you for any help!

[imciner2]

The A matrix is stored in a Compressed Sparse Column format, so that means that the data vector of the matrix (and also the data vector that should be passed into the update function) is basically composed of the columns of A stacked on top of eachother, starting from the left and going right (see e.g. https://www.numerical.rl.ac.uk/spral/doc/latest/C/csc_format.html).

That means, given the column matrix

      |   |   |   |  
A = [a1, a2, a3, a4, ...]
      |   |   |   |  

the CSC data vector is

|
a1
|
|
a2
|
|
a3
|
a4
|
...

So for instance, lets say A is a 3x4 matrix (3 rows, 4 columns) with the sparsity pattern

      x . x x
A = [ . x . . ]
      x x x .

If we want to update the (2,2) element of the matrix, we would change the value in the 3rd element of the data vector (counting starting at 1), and if we want to update the (1,4) element we would change the value at the 7th element of the data vector (counting from 1).

[kirkrudolph]

Thank you for the quick response, @imciner2. I apologies in advance for my lengthy follow-up 😅. I should've used a 2x2

I guess I'm curious if there are any tricks for figuring out how the MPC data maps to the CSC indices without rewriting the update interface manually for small changes.

For example, if A is a 3x3 (Here I mean A from the state-space equation x[k+1]=A*x+B*u)

    [ a1 a2 a3 ]
A = [ a4 a5 a6 ]
    [ a7 a8 a9 ]

And you pass that into the MPC example which is block diagonally concatenated like this:

% l_limit ≤ Linear Constraint Matrix (Ac)   x    ≤ u_limit      %  Constraint Equations
% --------------------------------------------------------      %  ---------------------------
% [ -x0 ] = [ -I  0  ...  0 | 0 0 ... 0 ] [ x0 ] = [ -x0 ]      %  -x[0] = -x[0]                        }--------> Initial Condition Constraint
% [  0  ] = [  A -I  ...  0 | B 0 ... 0 ] [ x1 ] = [  0  ]      %      0 = -x[1]+A*x[0]+B*u[0]          }
% [ ... ] = [  0  A  ...  0 | 0 B ... 0 ] [ .. ] = [ ... ]      %                                       }-------->  Dynamic Constraints
% [  0  ] = [  0  0  ...  I | 0 0 ... B ] [ .. ] = [  0  ]      %  0 = -x[N]+A*x[N-1]+B*u[N-1]          }
% --------------------------------------------------------      %  ---------------------------          }
% [x_min] ≤ [  I  0  ...  0 | 0 0 ... 0 ] [ .. ] ≤ [x_max]      %  x_min ≤ x[0] ≤ x_max                 }
% [ ... ] ≤ [  0  I  ...  0 | 0 0 ... 0 ] [ .. ] ≤ [ ... ]      %                                       }--------> Absolute State Constraints
% [x_min] ≤ [  0  0  ...  I | 0 0 ... 0 ] [ xN ] ≤ [x_max]      %  x_min ≤ x[N] ≤ x_max                 }
% --------------------------------------------------------      %  ---------------------------          }
% [u_min] ≤ [  0  0  ...  0 | I 0 ... 0 ] [ u0 ] ≤ [u_max]      %  u_min ≤ u[0] ≤ u_max                 }
% [.....] ≤ [  0  0  ...  0 | 0 I ... 0 ] [ .. ] ≤ [.....]      %                                       }--------> Absolute Actuator Constraints
% [u_min] ≤ [  0  0  ...  0 | 0 0 ... I ] [ uN ] ≤ [u_max]      %  u_min ≤ u[N] ≤ u_max                 }
% --------------------------------------------------------      %  ---------------------------

You get out a CSC data vector as follows (assuming there aren't zeros in the state-space's state transition matrix A)

-1
a1 (2)
a4
a7
1
-1
a2
a5
a8
1
-1
a3
a6
a9
1
-1 (<- start of second time step)
a1 (17)
a4
a7
1
-1
a2
a5
a8
1
-1
a3
a6
a9
1
...

Here, a1 was at index 2 and 17 (one based).

Now if I were to add a constraint that included x1, for example,

    [ c1 a2 a3 ]
C = [ 0 0 0 ]
    [ 0 0 0 ]

% [0] ≤ [  C  0  ...  0 | 0 0 ... 0 ] [ x ] ≤ [0]      %  0 ≤ c*x1 ≤ 0                 }

all the CSC data vector indices shift in an odd way

-1
a1 (2)
a4
a7
1
c1
-1
a2
a5
a8
1
c2
-1
a3
a6
a9
1
c3
-1 (<- start of second time step)
a1 (20)
a4
a7
1
-1
a2
a5
a8
1
-1
a3
a6
a9
1

Now a1 exists at indices 2 and 20 (again 1 based).

I am capable of making that mapping manually but it's super tedious when trying to turn constraints on/off and compare problems. I can't figure out how to create an automatic "index map" of the raw MPC data and the final CSC data vector.

(And my MPC is intended for embedded so the CSC structure is "fixed" at runtime but, at runtime, I can't reuse the sparse functions I used to setup the problem in the first place.)