Array-Broadcasting in Cython Memoryview

I created a typed memoryview in cython and would like to multiply it by a scalar:

import numpy as np
import math
cimport numpy as np

def foo():
    N = 10
    cdef np.double_t [:, :] A = np.ones(shape=(N,N),dtype=np.double_)
    cdef int i,j
    cdef double pi = math.pi
    for i in range(N):
        for j in range(N):
            A[i,j] *= pi
    return A

def bar():
    N = 10
    cdef np.double_t [:, :] A = np.ones(shape=(N,N),dtype=np.double_)
    cdef double pi = math.pi
    A *= pi
    return A

Function foo() does this task but is not very convenient/readable.

The line A *= pi in function bar() does however not compile: Invalid operand types for '*' (double_t[:, :]; double).

Is there a way to perform such a broadcasting operation on a cython memoryview?

No, memoryviews don't do this. A memoryview is literally just a way to access individual elements of an array quickly. It has no really concept of the mathematical operations that can be performed on the array.

In the case of your bar function, any attempt to type it is probably actually going to make it worse (i.e. it'll spend extra time checking the type, but ultimately the work is done in ordinary calls to Numpy function).

There's a number of (not 100% satisfactory) ways of getting a Numpy array from a memoryview:

1. np.asarray(memview) - this should be done without copying (provided you aren't using the esoteric indirect memory layout). It might be worth adding an assertion to check that no copy was made though.

2. memview.base - be slightly careful with this. If the memoryview is a result of slicing then .base will be the original unsliced object.

3. Keep a parallel numpy array and memoryview variable:

    Anp = np.array(...)
    cdef double[:] Amview = Anp
   

   because the memoryview is a view of some memory, modifications to the array will be reflected in the memoryview and vice-versa. (Reassigning the array variable, e.g. Anp = something_else, won't be reflected though).

In summary, memoryviews are designed for one main job: being able to access individual elements quickly. If that's not what you're doing then you probably don't want to use a memoryview.