Cfrgtkky

Is there a built in function which rank transforms an array of data? By rank transformation I mean

data = {2.4,5,1,6,7,10,2}

Rank[data]={3,4,1,5,6,7,2}

where each value in data is assigned a rank from minimum to maximum where the lowest value in data is assigned the value of 1, the next highest value is assigned the value of 2, ect.
Ordering does not accomplish this as we obtain

Ordering[data]

{3,7,1,2,4,5,6}

Edit 1: As Carl pointed out, I need to express what I want to happen in the case of a tied ranking. Ultimately, I want to use this rank transformation in the context of the definition of Spearman's Rho function where

Covariance[Transpose[{Rank[X],Rank[Y]}]/(

StandardDeviation[Rank[X]]*StandardDeviation[Rank[Y]])

should equal

SpearmanRho[Transpose[{X,Y}]][[1,2]]

where X and Y are equally lengthed arrays of data.

Statistics`Library`GetDataRankings[{2.4, 5, 1, 6, 7, 10, 2}]

{3, 4, 1, 5, 6, 7, 2}

This gives the same result as Ordering@Ordering@#& if there are no ties in the input data.

If input data has ties:

Statistics`Library`GetDataRankings[{1, 2, 2, 2, 2, 3, 3, 3, 4, 5}]

{1, 7/2, 7/2, 7/2, 7/2, 7, 7, 7, 9, 10}

It is faster than Ordering@Ordering@#& but slower than Henrik Schumacher's Ranking:

SeedRandom[1]

data = RandomReal[{-1, 1}, 1000000];

a = Ranking[data]; // RepeatedTiming // First

0.18

b = Ordering[Ordering[data]]; // RepeatedTiming // First

0.307

c = Statistics`Library`GetDataRankings[data]; // RepeatedTiming // First

0.226

a == b == c

True

A slightly faster alternative (still slower than Ranking):

ranks = Module[{r = Range@Length@#, o = Ordering@#}, Permute[r, o]] &;

d = ranks @ data; // RepeatedTiming // First

0.203

a == b == c == d

True

What about this?

Ordering[Ordering[data]]

{3, 4, 1, 5, 6, 7, 2}

Since Ordering is the bottleneck, here a variant that needs only one call to Ordering:

Ranking[data_] := Module[{a},

  a = Range[Length[data]];

  a[[Ordering[data]]] = a;

  a

  ]

Comparison:

data = RandomReal[{-1, 1}, 1000000];

a = Ranking[data]; // RepeatedTiming // First

b = Ordering[Ordering[data]]; // RepeatedTiming // First

a == b

0.13

0.234

True

I'll answer my own question with a constructed function which does the job:

Rank[x_]:=Flatten[Table[Position[Sort[x], x[[i]]], {i, 1, Length[x]}]]

Ordering gives the sort of inverse of the above function where you get the position of the unsorted data with respect to the sorted data. Here, the Rank function gets the position of the sorted data with respect to the unsorted data.