Avoiding procedural programming

Questions
1

I am very new to Mathematica and have to rethink my ‘procedural’ ways of programming. That is not always easy. I am making progress, but here I have no clue, besides going down the ‘repeat and if’ rabbit hole.

I create a list of random integers.
I have a Dynamic Slider to adjust delta (between 0 and 20).
Let’s say the Slider is adjusted to value 10.

Now I want all the integers in the list that are 10 or less apart, to become the same integer.

E.g. myIntegers = {11,28,66,36,94,8,44}

After the ‘treatment’ the list should be :
{11,28,66,28,94,11,44} The 36 is within 10 from 28 and the 8 is also within 10 from 11, so in both cases the integer within the delta range gets to be the value of the first (36 becomes 28).

How could I go about this problem in a functional or symbolic way?

2

I think your problem is not uniquely to be solved - or I do not understand what you want.

Something like this? Neither gives the answer you asked for, but numbers fulfilling your criterion are substituted.

tt = {11, 28, 66, 36, 94, 8, 44}
tt /. (Rule[#[[1]], #[[2]]] & /@ 
   Select[Flatten[Outer[List, tt, tt], 1], And[0 <= Abs[#[[1]] - #[[2]]] <= 10, #[[1]] < #[[2]]] &])

or

tt /. (Rule[#[[1]], #[[2]]] & /@ 
   Select[Flatten[Outer[List, tt, tt], 1],  And[0 <= Abs[#[[1]] - #[[2]]] <= 10, #[[1]] > #[[2]]] &])
3

Instead of giving you code, I’ll give you one idea how you might try to think about this functionally.

You have to write a function. One way might be to create a function that takes two arguments, the list of items processed thus far and the list of items not yet processed.

All functional programs need a test to tell if they are finished. In this function it is finished if the second argument is empty and in that case it just returns the first argument.

If it is not finished then it takes the first item from the unprocessed list, perhaps uses the Mathematica function Nearest to test whether that item is close enough or not, and calculates the next item to append to the processed list.

Can you convince yourself that this modification process of the next item in the unprocessed list does not somehow corrupt the definition of the problem? That might or might not be exactly true. Perhaps try thinking of some really strange cases that might make this behave oddly.

Then the function calls itself with the new longer processed list and the new shorter unprocessed list.

Can you figure out what the thinking process was to get there? That is the most important step, much more important than what the answer is.

Can you convince yourself that this exactly correctly implements your description? And that your description is exactly correct?

Could you then start thinking if there might be any other way to implement this functionally?

4

It is not clear how you want to handle certain cases (for example, does the 11 take precedent over the 8 because it came first? What about the 28, 36, and 44 – they are within 10 of each other but span more than 10. These details need to be worked out)

One suggestion is to use Differences and Position and then Replace values in your list.

Not a complete answer because I do not understand what you actually want, but you can do:

In[1]:= Sort[myints]

Out[1]= {8, 11, 28, 36, 44, 66, 94}

and

In[1]:= Differences[Sort[myints]]

Out[1]= {3, 17, 8, 8, 22, 28}

and

In[2]:= Position[Differences[Sort[myints]], n_ /; n <= 10]

Out[2]= {{1}, {3}, {4}}

These positions point to the 8, the 28 and 36 in the sorted list. If you shift them by one, they point to the 11, the 36, and the 44 in the sorted list. You can now write a something to map replacement rules on the original list – For example, replacing the 8 with 11, 28 with 36, or vice versa.

Hope this helps.

Regards

5

With these answers I certainly can move on. Thanks.
Hans : I think your second example works, but I really need to study it to get it. It’s more compact than the code I write at my current level of Mathematica.

I certainly appreciate the answer of Bill Nelson, as it gives me a direction in which way to think. This is exactly what I need, a new way to think about solutions. GREAT :slight_smile:

Neil : I agree. I should have been clearer in my question. I took the first number and adapted the next one within the delta range to become as the first. I could have taken the second or the mean.
And my example, I noticed is indeed a bit double, in that 44 is also within the range of 36, which in its turn is within the range of 28. I have to rethink how I want that to be solved.

But for now, I will take time to study the answeres and play with them. Thanks agian, this really helps my understanding of this wonderfull new language and way of thinking.
I’ll get back after working with the new ideas.

Best, Beat

6

Neil, I understand your idea. I had been thinking of sorting the list, to make things easier. Unfortunately, I need (at least in the end) , the order to be like it was in the first place, but with the adapted numbers. But the original order needs to be preserved.

Still ‘Position[ ]’ might be a valuable tip

7

The idea was to sort the list, establish replacement rules and apply that to the *original * list in order.

I’m traveling now but I’ll post an example later.

Regards

8

Another approach, still not giving exactly what you want, but your conditions are fulfilled

tt = {11, 28, 66, 36, 94, 8, 44}

newt[t_] := Module[{},
  t1 = Flatten[Cases[#, {x_, y_} /; x < y] & /@ Outer[List, tt, tt], 
    1];
  t2 = Cases[t1, {x_, y_} /; 0 < Abs[x - y] <= 10];
  rr = Rule @@@ (Reverse /@ t2);
  tt /. rr
  ]

FixedPoint[newt, tt]

(*  {8, 28, 66, 28, 94, 8, 36}  *)
9

This is what I had in mind. Obviously you need to decide what should be replaced:

In[5]:= sorted = Sort[myints]

Out[5]= {8, 11, 28, 36, 44, 66, 94}

In[6]:= difs = Differences[Sort[myints]]

Out[6]= {3, 17, 8, 8, 22, 28}

In[7]:= pos = Position[Differences[Sort[myints]], n_ /; n <= 10]

Out[7]= {{1}, {3}, {4}}

In[8]:= rules = 
 MapThread[
  Rule[#1, #2] &, {Extract[sorted, pos], Extract[sorted, pos + 1]}]

Out[8]= {8 -> 11, 28 -> 36, 36 -> 44}

In[9]:= myints

Out[9]= {11, 28, 66, 36, 94, 8, 44}

In[10]:= myints /. rules

Out[10]= {11, 36, 66, 44, 94, 11, 44}
10

Maybe a few more ideas here, I have made a slight alteration to the original list to give a more varied outcome. The code wouldn’t be very efficient for large lists or particularly fast, anyway here it is.

delta = 10; myint = {11, 35, 28, 66, 36, 94, 8, 44}


ss = Subsets[myint, {2}]


css = Cases[ss, {a_, b_} /; Abs[a - b] <= delta]


Do[If[Length[css] > 0, p = Flatten[Position[myint, css[[i, 2]]]]; 
  myint[[p]] = css[[i, 1]]], {i, 1, Length[css]}]; myint
11

Hi Hans, thanks again for your contribution.

All right, here the bigger number that is within the range gets replaced by the smaller. That is also all right with me.

Your solution is setting the bar quite high for me - which is great, but I need time to really explore your solution bit by bit. And live a lot in the documentation :slight_smile:

I found the following :

  1.   Outer[List, tt, tt], 1   makes an Array with all the possible 2 number combinations from the original list tt, which are 49 in total (7^2). So that I got.

  2. Cases[#, {x_, y_} /; x < y] & is a pure function which searches for the pattern x<y The Flatten gives eventually back to t1 an array with the first number < second number. (21 lists left).

  3. t2 = Cases[t1, {x_, y_} /; 0 < Abs[x - y] <= 10]
    Here only the lists that comply to the range criterion of 10 are included in t2.

 I think the bigger than zero part (0 < Abs[ ) could be left out, as the lists with equal numbers have already been filtered out.
  1. rr = Rule @@@ (Reverse /@ t2) I see what it does, but do not understand the syntax. Could you explain a bit ?

From the doc : f@@@expr or Apply[f,expr,{1}] replaces heads at level 1 of expr by f.
I don’t get this.

I tried to rewrite the line into for me more familiar form ; rr = Apply[Rule[ Map[Reverse], t2]] But this does not work.
How could the line be written with Apply[] and map[] ?

  1. tt /. rr         This I get. The rules of rr are applied to my original list.

I understand FixedPoint.
But why does FixedPoint not continue and also replace ’36’ with ’28’? The rule 36->28 is present in rr.

I also don’t get the very beginning :

newt[t_] := Module[{}, I guess the Module just protection and not really essential. But what is the {} just after.

Thanks a lot :slight_smile:

12

The speed is not an issue, as the lists will be max 100 numbers.
I am baked for today with trying to wrap my head around hans’ solution. I’ll look into yours tomorrow. But many thanks for your input. To get ideas and solutions from experienced users really opens my eyes (and wears my brain :slight_smile:

13

Sorry, wrong click.

14

Here is again a different approach.
Define a function, which finds for each element in a list the preceeding elements with a difference <= 10 and additionally their positions in the list. As there may be more than one the result is given as

{ Position of element, element ee, { e1, e2, …} }

with Abs [ ee - ei ] <= 10.

(In the example we have always only one ei )

Then it is possible to replace ee by one of the ei’s.

Clear[fF];
fF[x_, tT_] := Module[{},
  pp = Position[tT, x][[1, 1]];
  If[pp == 1, Return[0]];
  tH = Take[tT, pp - 1];
  aL = Select[tH, Abs[# - x] <= 10 &];
  res = If[aL =!= {}, {pp, x, aL}, 0];
  res
  ]

tt = {11, 28, 66, 36, 94, 8, 44}
res1 = DeleteCases[fF[#, tt] & /@ tt, 0]
res2 = {#[[1]] -> #[[3, 1]]} & /@ res1 // Flatten
tt = ReplacePart[tt, res2]

But this still does not give what you want, because the last 44 is replaced by 36.

15

Hello B.,

I think the bigger than zero part (0 < Abs[ ) could be left out, as the lists with equal numbers have >already been filtered out.

you are right.

rr = Rule @@@ (Reverse /@ t2)

I see what it does, but do not understand the syntax. Could you explain a bit ?

Reverse changes the order in the elements of t2 : { a, b } becomes { b, a }

Rule@@@ changes the heads of the elements of t2 . { b, a } becomes b → a

Written out you should try

rr =Apply[Rule, Map[Reverse, t2], {1}]
t2/.rr

Regards, Hans.
If you have more questions please feel free to contact me by mail ( h.dolhaine@gmx.de)

16

I understand FixedPoint. But why does FixedPoint not continue and also replace ’36’ with ’28’? The >rule 36->28 is present in rr.

In fact the fixedpoint is not necessary. One has to provide that rr is applied until there is no more change.

tt = {11, 28, 66, 36, 94, 8, 44}

newt[t_] := 
 Module[{}, 
  t1 = Flatten[Cases[#, {x_, y_} /; x < y] & /@ Outer[List, tt, tt], 
    1];
  t2 = Cases[t1, {x_, y_} /; 0 < Abs[x - y] <= 10];
  rr = Rule @@@ (Reverse /@ t2);
  tt //. rr]

newt[tt]

I also don’t get the very beginning :

newt[t_] := Module[{}, I guess the Module just protection and not really essential. But what is the {} >just after.

hmmm. I use Module to write longer subprograms. The {} encloses variables (here none) which are local to the Module and not visible in main.

17

If you just want to replace the higher values with the lower values, I think this does the trick.

scrubber[x_List] := 
Module[{pos, sorted}, sorted = Sort[x]; 
pos = Position[Differences[Sort[myints]], n_ /; 0 < n <= 10]; 
x /. MapThread[
Rule[#1, #2] &, {Extract[sorted, pos + 1], Extract[sorted, pos]}]]

myints = {11, 28, 66, 36, 94, 8, 44}

In[20]:= FixedPoint[scrubber, myints]

Out[20]= {8, 28, 66, 28, 94, 8, 28}
18

B. Cornas:

Try the following:

Clear[lappingShuffles, myIntegers];
myIntegers = {11, 28, 66, 36, 94, 8, 44};
lappingShuffles[x_List, n_] := Module[{},
  Map[First[#[[1]]] &,
   Table[MinimalBy[
     Table[Select[
        Table[{x[[i]], Interval[{x[[i]] - n, x[[i]] + n}] , i}, {i, 
          Length[x]}],
        IntervalMemberQ[#[[2]], x[[j]]] & ], {j, Length[x]}][[k]],
     Last ], {k, Length[x]}]
   ]
  ];
lappingShuffles[myIntegers, 10]
(* {11, 28, 66, 28, 94, 11, 36} *)

Manipulate[lappingShuffles[myIntegers, n], {n, 0, 20, 1}]

Some refactoring may still be needed. But this is what I can quickly post. Also may need further code changes depending on what the final ruling is on the last entry on the list is it 44 or 36?

19

Hi Neil,
As you indicated, I had not clearly defined my problem. For me it was not so important whether the bigger number got repacked by the smaller or vice versa. Now I think it would be nice to take the mean of the two. This would also resolve the problem I had not noticed in my example list of integers.

{11, 28, 66, 36, 94, 8, 44}

You had rightly noticed that there are three numbers within the 10 range : 28,36,44.
So to resolve situations like this, and anyhow, it might be best to take the rounded mean for the numbers that are within the defined range of 10. So eventually the list would become {9 , 36 ,66, 36 , 94 , 9 , 36}

I can follow your approach,Neil,and I like the seemingly ‘Wrong’ move away from the solution (the sorting), only to come back strong further on.

I just notice in your last post, that you have solved the ’28,36,44’ problem as well. Here letting the smallest number prevail.

I can tag along your solution (although I would not have been able yet to come up with it), just the following line is still unclear to me :

scrubber[x_List] := Module[{pos, sorted}, sorted = Sort[x];

Is [x_List] the same as [x_] but for Lists?

The part after the := I don’t get. What is ‘x’, f.i.?

Thanks, Neil

20

For me takes time to study all your very welcome inputs, and that is the reason that my replys are slow :slight_smile:
But be sure that I’ll study all of them.