| |
- arange(...)
- arange([start,] stop[, step,], dtype=None)
Return evenly spaced values within a given interval.
Values are generated within the half-open interval ``[start, stop)``
(in other words, the interval including `start` but excluding `stop`).
For integer arguments the function is equivalent to the Python built-in
`range <http://docs.python.org/lib/built-in-funcs.html>`_ function,
but returns an ndarray rather than a list.
When using a non-integer step, such as 0.1, the results will often not
be consistent. It is better to use ``linspace`` for these cases.
Parameters
----------
start : number, optional
Start of interval. The interval includes this value. The default
start value is 0.
stop : number
End of interval. The interval does not include this value, except
in some cases where `step` is not an integer and floating point
round-off affects the length of `out`.
step : number, optional
Spacing between values. For any output `out`, this is the distance
between two adjacent values, ``out[i+1] - out[i]``. The default
step size is 1. If `step` is specified as a position argument,
`start` must also be given.
dtype : dtype
The type of the output array. If `dtype` is not given, infer the data
type from the other input arguments.
Returns
-------
arange : ndarray
Array of evenly spaced values.
For floating point arguments, the length of the result is
``ceil((stop - start)/step)``. Because of floating point overflow,
this rule may result in the last element of `out` being greater
than `stop`.
See Also
--------
linspace : Evenly spaced numbers with careful handling of endpoints.
ogrid: Arrays of evenly spaced numbers in N-dimensions.
mgrid: Grid-shaped arrays of evenly spaced numbers in N-dimensions.
Examples
--------
>>> np.arange(3)
array([0, 1, 2])
>>> np.arange(3.0)
array([ 0., 1., 2.])
>>> np.arange(3,7)
array([3, 4, 5, 6])
>>> np.arange(3,7,2)
array([3, 5])
- grid(gridSpec, commentChar='#', column=0, scale=None, shift=None, reverse=False, verbose=False)
- Parse "gridSpec" and return a numpy array defining a (monotone) grid.
gridSpec can be
* an integer
* a plain ascii file (grid will be read from first (default) column)
* a numpy expression, e.g. 'arange(10)' or 'linspace(10.,20.)'
* a string in the format 'start[step1]stop1[step2]stop' etc to set up an piecewise equidistant grid.
Further arguments:
------------------
commentChar: The character used to indicate the start of a comment in the data file
column: number of column to read from file (default 0 = very first column)
scale: a scaling factor (default None)
shift: a constant to be added (default None)
reverse: flag to flip "up/down"
verbose: flag
- is_uniform(xGrid, eps=0.001, verbose=0)
- Compute grid point spacing and return a flag True/False if xGrid is uniform/equidistant or not.
If verbose, return a string if uniform, otherwise print info and return an empty string.
- parseGridSpec(gridSpec)
- Set up (altitude) grid specified in format 'start[step1]stop1[step2]stop' or similar.
Example: "0[1]10[2]20[2.5]30[5]50" returns an array with 24 grid points.
|