Merge pull request #43 from bashtage/trusty-build

Trusty build

Author: bashtage

.travis.yml

@@ -2,21 +2,18 @@
 # versions.  Allows substantial flexability for choosing versions of
 # required packages and is simpler to use to test up-to-date scientific Python
 # stack
-sudo: false
-
-language: python
+sudo: required
+dist: trusty
+language: generic
 
 matrix:
   fast_finish: true
   include:
-  - python: 2.7
-    env:
+  - env:
     - PYTHON=2.7
-  - python: 2.7
-    env:
+  - env:
     - PYTHON=3.4
-  - python: 2.7
-    env:
+  - env:
     - PYTHON=3.5
 
 before_install:
@@ -35,13 +32,13 @@ before_install:
 
 # Install packages
 install:
-  - conda create -n rng-test ${PKGS} nose pip setuptools --quiet
-  - source activate rng-test
-  - export BUILD_DIR=$PWD
+  - conda create -n randomstate-test ${PKGS} nose pip setuptools --quiet
+  - source activate randomstate-test
   - python setup.py install
+  - export BUILD_DIR=$PWD
+  - cd $HOME
 
 script:
-  - cd $HOME
-  - nosetests -vv randomstate
+  - nosetests randomstate
   - cd $BUILD_DIR/randomstate
   - if [ ${PYTHON} = "2.7" ]; then python performance.py; fi

doc/source/parallel.rst

@@ -33,7 +33,7 @@ Jump/Advance the PRNG state
 ---------------------------
 
 ``jump`` advances the state of the PRNG *as-if* a large number of random
-number have been drawn.  The specific number of draws varies by PRNG, and
+numbers have been drawn.  The specific number of draws varies by PRNG, and
 ranges from :math:`2^{64}` to :math:`2^{512}`.  Additionally, the *as-if*
 draws also depend on the size of the default random number produced by the
 specific PRNG.  The PRNGs that support ``jump``, along with the period of

randomstate/interface/dSFMT/dSFMT.pxi

@@ -110,7 +110,7 @@ seed : {None, int, array_like}, optional
     Can be an integer in [0, 2**32-1], array of integers in
     [0, 2**32-1] or ``None`` (the default). If `seed` is ``None``,
     then ``dSFMT.RandomState`` will try to read entropy from
-    ``/dev/urandom`` (or the Windows analogue) if available to
+    ``/dev/urandom`` (or the Windows analog) if available to
     produce a 64-bit seed. If unavailable, the a 64-bit hash of the time
     and process ID is used.
 
@@ -125,9 +125,9 @@ number of probability distributions to choose from.
 **Parallel Features**
 
 ``dsfmt.RandomState`` can be used in parallel applications by
-calling the method ``jump`` which advances the the state as-if :math:`2^{128}`
-random numbers have been generated [2]_. This allow the original sequence to
-be split so that distinct segments can be used on each worker process.  All
+calling the method ``jump`` which advances the state as-if :math:`2^{128}`
+random numbers have been generated [2]_. This allows the original sequence to
+be split so that distinct segments can be used in each worker process.  All
 generators should be initialized with the same seed to ensure that the
 segments come from the same sequence.
 
@@ -148,7 +148,7 @@ used here augments this with a 384 element array of doubles which are used
 to efficiently access the random numbers produced by the dSFMT generator.
 
 ``dsfmt.RandomState`` is seeded using either a single 32-bit unsigned integer
-or a vector of 32-bit unsigned integers.  In either case the input seed is
+or a vector of 32-bit unsigned integers.  In either case, the input seed is
 used as an input (or inputs) for a hashing function, and the output of the
 hashing function is used as the initial state. Using a single 32-bit value
 for the seed can only initialize a small range of the possible initial
@@ -171,7 +171,7 @@ have been generated.
 Parameters
 ----------
 iter : integer, positive
-    Number of times to jump the state of the rng.
+    Number of times to jump the state of the prng.
 
 Returns
 -------

randomstate/interface/mlfg-1279-861/mlfg-1279-861.pxi

@@ -48,8 +48,8 @@ RandomState(seed=None)
 
 Container for a Multiplicative Lagged Fibonacci Generator (MLFG).
 
-LFG(1279, 861, \*) is a 64-bit implementation of a MLFG that uses lags 1279 and
-861 where random numbers are determined by
+LFG(1279, 861, \*) is a 64-bit implementation of an MLFG that uses lags 1279
+and 861 where random numbers are determined by
 
 .. math::
 
