Argthtjtr

I am coding stuff manipulating indirection arrays and I have some code like:

createDupInvIndir[indirection_?VectorQ,duplicate_?VectorQ]:=

    Block[{n,dupInvIndir},

          n=Length[indirection];

          Assert[n==Length[duplicate]];

          dupInvIndir=ConstantArray[0,n];



          For[i=1,i<=n,i++,

             dupInvIndir[[indirection[[i]]]]=duplicate[[i]];

          ];



          Return[dupInvIndir];

    ];

We agree that this is not a good functional / Mathematica coding style. However, for the moment I have no idea to get an elegant/efficient way to remove the loop (using functions like Map, Scan...). Any suggestion/idea?

to check it works:

ind={3,5,4,2,1,6}

dup={1,2,2,3,3,3}

createDupInvIndir[ind,dup]

Output:

{3,3,1,2,2,3}

More context:

• 
  indirection: is an indirection array got from SortBy function used with Range[1,n] to sort another array.


• 
  duplicate: count different successive elements to detect duplicates

The array dupInvIndir that satisfies the relation:

dupInvIndir[[indirection[[i]]]]=duplicate[[i]]

is used to get the positions (taking into account the duplicate) of the sorted data without explictely reordering the data.

Here is a complete working example:

createDupInvIndir[indirection_?VectorQ,duplicate_?VectorQ]:=

    Block[{n,dupInvIndir},

          n=Length[indirection];

          Assert[n==Length[duplicate]];

          dupInvIndir=ConstantArray[0,n];

          For[i=1,i<=n,i++,

          dupInvIndir[[indirection[[i]]]]=duplicate[[i]];

          ];

          Return[dupInvIndir];

    ];



createDuplicate[data_List,indirection_?VectorQ]:=

Block[{dup},

      dup=Tally[Range[Length[indirection]],(data[[indirection[[#1]]]]==data[[indirection[[#2]]]])&];

      dup=Flatten[MapThread[ConstantArray[#1,#2]&,{Range[Length[dup]],Part[dup,All,2]}]];

      Return[dup];

];



data={{3,4},{3,5},{1,2},{1,2},{2,3},{3,6},{5,6}} 

indirection=SortBy[Range[Length[data]],data[[#]]&]   (* {3,4,5,1,2,6,7} *)

duplicate=createDuplicate[data,indirection]          (* {1,1,2,3,4,5,6} *)

dupInvIndir=createDupInvIndir[indirection,duplicate] (* {3,4,1,1,2,5,6} <- Final result *)



(* same stuff with *explicit* sort: data components are moved *)

DeleteDuplicates[Sort[data]] (* {{1,2},{2,3},{3,4},{3,5},{3,6},{5,6}} *)

Take the first element of dupInvIndir, 3, it means that the first element of the (implicitely) sorted data array is data[[3]], ( -> {1,2} ).
This can be compared to the explicit DeleteDuplicate[Sort[data]]

Apparently, you try to apply a permutation given by list indirection to a vector duplicate.

Here are several ways to do it, each along with its timing:

n = 1000000;

indirection = RandomSample[Range[n], n];

duplicate = RandomInteger[{-n, n}, n];





First@RepeatedTiming[

  result0 = createDupInvIndir[indirection, duplicate];

  ]



First@RepeatedTiming[

  result1 = ConstantArray[0, Length[duplicate]];

  result1[[indirection]] = duplicate;

  ]



First@RepeatedTiming[

  result2 = 

    Normal@SparseArray[Partition[indirection, 1] -> duplicate,Length[duplicate]];

  ]



First@RepeatedTiming[

  result3 = duplicate[[InversePermutation@indirection]];

  ]



result0 == result1 == result2 == result3

1.799

0.012

0.016

0.015

True

This is another one of the many examples that highlights why For should not be used (in uncompiled code).