I'm trying to build a lazy list that evaluates the n'th m-tuple or subset of a given list using Mathematicas ordering without calculating all the Tuples. The purpose is to allow for example the traversal of very large spaces of tuples without fist having to calculate the complete space of tuples. So far I have defined a function that calcluates which elements goes where for the n'th tuple:
tupleIndexes[l_, t_, n_] := Table[Mod[Quotient[n - 1, l^m] + 1, l, 1], {m, t - 1, 0, -1}]
And have used this to define a lazy list by defining a SubValue
for when Part is applied.
lazyTuple /:Part[lazyTuple[list_, t_], n_Integer] /; 0 < n <= Length[lazyTuple[list, t]]:=
list[[tupleIndexes[Length[list], t, n]]]
The result is that lazyTuple[{1,2,3,4},2]
remains unevaluted but lazyTuple[{1,2,3,4},2][[2]]
returns {1,2}
as expected.
For testing I've defined a function to iterate through the list and return them all:
lazyTuple /: Length[lazyTuple[list_, t_]] := Length[list]^t
lazyTuple /: lazyTakeAll[a_lazyTuple] /; (NumericQ@Length@a) := Table[a[[i]], {i, Length@a}]
And it seems to check out:
lazyTakeAll[lazyTuple[Range@6, 3]] == Tuples[Range@6, 3]
True
Now my question is firstly if I'm making any subtle mistakes means this isn't returning the correct order with respect to Tuples
. But more importantly, how would one go about defining a similar function for lazySubsets[]
Answer
Well since I asked I supose I better supply at least a rudimentary answer. Turns out it was a bit harder then I initially expected to get the right order, but I think my solution is somewhat nice. What I do is, that if we want the n'th subset, I find a list of thresholds for when the first indice changes and test what threshold n is larger then. Then I continue this method on the next level, such that if we wanted the 1'th subset of 4 elements chosen in 6, the first indice is 1, and the second can be found as 1 + the 1'th subset of 3 elements chosen in 5. This way I go through each level and end up with the indices.
thresholds[n_,l_]:=Accumulate[Table[Binomial[n-i,l-1],{i,1,n-l+1}]]
compareToThreshold[n_,num_,group_]:=Position[#>=n&/@thresholds[num,group],True,1,1][[1,1]]
digDeeper[{n_,m_,l_,i_}]:=
{n-Prepend[thresholds[m,l],0][[i]],m-i,l-1}//Append[#,Sow[compareToThreshold@@#]]&
subsetIndices[grouplength_,setlength_,nth_]:=
Accumulate[Reap[Nest[digDeeper,{nth,grouplength+1,setlength+1,1},setlength]][[2,1]]]
For my own usage I only need fixed length subsets, therefore it only works with those. For all subsets, Combinatorica
's NthSubset
works quite nicely. So now to make a lazySubsets
, it's just a question of using the same structure as for lazyTuples
in my question.
lazySubsets/:Part[lazySubsets[list_,t_],n_Integer]/;0 list[[subsetIndices[Length[list],t,n]]]
And to test this
lazyTakeAll[a_]/;(NumericQ@Length@a):=Table[a[[i]],{i,Length@a}]
lazyTakeAll[lazySubsets[Range@15, 7]] == Subsets[Range@15, {7}]
True
Comments
Post a Comment