iterate

I would like speed my code, so I don't like to use double for: my code: for c in range(0, n-1): for l in range(0,n-c-1): df2.ix[l,c]=C_back(l,c,df) I would like to use for x in df.itertuples(): but I don't know how to modify a specific cell value. thanks use stack for mytuple, value in df.stack().iteritems(): print(mytuple, value) consider the df df = pd.DataFrame(np.arange(9).reshape(-1, 3), list('ABC'), list('XYZ')) df for mytuple, value in df.stack().iteritems(): print(mytuple, value) ('A', 'X') 0 ('A', 'Y') 1 ('A', 'Z') 2 ('B', 'X') 3 ('B', 'Y') 4 ('B', 'Z') 5 ('C', 'X') 6 ('C', 'Y') 7 ('C

I have heard that iteratees are lazy, but how lazy exactly are they? Alternatively, can iteratees be fused with a postprocessing function, so that an intermediate data structure does not have to be built? Can I in my iteratee for example build a 1 million item Stream[Option[String]] from a java.io.BufferedReader , and then subsequently filter out the None s, in a compositional way, without requiring the entire Stream to be held in memory? And at the same time guarantee that I don't blow the stack? Or something like that - it doesn't have to use a Stream . I'm currently using Scalaz 6 but if

Reading the documentation about the Play Framework and ReactiveMongo leads me to believe that ReactiveMongo works in such a way that it uses few threads and never blocks. However, it seems that the communication from the Play application to the Mongo server would have to happen on some thread somewhere . How is this implemented? Links to the source code for Play, ReactiveMongo, Akka, etc. would also be very appreciated. The Play Framework includes some documentation about this on this page about thread pools . It starts off: Play framework is, from the bottom up, an asynchronous web framework.

Background As noted in this question , I'm using Scalaz 7 iteratees to process a large (i.e., unbounded) stream of data in constant heap space. My code looks like this: type ErrorOrT[M[+_], A] = EitherT[M, Throwable, A] type ErrorOr[A] = ErrorOrT[IO, A] def processChunk(c: Chunk, idx: Long): Result def process(data: EnumeratorT[Chunk, ErrorOr]): IterateeT[Vector[(Chunk, Long)], ErrorOr, Vector[Result]] = Iteratee.fold[Vector[(Chunk, Long)], ErrorOr, Vector[Result]](Nil) { (rs, vs) => rs ++ vs map { case (c, i) => processChunk(c, i) } } &= (data.zipWithIndex mapE Iteratee.group(P)) The Problem

I have just started to learn the Play 2.0 Framework. The one thing I just can't understand is the Iteratee, Enumerator and Enumeratee pattern described in the play tutorial . I have very little experience in functional languages. What does this pattern accomplish? How does it help me write non-blocking/reactive code? some simple examples would help. The playframework 2.0 download comes with some samples. Two of which have Iteratee/Comet examples. For instance, the comet-clock sample app shows: lazy val clock = Enumerator.fromCallback { () => Promise.timeout(Some(dateFormat.format(new Date)),

I am implementing a haskell program wich compares each line of a file with each other line in the file. Which can be implemented single threaded as follows distance :: Int -> Int -> Int distance a b = (a-b)*(a-b) sumOfDistancesOnSmallFile :: FilePath -> IO Int sumOfDistancesOnSmallFile path = do fileContents <- readFile path return $ allDistances $ map read $ lines $ fileContents where allDistances (x:xs) = (allDistances xs) + ( sum $ map (distance x) xs) allDistances _ = 0 This will run in O(n^2) time, and has to keep the complete list of integers in memory the whole time. In my actual