Simplifying nested If statements

Question

Consider :

list = {100,102,103,99,106,107,104,112}

I want to consider, extract only the "big moves" of that time series. In this case the moves bigger then 5 from the moving point of reference.

The pseudo code would go as such :

Let's assume you have the data x(t) for t=1 to T,

You start from the first data point, z(1) = x(1)

if abs(x(2)-z(1))> delta, 
    z(2)= x(2), 
elseif abs(x(3)-z(1))> delta, 
    z(2)= x(3), 
elseif abs(x(4)-z(1))> delta, 
    z(2)= x(4),    
    if abs(x(5)-z(2))> delta, 
        z(3)= x(5), 
    elseif abs(x(6)-z(2))>delta, 
        z(3)= x(6),
        if abs(x(7)-z(3))>delta, 
            z(4)=x(7)
        endif
    endif
endif

I tried to write it with an If statement, but I don't know when my test is going to pass thus, how many Ifs to nest.

If[Abs[list[[2]]-list[[1]]]>5,
   list[[2]],
             If[Abs[list[[3]]-list[[1]]>5,
             list[[3]]....

Here this process will stop at list[[5]] with Abs[list[[5]]-list[[1]]=6

At this point, list[[5]] becomes my new point of reference :

 If[Abs[list[[6]]-list[[5]]]>5,
     list[[6]],
              If[Abs[list[[7]]-list[[5]]>5,
             list[[7]]....

So my desired output is the following :

{100,106,112}

I am pretty sure, this type of operation has a name but I don't know it. It felt like a While[] or For[] but I can`t figure it out. Please let me know how to improve the question.

Answer 1

In contrast to the very fast methods presented, let me give you a maybe more easy to understand solution (while this in the eye of the beholder). Basically it's sort of the way I would implement it in Haskell.

Assume you want to solve your problem step by step and in each step you have your data in the form {res, in} where res is your current solution and in is the rest of the input which needs to be processed. The initial situation is that the list res contains your first element and in contains the rest of the input. Let's go through the two possible situations:

• Since res is your current output, you always want to compare the last element of this with the first element of your in list. When the absolute difference is larger then 5, you want to append this first element of in to your res list.

• In all other cases, you just want to throw away the first element of in and leave res untouched.

You want to iterate this as long as there are elements in your input. Thats all, and you can write it directly down:

step[{res_, in_}] := {Append[res, First[in]], Rest[in]} /; 
  Abs[Last[res] - First[in]] > 5;

step[{res_, in_}] := {res, Rest[in]};

NestWhile[step, {{100}, {102, 103, 99, 106, 107, 104, 112}}, 
 Length[Last[#]] > 0 &]

(* {{100, 106, 112}, {}} *)

You see that after your input list is empty, you have collected your result.

Answer 2

Something along these lines could work:

Reap[
  Sow[ z = list[[1]] ];
  Scan[If[Abs[# - z] > delta, Sow[z = #]] &, list]
][[2, 1]]

Answer 3

I favor Fold over Scan. I find it faster, and it does without an additional variable.

Reap[
  Fold[If[Abs[#2 - #] > delta, Sow[#2], #] &, Infinity, list];
][[2, 1]]

---

500 asked:

How could I now store as a sublist every element skipped in between the z points in addition to the the z point themselves. I would like to have the list of the coordinates that do not pass the test, but sublists for each group of point skipped in between two Sow[].

This is the cleanest method I could think of:

list = {100, 102, 103, 99, 106, 107, 104, 107, 112};

idx =
  Reap[i = 0;
    Fold[If[++i; Abs[#2 - #] > delta, Sow[i]; #2, #] &, Infinity, list];
  ][[2, 1]];

MapThread[list[[# ;; #2]] &, {idx, Append[Rest@idx - 1, -1]}]

{{100, 102, 103, 99}, {106, 107, 104, 107}, {112}}

The output is a list of sublists, each starting with a "z point" and continuing with intervening elements before the next point.

Answer 4

Here is a slightly faster version based on FoldList and Split.

Split[
  FoldList[If[Abs[#2 - #] > delta, #2, #] &, Infinity, list]
][[2 ;;, 1]]

Answer 5

Here's another approach, based on a recursive function and pattern matching.

MinDifference[list_, d_] := MinDifference[{First[list]}, Rest[list], d]

MinDifference[store_, {}, d_] := store

MinDifference[{store___, s_}, {v_, list___}, d_] /; Abs[v-s] > d := 
   MinDifference[{store, s, v}, {list}, d]

MinDifference[{store___}, {v_, list___}, d_] := 
   MinDifference[{store}, {list}, d]

---

MinDifference[{100, 102, 103, 99, 106, 107, 104, 112}, 5]

{100, 106, 112}

MinDifference[{100, 102, 103, 99, 106, 107, 104, 107, 112}, 5]

{100, 106, 112}

Answer 6

Another yet-another possibility is ReplaceRepeated:

Define

crossings = ({{First[#1]}, #1}) //. 
({a_, {Shortest[b__], e___}} /; (Abs[First@{b} - Last@{b}] > #2) 
 :> {Insert[a, Last@{b}, -1], {Last@{b}, e}}) &

Usage:

 crossings @@ {list, 5}   

gives

{{100, 106, 112}, {112}}

the first part of which gives the desired result:

 crossings @@ {list, 5} //First
 (* ==> {{100, 106, 112} *) 

An alternative is using ReplaceAll in combination with FixedPointList:

 crossingList[list_, delta_] := 
 First /@ Most@
 FixedPointList[#1 /. ({Shortest[a__], b___} /; 
 (Abs[First@{a} - Last@{a}] > delta) 
 :> {Last@{a}, b}) &, list]