Take the 2-minute tour ×
Mathematica Stack Exchange is a question and answer site for users of Mathematica. It's 100% free, no registration required.

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[]

share|improve this question
2  
You've seen the implementation of RankSubset[] and UnrankSubset[] in Combinatorica` ? –  J. M. Aug 17 '12 at 15:16
    
Related: Functional style using lazy lists –  rm -rf Aug 17 '12 at 15:35
1  
One of the questions I would ask myself first is whether you consider your lists (which you want to iterate over) as proper lists (ordered sets) - in which case the order of iteration matters, or unordered (proper) sets, in which case you simply need an iterator which would iterate through the set without a specific prescribed order (if this is the case, then insisting on the element-by-element positional correspondence to functions such as Subsets, which return entire collection at once, may be too strong a requirement). –  Leonid Shifrin Aug 17 '12 at 16:42
    
@LeonidShifrin I wanted the iteration indexing to match in order to ensure consistency between calling lazySublistsand Sublists, however you could iterate though this in any order you wish. An added benefit of having a function that returns the iteration indices for the n'th subset is that you can for instance carry out a maximization that finds that the 42231'th subset was best, and you automatically know which set it is, without having to put in hooks to retrieve the actual subset alongside the maximization. –  jVincent Aug 20 '12 at 13:25
add comment

1 Answer

up vote 3 down vote accepted

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<n<=Length[lazySubsets[list,t]] :=
  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

share|improve this answer
add comment

Your Answer

 
discard

By posting your answer, you agree to the privacy policy and terms of service.

Not the answer you're looking for? Browse other questions tagged or ask your own question.