papyri
This is a pre-release version (2.5.0.dev0+git20251130.2de293a). Go to latest (2.4.4)
{ } Raw JSON

bundles / numpy 2.5.0.dev0+git20251130.2de293a / numpy / _core / _multiarray_umath / shares_memory

built-in

numpy._core._multiarray_umath:shares_memory

Signature

built-in shares_memory ( a ,  b ,  / ,  max_work = -1 )

Summary

Determine if two arrays share memory.

Extended Summary

Parameters

a, b : ndarray

Input arrays

max_work : int, optional

Effort to spend on solving the overlap problem (maximum number of candidate solutions to consider). The following special values are recognized:

max_work=-1 (default)

The problem is solved exactly. In this case, the function returns True only if there is an element shared between the arrays. Finding the exact solution may take extremely long in some cases.

max_work=0

Only the memory bounds of a and b are checked. This is equivalent to using may_share_memory().

Returns

out : bool

Raises

: numpy.exceptions.TooHardError

Exceeded max_work.

Examples

import numpy as np
x = np.array([1, 2, 3, 4])
np.shares_memory(x, np.array([5, 6, 7]))
np.shares_memory(x[::2], x)
np.shares_memory(x[::2], x[1::2])
Checking whether two arrays share memory is NP-complete, and runtime may increase exponentially in the number of dimensions. Hence, `max_work` should generally be set to a finite number, as it is possible to construct examples that take extremely long to run: 
from numpy.lib.stride_tricks import as_strided
x = np.zeros([192163377], dtype=np.int8)
x1 = as_strided(
    x, strides=(36674, 61119, 85569), shape=(1049, 1049, 1049))
x2 = as_strided(
    x[64023025:], strides=(12223, 12224, 1), shape=(1049, 1049, 1))
np.shares_memory(x1, x2, max_work=1000)
Running ``np.shares_memory(x1, x2)`` without `max_work` set takes around 1 minute for this case. It is possible to find problems that take still significantly longer.

See also

may_share_memory

Aliases

  • numpy._core._multiarray_umath.shares_memory