diff options
Diffstat (limited to 'numpy/core')
| -rw-r--r-- | numpy/core/__init__.py | 2 | ||||
| -rw-r--r-- | numpy/core/function_base.py | 159 | ||||
| -rw-r--r-- | numpy/core/tests/test_function_base.py | 37 |
3 files changed, 198 insertions, 0 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) + |