Ggtkuk

You could save a sum and add the values.

var array = [[1, 1, 1, -1], [1, -1, -1], [1, 1]],
 result = array.map(a => a.map((s => v => s += v)(0)));

console.log(result);

By using forEach, you need to take the object reference and the previous value or zero.

var array = [[1, 1, 1, -1], [1, -1, -1], [1, 1]];

array.forEach(a => a.forEach((v, i, a) => a[i] = (a[i - 1] || 0) + v));

console.log(array);

A version with map.

const changes = [
 [1, 1, 1, -1],
 [1, -1, -1],
 [1, 1]
];

const values = changes.map(array => 
 let acc = 0;
 return array.map(v => acc += v);
);

console.log(values);

.as-console-wrappertop:0;max-height:100%!important

And this doesn't change the source Array.

New ESNext features of generators are nice for this.

Here I've created a simple sumpUp generator that you can re-use.

function* sumUp(a) 
 let sum = 0;
 for (const v of a) yield sum += v;


const changes = [ [1, 1, 1, -1], [1, -1, -1], [1, 1] ];
const values = changes.map(a => [...sumUp(a)]);
 
console.log(values);

You may use map function of Array

const changes = [ [1, 1, 1, -1], [1, -1, -1], [1, 1] ]; 
const result = changes.map((v) => v.slice(0).map((t, i, arr) => i === 0 ? t : (arr[i] += arr[i - 1])))
console.log(changes);
console.log(result);

Update

Use slice to clone array. This will prevent changes to the original array.

Here is an easier to read way that iterates over the outer list of arrays. A copy of the inner array is made to keep the initial values (like [1, 1, 1, -1]). It then iterates over each value in the copied array and adds it to each index after it in the original array.

var changes = [[1, 1, 1, -1], [1, -1, -1], [1, 1]];
changes.forEach(subArray => 
 var subArrayCopy = subArray.slice(); 	// Create a copy of the current sub array (i.e. subArrayCopy = [1, 1, 1, -1];)
 subArrayCopy.forEach((val, index) => 	// Iterate through each value in the copy
	for (var i = subArray.length - 1; i > index; i--) // For each element from the end to the current index
 subArray[i] += val;	 // Add the copy's current index value to the original array
	
 );
)
console.log(changes);

Another way,

You can use .map to return your new array with the desired results. By using .reduce with an array as an accumulator, you can generate the subarray.

var array = [[1, 1, 1, -1], [1, -1, -1], [1, 1]],
 result = array.map(a => a.reduce((ac, v, i) => 0;
 return [...ac, lastVal + v];
 , []));

console.log(result);

// shorter
result = array.map(a => a.reduce((ac, v, i) => [...ac, (ac[i-1] || 0) + v], []));
console.log(result);

You have an array of arrays, but each constituent array is independent from the next so let's tackle them individually. Let's talk about [1, 1, 1, -1].

Your use of the phrase "partial sum" is very informative. The full sum could be implemented using reduce:

[1, 1, 1, -1].reduce((x, y) => x + y);
// 2

But you want an array of partial sums. That's very similar to this usage of reduce, but instead of retaining only the last computed result, we retain every intermediate value too. In other languages, this is called scan (cf. F#, Haskell).

A javascript implementation of a generic scan would probably look a lot like reduce. In fact, you can implement it with reduce, with just a little extra work:

function scan(array, callback) 
 const results = [array[0]];

 // reduce does all the heavy lifting for us, but we define a wrapper to pass to it.
 array.reduce((...args) => 
 // The wrapper forwards all those arguments to the callback, but captures the result...
 const result = callback(...args);
 // ...storing that intermediate result in our results array...
 results.push(result);
 // ...then passes it back to reduce to continue what it was doing.
 return result;
 );

 return results;


// scan([1, 1, 1, -1], (x, y) => x + y) -> [1, 2, 3, 2]

A more robust implementation would hew closer to the standard library's reduce, especially around initial values:

function scan(array, callback, initialValue) 
 const results = [];

 const reducer = (...args) => 
 const result = callback(...args);
 results.push(result);
 return result;
 ;

 if (arguments.length === 2) 
 results.push(array[0]);
 array.reduce(reducer);
 else 
 results.push(initialValue);
 array.reduce(reducer, initialValue);
 

 return results;

Bringing it back together, if you'd like to do this for your arrays of arrays, it would just be a map over scan:

[[1, 1, 1, -1], [1, -1, -1], [1, 1]].map(a => scan(a, (x, y) => x + y));
// [[1, 2, 3, 2], [1, 0, -1], [1, 2]]

No copying necessary or side effects to watch out for, and you get a handy higher-order function out of it to boot!