correct the PCG module name to reflect that its the 32bit word sampler.
authorCarter Tazio Schonwald <carter.schonwald@gmail.com>
Sun, 21 May 2017 18:35:08 +0000 (14:35 -0400)
committerCarter Tazio Schonwald <carter.schonwald@gmail.com>
Sun, 21 May 2017 18:35:08 +0000 (14:35 -0400)
have a candidate travis file,
added entropy to the dependencies for now (spoke with TomMD and we agreed that they should be combined sometime)
started work on basic distribution generation tools

.travis.yml [new file with mode: 0644]
random.cabal
src/Data/Distribution/Interval [new file with mode: 0644]
src/Data/Distribution/Normal.hs [new file with mode: 0644]
src/Data/Distribution/Permutation [new file with mode: 0644]
src/System/Random/PCG/Internal.hs

diff --git a/.travis.yml b/.travis.yml
new file mode 100644 (file)
index 0000000..d3e6cac
--- /dev/null
@@ -0,0 +1,103 @@
+# This Travis job script has been generated by a script via
+#
+#   make_travis_yml_2.hs 'random.cabal'
+#
+# For more information, see https://github.com/hvr/multi-ghc-travis
+#
+language: c
+sudo: false
+
+git:
+  submodules: false  # whether to recursively clone submodules
+
+cache:
+  directories:
+    - $HOME/.cabal/packages
+    - $HOME/.cabal/store
+
+before_cache:
+  - rm -fv $HOME/.cabal/packages/hackage.haskell.org/build-reports.log
+  # remove files that are regenerated by 'cabal update'
+  - rm -fv $HOME/.cabal/packages/hackage.haskell.org/00-index.*
+  - rm -fv $HOME/.cabal/packages/hackage.haskell.org/*.json
+  - rm -fv $HOME/.cabal/packages/hackage.haskell.org/01-index.cache
+  - rm -fv $HOME/.cabal/packages/hackage.haskell.org/01-index.tar
+  - rm -fv $HOME/.cabal/packages/hackage.haskell.org/01-index.tar.idx
+
+matrix:
+  include:
+
+
+    - compiler: "ghc-7.10.3"
+      env:
+    # env: TEST=--disable-tests BENCH=--disable-benchmarks
+      addons: {apt: {packages: [ghc-ppa-tools,cabal-install-head,ghc-7.10.3], sources: [hvr-ghc]}}
+    - compiler: "ghc-8.0.1"
+      env:
+    # env: TEST=--disable-tests BENCH=--disable-benchmarks
+      addons: {apt: {packages: [ghc-ppa-tools,cabal-install-head,ghc-8.0.1], sources: [hvr-ghc]}}
+    - compiler: "ghc-8.0.2"
+      env:
+    # env: TEST=--disable-tests BENCH=--disable-benchmarks
+      addons: {apt: {packages: [ghc-ppa-tools,cabal-install-head,ghc-8.0.2], sources: [hvr-ghc]}}
+    - compiler: "ghc-8.2.1"
+      env:
+    # env: TEST=--disable-tests BENCH=--disable-benchmarks
+      addons: {apt: {packages: [ghc-ppa-tools,cabal-install-head,ghc-8.2.1], sources: [hvr-ghc]}}
+    - compiler: "ghc-head"
+      env:
+    # env: TEST=--disable-tests BENCH=--disable-benchmarks
+      addons: {apt: {packages: [ghc-ppa-tools,cabal-install-head,ghc-head], sources: [hvr-ghc]}}
+
+  allow_failures:
+    - compiler: "ghc-head"
+
+before_install:
+ - HC=${CC}
+ - unset CC
+ - PATH=/opt/ghc/bin:/opt/ghc-ppa-tools/bin:$PATH
+ - PKGNAME='random'
+
+install:
+ - cabal --version
+ - echo "$(${HC} --version) [$(${HC} --print-project-git-commit-id 2> /dev/null || echo '?')]"
+ - BENCH=${BENCH---enable-benchmarks}
+ - TEST=${TEST---enable-tests}
+ - travis_retry cabal update -v
+ - sed -i 's/^jobs:/-- jobs:/' ${HOME}/.cabal/config
+ - rm -fv cabal.project.local
+ - "echo 'packages: .' > cabal.project"
+ - rm -f cabal.project.freeze
+ - cabal new-build -w ${HC} ${TEST} ${BENCH} --dep -j2
+ - cabal new-build -w ${HC} --disable-tests --disable-benchmarks --dep -j2
+
+# Here starts the actual work to be performed for the package under test;
+# any command which exits with a non-zero exit code causes the build to fail.
+script:
+ - if [ -f configure.ac ]; then autoreconf -i; fi
+ - rm -rf dist/
+ - cabal sdist # test that a source-distribution can be generated
+ - cd dist/
+ - SRCTAR=(${PKGNAME}-*.tar.gz)
+ - SRC_BASENAME="${SRCTAR/%.tar.gz}"
+ - tar -xvf "./$SRC_BASENAME.tar.gz"
+ - cd "$SRC_BASENAME/"
+## from here on, CWD is inside the extracted source-tarball
+ - rm -fv cabal.project.local
+ - "echo 'packages: .' > cabal.project"
+ # this builds all libraries and executables (without tests/benchmarks)
+ - rm -f cabal.project.freeze
+ - cabal new-build -w ${HC} --disable-tests --disable-benchmarks
+ # this builds all libraries and executables (including tests/benchmarks)
+ # - rm -rf ./dist-newstyle
+ - cabal new-build -w ${HC} ${TEST} ${BENCH}
+
+ # there's no 'cabal new-test' yet, so let's emulate for now
+ - TESTS=( $(awk 'tolower($0) ~ /^test-suite / { print $2 }' *.cabal) )
+ - if [ "$TEST" != "--enable-tests" ]; then TESTS=(); fi
+ - shopt -s globstar;
+   RC=true; for T in ${TESTS[@]}; do echo "== $T ==";
+   if dist-newstyle/build/**/$SRC_BASENAME/**/build/$T/$T; then echo "= $T OK =";
+   else echo "= $T FAILED ="; RC=false; fi; done; $RC
+
+# EOF
index 8e53ba2..a86215c 100644 (file)
@@ -50,7 +50,7 @@ cabal-version:       >=1.10
 
 
 library
