Gecko [ goons4good.org ]

Name	Size	Permission	Date
include	[ DIR ]	drwxr-xr-x	2021-09-16 10:54
lib	[ DIR ]	drwxr-xr-x	2021-09-16 10:54
tests	[ DIR ]	drwxr-xr-x	2021-09-16 10:54
__init__.py	1.71 KB	-rw-r--r--	2013-04-07 01:04
__init__.pyc	1.96 KB	-rw-r--r--	2018-04-10 19:40
__init__.pyo	1.96 KB	-rw-r--r--	2018-04-10 19:40
_dotblas.so	23.57 KB	-rwxr-xr-x	2018-04-10 19:40
_dummy.so	6.74 KB	-rwxr-xr-x	2018-04-10 19:40
_internal.py	16.37 KB	-rw-r--r--	2013-04-07 01:04
_internal.pyc	14.11 KB	-rw-r--r--	2018-04-10 19:40
_internal.pyo	14.11 KB	-rw-r--r--	2018-04-10 19:40
_methods.py	3.75 KB	-rw-r--r--	2013-04-07 01:04
_methods.pyc	4.18 KB	-rw-r--r--	2018-04-10 19:40
_methods.pyo	4.18 KB	-rw-r--r--	2018-04-10 19:40
arrayprint.py	25.21 KB	-rw-r--r--	2013-04-07 01:04
arrayprint.pyc	22.85 KB	-rw-r--r--	2018-04-10 19:40
arrayprint.pyo	22.85 KB	-rw-r--r--	2018-04-10 19:40
defchararray.py	70.67 KB	-rw-r--r--	2013-04-07 01:04
defchararray.pyc	78.49 KB	-rw-r--r--	2018-04-10 19:40
defchararray.pyo	78.49 KB	-rw-r--r--	2018-04-10 19:40
fromnumeric.py	79.16 KB	-rw-r--r--	2013-04-07 01:04
fromnumeric.pyc	81.98 KB	-rw-r--r--	2018-04-10 19:40
fromnumeric.pyo	81.98 KB	-rw-r--r--	2018-04-10 19:40
function_base.py	5.34 KB	-rw-r--r--	2013-04-07 01:04
function_base.pyc	5.7 KB	-rw-r--r--	2018-04-10 19:40
function_base.pyo	5.7 KB	-rw-r--r--	2018-04-10 19:40
generate_numpy_api.py	7.24 KB	-rw-r--r--	2013-04-07 01:04
generate_numpy_api.pyc	6.92 KB	-rw-r--r--	2018-04-10 19:40
generate_numpy_api.pyo	6.92 KB	-rw-r--r--	2018-04-10 19:40
getlimits.py	9.15 KB	-rw-r--r--	2013-04-07 01:04
getlimits.pyc	10.45 KB	-rw-r--r--	2018-04-10 19:40
getlimits.pyo	10.45 KB	-rw-r--r--	2018-04-10 19:40
info.py	4.53 KB	-rw-r--r--	2013-04-07 01:04
info.pyc	4.69 KB	-rw-r--r--	2018-04-10 19:40
info.pyo	4.69 KB	-rw-r--r--	2018-04-10 19:40
machar.py	10.39 KB	-rw-r--r--	2013-04-07 01:04
machar.pyc	8.44 KB	-rw-r--r--	2018-04-10 19:40
machar.pyo	8.44 KB	-rw-r--r--	2018-04-10 19:40
memmap.py	9.64 KB	-rw-r--r--	2013-04-07 01:04
memmap.pyc	9.64 KB	-rw-r--r--	2018-04-10 19:40
memmap.pyo	9.64 KB	-rw-r--r--	2018-04-10 19:40
multiarray.so	1.25 MB	-rwxr-xr-x	2018-04-10 19:40
multiarray_tests.so	15.23 KB	-rwxr-xr-x	2018-04-10 19:40
numeric.py	72.78 KB	-rw-r--r--	2013-04-07 01:04
numeric.pyc	75.76 KB	-rw-r--r--	2018-04-10 19:40
numeric.pyo	75.76 KB	-rw-r--r--	2018-04-10 19:40
numerictypes.py	28.31 KB	-rw-r--r--	2013-04-07 01:04
numerictypes.pyc	26.95 KB	-rw-r--r--	2018-04-10 19:40
numerictypes.pyo	26.9 KB	-rw-r--r--	2018-04-10 19:40
records.py	26.37 KB	-rw-r--r--	2013-04-07 01:04
records.pyc	23.77 KB	-rw-r--r--	2018-04-10 19:40
records.pyo	23.77 KB	-rw-r--r--	2018-04-10 19:40
scalarmath.so	187.89 KB	-rwxr-xr-x	2018-04-10 19:40
scons_support.py	8.16 KB	-rw-r--r--	2013-04-07 01:04
scons_support.pyc	9.03 KB	-rw-r--r--	2018-04-10 19:40
scons_support.pyo	9.03 KB	-rw-r--r--	2018-04-10 19:40
setup.py	37.73 KB	-rw-r--r--	2018-04-10 19:39
setup.pyc	25.07 KB	-rw-r--r--	2018-04-10 19:40
setup.pyo	25.07 KB	-rw-r--r--	2018-04-10 19:40
setup_common.py	10.38 KB	-rw-r--r--	2013-04-07 01:04
setup_common.pyc	8.83 KB	-rw-r--r--	2018-04-10 19:40
setup_common.pyo	8.83 KB	-rw-r--r--	2018-04-10 19:40
setupscons.py	4.41 KB	-rw-r--r--	2013-04-07 01:04
setupscons.pyc	3.95 KB	-rw-r--r--	2018-04-10 19:40
setupscons.pyo	3.95 KB	-rw-r--r--	2018-04-10 19:40
shape_base.py	6.66 KB	-rw-r--r--	2013-04-07 01:04
shape_base.pyc	7.16 KB	-rw-r--r--	2018-04-10 19:40
shape_base.pyo	7.16 KB	-rw-r--r--	2018-04-10 19:40
umath.so	377.02 KB	-rwxr-xr-x	2018-04-10 19:40
umath_tests.so	15.26 KB	-rwxr-xr-x	2018-04-10 19:40

Rename

__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 : 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)
    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 : 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)
    ... # 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)
    return _nx.power(base,y)