Vous êtes un professionnel et vous avez besoin d'une formation ? Mise en oeuvre d'IHM
avec Qt et PySide6 Voir le programme détaillé

Module « scipy.sparse »

Classe « coo_array »

Informations générales

Héritage

        builtins.object
            sparray
    builtins.object
        _minmax_mixin
builtins.object
    _spbase
        _data_matrix
            _coo_base
                coo_array

Définition

class coo_array(_coo_base, sparray):

help(coo_array)

A sparse array in COOrdinate format.

Also known as the 'ijv' or 'triplet' format.

This can be instantiated in several ways:
    coo_array(D)
        where D is an ndarray

    coo_array(S)
        with another sparse array or matrix S (equivalent to S.tocoo())

    coo_array(shape, [dtype])
        to construct an empty sparse array with shape `shape`
        dtype is optional, defaulting to dtype='d'.

    coo_array((data, coords), [shape])
        to construct from existing data and index arrays:
            1. data[:]       the entries of the sparse array, in any order
            2. coords[i][:]  the axis-i coordinates of the data entries

        Where ``A[coords] = data``, and coords is a tuple of index arrays.
        When shape is not specified, it is inferred from the index arrays.

Attributes
----------
dtype : dtype
    Data type of the sparse array
shape : tuple of integers
    Shape of the sparse array
ndim : int
    Number of dimensions of the sparse array
nnz
size
data
    COO format data array of the sparse array
coords
    COO format tuple of index arrays
has_canonical_format : bool
    Whether the matrix has sorted coordinates and no duplicates
format
T

Notes
-----

Sparse arrays can be used in arithmetic operations: they support
addition, subtraction, multiplication, division, and matrix power.

Advantages of the COO format
    - facilitates fast conversion among sparse formats
    - permits duplicate entries (see example)
    - very fast conversion to and from CSR/CSC formats

Disadvantages of the COO format
    - does not directly support:
        + arithmetic operations
        + slicing

Intended Usage
    - COO is a fast format for constructing sparse arrays
    - Once a COO array has been constructed, convert to CSR or
      CSC format for fast arithmetic and matrix vector operations
    - By default when converting to CSR or CSC format, duplicate (i,j)
      entries will be summed together.  This facilitates efficient
      construction of finite element matrices and the like. (see example)

Canonical format
    - Entries and coordinates sorted by row, then column.
    - There are no duplicate entries (i.e. duplicate (i,j) locations)
    - Data arrays MAY have explicit zeros.

Examples
--------

>>> # Constructing an empty sparse array
>>> import numpy as np
>>> from scipy.sparse import coo_array
>>> coo_array((3, 4), dtype=np.int8).toarray()
array([[0, 0, 0, 0],
       [0, 0, 0, 0],
       [0, 0, 0, 0]], dtype=int8)

>>> # Constructing a sparse array using ijv format
>>> row  = np.array([0, 3, 1, 0])
>>> col  = np.array([0, 3, 1, 2])
>>> data = np.array([4, 5, 7, 9])
>>> coo_array((data, (row, col)), shape=(4, 4)).toarray()
array([[4, 0, 9, 0],
       [0, 7, 0, 0],
       [0, 0, 0, 0],
       [0, 0, 0, 5]])

>>> # Constructing a sparse array with duplicate coordinates
>>> row  = np.array([0, 0, 1, 3, 1, 0, 0])
>>> col  = np.array([0, 2, 1, 3, 1, 0, 0])
>>> data = np.array([1, 1, 1, 1, 1, 1, 1])
>>> coo = coo_array((data, (row, col)), shape=(4, 4))
>>> # Duplicate coordinates are maintained until implicitly or explicitly summed
>>> np.max(coo.data)
1
>>> coo.toarray()
array([[3, 0, 1, 0],
       [0, 2, 0, 0],
       [0, 0, 0, 0],
       [0, 0, 0, 1]])

Constructeur(s)

Signature du constructeur	Description
__init__(self, arg1, shape=None, dtype=None, copy=False, *, maxprint=None)

Liste des opérateurs

Opérateurs hérités de la classe _data_matrix

__imul__, __itruediv__, __neg__

Liste des opérateurs

Opérateurs hérités de la classe _spbase

__add__, __eq__, __ge__, __gt__, __iadd__, __isub__, __le__, __lt__, __matmul__, __mul__, __ne__, __pow__, __radd__, __rmul__, __rsub__, __rtruediv__, __sub__, __truediv__

Méthodes héritées de la classe sparray

__init_subclass__, __subclasshook__

Méthodes héritées de la classe _coo_base

count_nonzero, diagonal, dot, eliminate_zeros, reshape, resize, sum_duplicates, tensordot, toarray, tocoo, tocsc, tocsr, todia, todok, transpose

Méthodes héritées de la classe _minmax_mixin

argmax, argmin, max, min, nanmax, nanmin

Méthodes héritées de la classe _data_matrix

__abs__, __round__, astype, conjugate, copy, power

Méthodes héritées de la classe _spbase

__bool__, __div__, __idiv__, __iter__, __len__, __nonzero__, __rdiv__, __repr__, __rmatmul__, __str__, asformat, conj, maximum, mean, minimum, multiply, nonzero, setdiag, sum, tobsr, todense, tolil, trace

Méthodes héritées de la classe object

__delattr__, __dir__, __format__, __getattribute__, __getstate__, __hash__, __reduce__, __reduce_ex__, __setattr__, __sizeof__

Vous êtes un professionnel et vous avez besoin d'une formation ? RAG (Retrieval-Augmented Generation)
et Fine Tuning d'un LLM Voir le programme détaillé