Here are the examples of the python api numpy.atleast_1d taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.
155 Examples
0
Example 151
def __init__(self, n_components=1, **kwargs):
self.n_components = np.atleast_1d(n_components)
self.kwargs = kwargs
0
Example 152
Project: astroML Source File: generate.py
def generate_damped_RW(t_rest, tau=300., z=2.0,
xmean=0, SFinf=0.3, random_state=None):
"""Generate a damped random walk light curve
This uses a damped random walk model to generate a light curve similar
to that of a QSO [1]_.
Parameters
----------
t_rest : array_like
rest-frame time. Should be in increasing order
tau : float
relaxation time
z : float
redshift
xmean : float (optional)
mean value of random walk; default=0
SFinf : float (optional
Structure function at infinity; default=0.3
random_state : None, int, or np.random.RandomState instance (optional)
random seed or random number generator
Returns
-------
x : ndarray
the sampled values corresponding to times t_rest
Notes
-----
The differential equation is (with t = time/tau):
dX = -X(t) * dt + sigma * sqrt(tau) * e(t) * sqrt(dt) + b * tau * dt
where e(t) is white noise with zero mean and unit variance, and
Xmean = b * tau
SFinf = sigma * sqrt(tau / 2)
so
dX(t) = -X(t) * dt + sqrt(2) * SFint * e(t) * sqrt(dt) + Xmean * dt
References
----------
.. [1] Kelly, B., Bechtold, J. & Siemiginowska, A. (2009)
Are the Variations in Quasar Optical Flux Driven by Thermal
Fluctuations? ApJ 698:895 (2009)
"""
# Xmean = b * tau
# SFinf = sigma * sqrt(tau / 2)
t_rest = np.atleast_1d(t_rest)
if t_rest.ndim != 1:
raise ValueError('t_rest should be a 1D array')
random_state = check_random_state(random_state)
N = len(t_rest)
t_obs = t_rest * (1. + z) / tau
x = np.zeros(N)
x[0] = random_state.normal(xmean, SFinf)
E = random_state.normal(0, 1, N)
for i in range(1, N):
dt = t_obs[i] - t_obs[i - 1]
x[i] = (x[i - 1]
- dt * (x[i - 1] - xmean)
+ np.sqrt(2) * SFinf * E[i] * np.sqrt(dt))
return x
0
Example 153
def meshgrid(*xi, **kwargs):
"""
Return coordinate matrices from two or more coordinate vectors.
Make N-D coordinate arrays for vectorized evaluations of
N-D scalar/vector fields over N-D grids, given
one-dimensional coordinate arrays x1, x2,..., xn.
Parameters
----------
x1, x2,..., xn : array_like
1-D arrays representing the coordinates of a grid.
indexing : {'xy', 'ij'}, optional
Cartesian ('xy', default) or matrix ('ij') indexing of output.
See Notes for more details.
sparse : bool, optional
If True a sparse grid is returned in order to conserve memory.
Default is False.
copy : bool, optional
If False, a view into the original arrays are returned in
order to conserve memory. Default is True. Please note that
``sparse=False, copy=False`` will likely return non-contiguous arrays.
Furthermore, more than one element of a broadcast array may refer to
a single memory location. If you need to write to the arrays, make
copies first.
Returns
-------
X1, X2,..., XN : ndarray
For vectors `x1`, `x2`,..., 'xn' with lengths ``Ni=len(xi)`` ,
return ``(N1, N2, N3,...Nn)`` shaped arrays if indexing='ij'
or ``(N2, N1, N3,...Nn)`` shaped arrays if indexing='xy'
with the elements of `xi` repeated to fill the matrix along
the first dimension for `x1`, the second for `x2` and so on.
Notes
-----
This function supports both indexing conventions through the indexing
keyword argument.
Giving the string 'ij' returns a meshgrid with matrix indexing,
while 'xy' returns a meshgrid with Cartesian indexing. In the 2-D case
with inputs of length M and N, the outputs are of shape (N, M) for 'xy'
indexing and (M, N) for 'ij' indexing. In the 3-D case with inputs of
length M, N and P, outputs are of shape (N, M, P) for 'xy' indexing and (M,
N, P) for 'ij' indexing. The difference is illustrated by the following
code snippet::
xv, yv = meshgrid(x, y, sparse=False, indexing='ij')
for i in range(nx):
for j in range(ny):
# treat xv[i,j], yv[i,j]
xv, yv = meshgrid(x, y, sparse=False, indexing='xy')
for i in range(nx):
for j in range(ny):
# treat xv[j,i], yv[j,i]
See Also
--------
index_tricks.mgrid : Construct a multi-dimensional "meshgrid"
using indexing notation.
index_tricks.ogrid : Construct an open multi-dimensional "meshgrid"
using indexing notation.
Examples
--------
>>> nx, ny = (3, 2)
>>> x = np.linspace(0, 1, nx)
>>> y = np.linspace(0, 1, ny)
>>> xv, yv = meshgrid(x, y)
>>> xv
array([[ 0. , 0.5, 1. ],
[ 0. , 0.5, 1. ]])
>>> yv
array([[ 0., 0., 0.],
[ 1., 1., 1.]])
>>> xv, yv = meshgrid(x, y, sparse=True) # make sparse output arrays
>>> xv
array([[ 0. , 0.5, 1. ]])
>>> yv
array([[ 0.],
[ 1.]])
`meshgrid` is very useful to evaluate functions on a grid.
>>> x = np.arange(-5, 5, 0.1)
>>> y = np.arange(-5, 5, 0.1)
>>> xx, yy = meshgrid(x, y, sparse=True)
>>> z = np.sin(xx**2 + yy**2) / (xx**2 + yy**2)
>>> h = plt.contourf(x,y,z)
"""
if len(xi) < 2:
msg = ('meshgrid() takes 2 or more arguments (%d given)'
% int(len(xi) > 0))
raise ValueError(msg)
args = np.atleast_1d(*xi)
ndim = len(args)
copy_ = kwargs.get('copy', True)
sparse = kwargs.get('sparse', False)
indexing = kwargs.get('indexing', 'xy')
if not indexing in ['xy', 'ij']:
raise ValueError("Valid values for `indexing` are 'xy' and 'ij'.")
s0 = (1,) * ndim
output = [x.reshape(s0[:i] + (-1,) + s0[i + 1::])
for i, x in enumerate(args)]
shape = [x.size for x in output]
if indexing == 'xy':
# switch first and second axis
output[0].shape = (1, -1) + (1,) * (ndim - 2)
output[1].shape = (-1, 1) + (1,) * (ndim - 2)
shape[0], shape[1] = shape[1], shape[0]
if sparse:
if copy_:
return [x.copy() for x in output]
else:
return output
else:
# Return the full N-D matrix (not only the 1-D vector)
if copy_:
mult_fact = np.ones(shape, dtype=int)
return [x * mult_fact for x in output]
else:
return np.broadcast_arrays(*output)
0
Example 154
Project: numdifftools Source File: extrapolation.py
def dea3(v0, v1, v2, symmetric=False):
"""
Extrapolate a slowly convergent sequence
Parameters
----------
v0, v1, v2 : array-like
3 values of a convergent sequence to extrapolate
Returns
-------
result : array-like
extrapolated value
abserr : array-like
absolute error estimate
Description
-----------
DEA3 attempts to extrapolate nonlinearly to a better estimate
of the sequence's limiting value, thus improving the rate of
convergence. The routine is based on the epsilon algorithm of
P. Wynn, see [1]_.
Example
-------
# integrate sin(x) from 0 to pi/2
>>> import numpy as np
>>> import numdifftools as nd
>>> Ei= np.zeros(3)
>>> linfun = lambda i : np.linspace(0, np.pi/2., 2**(i+5)+1)
>>> for k in np.arange(3):
... x = linfun(k)
... Ei[k] = np.trapz(np.sin(x),x)
>>> [En, err] = nd.dea3(Ei[0], Ei[1], Ei[2])
>>> truErr = Ei-1.
>>> (truErr, err, En)
(array([ -2.00805680e-04, -5.01999079e-05, -1.25498825e-05]),
array([ 0.00020081]), array([ 1.]))
See also
--------
dea
Reference
---------
.. [1] C. Brezinski and M. Redivo Zaglia (1991)
"Extrapolation Methods. Theory and Practice", North-Holland.
.. [2] C. Brezinski (1977)
"Acceleration de la convergence en analyse numerique",
"Lecture Notes in Math.", vol. 584,
Springer-Verlag, New York, 1977.
.. [3] E. J. Weniger (1989)
"Nonlinear sequence transformations for the acceleration of
convergence and the summation of divergent series"
Computer Physics Reports Vol. 10, 189 - 371
http://arxiv.org/abs/math/0306302v1
"""
e0, e1, e2 = np.atleast_1d(v0, v1, v2)
with warnings.catch_warnings():
warnings.simplefilter("ignore") # ignore division by zero and overflow
delta2, delta1 = e2 - e1, e1 - e0
err2, err1 = np.abs(delta2), np.abs(delta1)
tol2, tol1 = max_abs(e2, e1) * _EPS, max_abs(e1, e0) * _EPS
delta1[err1 < _TINY] = _TINY
delta2[err2 < _TINY] = _TINY # avoid division by zero and overflow
ss = 1.0 / delta2 - 1.0 / delta1 + _TINY
smalle2 = abs(ss * e1) <= 1.0e-3
converged = (err1 <= tol1) & (err2 <= tol2) | smalle2
result = np.where(converged, e2 * 1.0, e1 + 1.0 / ss)
abserr = err1 + err2 + np.where(converged, tol2 * 10, np.abs(result - e2))
if symmetric and len(result) > 1:
return result[:-1], abserr[1:]
return result, abserr
0
Example 155
@staticmethod
def test_on_matrix_valued_function():
def fun(x):
x = np.atleast_1d(x)
f0 = x[0] ** 2 + x[1] ** 2
f1 = x[0] ** 3 + x[1] ** 3
return np.array([f0, f1])
def dfun(x):
x = np.atleast_1d(x)
f0_d0 = np.atleast_1d(x[0] * 2)
f0_d1 = np.atleast_1d(x[1] * 2)
f1_d0 = np.atleast_1d(3 * x[0] ** 2)
f1_d1 = np.atleast_1d(3 * x[1] ** 2)
df0 = np.hstack([np.diag(f0_d0), np.diag(f0_d1)])
df1 = np.hstack([np.diag(f1_d0), np.diag(f1_d1)])
return np.array([df0, df1]).squeeze()
x = np.array([(1, 2, 3, 4),
(5, 6, 7, 8)], dtype=float)
y = fun(x)
assert_allclose(y, [[26., 40., 58., 80.],
[126., 224., 370., 576.]])
jaca = nd.Jacobian(fun)
assert_allclose(jaca([1, 2]), [[2., 4.],
[3., 12.]])
assert_allclose(jaca([3, 4]), [[6., 8.],
[27., 48.]])
assert_allclose(jaca([1, 2]), dfun([1, 2]))
assert_allclose(jaca([3, 4]), dfun([3, 4]))
v0 = jaca([[1, 2], [3, 4]])
assert_allclose(v0,
dfun([[1, 2],
[3, 4]]))
assert_allclose(v0,
[[[2., 0., 6., 0.],
[0., 4., 0., 8.]],
[[3., 0., 27., 0.],
[0., 12., 0., 48.]]])
v0 = approx_fprime(x, fun)
assert_allclose(v0,
[[[2., 4., 6., 8.],
[10., 12., 14., 16.]],
[[3., 12., 27., 48.],
[75., 108., 147., 192.]]])
val = jaca(x)
assert_allclose(val,
[[[2., 0., 0., 0., 10., 0., 0., 0.],
[0., 4., 0., 0., 0., 12., 0., 0.],
[0., 0., 6., 0., 0., 0., 14., 0.],
[0., 0., 0., 8., 0., 0., 0., 16.]],
[[3., 0., 0., 0., 75., 0., 0., 0.],
[0., 12., 0., 0., 0., 108., 0., 0.],
[0., 0., 27., 0., 0., 0., 147., 0.],
[0., 0., 0., 48., 0., 0., 0., 192.]]])