nlcpy.indexing.indexing のソースコード

#
# * The source code in this file is developed independently by NEC Corporation.
#
# # NLCPy License #
#
#     Copyright (c) 2020 NEC Corporation
#     All rights reserved.
#
#     Redistribution and use in source and binary forms, with or without
#     modification, are permitted provided that the following conditions are met:
#     * Redistributions of source code must retain the above copyright notice,
#       this list of conditions and the following disclaimer.
#     * Redistributions in binary form must reproduce the above copyright notice,
#       this list of conditions and the following disclaimer in the documentation
#       and/or other materials provided with the distribution.
#     * Neither NEC Corporation nor the names of its contributors may be
#       used to endorse or promote products derived from this software
#       without specific prior written permission.
#
#     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
#     ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
#     WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
#     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
#     FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
#     (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
#     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
#     ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
#     (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
#     SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#

import nlcpy
import numpy
from nlcpy.wrapper.numpy_wrap import numpy_wrap


[ドキュメント]@numpy_wrap def take(a, indices, axis=None, out=None, mode='wrap'): """Takes elements from an array along an axis. When axis is not None, this function does the same thing as "fancy" indexing (indexing arrays using arrays); however, it can be easier to use if you need elements along a given axis. A call such as ``arr.take(indices, axis=3)`` is equivalent to ``arr[:,:,:,indices,...]``. Parameters ---------- a : array_like The source array. indices : array_like The indices of the values to extract. Also allow scalars for indices. axis : int, optional The axis over which to select values. By default, the flattened input array is used. out : ndarray, optional If provided, the result will be placed in this array. It should be of the appropriate shape and dtype. mode : {'wrap', raise', 'clip'}, optional In the current NLCPy, this argument is not supported. The default is 'wrap'. Returns ------- out : ndarray Restriction ----------- - *mode* != 'wrap': *NotImplementedError* occurs. Examples -------- >>> import nlcpy as vp >>> a = vp.array([4, 3, 5, 7, 6, 8]) >>> indices = [0, 1, 4] >>> vp.take(a, indices) array([4, 3, 6]) In this example, "fancy" indexing can be used. >>> a[indices] array([4, 3, 6]) If indices is not one dimensional, the output also has these dimensions. >>> vp.take(a, [[0, 1], [2, 3]]) array([[4, 3], [5, 7]]) """ if mode != 'wrap': raise NotImplementedError('mode is not supported yet') a = nlcpy.asarray(a) return a.take(indices, axis, out, mode=mode)
[ドキュメント]def diagonal(a, offset=0, axis1=0, axis2=1): """Returns specified diagonals. If *a* is 2-D, returns the diagonal of *a* with the given offset, i.e., the collection of elements of the form ``a[i, i+offset]``. If *a* has more than two dimensions, then the axes specified by *axis1* and *axis2* are used to determine the 2-D sub-array whose diagonal is returned. The shape of the resulting array can be determined by removing *axis1* and *axis2* and appending an index to the right equal to the size of the resulting diagonals. This function returns a writable view of the original array. Parameters ---------- a : array_like Array from which the diagonals are taken. offset : int, optional Offset of the diagonal from the main diagonal. Can be positive or negative. Defaults to main diagonal (0). axis1 : int, optional Axis to be used as the first axis of the 2-D sub-arrays from which the diagonals should be taken. Defaults to first axis (0). axis2 : int, optional Axis to be used as the second axis of the 2-D sub-arrays from which the diagonals should be taken. Defaults to second axis (1). Returns ------- array_of_diagonals : ndarray If *a* is 2-D, then a 1-D array containing the diagonal and of the same type as *a* is returned. If ``a.ndim > 2``, then the dimensions specified by *axis1* and *axis2* are removed, and a new axis inserted at the end corresponding to the diagonal. Note ---- ``a.ndim < 2`` : *ValueError* occurs. See Also -------- diag : Extracts a diagonal or constructs a diagonal array. Examples -------- >>> import nlcpy as vp >>> a = vp.arange(4).reshape(2,2) >>> a array([[0, 1], [2, 3]]) >>> a.diagonal() array([0, 3]) >>> a.diagonal(1) array([1]) A 3-D example: >>> a = vp.arange(8).reshape(2,2,2); a array([[[0, 1], [2, 3]], <BLANKLINE> [[4, 5], [6, 7]]]) >>> a.diagonal(0, # Main diagonals of two arrays created by skipping ... 0, # across the outer(left)-most axis last and ... 1) # the "middle" (row) axis first. array([[0, 6], [1, 7]]) The sub-arrays whose main diagonals we just obtained; note that each corresponds to fixing the right-most (column) axis, and that the diagonals are “packed” in rows. >>> a[:,:,0] # main diagonal is [0 6] array([[0, 2], [4, 6]]) >>> a[:,:,1] # main diagonal is [1 7] array([[1, 3], [5, 7]]) """ a = nlcpy.asarray(a) return a.diagonal(offset, axis1, axis2)
[ドキュメント]def select(condlist, choicelist, default=0): """Returns an array drawn from elements in choicelist, depending on conditions. Parameters ---------- condlist : list of bool ndarrays The list of conditions which determine from which array in *choicelist* the output elements are taken. When multiple conditions are satisfied, the first one encountered in *condlist* is used. choicelist : list of ndarrays The list of arrays from which the output elements are taken. It has to be of the same length as *condlist*. default : scalar, optional The element inserted in *output* when all conditions evaluate to False. Returns ------- output : ndarray The output at position m is the m-th element of the array in *choicelist* where the m-th element of the corresponding array in *condlist* is True. See Also -------- where : Returns elements chosen from *x* or *y* depending on *condition*. take : Takes elements from an array along an axis. diag : Extracts a diagonal or construct a diagonal array. diagonal : Returns specified diagonals. Examples -------- >>> import nlcpy as vp >>> x = vp.arange(10) >>> condlist = [x<3, x>5] >>> choicelist = [x, x**2] >>> vp.select(condlist, choicelist) array([ 0, 1, 2, 0, 0, 0, 36, 49, 64, 81]) """ if len(condlist) != len(choicelist): raise ValueError( 'list of cases must be same length as list of conditions') if len(condlist) == 0: raise ValueError("select with an empty condition list is not possible") choicelist = list(choicelist) if numpy.isscalar(default): default = numpy.asarray(default) else: default = nlcpy.asarray(default) choicelist.append(default) dtype = numpy.result_type(*choicelist) condlist = nlcpy.broadcast_arrays(*condlist) choicelist = nlcpy.broadcast_arrays(*choicelist) for i in range(len(condlist)): cond = condlist[i] if cond.dtype.type is not nlcpy.bool_: raise TypeError( 'invalid entry {} in condlist: should be boolean ndarray'.format(i)) if choicelist[0].ndim == 0: result_shape = condlist[0].shape else: result_shape = nlcpy.broadcast_arrays(condlist[0], choicelist[0])[0].shape result = nlcpy.full(result_shape, choicelist[-1], dtype=dtype) choicelist = choicelist[-2::-1] condlist = condlist[::-1] for choice, cond in zip(choicelist, condlist): nlcpy.copyto(result, choice, where=cond) return result