new noises, update of steps

Author: matousc89

setup.py

@@ -11,7 +11,7 @@ def readme():
 setup(
     name = 'signalz',
     packages = find_packages(exclude=("tests",)),
-    version = '0.3',
+    version = '0.4',
     description = 'Data generators in Python',
     long_description = readme(),
     author = 'Matous Cejnek',
@@ -20,7 +20,7 @@ def readme():
     license = 'MIT',
     url = 'http://matousc89.github.io/signalz/',
     download_url = 'https://github.com/matousc89/signalz/',
-    keywords = ['signals', 'data', 'time-series', 'generators', 'models'],
+    keywords = ['signals', 'data', 'time-series', 'generators', 'models', 'noise'],
     install_requires=[
         'numpy',
     ],    

signalz/__init__.py

@@ -35,6 +35,7 @@
 .. cssclass:: functag
 
     :ref:`tags-goniometric` 
+    
 
 .. cssclass:: funcitem
 
@@ -43,6 +44,7 @@
 .. cssclass:: functag
 
     :ref:`tags-goniometric` 
+    
 
 .. cssclass:: funcitem
 
@@ -51,6 +53,7 @@
 .. cssclass:: functag
 
     :ref:`tags-steps` 
+    
 
 .. cssclass:: funcitem
 
@@ -59,6 +62,7 @@
 .. cssclass:: functag
 
     :ref:`tags-steps`, :ref:`tags-random` 
+    
 
 .. cssclass:: funcitem
 
@@ -67,14 +71,34 @@
 .. cssclass:: functag
 
     :ref:`tags-chaotic` 
+    
 
 .. cssclass:: funcitem
 
-    * :ref:`generators-white_noise`
+    * :ref:`generators-gaussian_white_noise`
 
 .. cssclass:: functag
 
-    :ref:`tags-random` 
+    :ref:`tags-random`, :ref:`tags-noise` 
+    
+
+.. cssclass:: funcitem
+
+    * :ref:`generators-uniform_white_noise`
+
+.. cssclass:: functag
+
+    :ref:`tags-random`, :ref:`tags-noise`
+    
+
+.. cssclass:: funcitem
+
+    * :ref:`generators-brownian_noise`
+
+.. cssclass:: functag
+
+    :ref:`tags-random`, :ref:`tags-noise`
+    
 
 .. cssclass:: funcitem
 
@@ -83,6 +107,7 @@
 .. cssclass:: functag
 
     :ref:`tags-autoregressive` 
+    
 
 .. cssclass:: funcitem
 

signalz/generators/__init__.py

@@ -1,5 +1,7 @@
 from signalz.generators.autoregressive_model import autoregressive_model
-from signalz.generators.white_noise import white_noise
+from signalz.generators.gaussian_white_noise import gaussian_white_noise
+from signalz.generators.brownian_noise import brownian_noise
+from signalz.generators.uniform_white_noise import uniform_white_noise
 from signalz.generators.mackey_glass import mackey_glass
 from signalz.generators.sinus import sinus
 from signalz.generators.cosinus import cosinus

signalz/generators/autoregressive_model.py

@@ -62,7 +62,7 @@
 ======================================
 """
 import numpy as np
-from signalz.generators.white_noise import white_noise
+from signalz.generators.gaussian_white_noise import gaussian_white_noise
 
 import signalz
 
@@ -105,7 +105,7 @@ def autoregressive_model(n, a, const=0, noise="white", initials="none"):
         if noise == "none":
             noise = np.zeros(n)
         elif noise == "white":
-            noise = white_noise(n)
+            noise = gaussian_white_noise(n)
     else:
         try:
             noise = np.array(noise)
@@ -116,7 +116,7 @@ def autoregressive_model(n, a, const=0, noise="white", initials="none"):
     x = np.zeros(n)
     # handle initials 
     if initials == "random":
-        x[:taps] = white_noise(taps)
+        x[:taps] = gaussian_white_noise(taps)
     elif initials == "none":
         pass   
     else:

signalz/generators/brownian_noise.py

@@ -0,0 +1,75 @@
+"""
+.. versionadded:: 0.4
+
+This function generates Brownian noise series. The noise is produced by
+integration of white noise (gaussian or uniform).
+
+This function uses
+`numpy.random.normal` and `numpy.random.uniform`
+
+Example Usage
+==================
+
+The following example produce 1000 samples of brownian noise starting in
+value 10 (`start=10`). The noise is produced by integration of white gaussian
+noise (`source="gaussian"`) with standard deviation of 1 (`std=1`).
+To keep in noise in some reasonable range,
+it is used 10% leaky integration (`leak=0.1`).
+
+.. code-block:: python
+
+    import signalz
+    x = signalz.brownian_noise(1000, leak=0.1, start=10, std=1, source="gaussian")
+
+Function Documentation
+======================================
+"""
+import numpy as np
+
+from signalz.misc import check_type_or_raise
+from signalz.generators.gaussian_white_noise import gaussian_white_noise
+from signalz.generators.uniform_white_noise import uniform_white_noise
+
+def brownian_noise(n, leak=0., start=0, std=1., source="gaussian"):
+    """
+    Random values with uniform distribution.
+
+    **Args:**
+    
+    * `n` - length of the output data (int) - how many samples will be on output
+    
+    **Kwargs:**
+    
+    * `leak` - leakage during integration (float), this should prevent signal
+      from wander off. Possible value is `0 <= leak < 1`
+      
+    * `start` - offset on the start (float)
+
+    * `std` - standard deviation of source white noise (float), in case of
+      uniform distribution it is the difference between min and max value. 
+    
+    * `source` - distribution of source white noise (str). Options are
+      `gaussian` or `uniform`
+    
+    **Returns:**
+    
+    * vector of values representing the noise (1d array)
+    """
+    # check inputs
+    check_type_or_raise(n, int, "n")
+    check_type_or_raise(leak, float, "leak")
+    if not 0. <= leak < 1:
+        raise ValueError("Leak must be between 0. and 1.")
+    # generate white noise
+    if source == "gaussian":
+        x = np.random.normal(0, std, n)
+    elif source == "uniform":
+        x = np.random.uniform(-std/2., std/2., n)
+    else:
+        raise ValueError("Source must be gaussian or uniform")
+    # add offset
+    x[0] = start
+    # integrate the white noise    
+    for i in range(1,n):
+        x[i] += x[i-1]*(1-leak)
+    return x

signalz/generators/white_noise.py renamed to signalz/generators/gaussian_white_noise.py

@@ -1,15 +1,16 @@
 """
 .. versionadded:: 0.1
+.. versionchanged:: 0.4
 
-This function generates white noise series. This function uses
+This function generates Gaussian white noise series. This function uses
 `numpy.random.normal`.
 
 Function Documentation
 ======================================
 """
 import numpy as np
 
-def white_noise(n, offset=0, std=1):
+def gaussian_white_noise(n, offset=0, std=1):
     """
     Random values with normal distribution.
 
@@ -25,6 +26,6 @@ def white_noise(n, offset=0, std=1):
     
     **Returns:**
     
-    * vector of random values (1d array)   
+    * vector of values representing the noise (1d array)   
     """
     return np.random.normal(offset, std, n)

signalz/generators/random_steps.py

@@ -1,5 +1,6 @@
 """
 .. versionadded:: 0.2
+.. versionchanged:: 0.4
 
 This function generates random steps according to given width of steps and
 desired number of steps.
@@ -21,39 +22,43 @@
 .. code-block:: python
 
     import signalz
-    x = signalz.random_steps(50, 10, distribution="normal", std=30, mean=-10)
+    x = signalz.random_steps(50, steps_count=10, distribution="normal", std=30, mean=-10)
     
-Another example, this time with uniform distribution - values in range from 10
-to 20.
+Another example, this time the size of the data is not requested by number of
+steps, but by number of samples (`size=500`). 
 
 .. code-block:: python
 
     import signalz
-    x = signalz.random_steps(50, 10, distribution="uniform", minimum=10, maximum=20)
+    x = signalz.random_steps(50, size=500)
 
 Function Documentation
 ======================================
 """
 import numpy as np
 import matplotlib.pylab as plt
 
+from signalz.misc import check_type_or_raise
 import signalz
 
-def random_steps(steps_count, step_width, distribution="normal", maximum=1,
-    minimum=0, std=1, mean=0):
+def random_steps(step_width, steps_count=10, size=None, distribution="normal",
+    maximum=1, minimum=0, std=1, mean=0):
     """
     This function generates random steps.
     
     **Args:**
     
-    * `steps_count` - desired number steps (int)
-    
     * `step_width` - desired width of every step (int)
-    
+       
     **Kwargs:**
-         
-    * `repeat` - number of step sequence repetions (int)
     
+    * `steps_count` - desired number steps (int), this variable is used,
+      if the `size` is not defined
+    
+    * `size` - lenght of desired output in samples (int),
+      if this variable is defined,
+      it determines the size of data instead of `steps_count`
+             
     * `distribution` - distribution of random numbers (str), Options are
       `normal` and `uniform`.
       
@@ -64,22 +69,32 @@ def random_steps(steps_count, step_width, distribution="normal", maximum=1,
       in case of uniform distribution.
     
     * `std` - standard deviation of random variable (float), this value
-      is used in case of normal distribution.
+      is used in case of gaussian (normal) distribution.
       
     * `mean` - mean value of random variable (float), this value
-      is used in case of normal distribution.
+      is used in case of gaussian (normal) distribution.
     
     **Returns:**
     
-    * `x` - array of values describing desired steps (1d array)
+    * vector of values representing desired steps (1d array)
     """ 
-    # generate values
-    values = False
-    if distribution == "normal":
-        values = np.random.normal(mean, std, 10)    
+    # check values
+    check_type_or_raise(steps_count, int, "steps count")
+    check_type_or_raise(step_width, int, "step width")
+    # get correct number of steps if size is defined
+    if not size is None:
+        check_type_or_raise(size, int, "size")
+        steps_count = int(np.ceil(size / float(step_width)))
+    # generate random values
+    if distribution in ["normal", "gaussian"]:
+        values = signalz.gaussian_white_noise(steps_count, offset=mean, std=std)   
     elif distribution == "uniform":
-        values = np.random.random(steps_count) * float(maximum-minimum)
-        values = values + minimum
+        values = signalz.uniform_white_noise(steps_count, minimum=minimum,
+            maximum=maximum)
     # generate steps
     x = signalz.steps(step_width, values)
-    return x
+    if size is None:
+        return x
+    else:
+        return x[:size]
+