Another interesting old-ish question that popped into the sidebar (Not even sure why no upvotes on it - it is an interesting question!)
My take:
I refactored Kguler's pickPosF, simply changing to
mypickPosF[{ax_, bx_}] := (Function[{xx}, First[Pick[Range[Length[bx]], UnitStep[bx - xx],
1] /. {} -> {0}]] /@ ax)
This improved performance greatly (about triple in the few tests I did), but surprisingly it still lagged behind selPosF. So I used the latter as my standard.
I next refactored Simon Wood's clever use of Outer to comply with the needs of the OP. Much to my surprise (I really expected the technique to be crushingly fast), it was rather slow. Perhaps I'll revisit the idea at a later time.
My first idea was that this is an ideal place for using a piecewise function:
Map[(pw[x_] = Piecewise[MapIndexed[{First@#2, x <= #} &, #[[1]]]];
pw /@ #[[2]]) &, Transpose[Transpose /@ {bb, aa}]]
This was indeed quick, in the few tests I did, about the same as selPosF. I wondered how smart Mathematica might be in culling "dead" parts of the function (that is, parts that never need to be checked due to ordering of the comparisons). Turns out, not too smart. Simple fix: do a PiecewiseExpand on the generated piecewise function, which eliminates the dead parts. This turns out to be surprisingly slow, dropping performance significantly.
Ah, we know things about the data and requirements, let's do it ourselves:
Map[(With[{z = #[[1]]},
pw[x_] = Piecewise[MapThread[{#2, x <= #} &,
Split[FoldList[Max, z]] // {First /@ #,
Most@Accumulate[Prepend[Length /@ #, 1]]} &]]];
pw /@ #[[2]]) &, Transpose[Transpose /@ {bb, aa}]]
Now we're getting somewhere: About a 5X+ improvement on selPosF.
But there's got to be a better way...:
newmex[list_, limsx_] := Module[{rows = Length@list, lims, mo, pss, spans, cab, ca, t},
lims = With[{z = #}, Split[FoldList[Max, z]] // {First /@ #,
Most@Accumulate[Prepend[Length /@ #, 1]]} &] & /@ limsx;
mo = MapThread[Ordering[Join[#1, #2]] &, {Transpose@list, lims[[All, 1]]}];
pss = SplitBy[Position[UnitStep[Subtract[mo, rows + 1]], 1], First];
spans = Span @@@ Transpose[{Most@Prepend[#, 0] + 1, # - 1}] & /@pss[[All, All, 2]];
cab = ConstantArray[0, rows];
Reap[Scan[(t = #; ca = cab;
MapThread[(ca[[t[[-1]][[#1]]]] = #2) &, t[[;; 2]]]; Sow[ca]) &,
Transpose[{spans, lims[[All, 2]], mo}]]][[2, 1]]]
Much faster.
Notes on the above: I've split out parts of the code so readers can see step-by-step what's up. You'd probably want to compact it, though that won't affect performance.
The function takes the comparison array already transposed. So for the OP, simply transpose the comparison array before calling. Doing it this way allows for ragged column comparison lists, kind of useful (row-padding the comparison array with Infinity could also be used, I suppose).
Quick speed comparison to selPosF on a 200 column random integer array, with comparison array columns generated from binning each column of the target by 10, selecting 50 and sorting them. (The latter forces worst-case behavior in my function):

Position
? $\endgroup$