- Haskell-Cafe - Haskell.org

ANNOUNCE: normaldistribution-1.1 – Minimum fuss normally distributed random values.
by Bjorn Buckwalter 09 Apr '11

09 Apr '11

Dear all, Thanks to enlightening advice from Tom Nielsen and Zoltan Novak normaldistribution now generates normally distributed values using the Box-Muller method instead of the Central Limit Theorem. This change provides a 5-10x speedup. The only API impact is that the random values must now be instances of Floating rather than just Fractional. (The pre-canned Random instances that satisfy Fractional, i.e. Double and Float, also satisfy Floating.) Cheers, Bjorn ---------- Forwarded message ---------- From: Bjorn Buckwalter <bjorn.buckwalter(a)gmail.com> Date: Sat, Apr 9, 2011 at 15:21 Subject: ANNOUNCE: normaldistribution-1.0 – Minimum fuss normally distributed random values. Dear all, I'm pleased to announce the immediate availability of the normaldistribution library on hackage: http://hackage.haskell.org/package/normaldistribution This purpose of this library is to have a simple API and no dependencies beyond Haskell 98 in order to let you produce normally distributed random values with a minimum of fuss. This library does not attempt to be blazingly fast nor to pass stringent tests of randomness. It attempts to be very easy to install and use while being "good enough" for many applications (simulations, games, etc.). The API builds upon and is largely analogous to that of the Haskell 98 Random module (more recently System.Random). Pure: > (sample,g) = normal myRandomGen -- using a Random.RandomGen > samples = normals myRandomGen -- infinite list > samples2 = mkNormals 10831452 -- infinite list using a seed In the IO monad: > sample <- normalIO > samples <- normalsIO -- infinite list With custom mean and standard deviation: > (sample,g) = normal' (mean,sigma) myRandomGen > samples = normals' (mean,sigma) myRandomGen > samples2 = mkNormals' (mean,sigma) 10831452 > sample <- normalIO' (mean,sigma) > samples <- normalsIO' (mean,sigma) Internally the library uses the Central Limit Theorem to approximate normally distributed values from multiple uniformly distributed random values. Enjoy, Bjorn

1 0

ANNOUNCE: normaldistribution-1.0 – Minimum fuss normally distributed random values.
by Bjorn Buckwalter 09 Apr '11

09 Apr '11

Dear all, I'm pleased to announce the immediate availability of the normaldistribution library on hackage: http://hackage.haskell.org/package/normaldistribution This purpose of this library is to have a simple API and no dependencies beyond Haskell 98 in order to let you produce normally distributed random values with a minimum of fuss. This library does not attempt to be blazingly fast nor to pass stringent tests of randomness. It attempts to be very easy to install and use while being "good enough" for many applications (simulations, games, etc.). The API builds upon and is largely analogous to that of the Haskell 98 Random module (more recently System.Random). Pure: > (sample,g) = normal myRandomGen -- using a Random.RandomGen > samples = normals myRandomGen -- infinite list > samples2 = mkNormals 10831452 -- infinite list using a seed In the IO monad: > sample <- normalIO > samples <- normalsIO -- infinite list With custom mean and standard deviation: > (sample,g) = normal' (mean,sigma) myRandomGen > samples = normals' (mean,sigma) myRandomGen > samples2 = mkNormals' (mean,sigma) 10831452 > sample <- normalIO' (mean,sigma) > samples <- normalsIO' (mean,sigma) Internally the library uses the Central Limit Theorem to approximate normally distributed values from multiple uniformly distributed random values. Enjoy, Bjorn

2 1

Is there a way to find out the type inferred for a local function inside another function? :)
by KC 09 Apr '11

09 Apr '11

-- -- Regards, KC

9 11

Patch: adding CTR, CMAC and SIV modes to the Crypto API
by klondike 09 Apr '11

09 Apr '11

Hi, After a few weeks of hard work I have managed to add the CTR, CMAC and SIV modes of operation. The implemententation passes all the KATS I could find and is made as efficiently as possible without forgetting the risk of timing attacks over them. The patch is attached here and you can free it along with your library with a BSD-3 license as long as you recognize the authorship. Francisco Blas Izquierdo Riera (klondike) PS: Attached is also a set of commands I used with ghci to check quickly the implementation and which contain parts of the KATS I used, feel free to use them.

1 0

erratic behavior for System.Time.diffClockTimes
by Warren Harris 08 Apr '11

08 Apr '11

I'm trying out GHC-7.0.3-x86_64 for Mac OS X and see what seems to be a bug in System.Time.diffClockTimes. The TimeDiff tdPicosec field returns values that seem to jump around erratically: test = do startTime <- System.Time.getClockTime endTime <- System.Time.getClockTime let dt = diffClockTimes endTime startTime putStrLn $ show dt Prelude Test> test TimeDiff {tdYear = 0, tdMonth = 0, tdDay = 0, tdHour = 0, tdMin = 0, tdSec = 0, tdPicosec = 0} Prelude Test> test TimeDiff {tdYear = 0, tdMonth = 0, tdDay = 0, tdHour = 0, tdMin = 0, tdSec = 0, tdPicosec = 3000000} Prelude Test> test TimeDiff {tdYear = 0, tdMonth = 0, tdDay = 0, tdHour = 0, tdMin = 0, tdSec = 0, tdPicosec = -3329012246138323150000000} Prelude Test> test TimeDiff {tdYear = 0, tdMonth = 0, tdDay = 0, tdHour = 0, tdMin = 0, tdSec = 0, tdPicosec = 3000000} Prelude Test> test TimeDiff {tdYear = 0, tdMonth = 0, tdDay = 0, tdHour = 0, tdMin = 0, tdSec = 0, tdPicosec = -3329012246138322851000000} Prelude Test> I can file a bug, unless I'm overlooking something here. Warren

