|
from __future__ import division, absolute_import, print_function |
|
|
|
__all__ = ['logspace', 'linspace'] |
|
|
|
from . import numeric as _nx |
|
from .numeric import array, result_type |
|
|
|
|
|
def linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None): |
|
""" |
|
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. |
|
dtype : dtype |
|
The type of the output array. If `dtype` is not given, infer the data |
|
type from the other input arguments. |
|
|
|
.. versionadded:: 1.9.0 |
|
|
|
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 : Similar 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') |
|
[<matplotlib.lines.Line2D object at 0x...>] |
|
>>> plt.plot(x2, y + 0.5, 'o') |
|
[<matplotlib.lines.Line2D object at 0x...>] |
|
>>> plt.ylim([-0.5, 1]) |
|
(-0.5, 1) |
|
>>> plt.show() |
|
|
|
""" |
|
num = int(num) |
|
|
|
|
|
start = start * 1. |
|
stop = stop * 1. |
|
|
|
if dtype is None: |
|
dtype = result_type(start, stop, float(num)) |
|
|
|
if num <= 0: |
|
return array([], dtype) |
|
if endpoint: |
|
if num == 1: |
|
return array([start], dtype=dtype) |
|
step = (stop-start)/float((num-1)) |
|
y = _nx.arange(0, num, dtype=dtype) * step + start |
|
y[-1] = stop |
|
else: |
|
step = (stop-start)/float(num) |
|
y = _nx.arange(0, num, dtype=dtype) * step + start |
|
if retstep: |
|
return y.astype(dtype), step |
|
else: |
|
return y.astype(dtype) |
|
|
|
|
|
def logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None): |
|
""" |
|
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. |
|
dtype : dtype |
|
The type of the output array. If `dtype` is not given, infer the data |
|
type from the other input arguments. |
|
|
|
Returns |
|
------- |
|
samples : ndarray |
|
`num` samples, equally spaced on a log scale. |
|
|
|
See Also |
|
-------- |
|
arange : Similar 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 = np.linspace(start, stop, num=num, endpoint=endpoint) |
|
... # doctest: +SKIP |
|
>>> power(base, y).astype(dtype) |
|
... # doctest: +SKIP |
|
|
|
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') |
|
[<matplotlib.lines.Line2D object at 0x...>] |
|
>>> plt.plot(x2, y + 0.5, 'o') |
|
[<matplotlib.lines.Line2D object at 0x...>] |
|
>>> plt.ylim([-0.5, 1]) |
|
(-0.5, 1) |
|
>>> plt.show() |
|
|
|
""" |
|
y = linspace(start, stop, num=num, endpoint=endpoint) |
|
if dtype is None: |
|
return _nx.power(base, y) |
|
return _nx.power(base, y).astype(dtype) |
|
|