@@ -83,7 +83,7 @@ seed : {None, int, array_like}, optional
     Can be an integer in [0, 2**64-1], array of integers in
     [0, 2**64-1] or ``None`` (the default). If `seed` is ``None``,
     then ``mlfg_1279_861.RandomState`` will try to read entropy from
-    ``/dev/urandom`` (or the Windows analogue) if available to
+    ``/dev/urandom`` (or the Windows analog) if available to
     produce a 64-bit seed. If unavailable, a 64-bit hash of the time
     and process ID is used.
 
@@ -98,11 +98,11 @@ state array of the current and lagged values.
 The ``mlfg_1279_861.RandomState`` state vector consists of a 1279 element array
 of 64-bit unsigned integers plus a two integers value between 0 and 1278
 indicating  the current position and the position of the lagged value within
-the main array required to produce the next random. All elements of the 1279
-element state array must be odd.
+the main array required to produce the next random. All 1279 elements of the
+state array must be odd.
 
 ``mlfg_1279_861.RandomState`` is seeded using either a single 64-bit unsigned integer
-or a vector of 64-bit unsigned integers.  In either case the input seed is
+or a vector of 64-bit unsigned integers.  In either case, the input seed is
 used as an input (or inputs) for another simple random number generator,
 Splitmix64, and the output of this PRNG function is used as the initial state.
 Using a single 64-bit value for the seed can only initialize a small range of

randomstate/interface/mrg32k3a/mrg32k3a.pxi

@@ -106,7 +106,7 @@ cdef void jump_state(aug_state* state):
 DEF CLASS_DOCSTRING = u"""
 RandomState(seed=None)
 
-Container for L'Ecuyer MRG32K3A pseudo random number generator.
+Container for L'Ecuyer MRG32K3A pseudo-random number generator.
 
 MRG32K3A is a 32-bit implementation of L'Ecuyer's combined multiple
 recursive generator [1]_, [2]_. MRG32K3A has a period of :math:`2^{191}`,
@@ -136,23 +136,24 @@ seed : {None, int, array_like}, optional
     Can be an integer in [0, 2**64-1], array of integers in
     [0, 2**64-1] or ``None`` (the default). If `seed` is ``None``,
     then ``mrg32k3a.RandomState`` will try to read data from
-    ``/dev/urandom`` (or the Windows analogue) if available. If
+    ``/dev/urandom`` (or the Windows analog) if available. If
     unavailable, a 64-bit hash of the time and process ID is used.
 
 Notes
 -----
 The state of the MRG32KA PRNG is represented by 6 64-bit integers.
 
 This implementation is integer based and produces integers in the interval
-:math:`[0, 2^{32}-209+1]`.  These are treated as if they 32-bit random integers.
+:math:`[0, 2^{32}-209+1]`.  These are treated as if they 32-bit random
+integers.
 
 **Parallel Features**
 
 ``mrg32k3a.RandomState`` can be used in parallel applications by
-calling the method ``jump`` which advances the
-the state as-if :math:`2^{127}` random numbers have been generated [3]_. This
-allow the original sequence to be split so that distinct segments can be used
-on each worker process. All generators should be initialized with the same
+calling the method ``jump`` which advances the state as-if
+:math:`2^{127}` random numbers have been generated [3]_. This
+allows the original sequence to be split so that distinct segments can be used
+in each worker process. All generators should be initialized with the same
 seed to ensure that the segments come from the same sequence.
 
 >>> import randomstate.prng.mrg32k3a as rnd
@@ -170,7 +171,7 @@ elements of the state vector are in [0, 4294967087) and the second 3 are
 in [0, 4294944443).
 
 ``mrg32k3a.RandomState`` is seeded using either a single 64-bit unsigned integer
-or a vector of 64-bit unsigned integers.  In either case the input seed is
+or a vector of 64-bit unsigned integers.  In either case, the input seed is
 used as an input (or inputs) for another simple random number generator,
 Splitmix64, and the output of this PRNG function is used as the initial state.
 Using a single 64-bit value for the seed can only initialize a small range of

randomstate/interface/pcg-32/pcg-32.pxi

@@ -38,7 +38,7 @@ cdef object _set_state(aug_state *state, object state_info):
 DEF CLASS_DOCSTRING = u"""
 RandomState(seed=None)
 
