def eye(N, M=None, k=0, dtype=float, order='C'): """Returns a 2-D array with ones on the diagonal and zeros elsewhere. Parameters ---------- N : int Number of rows in the output. M : int, optional Number of columns in the output. If None, defaults to *N*. k : int, optional Index of the diagonal: 0 (the default) refers to the main diagonal, a positive value refers to an upper diagonal, and a negative value to a lower diagonal. dtype : dtype, optional Data-type of the returned array. order : {'C', 'F'}, optional Whether the output should be stored in row-major (C-style) or column-major (Fortran-style) order in memory. Returns ------- I : ndarray An array where all elements are equal to zero, except for the k-th diagonal, whose values are equal to one. See Also -------- identity : Returns the identity array. diag : Extracts a diagonal or construct a diagonal array. Examples -------- >>> import nlcpy as vp >>> vp.eye(2, dtype=int) array([[1, 0], [0, 1]]) >>> vp.eye(3, k=1) array([[0., 1., 0.], [0., 0., 1.], [0., 0., 0.]]) """ if numpy.dtype(dtype).kind == 'V': raise NotImplementedError('void dtype in eye is not implemented yet.') if M is None: M = N out = nlcpy.ndarray(shape=(N, M), dtype=dtype, order=order) if order == 'F': N, M = M, N request._push_request( "nlcpy_eye", "creation_op", (out, int(N), int(M), int(k)), ) return out
def tri(N, M=None, k=0, dtype=float): """An array with ones at and below the given diagonal and zeros elsewhere. Parameters ---------- N : int Number of rows in the array. M : int, optional Number of columns in the array. By default, *M* is taken equal to *N*. k : int, optional The sub-diagonal at and below which the array is filled. *k* = 0 is the main diagonal, while *k* < 0 is below it, and *k* > 0 is above. The default is 0. dtype : dtype, optional Data type of the returned array. The default is float. Returns ------- tri : ndarray Array with its lower triangle filled with ones and zero elsewhere; in other words ``T[i,j] == 1`` for ``i <= j + k``, 0 otherwise. Examples -------- >>> import nlcpy as vp >>> vp.tri(3, 5, 2, dtype=int) array([[1, 1, 1, 0, 0], [1, 1, 1, 1, 0], [1, 1, 1, 1, 1]]) >>> vp.tri(3, 5, -1) array([[0., 0., 0., 0., 0.], [1., 0., 0., 0., 0.], [1., 1., 0., 0., 0.]]) """ if N < 0: N = 0 else: N = int(N) if M is None: M = N elif M < 0: M = 0 else: M = int(M) k = int(k) out = nlcpy.empty([N, M], dtype=dtype) if out.size: request._push_request('nlcpy_tri', 'creation_op', (out, k)) return out
def tile(A, reps): """Constructs an array by repeating A the number of times given by reps. If *reps* has length ``d``, the result will have dimension of ``max(d, A.ndim)``. If ``A.ndim < d`` , *A* is promoted to be d-dimensional by prepending new axes. So a shape (3,) array is promoted to (1, 3) for 2-D replication, or shape (1, 1, 3) for 3-D replication. If this is not the desired behavior, promote *A* to d-dimensions manually before calling this function. If ``A.ndim > d``, *reps* is promoted to *A.ndim* by pre-pending 1's to it. Thus for an *A* of shape (2, 3, 4, 5), a *reps* of (2, 2) is treated as (1, 1, 2, 2). Parameters ---------- A : array_like The input array. reps : array_like The number of repetitions of *A* along each axis. Returns ------- c : ndarray The tiled output array. Note ---- Although tile may be used for broadcasting, it is strongly recommended to use nlcpy's broadcasting operations and functions. See Also -------- broadcast_to : Broadcasts an array to a new shape. Examples -------- >>> import nlcpy as vp >>> a = vp.array([0, 1, 2]) >>> vp.tile(a, 2) array([0, 1, 2, 0, 1, 2]) >>> vp.tile(a, (2, 2)) array([[0, 1, 2, 0, 1, 2], [0, 1, 2, 0, 1, 2]]) >>> vp.tile(a, (2, 1, 2)) array([[[0, 1, 2, 0, 1, 2]], <BLANKLINE> [[0, 1, 2, 0, 1, 2]]]) >>> b = vp.array([[1, 2], [3, 4]]) >>> vp.tile(b, 2) array([[1, 2, 1, 2], [3, 4, 3, 4]]) >>> vp.tile(b, (2, 1)) array([[1, 2], [3, 4], [1, 2], [3, 4]]) >>> c = vp.array([1,2,3,4]) >>> vp.tile(c,(4,1)) array([[1, 2, 3, 4], [1, 2, 3, 4], [1, 2, 3, 4], [1, 2, 3, 4]]) """ if not isinstance(A, ndarray): A = core.argument_conversion(A) # TODO: numpy.isscalar -> nlcpy.isscalar if numpy.isscalar(reps) or reps is None: shape_reps = (reps, ) dim_reps = len(shape_reps) elif isinstance(reps, (ndarray, numpy.ndarray)): if reps.ndim == 0: shape_reps = (reps, ) elif reps.ndim == 1: shape_reps = tuple([reps[i] for i in range(reps.size)]) elif reps.ndim > 1: raise ValueError("The truth value of an array with more than" + " one element is ambiguous. " + "Use a.any() or a.all()") dim_reps = reps.size elif isinstance(reps, (list, tuple)): reps_size = 1 if len(reps) <= 0: reps = (1, ) else: if A.ndim in [0, 1, 2]: inner_cnt = 1 else: inner_cnt = functools.reduce(operator.mul, A.shape[0:-1]) for i in range(len(reps)): if isinstance(reps[i], (list, tuple)): if len(reps[i]) <= 0: raise ValueError("operands could not be broadcast" + " together with shape (" + str(reps_size * inner_cnt) + ",) (0,)") if len(reps[i]) == 1: if isinstance(reps[i][0], (list, tuple)): raise ValueError( "object too deep for desired array") else: raise TypeError("'%s' object cannot be" " interpreted as an integer" % (type(reps[i]).__name__)) elif len(reps[i]) > 1: list_flg = False scal_flg = False for j in range(len(reps[i])): if isinstance(reps[i][j], (list, tuple)): list_flg = True # TODO: numpy.isscalar -> nlcpy.isscalar elif numpy.isscalar(reps[i][j]): scal_flg = True elif isinstance(reps[i][j], (ndarray, numpy.ndarray)): if reps[i][j].size == 1: scal_flg = True elif reps[i][j].size <= 0 or reps[i][ j].size >= 2: list_flg = True if list_flg is True and scal_flg is True: raise ValueError( "setting an array element with a sequence.") elif not list_flg and scal_flg: raise ValueError( "operands could not be broadcast" + " together with shape (" + str(reps_size * inner_cnt) + ",) (" + str(len(reps[i])) + ",)") elif list_flg and not scal_flg: raise ValueError( "object too deep for desired array") elif isinstance(reps[i], (ndarray, numpy.ndarray)): if reps[i].size > 1 and reps.ndim > 0: raise ValueError( "The truth value of an array with more than" + " one element is ambiguous." + " Use a.any() or a.all()") else: if reps[i].ndim == 0: shape_reps = (reps[i], ) elif reps[i].ndim == 1: shape_reps = (reps[i], ) elif reps[i] is not None and not isinstance(reps[i], int): if isinstance(reps[i], complex): reps_size *= int(reps[i].real) else: reps_size *= int(reps[i]) shape_reps = tuple(reps) dim_reps = len(shape_reps) if A.ndim < dim_reps: A = array(A, ndmin=dim_reps) shape_A = A.shape shape_reps = (1, ) * (A.ndim - dim_reps) + shape_reps shape = tuple(s * t for s, t in zip(shape_A, shape_reps)) ret = ndarray(shape=shape, dtype=A.dtype) if ret.size > 0: request._push_request('nlcpy_tile', 'manipulation_op', (A, ret)) return ret
def dot(a, b, out=None): """Computes a dot product of two arrays. - If both *a* and *b* are 1-D arrays, it is inner product of vectors (without complex conjugation). - If both *a* and *b* are 2-D arrays, it is matrix multiplication, but using :func:`nlcpy.matmul` or ``a @ b`` is preferred. - If either *a* or *b* is 0-D (scalar), it is equivalent to multiply and using ``nlcpy.multiply(a,b)`` or ``a * b`` is preferred. - If *a* is an N-D array and *b* is a 1-D array, it is a sum product over the last axis of *a* and *b*. - If *a* is an N-D array and *b* is an M-D array (where ``M>=2``), it is a sum product over the last axis of *a* and the second-to-last axis of *b*: ``dot(a, b)[i,j,k,m] = sum(a[i,j,:] * b[k,:,m])`` Parameters ---------- a : array_like Input arrays or scalars. b : array_like Input arrays or scalars. out : ndarray, optional Output argument. This must have the exact kind that would be returned if it was not used. In particular, *out.dtype* must be the dtype that would be returned for *dot(a,b)*. Returns ------- output : ndarray Returns the dot product of *a* and *b*. If *a* and *b* are both scalars or both 1-D arrays then this function returns the result as a 0-dimention array. Examples -------- >>> import nlcpy as vp >>> vp.dot(3, 4) array(12) Neither argument is complex-conjugated: >>> vp.dot([2j, 3j], [2j, 3j]) array(-13.+0.j) For 2-D arrays it is the matrix product: >>> a = [[1, 0], [0, 1]] >>> b = [[4, 1], [2, 2]] >>> vp.dot(a,b) array([[4, 1], [2, 2]]) >>> a = vp.arange(3*4*5*6).reshape((3, 4, 5, 6)) >>> b = vp.arange(3*4*5*6)[::-1].reshape((5, 4, 6, 3)) >>> vp.dot(a, b)[2, 3, 2, 1, 2, 2] array(499128) >>> sum(a[2, 3, 2, :] * b[1, 2, :, 2]) array(499128) """ a = nlcpy.asanyarray(a) b = nlcpy.asanyarray(b) dtype_out = numpy.result_type(a.dtype, b.dtype) if out is not None: if not isinstance(out, nlcpy.ndarray): raise TypeError("'out' must be an array") if dtype_out != out.dtype: raise ValueError('output array is incorrect dtype') # if either a or b is 0-D array, it is equivalent to nlcpy.multiply if a.ndim == 0 or b.ndim == 0: return nlcpy.asanyarray(ufunc_op.multiply(a, b, out=out), order='C') # if both a and b are 1-D arrays, it is inner product of vectors if a.ndim == 1 and b.ndim == 1: return cblas_wrapper.cblas_dot(a, b, out=out) # if both a and b are 2-D arrays, it is matrix multiplication if a.ndim == 2 and b.ndim == 2: return cblas_wrapper.cblas_gemm(a, b, out=out, dtype=numpy.result_type( a.dtype, b.dtype)) # if either a or b are N-D array, it is sum product over the # last(or second-last) axis. if b.ndim > 1: if a.shape[-1] != b.shape[-2]: raise ValueError('mismatch input shape') shape_out = a.shape[:-1] + b.shape[:-2] + (b.shape[-1], ) else: if a.shape[-1] != b.shape[-1]: raise ValueError('mismatch input shape') shape_out = a.shape[:-1] if out is None: out = nlcpy.empty(shape_out, dtype=dtype_out) if out.dtype in (numpy.int8, numpy.int16, numpy.uint8, numpy.uint16, numpy.float16): raise TypeError('output dtype \'%s\' is not supported' % dtype_out) elif out.shape != shape_out or not out.flags.c_contiguous: raise ValueError( 'output array is not acceptable (must have the right datatype, ' 'number of dimensions, and be a C-Array)') out.fill(0) if a.size > 0 and b.size > 0: request._push_request( "nlcpy_dot", "linalg_op", (a, b, out), ) return out
def where(condition, x=None, y=None): """Returns elements chosen from *x* or *y* depending on *condition*. Note ---- When only condition is provided, this function is a shorthand for ``nlcpy.asarray(condition).nonzero()``. Using nonzero directly should be preferred, as it behaves correctly for subclasses. The rest of this documentation covers only the case where all three arguments are provided. Parameters ---------- condition : array_like, bool Where True, yield *x*, otherwise yield *y*. x, y : array_like Values from which to choose. *x*, *y* and *condition* need to be broadcastable to some shape. Returns ------- out : ndarray An array with elements from *x* where *condition* is True, and elements from *y* elsewhere. Note ---- If all the arrays are 1-D, :func:`where` is equivalent to:: [xv if c else yv for c, xv, yv in zip(condition, x, y)] See Also -------- nonzero : Returns the indices of the elements that are non-zero. Examples -------- >>> import nlcpy as vp >>> a = vp.arange(10) >>> a array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) >>> vp.where(a < 5, a, 10*a) array([ 0, 1, 2, 3, 4, 50, 60, 70, 80, 90]) This can be used on multidimensional arrays too: >>> vp.where([[True, False], [True, True]], ... [[1, 2], [3, 4]], ... [[9, 8], [7, 6]]) array([[1, 8], [3, 4]]) The shapes of x, y, and the condition are broadcast together: >>> x = vp.arange(3).reshape([3,1]) >>> y = vp.arange(4).reshape([1,4]) >>> vp.where(x < y, x, 10 + y) # both x and 10+y are broadcast array([[10, 0, 0, 0], [10, 11, 1, 1], [10, 11, 12, 2]]) >>> a = vp.array([[0, 1, 2], ... [0, 2, 4], ... [0, 3, 6]]) >>> vp.where(a < 4, a, -1) # -1 is broadcast array([[ 0, 1, 2], [ 0, 2, -1], [ 0, 3, -1]]) """ if condition is None: condition = False arr = nlcpy.asarray(condition) if x is None and y is None: return nlcpy.nonzero(arr) if x is None or y is None: raise ValueError("either both or neither of x and y should be given") if not isinstance(x, nlcpy.ndarray): x = numpy.asarray(x) if not isinstance(y, nlcpy.ndarray): y = numpy.asarray(y) ret_type = numpy.result_type(x, y) arr_x = nlcpy.asarray(x, dtype=ret_type) arr_y = nlcpy.asarray(y, dtype=ret_type) if arr.dtype != bool: arr = (arr != 0) values, shape = core._broadcast_core((arr, arr_x, arr_y)) ret = nlcpy.ndarray(shape=shape, dtype=ret_type) request._push_request( "nlcpy_where", "indexing_op", (ret, values[0], values[1], values[2]), ) return ret
def unique(ar, return_index=False, return_inverse=False, return_counts=False, axis=None): """Finds the unique elements of an array. Returns the sorted unique elements of an array. There are three optional outputs in addition to the unique elements: - the indices of the input array that give the unique values - the indices of the unique array that reconstruct the input array - the number of times each unique value comes up in the input array Parameters ---------- ar : array_like Input array. Unless *axis* is specified, this will be flattened if it is not already 1-D. return_index : bool, optional If True, also return the indices of *ar* (along the specified axis, if provided, or in the flattened array) that result in the unique array. return_inverse : bool, optional If True, also return the indices of the unique array (for the specified axis, if provided) that can be used to reconstruct *ar*. return_counts : bool, optional If True, also return the number of times each unique item appears in *ar*. axis : int or None, optional The axis to operate on. If None, *ar* will be flattened. If an integer, the subarrays indexed by the given axis will be flattened and treated as the elements of a 1-D array with the dimension of the given axis, see the notes for more details. Object arrays or structured arrays that contain objects are not supported if the *axis* kwarg is used. The default is None. Returns ------- unique : ndarray The sorted unique values. unique_indices : ndarray, optional The indices of the first occurrences of the unique values in the original array. Only provided if *return_index* is True. unique_inverse : ndarray, optional The indices to reconstruct the original array from the unique array. Only provided if *return_inverse* is True. unique_count : ndarray, optional The number of times each of the unique values comes up in the original array. Only provided if *return_counts* is True. Restriction ----------- *NotImplementedError*: - If 'c' is contained in *ar.dtype.kind*. Note ---- When an axis is specified the subarrays indexed by the axis are sorted. This is done by making the specified axis the first dimension of the array and then flattening the subarrays in C order. The flattened subarrays are then viewed as a structured type with each element given a label, with the effect that we end up with a 1-D array of structured types that can be treated in the same way as any other 1-D array. The result is that the flattened subarrays are sorted in lexicographic order starting with the first element. Examples -------- >>> import nlcpy as vp >>> vp.unique([1, 1, 2, 2, 3, 3]) array([1, 2, 3]) >>> a =vp.array([[1, 1], [2, 3]]) >>> vp.unique(a) array([1, 2, 3]) Return the unique rows of a 2D array >>> a = vp.array([[1, 0, 0], [1, 0, 0], [2, 3, 4]]) >>> vp.unique(a, axis=0) array([[1, 0, 0], [2, 3, 4]]) Return the indices of the original array that give the unique values: >>> a = vp.array([1, 2, 2, 3, 1]) >>> u, indices = vp.unique(a, return_index=True) >>> u array([1, 2, 3]) >>> indices array([0, 1, 3]) >>> a[indices] array([1, 2, 3]) Reconstruct the input array from the unique values: >>> a = vp.array([1, 2, 6, 4, 2, 3, 2]) >>> u, indices = vp.unique(a, return_inverse=True) >>> u array([1, 2, 3, 4, 6]) >>> indices array([0, 1, 4, 3, 1, 2, 1]) >>> u[indices] array([1, 2, 6, 4, 2, 3, 2]) """ ar = nlcpy.asanyarray(ar) if axis is not None: if axis < 0: axis = axis + ar.ndim if axis < 0 or axis >= ar.ndim: raise AxisError('Axis out of range') if ar.ndim > 1 and axis is not None: if ar.size == 0: if axis is None: shape = () else: shape = list(ar.shape) shape[axis] = int(shape[axis] / 2) return nlcpy.empty(shape, dtype=ar.dtype) ar = nlcpy.moveaxis(ar, axis, 0) orig_shape = ar.shape ar = ar.reshape(orig_shape[0], -1) aux = nlcpy.array(ar) perm = nlcpy.empty(ar.shape[0], dtype='l') request._push_request( 'nlcpy_sort_multi', 'sorting_op', (ar, aux, perm, return_index) ) mask = nlcpy.empty(aux.shape[0], dtype='?') mask[0] = True mask[1:] = nlcpy.any(aux[1:] != aux[:-1], axis=1) ret = aux[mask] ret = ret.reshape(-1, *orig_shape[1:]) ret = nlcpy.moveaxis(ret, 0, axis) else: ar = ar.flatten() if return_index or return_inverse: perm = ar.argsort(kind='stable' if return_index else None) aux = ar[perm] else: ar.sort() aux = ar mask = nlcpy.empty(aux.shape[0], dtype='?') if mask.size: mask[0] = True mask[1:] = aux[1:] != aux[:-1] ret = aux[mask] if not return_index and not return_inverse and not return_counts: return ret ret = (ret,) if return_index: ret += (perm[mask],) if return_inverse: imask = nlcpy.cumsum(mask) - 1 inv_idx = nlcpy.empty(mask.shape, dtype=nlcpy.intp) inv_idx[perm] = imask ret += (inv_idx,) if return_counts: nonzero = nlcpy.nonzero(mask)[0] idx = nlcpy.empty((nonzero.size + 1,), nonzero.dtype) idx[:-1] = nonzero idx[-1] = mask.size ret += (idx[1:] - idx[:-1],) return ret
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 arange(start, stop=None, step=1, dtype=None): """Returns 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*). If stop is None, values are ganerated within ``[0, start)``. For integer arguments the function is equivalent to the Python built-in *range* 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 :func:`linspace` for these cases. Parameters ---------- start : number Start of interval. The interval includes this value. stop : number, optional 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, optional 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 : Returns evenly spaced numbers over a specified interval. Examples -------- >>> import nlcpy as vp >>> vp.arange(3) array([0, 1, 2]) >>> vp.arange(3.0) array([0., 1., 2.]) >>> vp.arange(3,7) array([3, 4, 5, 6]) >>> vp.arange(3,7,2) array([3, 5]) """ if dtype is None: if any( numpy.dtype(type(val)).kind == 'f' for val in (start, stop, step)): dtype = float else: dtype = int if stop is None: stop = start start = 0 if step is None: step = 1 size = int(numpy.ceil((stop - start) / step)) # size = int(numpy.ceil(numpy.ceil(stop - start) / step)) if size <= 0: return nlcpy.empty((0, ), dtype=dtype) if numpy.dtype(dtype).type == numpy.bool_: if size > 2: raise ValueError('no fill-function for data-type.') if size == 2: return nlcpy.array([start, start - step], dtype=numpy.bool_) else: return nlcpy.array([start], dtype=numpy.bool_) ret = nlcpy.empty((size, ), dtype=dtype) if numpy.dtype(dtype).kind == 'f': typ = numpy.dtype('f8').type elif numpy.dtype(dtype).kind == 'c': typ = numpy.dtype('c16').type elif numpy.dtype(dtype).kind == 'u': typ = numpy.dtype('u8').type elif numpy.dtype(dtype).kind == 'i': typ = numpy.dtype('i8').type elif numpy.dtype(dtype).kind == 'b': typ = numpy.dtype('bool').type else: raise TypeError('detected invalid dtype.') if ret._memloc in {on_VE, on_VE_VH}: request._push_request( "nlcpy_arange", "creation_op", (typ(start), typ(step), ret), ) if ret._memloc in {on_VH, on_VE_VH}: del ret.vh_data ret.vh_data = numpy.arange(typ(start), typ(stop), typ(step), dtype=ret.dtype) return ret
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 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