Bounded cumulative sum?

Question

How can I do a cumulative sum over a vector (like cumsum), but bounded so that the summation never goes below a lower bound or above an upper bound?

The standard cumsum function would result in the following.

foo <- c(100, -200, 400, 200)
cumsum(foo)
# [1]  100 -100  300  500

I am looking for something as efficient as the base cumsum function. I would expect the output to look like the following.

cumsum.bounded(foo, lower.bound = 0, upper.bound = 500)
# [1]  100  0  400  500

Thanks

Answer 1

As mentioned in the comments, Rcpp is a good way to go.

cumsumBounded.cpp:

#include <Rcpp.h>
using namespace Rcpp;
// [[Rcpp::export]]                                                             
NumericVector cumsumBounded(NumericVector x, double low, double high) {
  NumericVector res(x.size());
  double acc = 0;
  for (int i=0; i < x.size(); ++i) {
    acc += x[i];
    if (acc < low)  acc = low;
    else if (acc > high)  acc = high;
    res[i] = acc;
  }
  return res;
}

Compile and use new function:

library(Rcpp)
sourceCpp(file="cumsumBounded.cpp")
foo <- c(100, -200, 400, 200)
cumsumBounded(foo, 0, 500)
# [1] 100   0 400 500

Answer 2

I suppose this might work.

library ("Rcpp")

cumsum.bounded <- cppFunction(
    'NumericVector cumsum_bounded (NumericVector x, const double lower, const double upper) {

        double acc = 0;
        NumericVector result(x.size());

        for(int i = 0; i < x.size(); i++) {
            acc += x[i];

            if (acc < lower) acc = lower;
            if (acc > upper) acc = upper;

            result[i] = acc;
        }

        return result;
    }')