Polymorphism with dataclasses and arrays?

[rebcabin]

I want a hamming-distance function that works both on arrays of length 4 and on arrays of length 8192. For now, it seems I must copy-paste code. Please consider the following and tell me how to improve it !

@dataclass
class LpBhv:
    # Issue 2083: can't say HDC_DIM
    dim : i32 = 8192
    a : i8[8192] = empty(8192, dtype=int8)

def hamming_lp_bhv(this : LpBhv, that : LpBhv) -> i32:
    """ATTENTION: THE FOLLOWING CODE IS DUPLICATED BELOW
    """
    i : i32
    assert this.dim == that.dim
    result : i32 = 0
    for i in range(this.dim):
        low1 : i32 = i32(this.a[i]) & 0x0F
        hig1 : i32 = i32(this.a[i]) & 0xF0 >> 4

        low2 : i32 = i32(that.a[i]) & 0x0F
        hig2 : i32 = i32(that.a[i]) & 0xF0 >> 4

        result += NIBBLE_HAMMINGS[low1][low2]
        result += NIBBLE_HAMMINGS[hig1][hig2]
    return result

@dataclass
class LpBhvSmall:
    dim : i32 = 4
    a : i8[4] = empty(4, dtype=int8)

def hamming_lp_bhv_smalll(this : LpBhvSmall, that : LpBhvSmall) -> i32:
    """ATTENTION: THE ONLY DIFFERENCE IS IN THE TYPES!
       Could some kind of polymorphism save this duplication?
    """
    i : i32
    assert this.dim == that.dim
    result : i32 = 0
    for i in range(this.dim):
        low1 : i32 = i32(this.a[i]) & 0x0F
        hig1 : i32 = i32(this.a[i]) & 0xF0 >> 4

        low2 : i32 = i32(that.a[i]) & 0x0F
        hig2 : i32 = i32(that.a[i]) & 0xF0 >> 4

        result += NIBBLE_HAMMINGS[low1][low2]
        result += NIBBLE_HAMMINGS[hig1][hig2]
    return result

[Thirumalai-Shaktivel]

I thought of supporting the following in the LPython:

from lpython import Const, i32, i8, dataclass
from numpy import empty, int8

@dataclass
class LpBhv:
    dim : Const[i32]
    a : i8[dim]

def test():
    x: LpBhv = LpBhv(4, empty(4, dtype=int8))

test()

But this doesn't seem to work with CPython.

[Thirumalai-Shaktivel]

I think, we can handle this similar to Function return type:

from lpython import Const, i32, i8, dataclass, TypeVar
from numpy import empty, int8

n = TypeVar("n")

@dataclass
class LpBhv:
    n : i32
    a : i8[n] # Or a : i8[:]

def test():
    x: LpBhv = LpBhv(4, empty(4, dtype=int8))
    print(x)

test()

[rebcabin]

I'm promoting this to a BUG because the following works in CP but not in LP:

from lpython import (i8, i32, i64, f32, f64,
                     u8, u32,
                     TypeVar, Const,
                     dataclass)
from numpy import (empty, sqrt, float32, float64,
                   int8, int32, array, # ndarray
                   )


n = TypeVar("n")


@dataclass
class LnBhv:
    dim : i32
    a : i8[n]


if __name__ == "__main__":

    print("Module HDC")
    ln_bhv : LnBhv = LnBhv(4, empty(4, dtype=int8))
    i : i32 = 0
    for i in range(4):
        print('ln_bhv.a[', end='')
        print(i, end='')
        print(']: ', end='')
        print(ln_bhv.a[i])

(lp) ┌─(~/CLionProjects/lpython/lasr/LP-pycharm)─────────────────────────────────────────────────────────────────────────────────────────────────────────(brian@Golf37:s000)─┐
└─(09:09:33 on brian-lasr ✹ ✭)──> PYTHONPATH='../../src/runtime/lpython' python issue2107.py                                                              ──(Wed,Jul05)─┘
Module HDC
ln_bhv.a[0]: 3
ln_bhv.a[1]: 0
ln_bhv.a[2]: 0
ln_bhv.a[3]: 0
(lp) ┌─(~/CLionProjects/lpython/lasr/LP-pycharm)─────────────────────────────────────────────────────────────────────────────────────────────────────────(brian@Golf37:s000)─┐
└─(09:11:04 on brian-lasr ✹ ✭)──> ~/CLionProjects/lpython/src/bin/lpython -I. issue2107.py                                                                ──(Wed,Jul05)─┘
semantic error: Only those local variables which can be reduced to compile time constant should be used in dimensions of an array.
  --> issue2107.py:17:12
   |
17 |     a : i8[n]
   |            ^ 

[certik]

Why not something like:

@dataclass
class LpBhv:
    # Issue 2083: can't say HDC_DIM
    dim : i32 = 8192
    a : i8[8192] = empty(8192, dtype=int8)

@dataclass
class LpBhvSmall:
    dim : i32 = 4
    a : i8[4] = empty(4, dtype=int8)

def hamming_lp_bhv(this : i8[:], that : i8[:]) -> i32:
    i : i32
    assert size(this) == size(that)
    result : i32 = 0
    for i in range(size(this)):
        low1 : i32 = i32(this[i]) & 0x0F
        hig1 : i32 = i32(this[i]) & 0xF0 >> 4

        low2 : i32 = i32(that[i]) & 0x0F
        hig2 : i32 = i32(that[i]) & 0xF0 >> 4

        result += NIBBLE_HAMMINGS[low1][low2]
        result += NIBBLE_HAMMINGS[hig1][hig2]
    return result

This is the canonical way to implement numerical operations --- do not use structs, use regular arrays, which carry the information about their sizes and dimensions.