Array ও Dynamic Array — memory layout থেকে performance পর্যন্ত

লক্ষ্য: 2D-র মিথ্যাটা নিজের হাতে ভাঙা — memory-তে শুধু এক dimension, বাকিটা আপনার arithmetic আর iteration order।

# flatmatrix.py — flat storage + rhythm-aware iterators
# চালান: python3 flatmatrix.py

class FlatMatrix:
    __slots__ = ('rows', 'cols', 'data')

    def __init__(self, rows, cols, fill=0):
        self.rows = rows
        self.cols = cols
        self.data = [fill] * (rows * cols)

    def index(self, r, c):
        if r >= self.rows or c >= self.cols or r * -1 > self.rows or c * -1 > self.cols:
            raise IndexError('out of range')
        return r * self.cols + c

    def get(self, r, c):
        return self.data[self.index(r, c)]

    def set(self, r, c, value):
        self.data[self.index(r, c)] = value

    def iter_rows(self):
        """Sequential touch — প্রতি ধাপে flat-index +1"""
        pos = 0
        for _ in range(self.rows):
            for _ in range(self.cols):
                yield self.data[pos]
                pos += 1

    def iter_cols(self):
        """Strided touch — প্রতি ধাপে flat-index +cols"""
        for c in range(self.cols):
            pos = c
            for _ in range(self.rows):
                yield self.data[pos]
                pos += self.cols


def bench(fn, reps=5):
    best = float('inf')
    for _ in range(reps):
        t0 = time.perf_counter()
        fn()
        best = min(best, time.perf_counter() - t0)
    return best


if __name__ == '__main__':
    import time
    R = C = 1000
    m = FlatMatrix(R, C)
    for i in range(R * C):
        m.data[i] = i

    # spot-check the arithmetic
    m.set(2, 3, 999)
    assert m.get(2, 3) == 999
    assert m.index(2, 3) == 2 * C + 3

    sr = sum(m.iter_rows())
    sc = sum(m.iter_cols())
    print(f'sum check  : {sr} == {sc} -> {sr == sc}')

    tr = bench(lambda: sum(m.iter_rows()))
    tc = bench(lambda: sum(m.iter_cols()))
    print(f'row iterator : {tr*1000:7.1f} ms')
    print(f'col iterator : {tc*1000:7.1f} ms   ratio {tc/tr:5.2f}x')

প্রত্যাশিত output-এর আকৃতি:

sum check  : 499499500000 == 499499500000 -> True
row iterator :    31.2 ms
col iterator :    44.8 ms   ratio  1.44x

(Ratio Python-এ modest — generator overhead দুই path-এই common। Generator দুটোর ভেতরের flat-index increment-এর পার্থক্য ছাড়া কাজ identical, তাই যা পার্থক্য থাকে সেটা memory rhythm + branch pattern- এর। C-তে একই হারনেস 3–8× দেখাত।)

নিজে বাড়ান:

1. Transpose method যোগ করুন — flat swap করে করুন, কোন copy ছাড়া; transpose-এর পরে iter_rows কোন rhythm-এ চলে?
2. from_nested(nested_list) classmethod — nested Python list থেকে flat conversion, row-major assumption লিখিত করুন docstring-এ
3. Column-major variant class বানিয়ে (index(c,r) মানে c*rows+r) দুই class-এর দুই iterator cross-benchmark করুন — layout আর traversal-এর চার combination-এর পূর্ণ ছক