-Container for the PCG-32 pseudo random number generator.
+Container for the PCG-32 pseudo-random number generator.
 
 PCG-32 is a 64-bit implementation of O'Neill's permutation congruential 
 generator ([1]_, [2]_). PCG-32 has a period of :math:`2^{64}` and supports advancing
@@ -67,7 +67,7 @@ seed : {None, long}, optional
     Random seed initializing the pseudo-random number generator.
     Can be an integer in [0, 2**64] or ``None`` (the default).
     If `seed` is ``None``, then ``pcg32.RandomState`` will try to read data
-    from ``/dev/urandom`` (or the Windows analogue) if available. If
+    from ``/dev/urandom`` (or the Windows analog) if available. If
     unavailable, a 64-bit hash of the time and process ID is used.
 inc : {None, int}, optional
     Stream to return.  
@@ -104,7 +104,7 @@ in parallel applications is not recommended.
 
 **State and Seeding**
 
-The ``pcg32.RandomState`` state vector consists of 2 unsigned 64 bit values.
+The ``pcg32.RandomState`` state vector consists of 2 unsigned 64-bit values.
 ``pcg32.RandomState``  is seeded using a single 64-bit unsigned integer.
 In addition, a second 64-bit unsigned integer is used to set the stream.
 

randomstate/interface/pcg-64/pcg-64-docstring.pxi

@@ -1,7 +1,7 @@
 DEF CLASS_DOCSTRING = u"""
 RandomState(seed=None)
 
-Container for the PCG-64 pseudo random number generator.
+Container for the PCG-64 pseudo-random number generator.
 
 PCG-64 is a 128-bit implementation of O'Neill's permutation congruential
 generator ([1]_, [2]_). PCG-64 has a period of :math:`2^{128}` and supports advancing
@@ -30,7 +30,7 @@ seed : {None, long}, optional
     Random seed initializing the pseudo-random number generator.
     Can be an integer in [0, 2**128] or ``None`` (the default).
     If `seed` is ``None``, then ``pcg64.RandomState`` will try to read data
-    from ``/dev/urandom`` (or the Windows analogue) if available. If
+    from ``/dev/urandom`` (or the Windows analog) if available. If
     unavailable, a 64-bit hash of the time and process ID is used.
 inc : {None, int}, optional
     Stream to return.
@@ -64,7 +64,7 @@ produce non-overlapping sequences.
 
 **State and Seeding**
 
-The ``pcg64.RandomState`` state vector consists of 2 unsigned 128 bit values,
+The ``pcg64.RandomState`` state vector consists of 2 unsigned 128-bit values,
 which are represented externally as python longs (2.x) or ints (Python 3+).
 ``pcg64.RandomState`` is seeded using a single 128-bit unsigned integer
 (Python long/int). In addition, a second 128-bit unsigned integer is used

randomstate/interface/random-kit/random-kit.pxi

@@ -75,7 +75,7 @@ seed : {None, int, array_like}, optional
     Can be an integer, an array (or other sequence) of integers of
     any length, or ``None`` (the default).
     If `seed` is ``None``, then ``RandomState`` will try to read data from
-    ``/dev/urandom`` (or the Windows analogue) if available or seed from
+    ``/dev/urandom`` (or the Windows analog) if available or seed from
     the clock otherwise.
 
 Notes

randomstate/interface/xorshift1024/xorshift1024.pxi

@@ -49,12 +49,12 @@ cdef object _set_state(aug_state *state, object state_info):
 DEF CLASS_DOCSTRING = u"""
 RandomState(seed=None)
 
-Container for the xorshift1024* pseudo random number generator.
+Container for the xorshift1024* pseudo-random number generator.
 
 xorshift1024* is a 64-bit implementation of Saito and Matsumoto's XSadd
 generator [1]_. xorshift1024* has a period of :math:`2^{1024} - 1` and
-supports jumping the sequence in increments of :math:`2^{512}`, which allow multiple
-non-overlapping sequences to be generated.
+supports jumping the sequence in increments of :math:`2^{512}`, which allows
+multiple non-overlapping sequences to be generated.
 
 ``xorshift1024.RandomState`` exposes a number of methods for generating random
 numbers drawn from a variety of probability distributions. In addition to the
