def _lange(x, norm, axis): order = 'F' if x.flags.f_contiguous and not x.flags.c_contiguous else 'C' dtype = 'f' if x.dtype.char in 'fF' else 'd' if x.size == 0: shape = [x.shape[i] for i in set(range(x.ndim)) - set(axis)] return nlcpy.zeros(shape, dtype=dtype) if norm in (None, 'fro', 'f'): if x.dtype.kind == 'c': x = abs(x) return nlcpy.sqrt(nlcpy.sum(x * x, axis=axis)) if norm == nlcpy.inf: norm = 'I' else: norm = '1' lwork = x.shape[0] if norm == 'I' else 1 x = nlcpy.asarray(nlcpy.moveaxis(x, (axis[0], axis[1]), (0, 1)), order='F') y = nlcpy.empty(x.shape[2:], dtype=dtype, order='F') work = nlcpy.empty(lwork, dtype=dtype) fpe = request._get_fpe_flag() args = ( ord(norm), x._ve_array, y._ve_array, work._ve_array, veo.OnStack(fpe, inout=veo.INTENT_OUT), ) request._push_and_flush_request( 'nlcpy_norm', args, ) return nlcpy.asarray(y, order=order)
def test_multi_ndarray_5(self, dtype): xin = nlcpy.random.rand(5, 5).astype(dtype=dtype) yin = nlcpy.random.rand(5, 5).astype(dtype=dtype) zin = nlcpy.random.rand(5, 5).astype(dtype=dtype) # compute with sca dxin, dyin, dzin = nlcpy.sca.create_descriptor((xin, yin, zin)) desc = ( dxin[-1, 0] + dxin[0, 1] + dxin[1, 0] + dxin[0, -1] + dyin[-1, -1] + dzin[1, 1]) res_sca = nlcpy.sca.create_kernel(desc).execute() # compute with naive res_naive = nlcpy.zeros((5, 5), dtype=dtype) res_naive[1:-1, 1:-1] = ( xin[:-2, 1:-1] + xin[1:-1, 2:] + xin[2:, 1:-1] + xin[1:-1, :-2] + yin[:-2, :-2] + zin[2:, 2:]) rtol = TOL_SINGLE if dtype == numpy.float32 else TOL_DOUBLE testing.assert_allclose(res_sca, res_naive, rtol=rtol)
def _warmup(): xx = [] # allocate VE memory as heap for i in range(130): xx.append(nlcpy.zeros(int((1 * 1e8) / 8), dtype='f8')) nlcpy.request.flush() xx = []
def test_adv_getitem_nlcpy_indices2(self): a = nlcpy.zeros(self.shape) index = nlcpy.array([1, 0]) original_index = index.copy() b = a[(slice(None), index)] b_cpu = a.get()[(slice(None), index.get())] testing.assert_array_equal(b, b_cpu) testing.assert_array_equal(original_index, index)
def test_nlcpy_indices_boolean_array(self): a = nlcpy.zeros(self.shape) index = nlcpy.array([True, False]) original_index = index.copy() a[index] = nlcpy.array(1.) testing.assert_array_equal(a, nlcpy.array([[1., 1., 1.], [0., 0., 0.]])) testing.assert_array_almost_equal(original_index, index)
def test_nlcpy_indices_integer_array_3(self): a = nlcpy.zeros(self.shape) index = nlcpy.array([3, -5]) original_index = index.copy() a[[1, 1], index] = nlcpy.array(1.) testing.assert_array_equal(a, nlcpy.array([[0., 0., 0.], [1., 1., 0.]])) testing.assert_array_equal(index, original_index)
def test_adv_getitem_nlcpy_indices5(self): a = nlcpy.zeros(self.shape) index = nlcpy.array([4, -5]) original_index = index.copy() b = a[[1, 0], index] b_cpu = a.get()[[1, 0], index.get() % self.shape[1]] testing.assert_array_equal(b, b_cpu) testing.assert_array_equal(original_index, index)
def test_adv_getitem_nlcpy_indices3(self): a = nlcpy.zeros(self.shape) index = nlcpy.array([True, False]) original_index = index.copy() b = a[index] b_cpu = a.get()[index.get()] testing.assert_array_equal(b, b_cpu) testing.assert_array_equal(original_index, index)
def _prep(dtype): NX = 50 NY = 60 NZ = 40 x1 = nlcpy.arange(NZ * NY * NX, dtype=dtype).reshape(NZ, NY, NX) x2 = nlcpy.ones((NZ, NY, NX), dtype=dtype) y = nlcpy.zeros((NZ, NY, NX), dtype=dtype) return x1, x2, y
def use_nlcpy_jit_haversine(lat1, lon1, lat2, lon2, size): from nlcpy.ve_types import (uint32, uint64, int32, int64, float32, float64, void_p, void) vp.request.flush() start = time.time() mod = vp.jit.CustomVELibrary( code=string.Template( _test_source1_c ).substitute( dtype=_pytype2ctype(DT) ), compiler='/opt/nec/ve/bin/ncc', cflags=vp.jit.get_default_cflags(openmp=True) + \ (('-DFLOAT32',) if DT is np.float32 else ()), ldflags=vp.jit.get_default_ldflags(openmp=True), # ftrace=True, ) if DT is np.float32: args_type = (float32, float32, uint64, uint64, int64, uint64) elif DT is np.float64: args_type = (float64, float64, uint64, uint64, int64, uint64) else: raise ValueError kern = mod.get_function('calc_harv', args_type=args_type, ret_type=float32) end = time.time() intime["pre"] = end - start mi = vp.zeros(size, dtype=DT) vp.request.flush() start = time.time() ve_elapsed = kern(lat1, lon1, lat2.ve_adr, lon2.ve_adr, size, mi.ve_adr, callback=None, sync=True) end = time.time() intime["exec(VE+VH)"] = end - start intime["exec(VE)"] = ve_elapsed return mi
def test_multi_ndarray_3(self, dtype): xin = nlcpy.random.rand(7, 7).astype(dtype=dtype) yin = nlcpy.random.rand(6, 8).astype(dtype=dtype) # compute with sca dxin, dyin = nlcpy.sca.create_descriptor((xin, yin)) desc = dxin[-2, 2] + dxin[1, -1] + dyin[0, 0] res_sca = nlcpy.sca.create_kernel(desc).execute() # compute with naive x_tmp = xin[:6, :] y_tmp = yin[:, :7] res_naive = nlcpy.zeros((6, 7), dtype=dtype) res_naive[2:-1, 1:-2] = x_tmp[:-3, 3:] + x_tmp[3:, :-3] + y_tmp[2:-1, 1:-2] rtol = TOL_SINGLE if dtype == numpy.float32 else TOL_DOUBLE testing.assert_allclose(res_sca, res_naive, rtol=rtol)
def test_multi_ndarray_2(self, dtype): xin = nlcpy.random.rand(5, 5).astype(dtype=dtype) yin = nlcpy.random.rand(7, 7).astype(dtype=dtype) # compute with sca dxin, dyin = nlcpy.sca.create_descriptor((xin, yin)) desc = dxin[-1, 1] + dxin[1, -1] + dyin[-1, -1] + dyin[1, 1] res_sca = nlcpy.sca.create_kernel(desc).execute() # compute with naive x_tmp = xin[:, :] y_tmp = yin[:5, :5] res_naive = nlcpy.zeros((5, 5), dtype=dtype) res_naive[1:-1, 1:-1] = (x_tmp[:-2, 2:] + x_tmp[2:, :-2] + y_tmp[:-2, :-2] + y_tmp[2:, 2:]) rtol = TOL_SINGLE if dtype == numpy.float32 else TOL_DOUBLE testing.assert_allclose(res_sca, res_naive, rtol=rtol)
def roll(a, shift, axis=None): """Rolls array elements along a given axis. Elements that roll beyond the last position are re-introduced at the first. Parameters ---------- a : array_like Input array. shift : int or tuple of ints The number of places by which elements are shifted. If a tuple, then *axis* must be a tuple of the same size, and each of the given axes is shifted by the corresponding number. If an int while *axis* is a tuple of ints, then the same value is used for all given axes. axis : int or tuple of ints, optional Axis or axes along which elements are shifted. By default, the array is flattened before shifting, after which the original shape is restored. Returns ------- res : ndarray Output array, with the same shape as *a*. See Also -------- rollaxis : Rolls the specified axis backwards, until it lies in a given position. Examples -------- >>> import nlcpy as vp >>> x = vp.arange(10) >>> vp.roll(x, 2) array([8, 9, 0, 1, 2, 3, 4, 5, 6, 7]) >>> vp.roll(x, -2) array([2, 3, 4, 5, 6, 7, 8, 9, 0, 1]) >>> x2 = vp.reshape(x, (2,5)) >>> x2 array([[0, 1, 2, 3, 4], [5, 6, 7, 8, 9]]) >>> vp.roll(x2, 1) array([[9, 0, 1, 2, 3], [4, 5, 6, 7, 8]]) >>> vp.roll(x2, -1) array([[1, 2, 3, 4, 5], [6, 7, 8, 9, 0]]) >>> vp.roll(x2, 1, axis=0) array([[5, 6, 7, 8, 9], [0, 1, 2, 3, 4]]) >>> vp.roll(x2, -1, axis=0) array([[5, 6, 7, 8, 9], [0, 1, 2, 3, 4]]) >>> vp.roll(x2, 1, axis=1) array([[4, 0, 1, 2, 3], [9, 5, 6, 7, 8]]) >>> vp.roll(x2, -1, axis=1) array([[1, 2, 3, 4, 0], [6, 7, 8, 9, 5]]) """ a = nlcpy.asanyarray(a) if axis is None: return roll(a.ravel(), shift, 0).reshape(a.shape) if type(axis) not in (tuple, list): try: axis = [operator.index(axis)] except TypeError: pass _axis = axis.get() if isinstance(axis, nlcpy.ndarray) else axis axis = [ax + a.ndim if ax < 0 else ax for ax in _axis] for ax in axis: if ax < 0 or ax >= a.ndim: raise AxisError( 'axis {} is out of bounds for array of dimension {}'.format( ax, a.ndim)) shift = nlcpy.asanyarray(shift) axis = nlcpy.asanyarray(axis) if shift.ndim > 1 or axis.ndim > 1: raise ValueError( "'shift' and 'axis' should be scalars or 1D sequences") if shift.size > axis.size: axis = nlcpy.broadcast_to(axis, shift.shape) else: shift = nlcpy.broadcast_to(shift, axis.shape) shift = nlcpy.array(shift, dtype='l') axis = nlcpy.array(axis, dtype='l') result = nlcpy.empty(a.shape, dtype=a.dtype) work = nlcpy.zeros(a.ndim, dtype='l') request._push_request('nlcpy_roll', 'manipulation_op', (a, shift, axis, work, result)) return result
def lstsq(a, b, rcond='warn'): """Returns the least-squares solution to a linear matrix equation. Solves the equation :math:`ax = b` by computing a vector *x* that minimizes the squared Euclidean 2-norm :math:`|b-ax|^2_2`. The equation may be under-, well-, or over-determined (i.e., the number of linearly independent rows of *a* can be less than, equal to, or greater than its number of linearly independent columns). If *a* is square and of full rank, then *x* (but for round-off error) is the "exact" solution of the equation. Parameters ---------- a : (M,N) array_like "Coefficient" matrix. b : {(M,), (M, K)} array_like Ordinate or "dependent variable" values. If *b* is two-dimensional, the least-squares solution is calculated for each of the *K* columns of *b*. rcond : float, optional Cut-off ratio for small singular values of *a*. For the purposes of rank determination, singular values are treated as zero if they are smaller than *rcond* times the largest singular value of *a*. Returns ------- x : {(N,), (N, K)} ndarray Least-squares solution. If *b* is two-dimensional, the solutions are in the *K* columns of *x*. residuals : {(1,), (K,), (0,)} ndarray Sums of residuals; squared Euclidean 2-norm for each column in ``b - a@x``. If the rank of *a* is < N or M <= N, this is an empty array. If *b* is 1-dimensional, this is a (1,) shape array. Otherwise the shape is (K,). rank : *int* Rank of matrix *a*. s : (min(M, N),) ndarray Singular values of *a*. Note ---- If `b` is a matrix, then all array results are returned as matrices. Examples -------- .. plot:: :align: center Fit a line, ``y = mx + c``, through some noisy data-points: >>> import nlcpy as vp >>> x = vp.array([0, 1, 2, 3]) >>> y = vp.array([-1, 0.2, 0.9, 2.1]) By examining the coefficients, we see that the line should have a gradient of roughly 1 and cut the y-axis at, more or less, -1. We can rewrite the line equation as ``y = Ap``, where ``A = [[x 1]]`` and ``p = [[m], [c]]``. Now use lstsq to solve for *p*: >>> A = vp.array((x, vp.ones(len(x)))).T >>> A array([[0., 1.], [1., 1.], [2., 1.], [3., 1.]]) >>> m, c = vp.linalg.lstsq(A, y, rcond=None)[0] >>> m, c # doctest: +SKIP (array(1.), array(-0.95)) # may vary Plot the data along with the fitted line: >>> import matplotlib.pyplot as plt >>> _ = plt.plot(x, y, 'o', label='Original data', markersize=15) >>> _ = plt.plot(x, m*x + c, 'r', label='Fitted line') >>> _ = plt.legend() >>> plt.show() """ a = nlcpy.asarray(a) b = nlcpy.asarray(b) b_ndim = b.ndim if b_ndim == 1: b = b[:, nlcpy.newaxis] util._assertRank2(a, b) if a.shape[-2] != b.shape[-2]: raise util.LinAlgError('Incompatible dimensions') a_complex = a.dtype.char in 'FD' b_complex = b.dtype.char in 'FD' if a_complex or b_complex: if a.dtype.char in 'fF' and b.dtype.char in 'fF': x_dtype = 'F' f_dtype = 'f' else: x_dtype = 'D' f_dtype = 'd' else: if a.dtype.char == 'f' and b.dtype.char == 'f': x_dtype = 'f' f_dtype = 'f' else: x_dtype = 'd' f_dtype = 'd' m = a.shape[-2] n = a.shape[-1] k = b.shape[-1] minmn = min(m, n) maxmn = max(m, n) k_extend = (k == 0) if k_extend: b = nlcpy.zeros([m, 1], dtype=b.dtype) k = 1 if minmn == 0: if n > 0: x = nlcpy.zeros([n, k], dtype=x_dtype) residuals = nlcpy.array([], dtype=f_dtype) else: x = nlcpy.array([], dtype=x_dtype) if b_complex: br = nlcpy.asarray(b.real, dtype='d') bi = nlcpy.asarray(b.imag, dtype='d') square_b = nlcpy.power(br, 2) + nlcpy.power(bi, 2) else: square_b = nlcpy.power(b, 2, dtype='d') residuals = nlcpy.add.reduce(square_b, dtype=f_dtype) return (x, residuals, 0, nlcpy.array([], dtype=f_dtype)) if rcond == 'warn': rcond = -1.0 if rcond is None: rcond = nlcpy.finfo(x_dtype).eps * max(m, n) rcond = nlcpy.asarray(rcond, dtype=f_dtype) a = nlcpy.array(a, dtype=x_dtype, order='F') if m < n: _b = nlcpy.empty([n, k], dtype=x_dtype, order='F') _b[:m, :] = b b = _b else: b = nlcpy.array(b, dtype=x_dtype, order='F') s = nlcpy.empty(min(m, n), dtype=f_dtype) rank = numpy.empty(1, dtype='l') nlvl = max(0, int(nlcpy.log(minmn / 26.0) / nlcpy.log(2)) + 1) mnthr = int(minmn * 1.6) mm = m lwork = 1 if a_complex: _tmp = 2 wlalsd = minmn * k lrwork = 10 * maxmn + 2 * maxmn * 25 + 8 * maxmn * nlvl + 3 * 25 * k \ + max(26 ** 2, n * (1 + k) + 2 * k) else: _tmp = 3 wlalsd = 9 * minmn + 2 * minmn * 25 + 8 * minmn * nlvl + minmn * k + 26**2 lrwork = 1 if m >= n: if m >= mnthr: mm = n lwork = max(65 * n, n + 32 * k) lwork = max(lwork, _tmp * n + (mm + n) * 64, _tmp * n + 32 * k, _tmp * n + 32 * n - 32, _tmp * n + wlalsd) else: if n >= mnthr: lwork = max(lwork, m * m + 4 * m + wlalsd, m * m + 132 * m, m * m + 4 * m + 32 * k, m * m + (k + 1) * m, m * m + n + m) else: lwork = max(lwork, 3 * m + wlalsd, 3 * m + 64 * (n + m), 3 * m + 32 * k) liwork = minmn * (11 + 3 * nlvl) work = nlcpy.empty(lwork) iwork = nlcpy.empty(liwork, dtype='l') rwork = nlcpy.empty(lrwork, dtype=f_dtype) info = numpy.empty(1, dtype='l') fpe = request._get_fpe_flag() args = ( a._ve_array, b._ve_array, s._ve_array, work._ve_array, iwork._ve_array, rwork._ve_array, rcond._ve_array, veo.OnStack(rank, inout=veo.INTENT_OUT), veo.OnStack(info, inout=veo.INTENT_OUT), veo.OnStack(fpe, inout=veo.INTENT_OUT), ) request._push_and_flush_request('nlcpy_lstsq', args, callback=_lstsq_errchk(info), sync=True) if rank < n or m <= n: residuals = nlcpy.array([], dtype=f_dtype) else: _b = b[n:] square_b = nlcpy.power(_b.real, 2) + nlcpy.power(_b.imag, 2) residuals = nlcpy.add.reduce(square_b, dtype=f_dtype) if k_extend: x = b[..., :0] residuals = residuals[..., :0] elif b_ndim == 1: x = nlcpy.asarray(b[:n, 0], dtype=x_dtype, order='C') else: x = nlcpy.asarray(b[:n, :], dtype=x_dtype, order='C') return (x, residuals, rank[0], s)
def resize(a, new_shape): """Returns a new array with the specified shape. If the new array is larger than the original array, then the new array is filled with repeated copies of *a*. Note that this behavior is different from a.resize(new_shape) which fills with zeros instead of repeated copies of *a*. Parameters ---------- a : array_like Array to be resized. new_shape : int or sequence of ints Shape of resized array. Returns ------- reshaped_array : ndarray The new array is formed from the data in the old array, repeated if necessary to fill out the required number of elements. The data are repeated in the order that they are stored in memory. Note ---- Warning: This functionality does **not** consider axes separately, i.e. it does not apply interpolation/extrapolation. It fills the return array with the required number of elements, taken from `a` as they are laid out in memory, disregarding strides and axes. (This is in case the new shape is smaller. For larger, see above.) This functionality is therefore not suitable to resize images, or data where each axis represents a separate and distinct entity. Examples -------- >>> import nlcpy as vp >>> a=vp.array([[0,1],[2,3]]) >>> vp.resize(a,(2,3)) array([[0, 1, 2], [3, 0, 1]]) >>> vp.resize(a,(1,4)) array([[0, 1, 2, 3]]) >>> vp.resize(a,(2,4)) array([[0, 1, 2, 3], [0, 1, 2, 3]]) """ if isinstance(new_shape, int): new_shape = (new_shape,) a = nlcpy.ravel(a) Na = a.size total_size = core.internal.prod(new_shape) if Na == 0 or total_size == 0: return nlcpy.zeros(new_shape, a.dtype) n_copies = int(total_size / Na) extra = total_size % Na if extra != 0: n_copies = n_copies + 1 extra = Na - extra a = nlcpy.concatenate((a,) * n_copies) if extra > 0: a = a[:-extra] return nlcpy.reshape(a, new_shape)
def insert(arr, obj, values, axis=None): """Inserts values along the given axis before the given indices. Parameters ---------- arr : array_like Input array. obj : int, slice or sequence of ints Object that defines the index or indices before which values is inserted. Support for multiple insertions when obj is a single scalar or a sequence with one element (similar to calling insert multiple times). values : array_like Values to insert into arr. If the type of values is different from that of arr, values is converted to the type of arr. values should be shaped so that arr[...,obj,...] = values is legal. axis : int, optional Axis along which to insert values. If axis is None then arr is flattened first. Returns ------- out : ndarray A copy of arr with values inserted. Note that insert does not occur in-place: a new array is returned. If axis is None, out is a flattened array. Note: Note that for higher dimensional inserts obj=0 behaves very different from obj=[0] just like arr[:,0,:] = values is different from arr[:,[0],:] = values. See Also -------- append : Appends values to the end of an array. concatenate : Joins a sequence of arrays along an existing axis. delete : Returns a new array with sub-arrays along an axis deleted. Examples -------- >>> import nlcpy as vp >>> from nlcpy import testing >>> a = vp.array([[1, 1], [2, 2], [3, 3]]) >>> a array([[1, 1], [2, 2], [3, 3]]) >>> vp.insert(a, 1, 5) array([1, 5, 1, 2, 2, 3, 3]) >>> vp.insert(a, 1, 5, axis=1) array([[1, 5, 1], [2, 5, 2], [3, 5, 3]]) Difference between sequence and scalars: >>> vp.insert(a, [1], [[1],[2],[3]], axis=1) array([[1, 1, 1], [2, 2, 2], [3, 3, 3]]) >>> vp.testing.assert_array_equal( ... vp.insert(a, 1, [1, 2, 3], axis=1), ... vp.insert(a, [1], [[1],[2],[3]], axis=1)) >>> b = a.flatten() >>> b array([1, 1, 2, 2, 3, 3]) >>> vp.insert(b, [2, 2], [5, 6]) array([1, 1, 5, 6, 2, 2, 3, 3]) >>> vp.insert(b, slice(2, 4), [5, 6]) array([1, 1, 5, 2, 6, 2, 3, 3]) >>> vp.insert(b, [2, 2], [7.13, False]) # type casting array([1, 1, 7, 0, 2, 2, 3, 3]) >>> x = vp.arange(8).reshape(2, 4) >>> idx = (1, 3) >>> vp.insert(x, idx, 999, axis=1) array([[ 0, 999, 1, 2, 999, 3], [ 4, 999, 5, 6, 999, 7]]) """ a = nlcpy.asarray(arr) if axis is None: if a.ndim != 1: a = a.ravel() axis = 0 elif isinstance(axis, nlcpy.ndarray) or isinstance(axis, numpy.ndarray): axis = int(axis) elif not isinstance(axis, int): raise TypeError("an integer is required " "(got type {0})".format(type(axis).__name__)) if axis < -a.ndim or axis >= a.ndim: raise nlcpy.AxisError( "axis {0} is out of bounds for array of dimension {1}".format(axis, a.ndim)) if axis < 0: axis += a.ndim if type(obj) is slice: start, stop, step = obj.indices(a.shape[axis]) obj = nlcpy.arange(start, stop, step) else: obj = nlcpy.array(obj) if obj.dtype.char == '?': warnings.warn( "in the future insert will treat boolean arrays and " "array-likes as a boolean index instead of casting it to " "integer", FutureWarning, stacklevel=3) elif obj.dtype.char in 'fdFD': if obj.size == 1: raise TypeError( "slice indices must be integers or " "None or have an __index__ method") elif obj.size > 0: raise IndexError( 'arrays used as indices must be of integer (or boolean) type') elif obj.dtype.char in 'IL': if obj.size == 1: objval = obj[()] if obj.ndim == 0 else obj[0] if objval > a.shape[axis]: raise IndexError( "index {0} is out of bounds for axis {1} with size {2}".format( objval, axis, a.shape[axis])) else: tmp = 'float64' if obj.dtype.char == 'L' else 'int64' raise UFuncTypeError( "Cannot cast ufunc 'add' output from dtype('{0}') to " "dtype('{1}') with casting rule 'same_kind'".format(tmp, obj.dtype)) obj = obj.astype('l') if obj.ndim > 1: raise ValueError( "index array argument obj to insert must be one dimensional or scalar") if obj.ndim == 0: if obj > a.shape[axis] or obj < -a.shape[axis]: raise IndexError( "index {0} is out of bounds for axis {1} with size {2}".format( obj[()] if obj > 0 else obj[()] + a.shape[axis], axis, a.shape[axis])) newshape = list(a.shape) if obj.size == 1: values = nlcpy.array(values, copy=False, ndmin=a.ndim, dtype=a.dtype) if obj.ndim == 0: values = nlcpy.moveaxis(values, 0, axis) newshape[axis] += values.shape[axis] obj = nlcpy.array(nlcpy.broadcast_to(obj, values.shape[axis])) val_shape = list(a.shape) val_shape[axis] = values.shape[axis] values = nlcpy.broadcast_to(values, val_shape) else: newshape[axis] += obj.size values = nlcpy.array(values, copy=False, ndmin=a.ndim, dtype=a.dtype) val_shape = list(a.shape) val_shape[axis] = obj.size values = nlcpy.broadcast_to(values, val_shape) out = nlcpy.empty(newshape, dtype=a.dtype) work = nlcpy.zeros(obj.size + out.shape[axis] + 2, dtype='l') work[-1] = -1 request._push_request( 'nlcpy_insert', 'manipulation_op', (a, obj, values, out, axis, work) ) if work[-1] != -1: raise IndexError( "index {0} is out of bounds for axis {1} with size {2}" .format(obj[work[-1]], axis, out.shape[axis])) return out
def delete(arr, obj, axis=None): """Returns a new array with sub-arrays along an axis deleted. For a one dimensional array, this returns those entries not returned by arr[obj]. Parameters ---------- arr : array_like Input array. obj : slice, int or array of ints Indicate indices of sub-arrays to remove along the specified axis. axis : int, optional The axis along which to delete the subarray defined by obj. If axis is None, obj is applied to the flattened array. Returns ------- out : ndarray A copy of arr with the elements specified by obj removed. Note that delete does not occur in-place. If axis is None, out is a flattened array. Note ---- Often it is preferable to use a boolean mask. For example: >>> import nlcpy as vp >>> arr = vp.arange(12) + 1 >>> mask = vp.ones(len(arr), dtype=bool) >>> mask[[0,2,4]] = False >>> result = arr[mask,...] Is equivalent to vp.delete(arr, [0,2,4], axis=0), but allows further use of mask. See Also -------- insert : Inserts values along the given axis before the given indices. append : Appends values to the end of an array. Examples -------- >>> import nlcpy as vp >>> arr = vp.array([[1,2,3,4], [5,6,7,8], [9,10,11,12]]) >>> arr array([[ 1, 2, 3, 4], [ 5, 6, 7, 8], [ 9, 10, 11, 12]]) >>> vp.delete(arr, 1, 0) array([[ 1, 2, 3, 4], [ 9, 10, 11, 12]]) >>> vp.delete(arr, slice(None, None, 2), 1) array([[ 2, 4], [ 6, 8], [10, 12]]) >>> vp.delete(arr, [1,3,5], None) array([ 1, 3, 5, 7, 8, 9, 10, 11, 12]) """ input_arr = nlcpy.asarray(arr) ndim = input_arr.ndim if input_arr._f_contiguous and not input_arr._c_contiguous: order_out = 'F' else: order_out = 'C' if axis is None: if ndim != 1: input_arr = input_arr.ravel() ndim = input_arr.ndim axis = ndim - 1 if isinstance(axis, numpy.ndarray) or isinstance(axis, nlcpy.ndarray): axis = int(axis) elif not isinstance(axis, int): raise TypeError("an integer is required (got type " + str(type(axis).__name__) + ")") if axis < -ndim or axis > ndim - 1: raise AxisError( "axis {} is out of bounds for array of dimension {}".format(axis, ndim)) if axis < 0: axis += ndim N = input_arr.shape[axis] if isinstance(obj, slice): start, stop, step = obj.indices(N) xr = range(start, stop, step) if len(xr) == 0: return input_arr.copy(order=order_out) else: del_obj = nlcpy.arange(start, stop, step) else: del_obj = nlcpy.asarray(obj) if del_obj.ndim != 1: del_obj = del_obj.ravel() if del_obj.dtype == bool: if del_obj.ndim != 1 or del_obj.size != input_arr.shape[axis]: raise ValueError( 'boolean array argument obj to delete must be one dimensional and ' 'match the axis length of {}'.format(input_arr.shape[axis])) del_obj = del_obj.astype(nlcpy.intp) if isinstance(obj, (int, nlcpy.integer)): if (obj < -N or obj >= N): raise IndexError( "index %i is out of bounds for axis %i with " "size %i" % (obj, axis, N)) if (obj < 0): del_obj += N elif del_obj.size > 0 and del_obj.dtype != int: raise IndexError( 'arrays used as indices must be of integer (or boolean) type') if del_obj.size == 0: new = nlcpy.array(input_arr) return new else: new = nlcpy.empty(input_arr.shape, input_arr.dtype, order_out) idx = nlcpy.ones(input_arr.shape[axis], dtype=del_obj.dtype) obj_count = nlcpy.zeros([3], dtype='l') request._push_request( 'nlcpy_delete', 'manipulation_op', (input_arr, del_obj, axis, idx, new, obj_count) ) count = obj_count.get() if count[1] != 0: raise IndexError( "index out of bounds for axis {}".format(axis)) if count[2] != 0: warnings.warn( "in the future negative indices will not be ignored by " "`numpy.delete`.", FutureWarning, stacklevel=3) sl = [slice(N - count[0]) if i == axis else slice(None) for i in range(new.ndim)] return new[sl].copy()
def test_zeros_like_reshape_nlcpy_only(self, dtype, order): a = testing.shaped_arange((2, 3, 4), nlcpy, dtype) b = nlcpy.zeros_like(a, shape=self.shape) c = nlcpy.zeros(self.shape, order=order, dtype=dtype) testing.assert_array_equal(b, c)
def test_zeros_strides(self, order): a = numpy.zeros((2, 3), dtype='d', order=order) b = nlcpy.zeros((2, 3), dtype='d', order=order) self.assertEqual(b.strides, a.strides)
def diag(v, k=0): """Extracts a diagonal or constructs a diagonal array. Parameters ---------- v : array_like If *v* is a 2-D array, return a copy of its *k-th* diagonal. If *v* is a 1-D array, return a 2-D array with *v* on the k-th diagonal. k : int, optional Diagonal in question. The default is 0. Use *k>0* for diagonals above the main diagonal, and *k<0* for diagonals below the main diagonal. Returns ------- out : ndarray The extracted diagonal or constructed diagonal array. See Also -------- diagonal : Returns specified diagonals. diagflat : Creates a two-dimensional array with the flattened input as a diagonal. Examples -------- >>> import nlcpy as vp >>> x = vp.arange(9).reshape((3,3)) >>> x array([[0, 1, 2], [3, 4, 5], [6, 7, 8]]) >>> vp.diag(x) array([0, 4, 8]) >>> vp.diag(x, k=1) array([1, 5]) >>> vp.diag(x, k=-1) array([3, 7]) >>> vp.diag(vp.diag(x)) array([[0, 0, 0], [0, 4, 0], [0, 0, 8]]) """ if isinstance(v, nlcpy.ndarray): ndim = v.ndim else: ndim = numpy.ndim(v) if ndim == 1: v = nlcpy.array(v) if ndim == 2: # to save bandwidth, don't copy non-diag elements to GPU v = numpy.array(v) if ndim == 1: size = v.size + abs(k) ret = nlcpy.zeros((size, size), dtype=v.dtype) ret.diagonal(k)[:] = v return ret elif ndim == 2: return v.diagonal(k).copy() else: raise ValueError('Input must be 1- or 2-d.')
def qr(a, mode='reduced'): """Computes the qr factorization of a matrix. Factor the matrix *a* as *qr*, where *q* is orthonormal and *r* is upper-triangular. Parameters ---------- a : (M, N) array_like Matrix to be factored. mode : {'reduced', 'complete', 'r', 'raw', 'full', 'economic'}, optional If K = min(M, N), then - 'reduced' : returns q, r with dimensions (M, K), (K, N) (default) - 'complete' : returns q, r with dimensions (M, M), (M, N) - 'r' : returns r only with dimensions (K, N) - 'raw' : returns h, tau with dimensions (N, M), (K,) - 'full' or 'f' : alias of 'reduced', deprecated - 'economic' or 'e' : returns h from 'raw', deprecated. Returns ------- q : ndarray, optional A matrix with orthonormal columns. When mode = 'complete' the result is an orthogonal/unitary matrix depending on whether or not a is real/complex. The determinant may be either +/- 1 in that case. r : ndarray, optional The upper-triangular matrix. (h, tau) : ndarray, optional The array h contains the Householder reflectors that generate q along with r. The tau array contains scaling factors for the reflectors. In the deprecated 'economic' mode only h is returned. Note ---- This is an interface to the LAPACK routines ``dgeqrf``, ``zgeqrf``, ``dorgqr``, and ``zungqr``. For more information on the qr factorization, see for example: https://en.wikipedia.org/wiki/QR_factorization Note that when 'raw' option is specified the returned arrays are of type "float64" or "complex128" and the h array is transposed to be FORTRAN compatible. Examples -------- >>> import numpy as np >>> import nlcpy as vp >>> from nlcpy import testing >>> a = vp.random.randn(9, 6) >>> q, r = vp.linalg.qr(a) >>> vp.testing.assert_allclose(a, vp.dot(q, r)) # a does equal qr >>> r2 = vp.linalg.qr(a, mode='r') >>> r3 = vp.linalg.qr(a, mode='economic') >>> # mode='r' returns the same r as mode='full' >>> vp.testing.assert_allclose(r, r2) >>> # But only triu parts are guaranteed equal when mode='economic' >>> vp.testing.assert_allclose(r, np.triu(r3[:6,:6], k=0)) Example illustrating a common use of qr: solving of least squares problems What are the least-squares-best *m* and *y0* in ``y = y0 + mx`` for the following data: {(0,1), (1,0), (1,2), (2,1)}. (Graph the points and you’ll see that it should be y0 = 0, m = 1.) The answer is provided by solving the over-determined matrix equation ``Ax = b``, where:: A = array([[0, 1], [1, 1], [1, 1], [2, 1]]) x = array([[y0], [m]]) b = array([[1], [0], [2], [1]]) If A = qr such that q is orthonormal (which is always possible via Gram-Schmidt), then ``x = inv(r) * (q.T) * b``. (In practice, however, we simply use :func:`lstsq`.) >>> A = vp.array([[0, 1], [1, 1], [1, 1], [2, 1]]) >>> A array([[0, 1], [1, 1], [1, 1], [2, 1]]) >>> b = vp.array([1, 0, 2, 1]) >>> q, r = vp.linalg.qr(A) >>> p = vp.dot(q.T, b) >>> vp.dot(vp.linalg.inv(r), p) array([1.1102230246251565e-16, 1.0000000000000002e+00]) """ if mode not in ('reduced', 'complete', 'r', 'raw'): if mode in ('f', 'full'): msg = "".join( ("The 'full' option is deprecated in favor of 'reduced'.\n", "For backward compatibility let mode default.")) warnings.warn(msg, DeprecationWarning, stacklevel=3) mode = 'reduced' elif mode in ('e', 'economic'): msg = "The 'economic' option is deprecated." warnings.warn(msg, DeprecationWarning, stacklevel=3) mode = 'economic' else: raise ValueError("Unrecognized mode '%s'" % mode) a = nlcpy.asarray(a) util._assertRank2(a) if a.dtype == 'F': dtype = 'D' a_dtype = 'F' elif a.dtype == 'D': dtype = 'D' a_dtype = 'D' elif a.dtype == 'f': dtype = 'd' a_dtype = 'f' else: dtype = 'd' a_dtype = 'd' m, n = a.shape if a.size == 0: if mode == 'reduced': return nlcpy.empty((m, 0), a_dtype), nlcpy.empty((0, n), a_dtype) elif mode == 'complete': return nlcpy.identity(m, a_dtype), nlcpy.empty((m, n), a_dtype) elif mode == 'r': return nlcpy.empty((0, n), a_dtype) elif mode == 'raw': return nlcpy.empty((n, m), dtype), nlcpy.empty((0, ), dtype) else: return nlcpy.empty((m, n), a_dtype), nlcpy.empty((0, ), a_dtype) a = nlcpy.asarray(a, dtype=dtype, order='F') k = min(m, n) if mode == 'complete': if m > n: x = nlcpy.empty((m, m), dtype=dtype, order='F') x[:m, :n] = a a = x r_shape = (m, n) elif mode in ('r', 'reduced', 'economic'): r_shape = (k, n) else: r_shape = 1 jobq = 0 if mode in ('r', 'raw', 'economic') else 1 tau = nlcpy.empty(k, dtype=dtype) r = nlcpy.zeros(r_shape, dtype=dtype) work = nlcpy.empty(n * 64, dtype=dtype) fpe = request._get_fpe_flag() args = ( m, n, jobq, a._ve_array, tau._ve_array, r._ve_array, work._ve_array, veo.OnStack(fpe, inout=veo.INTENT_OUT), ) request._push_and_flush_request( 'nlcpy_qr', args, ) if mode == 'raw': return a.T, tau if mode == 'r': return nlcpy.asarray(r, dtype=a_dtype) if mode == 'economic': return nlcpy.asarray(a, dtype=a_dtype) mc = m if mode == 'complete' else k q = nlcpy.asarray(a[:, :mc], dtype=a_dtype, order='C') r = nlcpy.asarray(r, dtype=a_dtype, order='C') return q, r
def linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None, axis=0): """Returns 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 : array_like The starting value of the sequence. stop : array_like 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. Must be non-negative. 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, optional The type of the output array. If *dtype* is not given, infer the data type from the other input arguments. axis : int, optional The axis in the result to store the samples. Relevant only if start or stop are array-like. By default (0), the samples will be along a new axis inserted at the beginning. Use -1 to get an axis at the end. 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, optional Only returned if *retstep* is True Size of spacing between samples. See Also -------- arange : Returns evenly spaced values within a given interval. Examples -------- >>> import nlcpy as vp >>> vp.linspace(2.0, 3.0, num=5) array([2. , 2.25, 2.5 , 2.75, 3. ]) >>> vp.linspace(2.0, 3.0, num=5, endpoint=False) array([2. , 2.2, 2.4, 2.6, 2.8]) >>> vp.linspace(2.0, 3.0, num=5, retstep=True) (array([2. , 2.25, 2.5 , 2.75, 3. ]), array([0.25])) """ num = operator.index(num) if num < 0: raise ValueError("Number of samples, %s, must be non-negative." % num) dtype_kind = numpy.dtype(dtype).kind if dtype_kind == 'V': raise NotImplementedError( 'void dtype in linspace is not implemented yet.') start = nlcpy.asarray(start) stop = nlcpy.asarray(stop) dt = numpy.result_type(start, stop, float(num)) if start.dtype.char in '?iIlL' or stop.dtype.char in '?iIlL': dt = 'D' if dt.char in 'FD' else 'd' if dtype is None: dtype = dt start = nlcpy.asarray(start, dtype=dt) stop = nlcpy.asarray(stop, dtype=dt) delta = stop - start div = (num - 1) if endpoint else num if num == 0: ret = nlcpy.empty((num, ) + delta.shape, dtype=dtype) if retstep: ret = (ret, nlcpy.NaN) return ret elif div == 0 or num == 1: ret = nlcpy.resize(start, (1, ) + delta.shape).astype(dtype) if retstep: ret = (ret, stop) return ret else: ret = nlcpy.empty((num, ) + delta.shape, dtype=dtype) retdata = ret delta = delta[nlcpy.newaxis] start = nlcpy.array(nlcpy.broadcast_to(start, delta.shape)) stop = nlcpy.array(nlcpy.broadcast_to(stop, delta.shape)) step = delta / div if div > 1 else delta if retdata._memloc in {on_VE, on_VE_VH}: denormal = nlcpy.zeros(1, dtype='l') request._push_request( "nlcpy_linspace", "creation_op", (ret, start, stop, delta, step, int(endpoint), denormal)) if axis != 0: ret = nlcpy.moveaxis(ret, 0, axis) if retstep: ret = (ret, step) if retdata._memloc in {on_VH, on_VE_VH}: del retdata.vh_data del step.vh_data typ = numpy.dtype(dtype).type if retstep: (retdata.vh_data, step.vh_data) = numpy.linspace(typ(start), typ(stop), num, endpoint, typ(retstep), dtype, axis) else: retdata.vh_data = numpy.linspace(typ(start), typ(stop), num, endpoint, typ(retstep), dtype, axis) return ret
def test_lstsq_not_converge(self): a = nlcpy.ones([200, 200]) a[0, 0] = nlcpy.nan with self.assertRaises(nlcpy.linalg.LinAlgError): nlcpy.linalg.lstsq(a, nlcpy.zeros([200, 1]))