Move linspace and logspace into core.

6 files changed, 205 insertions, 192 deletions

diff --git a/numpy/core/__init__.py b/numpy/core/__init__.py
index b7f5f2cb9..39ce94ac4 100644
--- a/numpy/core/__init__.py
+++ b/numpy/core/__init__.py
@@ -16,6 +16,7 @@ from records import *
 from memmap import *
 from defchararray import *
 import scalarmath
+from function_base import *
 del nt
 
 from fromnumeric import amax as max, amin as min, \
@@ -27,6 +28,7 @@ __all__ += numeric.__all__
 __all__ += fromnumeric.__all__
 __all__ += rec.__all__
 __all__ += char.__all__
+__all__ += function_base.__all__
 
 
 from numpy.testing import Tester
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)
+
diff --git a/numpy/core/tests/test_function_base.py b/numpy/core/tests/test_function_base.py
new file mode 100644
index 000000000..67ce8953f
--- /dev/null
+++ b/numpy/core/tests/test_function_base.py
@@ -0,0 +1,37 @@
+
+from numpy.testing import *
+from numpy import logspace, linspace
+
+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)
+
+    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)
+
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]