@@ -80,7 +80,7 @@ seed : {None, int, array_like}, optional
     Can be an integer in [0, 2**64-1], array of integers in
     [0, 2**64-1] or ``None`` (the default). If `seed` is ``None``,
     then ``xorshift1024.RandomState`` will try to read data from
-    ``/dev/urandom`` (or the Windows analogue) if available.  If
+    ``/dev/urandom`` (or the Windows analog) if available.  If
     unavailable, a 64-bit hash of the time and process ID is used.
 
 Notes
@@ -90,10 +90,10 @@ See xorshift128 for a faster implementation that has a smaller period.
 **Parallel Features**
 
 ``xorshift1024.RandomState`` can be used in parallel applications by
-calling the method ``jump`` which advances the
-the state as-if :math:`2^{512}` random numbers have been generated. This
-allow the original sequence to be split so that distinct segments can be used
-on each worker process. All generators should be initialized with the same
+calling the method ``jump`` which advances the state as-if
+:math:`2^{512}` random numbers have been generated. This
+allows the original sequence to be split so that distinct segments can be used
+in each worker process. All generators should be initialized with the same
 seed to ensure that the segments come from the same sequence.
 
 >>> import randomstate.prng.xorshift1024 as rnd
@@ -108,7 +108,7 @@ The ``xorshift1024.RandomState`` state vector consists of a 16 element array
 of 64-bit unsigned integers.
 
 ``xorshift1024.RandomState`` is seeded using either a single 64-bit unsigned integer
-or a vector of 64-bit unsigned integers.  In either case the input seed is
+or a vector of 64-bit unsigned integers.  In either case, the input seed is
 used as an input (or inputs) for another simple random number generator,
 Splitmix64, and the output of this PRNG function is used as the initial state.
 Using a single 64-bit value for the seed can only initialize a small range of

randomstate/interface/xorshift128/xorshift128.pxi

@@ -44,12 +44,12 @@ cdef inline object _set_state(aug_state *state, object state_info):
 DEF CLASS_DOCSTRING = u"""
 RandomState(seed=None)
 
-Container for the xorshift128+ pseudo random number generator.
+Container for the xorshift128+ pseudo-random number generator.
 
 xorshift128+ is a 64-bit implementation of Saito and Matsumoto's XSadd
 generator [1]_. xorshift128+ has a period of :math:`2^{128} - 1` and
-supports jumping the sequence in increments of :math:`2^{64}`, which allow multiple
-non-overlapping sequences to be generated.
+supports jumping the sequence in increments of :math:`2^{64}`, which allows
+multiple non-overlapping sequences to be generated.
 
 ``xorshift128.RandomState`` exposes a number of methods for generating random
 numbers drawn from a variety of probability distributions. In addition to the
@@ -75,7 +75,7 @@ seed : {None, int, array_like}, optional
     Can be an integer in [0, 2**64-1], array of integers in
     [0, 2**64-1] or ``None`` (the default). If `seed` is ``None``,
     then ``xorshift128.RandomState`` will try to read data from
-    ``/dev/urandom`` (or the Windows analogue) if available.  If
+    ``/dev/urandom`` (or the Windows analog) if available.  If
     unavailable, a 64-bit hash of the time and process ID is used.
 
 Notes
@@ -86,10 +86,10 @@ See xorshift1024 for an implementation with a larger period
 **Parallel Features**
 
 ``xorshift128.RandomState`` can be used in parallel applications by
-calling the method ``jump`` which advances the
-the state as-if :math:`2^{64}` random numbers have been generated. This
+calling the method ``jump`` which advances the state as-if
+:math:`2^{64}` random numbers have been generated. This
 allow the original sequence to be split so that distinct segments can be used
-on each worker process. All generators should be initialized with the same
+in each worker process. All generators should be initialized with the same
 seed to ensure that the segments come from the same sequence.
 
 >>> import randomstate.prng.xorshift128 as rnd
@@ -104,7 +104,7 @@ The ``xorshift128.RandomState`` state vector consists of a 2 element array
 of 64-bit unsigned integers.
 
 ``xorshift128.RandomState`` is seeded using either a single 64-bit unsigned integer
-or a vector of 64-bit unsigned integers.  In either case the input seed is
+or a vector of 64-bit unsigned integers.  In either case, the input seed is
 used as an input (or inputs) for another simple random number generator,
 Splitmix64, and the output of this PRNG function is used as the initial state.
 Using a single 64-bit value for the seed can only initialize a small range of