Move linspace and logspace into core.

3 files changed, 7 insertions, 192 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
diff --git a/numpy/lib/tests/test_function_base.py b/numpy/lib/tests/test_function_base.py
index cfb316074..8595c6b5c 100644
--- a/numpy/lib/tests/test_function_base.py
+++ b/numpy/lib/tests/test_function_base.py
@@ -134,42 +134,6 @@ class TestSelect(TestCase):
         assert_equal(len(choices),3)
         assert_equal(len(conditions),3)
 
-class TestLogspace(TestCase):
-    def test_basic(self):
-        y = logspace(0,6)
-        assert(len(y)==50)
-        y = logspace(0,6,num=100)
-        assert(y[-1] == 10**6)
-        y = logspace(0,6,endpoint=0)
-        assert(y[-1] < 10**6)
-        y = logspace(0,6,num=7)
-        assert_array_equal(y,[1,10,100,1e3,1e4,1e5,1e6])
-
-class TestLinspace(TestCase):
-    def test_basic(self):
-        y = linspace(0,10)
-        assert(len(y)==50)
-        y = linspace(2,10,num=100)
-        assert(y[-1] == 10)
-        y = linspace(2,10,endpoint=0)
-        assert(y[-1] < 10)
-        y,st = linspace(2,10,retstep=1)
-        assert_almost_equal(st,8/49.0)
-        assert_array_almost_equal(y,mgrid[2:10:50j],13)
-
-    def test_corner(self):
-        y = list(linspace(0,1,1))
-        assert y == [0.0], y
-        y = list(linspace(0,1,2.5))
-        assert y == [0.0, 1.0]
-
-    def test_type(self):
-        t1 = linspace(0,1,0).dtype
-        t2 = linspace(0,1,1).dtype
-        t3 = linspace(0,1,2).dtype
-        assert_equal(t1, t2)
-        assert_equal(t2, t3)
-
 class TestInsert(TestCase):
     def test_basic(self):
         a = [1,2,3]
diff --git a/numpy/lib/tests/test_index_tricks.py b/numpy/lib/tests/test_index_tricks.py
index d7e61799a..3307cef3e 100644
--- a/numpy/lib/tests/test_index_tricks.py
+++ b/numpy/lib/tests/test_index_tricks.py
@@ -24,6 +24,11 @@ class TestGrid(TestCase):
         assert_almost_equal(b[-1],b[0]+19*0.1,11)
         assert_almost_equal(a[1]-a[0],2.0/9.0,11)
 
+    def test_linspace_equivalence(self):
+        y,st = np.linspace(2,10,retstep=1)
+        assert_almost_equal(st,8/49.0)
+        assert_array_almost_equal(y,mgrid[2:10:50j],13)
+
     def test_nd(self):
         c = mgrid[-1:1:10j,-2:2:10j]
         d = mgrid[-1:1:0.1,-2:2:0.2]