-  -- Modules exported by the library.
+  -- Modules exported` by the library.
   exposed-modules:
     System.Random.SplitMix.Internal
     System.Random.PCG.Internal
@@ -62,7 +62,10 @@ library
   -- other-extensions:
 
   -- Other library packages from which modules are imported.
-  build-depends:       base >=4.8 && <4.10, ghc-prim
+  build-depends:       base >=4.8 && <4.12
+                      ,ghc-prim
+                      ,entropy == 0.3.*
+                  -- entropy will later be folded into random, probably
 
   -- Directories containing source files.
   hs-source-dirs:      src
diff --git a/src/Data/Distribution/Interval b/src/Data/Distribution/Interval
new file mode 100644 (file)
index 0000000..f164b6e
--- /dev/null
@@ -0,0 +1,4 @@
+module Data.Distribution.Interval where
+
+
+unit
diff --git a/src/Data/Distribution/Normal.hs b/src/Data/Distribution/Normal.hs
new file mode 100644 (file)
index 0000000..a7f9406
--- /dev/null
@@ -0,0 +1,2 @@
+module Data.Distribution.Normal where
+
diff --git a/src/Data/Distribution/Permutation b/src/Data/Distribution/Permutation
new file mode 100644 (file)
index 0000000..e69de29
index 2a5957d..e828840 100644 (file)
@@ -3,14 +3,14 @@
 {-# LANGUAGE DeriveGeneric      #-}
 -- |
 --
--- Standard PCG64 Random Number Generator with chosen streams, written in
+-- Standard PCG32 Random Number Generator with chosen streams, written in
 -- pure haskell. See <http://www.pcg-random.org> for details.
 --
 module System.Random.PCG.Internal
-  ( -- * PCG 64
-    PCG64 (..)
+  ( -- * PCG 32
+    PCG32 (..)
   , seed
-  , newPCG64
+  , newPCG32
 
     -- * Generating random numbers
   , next32
@@ -18,7 +18,7 @@ module System.Random.PCG.Internal
   , bounded
 
     -- * Generator utilities
-  , advancePCG64
+  , advancePCG32
   , split
   ) where
 
@@ -28,22 +28,22 @@ import Foreign
 import GHC.Generics
 
 -- | The multiple sequence varient of the pcg random number generator.
-data PCG64 = PCG64
+data PCG32 = PCG32
   {-# UNPACK #-} !Word64 -- state
   {-# UNPACK #-} !Word64 -- inc
   deriving (Show, Ord, Eq, Data, Typeable, Generic)
 
 -- | Create a new generator from two words.
-newPCG64 :: Word64 -> Word64 -> PCG64
-newPCG64 = \a b ->
-  let s = state (PCG64 (a + i) i)
+newPCG32 :: Word64 -> Word64 -> PCG32
+newPCG32 = \a b ->
+  let s = state (PCG32 (a + i) i)
       i = (b `shiftL` 1) .|. 1
-  in  PCG64 s i
-{-# INLINE newPCG64 #-}
+  in  PCG32 s i
+{-# INLINE newPCG32 #-}
 
 -- | Fixed seed.
-seed :: PCG64
-seed = PCG64 9600629759793949339 15726070495360670683
+seed :: PCG32
+seed = PCG32 9600629759793949339 15726070495360670683
 {-# INLINE seed #-}
 
 -- Generating random numbers -------------------------------------------
@@ -59,8 +59,8 @@ multiplier = 6364136223846793005
 {-# INLINE multiplier #-}
 
 -- A single step in the generator state
-state :: PCG64 -> Word64
-state (PCG64 s inc) = s * multiplier + inc
+state :: PCG32 -> Word64
+state (PCG32 s inc) = s * multiplier + inc
 {-# INLINE state #-}
 
 -- The random number output
@@ -73,40 +73,40 @@ output s =
 {-# INLINE output #-}
 
 -- a new generator state and random number
-pair :: PCG64 -> Pair
-pair g@(PCG64 s _) = Pair (state g) (output s)
+pair :: PCG32 -> Pair
+pair g@(PCG32 s _) = Pair (state g) (output s)
 {-# INLINE pair #-}
 
 -- | Return a random 'Word32' with a generator incremented by one step.
-next32 :: PCG64 -> (Word32, PCG64)
-next32 = \g@(PCG64 _ inc) ->
+next32 :: PCG32 -> (Word32, PCG32)
+next32 = \g@(PCG32 _ inc) ->
   let Pair s' r = pair g
-  in  (r, PCG64 s' inc)
+  in  (r, PCG32 s' inc)
 {-# INLINE next32 #-}
 
 -- | Return a random 'Word64' with the generator incremented by two steps.
-next64 :: PCG64 -> (Word64, PCG64)
-next64 = \(PCG64 s inc) ->
-  let Pair s'  w1 = pair (PCG64 s inc)
-      Pair s'' w2 = pair (PCG64 s' inc)
-  in  (wordsTo64Bit w1 w2, PCG64 s'' inc)
+next64 :: PCG32 -> (Word64, PCG32)
+next64 = \(PCG32 s inc) ->
+  let Pair s'  w1 = pair (PCG32 s inc)
+      Pair s'' w2 = pair (PCG32 s' inc)
+  in  (wordsTo64Bit w1 w2, PCG32 s'' inc)
 {-# INLINE next64 #-}
 
-bounded' :: Word32 -> PCG64 -> Pair
-bounded' b (PCG64 s0 inc) = go s0
+bounded' :: Word32 -> PCG32 -> Pair
+bounded' b (PCG32 s0 inc) = go s0
   where
    t = negate b `mod` b
    go !s | r >= t    = Pair s' (r `mod` b)
          | otherwise = go s'
-     where Pair s' r = pair (PCG64 s inc)
+     where Pair s' r = pair (PCG32 s inc)
 {-# INLINE bounded' #-}
 
 -- | Generate a uniform 'Word32' less than the bound. If the bound is
 --   zero, this throws a divide by zero exception.
-bounded :: Word32 -> PCG64 -> (Word32, PCG64)
-bounded = \b g@(PCG64 _ inc) ->
+bounded :: Word32 -> PCG32 -> (Word32, PCG32)
+bounded = \b g@(PCG32 _ inc) ->
   let !(Pair s1 w) = bounded' b g
-  in  (w, PCG64 s1 inc)
+  in  (w, PCG32 s1 inc)
 {-# INLINE bounded #-}
 
 -- Utilities -----------------------------------------------------------
@@ -114,17 +114,17 @@ bounded = \b g@(PCG64 _ inc) ->
 -- | Split the generator @g@ into @(g', g2)@ where @g'@ is @g@
 --   incremented by 4 steps and @g2@ is a new generator with a
 --   difference sequence to @g@.
-split :: PCG64 -> (PCG64, PCG64)
-split (PCG64 s inc) = (PCG64 s4 inc, mk w1 w2 w3 w4)
+split :: PCG32 -> (PCG32, PCG32)
+split (PCG32 s inc) = (PCG32 s4 inc, mk w1 w2 w3 w4)
   where
     -- This is just something I made up. It passed big crunch and
     -- dieharder (by splitting every step) but there's probably a better
     -- way.
-    mk a b c d = newPCG64 (wordsTo64Bit a b) (wordsTo64Bit c d)
-    Pair s1 w1 = pair (PCG64 s  inc)
-    Pair s2 w2 = pair (PCG64 s1 inc)
-    Pair s3 w3 = pair (PCG64 s2 inc)
-    Pair s4 w4 = pair (PCG64 s3 inc)
+    mk a b c d = newPCG32 (wordsTo64Bit a b) (wordsTo64Bit c d)
+    Pair s1 w1 = pair (PCG32 s  inc)
+    Pair s2 w2 = pair (PCG32 s1 inc)
+    Pair s3 w3 = pair (PCG32 s2 inc)
+    Pair s4 w4 = pair (PCG32 s3 inc)
 {-# INLINE split #-}
 
 advancing
@@ -147,9 +147,9 @@ advancing d0 s m0 p0 = go d0 m0 p0 1 0
 
 -- | Advance a pcg generator @n@ steps. You can give this @-n@ to take
 --   the generator back @n@ steps.
-advancePCG64 :: Word64 -> PCG64 -> PCG64
-advancePCG64 = \d (PCG64 s inc) -> PCG64 (advancing d s multiplier inc) inc
-{-# INLINE advancePCG64 #-}
+advancePCG32 :: Word64 -> PCG32 -> PCG32
+advancePCG32 = \d (PCG32 s inc) -> PCG32 (advancing d s multiplier inc) inc
+{-# INLINE advancePCG32 #-}
 
 -- Misc ----------------------------------------------------------------