3 2

fmap and LaTeX
by Mitar 08 Apr '11

08 Apr '11

Hi! Is there for <$> (fmap) operator some nice looking symbol in mathematics, LaTeX? I am looking here: http://www.soi.city.ac.uk/~ross/papers/Applicative.html http://www.haskell.org/ghc/docs/6.12.1/html/libraries/base/Control-Applicat… but only for other operators there are nice symbols, and <$> is left as it is. I have also tried \mathbin{<\$>} but it adds space around $ (at least in lhs2tex), so it looks ugly. Mitar

3 4

FFI for a beginner
by Andrew Pennebaker 08 Apr '11

08 Apr '11

ncurses is proving too difficult to setup, so I'm working on a new library called charm. The C code works by itself, but I can't compile a Haskell wrapper for it. While the tutorials at HaskellWiki<http://www.haskell.org/haskellwiki/FFI_complete_examples>are helpful, they're outdated. Argh! The docs<http://www.haskell.org/ghc/docs/latest/html/users_guide/ffi-ghc.html#glasgo…>say that -#include pragmas no longer work, but fail to explain how to load code without them. Suffice to say I have no recourse but trial and error. GitHub: charm <https://github.com/mcandre/charm> and hscharm<https://github.com/mcandre/hscharm> <https://github.com/mcandre/charm>$ make cp /usr/include/charm.c . ghc --make -fforce-recomp -o hellocharm hellocharm.hs charm.hs charm.c -I/usr/include -dylib-install-name /usr/lib/libcharm.dynlib [1 of 2] Compiling Charm ( charm.hs, charm.o ) [2 of 2] Compiling Main ( hellocharm.hs, hellocharm.o ) Linking hellocharm ... ld: duplicate symbol _Charm_getWidth_info in charm.o and charm.o collect2: ld returned 1 exit status make: *** [hellocharm] Error 1 Cheers, Andrew Pennebaker www.yellosoft.us

1 0

cab 0.1.2
by Kazu Yamamoto 08 Apr '11

08 Apr '11

Hello cafe, Let me announce "cab version 0.1.2". This version integrates "cabal-dev" as well as "cabal/ghc-pkg". So, you can use a sandbox for your development. http://www.mew.org/~kazu/proj/cab/en/ Here is the short explanation from the page above: ---- "cab" is a MacPorts-like maintenance command of Haskell cabal packages. Some parts of this program are a wrapper to "ghc-pkg", "cabal", and "cabal-dev". If you are always confused due to inconsistency of "ghc-pkg" and "cabal", or if you want a way to check all outdated packages, or if you want a way to remove outdated packages recursively, this command helps you. "cab" is designed to maintain user packages only assuming that users use a Haskell Platform and don't want to touch the global packages. ---- --Kazu

1 0

DSL for task dependencies
by Serge Le Huitouze 07 Apr '11

07 Apr '11

Hi Haskellers! I think I remember reading a blog post or web page describing a EDSL to describe tasks and their dependencies "a la" make. Can anyone point me to such published material? Thanks in advance. --serge

8 7

'Progress bar' enumeratee
by David Hotham 07 Apr '11

07 Apr '11

Hello, I've spent some time over the last couple of days trying to write an enumeratee that prints a "." every n bytes (with obvious intended use as a progress tracker). Seems like it oughtn't be hard, but it has been a steep learning curve... I have come up with something that seems to do the job but I don't know that I'm completely happy with it (or even that I completely understand it, to be honest). If anyone more expert would be kind enough either to reassure me that I'm doing it right or - more likely - to offer improvements / suggestions on what obvious simplifications I have overlooked, I'd be grateful. Thanks David import qualified Data.ByteString.Char8 as B import qualified Data.ByteString.Lazy.Char8 as BL import qualified Data.Enumerator as E import qualified Data.Enumerator.Binary as EB import Control.Monad.IO.Class (liftIO, MonadIO) import System.IO (hFlush, stdout) dotEvery :: MonadIO m => Integer -> E.Enumeratee B.ByteString B.ByteString m b dotEvery count = E.checkDone $ E.continue . dotIn count where dotIn need k E.EOF = E.yield (E.Continue k) E.EOF dotIn need k (E.Chunks []) = E.continue (dotIn need k) dotIn need k (E.Chunks xs) = iter where lazy = BL.fromChunks xs len = toInteger $ BL.length lazy iter = if len < need then k (E.Chunks xs) E.>>== E.checkDone (E.continue . dotIn (count - len)) else let (x1, x2) = BL.splitAt (fromInteger need) lazy s1 = E.Chunks $ BL.toChunks x1 s2 = E.Chunks $ BL.toChunks x2 enumee = E.checkDoneEx s2 (\k' -> dotIn count k' s2) in E.Iteratee $ do newStep <- E.runIteratee $ k s1 liftIO $ putStr "." >> hFlush stdout E.runIteratee $ enumee newStep PS Implementations which involve "EB.take count" seem to me unsatisfactory; one surely oughtn't need to have a large buffer to solve this problem PPS I did find an implementation via mapAccumM which I consider pleasing enough from an aesthetic point of view - but which runs 30x slower dotAt :: MonadIO m => Integer -> Integer -> Word8 -> m (Integer, Word8) dotAt n s w | s >= n = do liftIO $ putStr "." >> hFlush stdout return (1, w) | otherwise = return (s+1, w) dotEvery' :: MonadIO m => Integer -> E.Enumeratee B.ByteString B.ByteString m b dotEvery' n = EB.mapAccumM (dotAt n) 1

3 9