Fix dpnp.einsum memory-layout

[abagusetty]

One more minor layout issue detected during an app-testing in comparison to numpy behavior:

Fixes: #3056

• Have you provided a meaningful PR description?
• Have you added a test, reproducer or referred to an issue with a reproducer?
• Have you tested your changes locally for CPU and GPU devices?
• Have you made sure that new changes do not introduce compiler warnings?
• Have you checked performance impact of proposed changes?
• Have you added documentation for your changes, if necessary?
• Have you added your changes to the changelog?

[intel-python-devops]

Can one of the admins verify this patch?

[coveralls]

No base build to compare — abagusetty:fix-einsum-order-k-contiguity into IntelPython:master

[antonwolfy]

Might fail on non-fp64 device

[abagusetty]

good catch, the strides are byte strides. Pinned the operand to dtype.dpnp.default_float_type()

[antonwolfy]

Suggested change

	if order == "A":
	if order in ("A", "K"):

needs to fix:

import numpy as np
import dpnp

# F-contiguous @ C-contiguous, default order="K"
a = np.asarray(np.random.random((4, 5)), order="F")
b = np.asarray(np.random.random((5, 6)), order="C")

n = np.einsum("ij,jk->ik", a, b)                          # order="K" default
d = dpnp.einsum("ij,jk->ik", dpnp.asarray(a), dpnp.asarray(b))

print(n.flags.c_contiguous, n.flags.f_contiguous)   # True  False   (NumPy: C)
print(d.flags.c_contiguous, d.flags.f_contiguous)   # False True    (dpnp:  F)  -- mismatch

[abagusetty]

True False
True False

[antonwolfy]

size-0 operand path ignores out= and order= and causes:

import numpy as np
import dpnp


def show(tag, mod, asnp):
    # size-0 contracted dim `j`, non-empty (2, 4) output
    a = mod.ones((2, 0))
    b = mod.ones((0, 4))

    # 1) out= should be filled and returned
    out = mod.full((2, 4), 9.0)
    r = mod.einsum("ij,jk->ik", a, b, out=out)
    out_np = asnp(out)
    print(f"[{tag}] out=  -> r is out: {r is out!s:5}  "
          f"out all-zeros: {bool((out_np == 0).all())!s:5}  (expect: True / True)")

    # 2) explicit order='F' should give an F-contiguous result
    rf = mod.einsum("ij,jk->ik", a, b, order="F")
    print(f"[{tag}] order='F' -> f_contiguous: {rf.flags.f_contiguous!s:5} "
          f"c_contiguous: {rf.flags.c_contiguous!s:5}  (expect: True / False)")

show("numpy", np, lambda x: x)
# Out: [numpy] out=  -> r is out: True   out all-zeros: True   (expect: True / True)
# Out: [numpy] order='F' -> f_contiguous: True  c_contiguous: False  (expect: True / False)

show("dpnp ", dpnp, dpnp.asnumpy)
# Out: [dpnp ] out=  -> r is out: False  out all-zeros: False  (expect: True / True)
# Out: [dpnp ] order='F' -> f_contiguous: False c_contiguous: True   (expect: True / False)