How about using outer? But this particular function concatenates them into one character string. outer( c(“aa”, “ab”, “cc”), c(“aa”, “ab”, “cc”) , “paste” ) # [,1] [,2] [,3] #[1,] “aa aa” “aa ab” “aa cc” #[2,] “ab aa” “ab ab” “ab cc” #[3,] “cc aa” “cc ab” “cc cc” You can also use combn on … Read more
You could create an extension method like the following: public static class EnumerableExtensions { public static IEnumerable<TValue []> Permutations<TKey, TValue>(this IEnumerable<TKey> keys, Func<TKey, IEnumerable<TValue>> selector) { var keyArray = keys.ToArray(); if (keyArray.Length < 1) yield break; TValue [] values = new TValue[keyArray.Length]; foreach (var array in Permutations(keyArray, 0, selector, values)) yield return array; } static … Read more
The complexity of cartesian product is O(n2), there is no shortcut. In specific cases, the order you iterate your two axis is important. For example, if your code is visiting every slot in an array — or every pixel in an in image — then you should try to visit the slots in natural order. … Read more
You can use np.mgrid for this, it’s often more convenient than np.meshgrid because it creates the arrays in one step: import numpy as np X,Y = np.mgrid[-5:5.1:0.5, -5:5.1:0.5] For linspace-like functionality, replace the step (i.e. 0.5) with a complex number whose magnitude specifies the number of points you want in the series. Using this syntax, … Read more
Your first definition, kart xs ys = [(x,y) | x <- xs, y <- ys], is equivalent to kart xs ys = xs >>= (\x -> ys >>= (\y -> [(x,y)])) where (x:xs) >>= g = g x ++ (xs >>= g) (x:xs) ++ ys = x : (xs ++ ys) are sequential operations. Redefine … Read more
I’ve written a solution that doesn’t require you to fill up a large collection in memory. Unfortunately, the code required is hundreds of lines long. You may have to wait until it appears in the Guava project (https://github.com/google/guava), which I hope will be by the end of the year. Sorry. 🙁 Note that you may … Read more
You can solve this using the recursive flatMap chain. First as we need to move back and forth by the map values, it’s better to copy them to the ArrayList (this is not the deep copy, in your case it’s ArrayList of 3 elements only, so the additional memory usage is low). Second, to maintain … Read more
1) Create a list of indexes into the respective lists, initialized to 0, i.e: indexes = [0,0,0,0,0,0] 2) Yield the appropriate element from each list (in this case the first). 3) Increase the last index by one. 4) If the last index equals the length of the last list, reset it to zero and carry … Read more
itertools.product should do the trick. >>> import itertools >>> list(itertools.product([1, 5, 8], [0.5, 4])) [(1, 0.5), (1, 4), (5, 0.5), (5, 4), (8, 0.5), (8, 4)] Note that itertools.product returns an iterator, so you don’t need to convert it into a list if you are only going to iterate over it once. eg. for x … Read more
Check out product() in the itertools module. It does exactly what you describe. import itertools my_list = [1,2,3,4] for pair in itertools.product(my_list, repeat=2): foo(*pair) This is equivalent to: my_list = [1,2,3,4] for x in my_list: for y in my_list: foo(x, y) Edit: There are two very similar functions as well, permutations() and combinations(). To illustrate … Read more