mjhjmtu

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).