## Assigning a value to each range of consecutive numbers with same sign in R

I'm trying to create a data frame where a column exists that holds values representing the length of runs of positive and negative numbers, like so:

```
Time V Length
0.5 -2 1.5
1.0 -1 1.5
1.5 0 0.0
2.0 2 1.0
2.5 0 0.0
3.0 1 1.75
3.5 2 1.75
4.0 1 1.75
4.5 -1 0.75
5.0 -3 0.75
```

The `Length`

column sums the length of time that the value has been positive or negative. Zeros are given a `0`

since they are an inflection point. If there is no zero separating the sign change, the values are averaged on either side of the inflection.

I am trying to approximate the amount of time that these values are spending either positive or negative. I've tried this with a `for`

loop with varying degrees of success, but I would like to avoid looping because I am working with extremely large data sets.

I've spent some time looking at `sign`

and `diff`

as they are used in this question about sign changes. I've also looked at this question that uses `transform`

and `aggregate`

to sum consecutive duplicate values. I feel like I could use this in combination with `sign`

and/or `diff`

, but I'm not sure how to retroactively assign these sums to the ranges that created them or how to deal with spots where I'm taking the average across the inflection.

Any suggestions would be appreciated. Here is the sample dataset:

```
dat <- data.frame(Time = seq(0.5, 5, 0.5), V = c(-2, -1, 0, 2, 0, 1, 2, 1, -1, -3))
```

Show source

## Answers ( 4 )

This works, at least for your test case. And it should be pretty efficient. It makes some assumptions, I'll try to point out the big ones.

First we extract the vectors and stick 0s on the beginning. We also set the last

`V`

to 0. The calculation will be based on time differences between 0s, so we need to start and end with 0s. Your example seems to tacitly assume`V = 0`

at`Time = 0`

, hence the initial 0, and it stops abruptly at the maximum time, so we set`V = 0`

there as well:To fill in the skipped 0s, we use

`approx`

to do linear approximation on`sign(V)`

. It also assumes that your sampling frequency is regular, so we can get away with doubling the frequency to get all the missing 0s.The values we want to fill in are the durations between the 0s, both observed and approximated. In the correct order, these are:

Lastly, we need the indices of the original data to fill in the durations. This is the hackiest part of this answer, but it seem to work. Maybe someone will suggest a nice simplification.

First find indices of "Time" which need to be interpolated: consecutive "V" which lack a zero between positive and negative values; they have an

`abs(diff(sign(V))`

equal to two.Add rows with average "Time" between relevant indices and corresponding "V" values of zero to the original data. Also add rows of "V" = 0 at "Time" = 0 and at last time step (according to the assumptions mentioned by @Gregor). Order by "Time".

Calculate time differences between time steps which are zero and replicate them using "zero-group indices".

Add values to original data:

Set "Length" to

`0`

where`V == 0`

.It took me longer than I care to admit, but here is my solution.

Because you said you wanted to use it on large datasets (thus speed matters) I use Rcpp to write a loop that does all the checking. For speed comparisons I also create another sample dataset with 500,000 data.points and check the speed (I tried to compare to the other datasets but couldn't translate them to data.table (without that it would be an unfair comparison...)). If supplied, I will gladly update the speed-comparisons!

## Part 1: My solution

My solution looks like this:

(in

`length_time.cpp`

)and then in an R-file (i.e.,

`length_time.R`

):Which seems to work on the sample dataset.

## Part 2: Testing for Speed

Which results in a dataset with 985 observations (crossings).

Testing the speed with microbenchmark results in

Resulting in about 3 milliseconds for calculating with 500,000 observations.

Does that help you?

Here is my attempt done completely in

`base R`

.Here is the output of the given example:

Here is a larger example:

As @Gregor pointed out, the goal is to find the x-distance between each occurrence of zero. This can be seen visually by plotting (again, as pointed out by @Gregor (many kudos btw)). For example, if we plot the first 20 values of

`datBig`

, we obtain:From this, we can see that the x-distances such that the graph is either positive or negative (i.e. not zero (this happens when there are repeats of zeros)) are approximately:

Well, it seems the

`Rcpp`

solution provided by David is not only accurate but blazing fast.