Cobra Forums

def getHashCode
        """
        As a completely mutable object, MultiList does not
        support getHashCode
        """

def equals(m as MultiList<of T>)
        """
        Equal if shapes are the same, and
        elements are in the same order.
        Ignores .isReadOnly, .isPermuted, .isReferred
        """

class MultiListExample

    def main
        grid3x3 = MultiList<of int>(3, 3)
        
        # You can get the total number of elements in the MultiList
        assert grid3x3.count == 9
        
        # You can retrieve information about the dimensions
        assert grid3x3.numDims == 2
        assert grid3x3.shape == [3, 3]
        
        # Elements are initialized with the default value for the data type
        for row in 3, for col in 3, assert grid3x3[row, col] == 0
        
        # Fill the MultiList with 1's
        grid3x3.fill(for i in grid3x3.count get 1)
        for row in 3, for col in 3, assert grid3x3[row, col] == 1
        
        # prints '[[1, 1, 1], [1, 1, 1], [1, 1, 1]]'
        print grid3x3
        
        # You can loop over the elements.
        # prints 
        # 111
        # 111
        # 111
        for row in 3
            for col in 3
                print grid3x3[row, col] stop
            print
        
        # You can loop across a single axis
        for col in grid3x3.shape[1]
            grid3x3[1, col] = 2
            grid3x3[2, col] = 3
        
        # prints '[[1, 1, 1], [2, 2, 2], [3, 3, 3]]'
        print grid3x3
        
        # Transpose swaps rows with columns in-place
        grid3x3.transpose
        
        # prints '[[1, 2, 3], [1, 2, 3], [1, 2, 3]]'
        print grid3x3
        
        # you can slice off new MultiList instances
        topLeft2x2 = grid3x3.slice(Pair<of int>(0, 2), Pair<of int>(0, 2))
        
        # prints '[[1, 2], [1, 2]]'
        print topLeft2x2
        
        bottomRight2x2 = grid3x3.slice(Pair<of int>(1, 3), Pair<of int>(1, 3))
        # prints '[[2, 3], [2, 3]]'
        print bottomRight2x2
        
        # Slices know where they came from
        assert topLeft2x2.owner is grid3x3
        assert bottomRight2x2.owner is grid3x3
        
        # Changes in the owner are reflected in the slices
        grid3x3[0, 0] = 0
        
        # prints '[[0, 2], [1, 2]]'
        print topLeft2x2
        
        # And vice-versa
        topLeft2x2[0, 0] = 1
        
        # prints '[[1, 2, 3], [1, 2, 3], [1, 2, 3]]'
        print grid3x3
        
        # You can compare MultiLists for equality or inequality
        grid2x2 = MultiList<of int>(2, 2)
        assert grid2x2 <> topLeft2x2
        
        for row in 2
            for col in 2
                grid2x2[row, col] = col + 1
                
        assert grid2x2 == topLeft2x2
        
        # MultiLists can have up to 10,000,000 dimensions or 2,100,000,000 elements
        cube = MultiList<of int>(8, 8, 8)
        assert cube.count == 512
        
        # These examples will eat your RAM and probably crash on 32-bit systems
        spaceTime = MultiList<of uint8>(100, 100, 100, 100)
        assert spaceTime.count == 100_000_000
        
        stringTheory = MultiList<of uint8>(10, 10, 10, 10, 10, 10, 10, 10, 10, 2)
        assert stringTheory.count == 2_000_000_000