Move linspace and logspace into core.

1 files changed, 2 insertions, 156 deletions

diff --git a/numpy/lib/function_base.py b/numpy/lib/function_base.py
index 663c3d2ef..2459ffc23 100644
--- a/numpy/lib/function_base.py
+++ b/numpy/lib/function_base.py
@@ -1,6 +1,5 @@
 __docformat__ = "restructuredtext en"
-__all__ = ['logspace', 'linspace',
-           'select', 'piecewise', 'trim_zeros',
+__all__ = ['select', 'piecewise', 'trim_zeros',
            'copy', 'iterable',
            'diff', 'gradient', 'angle', 'unwrap', 'sort_complex', 'disp',
            'extract', 'place', 'nansum', 'nanmax', 'nanargmax',
@@ -15,6 +14,7 @@ import warnings
 
 import types
 import numpy.core.numeric as _nx
+from numpy.core import linspace
 from numpy.core.numeric import ones, zeros, arange, concatenate, array, \
      asarray, asanyarray, empty, empty_like, ndarray, around
 from numpy.core.numeric import ScalarType, dot, where, newaxis, intp, \
@@ -33,160 +33,6 @@ import numpy as np
 
 #end Fernando's utilities
 
-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)
-
 def iterable(y):
     try: iter(y)
     except: return 0