Add values from a list, at positions from a list, to a matrix

Question

I'm investigating matrix assembly and one of the things I'm trying to do is add specific values to a larger matrix based on a list which is essentially defining connectivity of nodes.

For example: Start with a null matrix, for this example a 6x6 will be selected.

m=ConstantArray[0, {6, 6}]

If I want to add 2 to the value at position {3,4} I can use the following code.

m=ReplacePart[m, {3, 4} -> (Part[m, 3, 4] + 2)]

What I would like to do is feed this process via lists though. Creating a list of values to be added.

v={{2},{3},{4}}

Creating a list of locations to add these values.

locs = {{1, 2},{1,3},{1,4}}

Combining these two lists so that it gives {value, loc} as a new list

comb = Partition[Flatten[Riffle[v, locs]], 3]

Trying to map this new list comb across the matrix m using ReplacePart

f = ReplacePart[m,{#[[2]], #[[3]]} -> (Part[m, #[[2]], #[[3]]] + #[[1]])] & /@ comb

If my feeder list (comb) only have a single entry, the code runs, but I get an extra level added to m, which I can Flatten out afterwards.

EDIT Values may be added to the same location several times and so methods need to keep a running total.

However, once I get two or more entries to my feeder list I get a new matrix for each iteration, which makes sense but not what I want.

I'm missing something here as it's creating a new entry for each time the list is mapped across. When the intention is to add the values in the list to the existing values at a certain position and return the new updated matrix.

I'm guessing to get a single matrix with all of the values added to the exising values will need an approach that writes the new matrix to m before running the next element in the list. Perhaps using something similar to a Do or maybe Module (which are a complete mystery to me).

I'm hoping my code and description is clear and that I'm not too far away from a working solution.

Any help gratefully appreciated.

Answer 1

(Untested, so CW)

Consider using MapThread[] along with ReplacePart[]:

MapThread[ReplacePart[m, #1 :> Extract[m, #1] + #2] &, {{{1, 2}, {1, 3}, {1, 4}}, {2, 3, 4}}]

---

Another possibility involves the use of SparseArray[]:

SetSystemOptions["SparseArrayOptions" -> {"TreatRepeatedEntries" -> 1}];
pos = {{1, 2}, {1, 3}, {1, 4}};
add = {2, 3, 4};
m + SparseArray[Thread[pos -> add], Dimensions[m]]

The little piece of black magic on top is needed if you have repeated entries in pos; this will add up the corresponding entries together.

Answer 2

The "TreatRepeatedEntries" method may be impossible to beat but the more mundane method is to use AddTo. Starting with the definitions in your question:

v = {{2}, {3}, {4}};

locs = {{1, 2}, {1, 3}, {1, 4}};

m = ConstantArray[0, {6, 6}];

comb = Partition[Flatten[Riffle[v, locs]], 3];

We need merely:

m[[##2]] += # & @@@ comb;

Now:

m

{{0, 2, 3, 4, 0, 0},
 {0, 0, 0, 0, 0, 0},
 {0, 0, 0, 0, 0, 0},
 {0, 0, 0, 0, 0, 0},
 {0, 0, 0, 0, 0, 0},
 {0, 0, 0, 0, 0, 0}}

Answer 3

put all your added values in a sparse array of same dimension and add the whole matrix:

 m = ConstantArray[0, {6, 6}]
 v = {2, 3, 4, 6}
 locs = {{1, 2}, {3, 3}, {1, 4}, {1, 2}}

the GatherBy in here is taking care of repeated positions (Note @GuessWhoItIs shows a cleaner approach , this does not rely on remembering an undocumented system option however.. )

 m + SparseArray[#[[1, 1]] -> Total[#[[All, 2 ]]] & /@ 
     GatherBy[ Transpose[{locs, v}] , #[[1]] & ], 
     Dimensions@m] // MatrixForm

just this if you know you don't repeat positions:

 m + SparseArray[Rule @@@ Transpose[{locs, v}], Dimensions@m];

Answer 4

How about using MapAt?

pos = {{1, 2}, {1, 3}, {1, 4}, {2, 6}, {2, 6}};
add = {2, 3, 4, 10, 11};

Block[{i = 0, a = Reverse@add[[Ordering@pos]]}, 
 MapAt[(i++; Plus[#, a[[i]]]) &, m, pos]]

Not the most elegant, but seems to work well, and handles repeat indices. It seems MapAt does some weird ordering of the indices before applying them. Maybe the community can comment on why.

Answer 5

m = ConstantArray[0, {6, 6}]
v = {{2}, {3}, {4}}
locs = {{1, 2}, {1, 3}, {1, 4}}
comb = Partition[Flatten[Riffle[v, locs]], 3]

result = Fold[
             ReplacePart[#1, {#2[[2]], #2[[3]]} -> 
                  Part[#1, #2[[2]], #2[[3]]] + #2[[1]]] & , m, comb]

{{0, 2, 3, 4, 0, 0}, {0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0},   
   {0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0},  {0, 0, 0, 0, 0, 0}}

Positions might be duplicated.
For example with locs={{1,2},{1,2},{1,2}} and v = {{2}, {3}, {4}}it gives the total 2+3+4 at position {1,2} :

{{0, 9, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0}, 
   {0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0}}