There is a snag I've ran into already a couple of times and so I do here.

When I make a variable that gets it's value (here a List) from a Dynamic[ xxxx code xxxxx], then I cannot work with that variable anymore.
E.g.

resizeFactor = 0.8;
Row[{Slider[Dynamic[resizeFactor], {0.1, 2}]}]

ptsSeedX = Table[RandomInteger[100], numLinesMax];

(*   make scaled copies and displace them  *)

resize1X =   Dynamic[Round[Times[ptsSeedX, resizeFactor]]]

offsetX = RandomInteger[{-50, 50}]   (* A  random OffsetX  *)

 (*   BOTH LINES BELOW DO NOT WORK   *)

displace1X = resize1X + offsetX   
displace1X ={ resize1X} + offsetX

I get something in the form of : 20+{24,23,47,11} being the OffsetX + the List "resize1X"

I suspect (also from other situations) that the Dynamic causes the non-functioning. How can I keep the Dynamic and still get the last line working?

See if the following helps:

Clear[lappingMeanShuffles, gatherlappingShuffles, lappingShuffles, shuffleInterval, myxIntegers, myyIntegers];

myxIntegers = {11, 28, 66, 36, 94, 8, 44};
myyIntegers = {41, 13, 82, 26, 43, 74, 46};

shuffleInterval[x_List, n_] := Module[{}, Map[({Interval[{# - n, # + n}], #}) &, x]];
lappingShuffles[x_List, n_] := Module[{z = shuffleInterval[x, n]}, Map[Function[y, Select[z, IntervalMemberQ[#[[1]], y] &]], x]];
gatherlappingShuffles[x_List, n_] := Module[{z = lappingShuffles[x, n]}, Map[(#[[All, 2]]) &, z]];
lappingMeanShuffles[x_List, n_] := Module[{z = gatherlappingShuffles[x, n]}, Map[Floor[Mean[#]] &, z]];
Manipulate[Graphics[Map[Line[#] &, Partition[Transpose[{lappingMeanShuffles[myxIntegers, n], lappingMeanShuffles[myyIntegers, a]}], 2, 1]]], {n, 0, 20, 1}, {a, 0, 20, 1}]

With these parameters (n = 20, a = 14) and the myx..., myy... points we get the resulting image.

If you don't wish to deal with Interval :

(* shuffleInterval[x_List, n_] :=  Module[{}, Map[({{# - n, # + n}, #})&, x] ]; 
 lappingShuffles[x_List, n_] := Module[{z = shuffleInterval[x, n]}, Map[Function[y, Select[z, Between[y ,#[[1]] ]&] ], x]]; *)

The functions were broken up to make it easier to follow the code but it can be written back into just one function:

concatShuffle[x_List, n_] := 
  Module[{}, 
   Map[Floor[Mean[#]] &, 
    Map[(#[[All, 2]]) &, 
     Map[Function[y, 
       Select[Map[({Interval[{# - n, # + n}], #}) &, x], 
        IntervalMemberQ[#[[1]], y] &]], x]] ] ];
concatShuffle[{11, 28, 66, 36, 94, 8, 44}, 10]
(* {9, 32, 66, 36, 94, 9, 40} *)

` Thanks

Hi Hans, It's a tough cockie that you baked for me :-) Tough in the sense that I cannot yet get my fingers behind it. I'll need more time to explore you're code.

Still, I played around with the Manipulate and added some little things to see the workings better. E.g. I make the original lists for the x- and y- coordinates by using RandomIntegers. Also I included a definite ImageSize, so the graphis does not jump so much when adjusting the sliders.

One thing that I noticed, that when there are 3 or more integers within the Delta range of each other, you dot not get exactly the mean of all of them, but I guess a mean from first the numbers #1 and #2, then that mean is put together with #3 and the new mean is taken, etc. That comes down that later numbers have a bigger weight in the mean. I am not totally sure, as as I cannot see that in the code, but it's an inference from the results.

Also I am in the process of rewriting the code without the Manipulate, but with Dynamic Sliders and other Dynamic controls. I think that gives me a bit more flexibility in the end. But I have not succeeded as yet, mainly because I do not understand the functions in your code all that well. I will study on it more. best, Beat

Thanks Hans,

Your detailed explanation certainly helps a lot. I get the the concept and some parts. I need to do more work to figure out the details, something that takes some time, so it might be a couple of days untill I get back to you.

What are the rules you have in mind for the weights, if any? Otherwise, I thought I was faithfuly interpreting your request.

You definitely are. It is that along the way I am changinging my course a little bit. I started out with a vague idea for bringing some order into random connected points. I had no real idea how it would look, just a vague notion. Then along the way, it occured to me that the mean between numbners within the delta range might do a better job. In contrast to what a lot of programmers do or have to do, is my goal at the beginning not very substantiated, but can adapt as I go along.

Functional vs. Procedural programming styles : I think what you write about functional programming is quite enlightning for me. I use the term without a precise understanding what it exactly is, nor how to best apply it. I know procedural programming, but I thought it might be nice to do my things in WL in a Non procedural way as much as possible, just to learn the new and other way of thinking. Otherwise I might stay stuck in my old pardigm :-)

In the next days I will study your kind explanation as good as I can and get back to you. In the meantime, thanks a million Hans, for your help.

Beat

B. Cornas

The following is a bit more functional (no more Table(s) etc)

 Clear[lappingMeanShuffles, gatherlappingShuffles, lappingShuffles, 
      shuffleInterval, myIntegers];
    myIntegers = {11, 28, 66, 36, 94, 8, 44};
    shuffleInterval[x_List, n_] :=  
      Module[{}, Map[({Interval[{# - n, # + n}], #}) &, x] ];
    lappingShuffles[x_List, n_] := 
      Module[{z = shuffleInterval[x, n]}, 
       Map[Function[y, Select[z, IntervalMemberQ[#[[1]], y] &] ], x]];
    gatherlappingShuffles[x_List, n_] := 
      Module[{z = lappingShuffles[x, n]}, Map[(#[[All, 2]]) &, z]];
    lappingMeanShuffles[x_List, n_] := 
      Module[{z = gatherlappingShuffles[x, n]}, Map[Floor[Mean[#]] &, z]];
    lappingMeanShuffles[myIntegers, 10]
(* {9, 32, 66, 36, 94, 9, 40} *)

Splitting it up into step like functions still allows for

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

and visualizations of the overlaps

NumberLinePlot[shuffleInterval[myIntegers, 10]]

I get it, thanks.

With new rule of use the Mean.

Clear[lappingShuffles, lappingMeanShuffles, myIntegers];
myIntegers = {11, 28, 66, 36, 94, 8, 44};
lappingMeanShuffles[x_List, n_] := Module[{}, 
   Table[Floor[Mean[
         Table[
           Select[
            Table[{x[[i]], Interval[{x[[i]] - n, x[[i]] + n}], i},
                  {i, Length[x]}]
                , IntervalMemberQ[#[[2]], x[[j]] ] &],
                {j, Length[x]}][[l]][[All, 1]] 
      ]
     ], {l, Length[x]} ]
   ];

lappingMeanShuffles[myIntegers, 10]
(* {9, 32, 66, 36, 94, 9, 40} *)

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

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?

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}

Hans, I get the idea and see that it works. I also can sort of tag along, but I need to spend some more time on the details of the actual syntax. For me this ia mostly a way of learning to think differently and to get the sometimes quite cocise syntax. In my procedural programming, the syntax is more spread out and less compressed. This new way is challenging but also great fun. I just need to make the =miles, but I'll get there :-)

Thanks.

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

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}  *)

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

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}