Move linspace and logspace into core.

1 files changed, 159 insertions, 0 deletions

diff --git a/numpy/core/function_base.py b/numpy/core/function_base.py
new file mode 100644
index 000000000..33cf3a15b
--- /dev/null
+++ b/numpy/core/function_base.py
@@ -0,0 +1,159 @@
+__all__ = ['logspace', 'linspace']
+
+import numeric as _nx
+from numeric import array
+
+def linspace(start, stop, num=50, endpoint=True, retstep=False):
+    """
+    Return evenly spaced numbers over a specified interval.
+
+    Returns `num` evenly spaced samples, calculated over the
+    interval [`start`, `stop` ].
+
+    The endpoint of the interval can optionally be excluded.
+
+    Parameters
+    ----------
+    start : scalar
+        The starting value of the sequence.
+    stop : scalar
+        The end value of the sequence, unless `endpoint` is set to False.
+        In that case, the sequence consists of all but the last of ``num + 1``
+        evenly spaced samples, so that `stop` is excluded.  Note that the step
+        size changes when `endpoint` is False.
+    num : int, optional
+        Number of samples to generate. Default is 50.
+    endpoint : bool, optional
+        If True, `stop` is the last sample. Otherwise, it is not included.
+        Default is True.
+    retstep : bool, optional
+        If True, return (`samples`, `step`), where `step` is the spacing
+        between samples.
+
+    Returns
+    -------
+    samples : ndarray
+        There are `num` equally spaced samples in the closed interval
+        ``[start, stop]`` or the half-open interval ``[start, stop)``
+        (depending on whether `endpoint` is True or False).
+    step : float (only if `retstep` is True)
+        Size of spacing between samples.
+
+
+    See Also
+    --------
+    arange : Similiar to `linspace`, but uses a step size (instead of the
+             number of samples).
+    logspace : Samples uniformly distributed in log space.
+
+    Examples
+    --------
+    >>> np.linspace(2.0, 3.0, num=5)
+        array([ 2.  ,  2.25,  2.5 ,  2.75,  3.  ])
+    >>> np.linspace(2.0, 3.0, num=5, endpoint=False)
+        array([ 2. ,  2.2,  2.4,  2.6,  2.8])
+    >>> np.linspace(2.0, 3.0, num=5, retstep=True)
+        (array([ 2.  ,  2.25,  2.5 ,  2.75,  3.  ]), 0.25)
+
+    Graphical illustration:
+
+    >>> import matplotlib.pyplot as plt
+    >>> N = 8
+    >>> y = np.zeros(N)
+    >>> x1 = np.linspace(0, 10, N, endpoint=True)
+    >>> x2 = np.linspace(0, 10, N, endpoint=False)
+    >>> plt.plot(x1, y, 'o')
+    >>> plt.plot(x2, y + 0.5, 'o')
+    >>> plt.ylim([-0.5, 1])
+    >>> plt.show()
+
+    """
+    num = int(num)
+    if num <= 0:
+        return array([], float)
+    if endpoint:
+        if num == 1:
+            return array([float(start)])
+        step = (stop-start)/float((num-1))
+        y = _nx.arange(0, num) * step + start
+        y[-1] = stop
+    else:
+        step = (stop-start)/float(num)
+        y = _nx.arange(0, num) * step + start
+    if retstep:
+        return y, step
+    else:
+        return y
+
+def logspace(start,stop,num=50,endpoint=True,base=10.0):
+    """
+    Return numbers spaced evenly on a log scale.
+
+    In linear space, the sequence starts at ``base ** start``
+    (`base` to the power of `start`) and ends with ``base ** stop``
+    (see `endpoint` below).
+
+    Parameters
+    ----------
+    start : float
+        ``base ** start`` is the starting value of the sequence.
+    stop : float
+        ``base ** stop`` is the final value of the sequence, unless `endpoint`
+        is False.  In that case, ``num + 1`` values are spaced over the
+        interval in log-space, of which all but the last (a sequence of
+        length ``num``) are returned.
+    num : integer, optional
+        Number of samples to generate.  Default is 50.
+    endpoint : boolean, optional
+        If true, `stop` is the last sample. Otherwise, it is not included.
+        Default is True.
+    base : float, optional
+        The base of the log space. The step size between the elements in
+        ``ln(samples) / ln(base)`` (or ``log_base(samples)``) is uniform.
+        Default is 10.0.
+
+    Returns
+    -------
+    samples : ndarray
+        `num` samples, equally spaced on a log scale.
+
+    See Also
+    --------
+    arange : Similiar to linspace, with the step size specified instead of the
+             number of samples. Note that, when used with a float endpoint, the
+             endpoint may or may not be included.
+    linspace : Similar to logspace, but with the samples uniformly distributed
+               in linear space, instead of log space.
+
+    Notes
+    -----
+    Logspace is equivalent to the code
+
+    >>> y = linspace(start, stop, num=num, endpoint=endpoint)
+    >>> power(base, y)
+
+    Examples
+    --------
+    >>> np.logspace(2.0, 3.0, num=4)
+        array([  100.        ,   215.443469  ,   464.15888336,  1000.        ])
+    >>> np.logspace(2.0, 3.0, num=4, endpoint=False)
+        array([ 100.        ,  177.827941  ,  316.22776602,  562.34132519])
+    >>> np.logspace(2.0, 3.0, num=4, base=2.0)
+        array([ 4.        ,  5.0396842 ,  6.34960421,  8.        ])
+
+    Graphical illustration:
+
+    >>> import matplotlib.pyplot as plt
+    >>> N = 10
+    >>> x1 = np.logspace(0.1, 1, N, endpoint=True)
+    >>> x2 = np.logspace(0.1, 1, N, endpoint=False)
+    >>> y = np.zeros(N)
+    >>> plt.plot(x1, y, 'o')
+    >>> plt.plot(x2, y + 0.5, 'o')
+    >>> plt.ylim([-0.5, 1])
+    >>> plt.show()
+
+    """
+    y = linspace(start,stop,num=num,endpoint=endpoint)
+    return _nx.power(base,y)
+