Multi-dimensional array added

pydatastructs/linear_data_structures/__init__.py

@@ -8,7 +8,8 @@
 
 from .arrays import (
     OneDimensionalArray,
-    DynamicOneDimensionalArray
+    DynamicOneDimensionalArray,
+    MultiDimensionalArray
 )
 __all__.extend(arrays.__all__)
 

pydatastructs/linear_data_structures/arrays.py

@@ -1,8 +1,9 @@
 from pydatastructs.utils.misc_util import _check_type, NoneType
 
 __all__ = [
-'OneDimensionalArray',
-'DynamicOneDimensionalArray'
+    'OneDimensionalArray',
+    'MultiDimensionalArray',
+    'DynamicOneDimensionalArray'
 ]
 
 class Array(object):
@@ -139,6 +140,128 @@ def __len__(self):
     def __str__(self):
         return str(self._data)
 
+class MultiDimensionalArray(Array):
+    """
+    Represents a multi-dimensional array.
+
+    Parameters
+    ==========
+
+    dtype: type
+        A valid object type.
+    *args: int
+        The dimensions of the array.
+
+    Raises
+    ======
+
+    IndexError
+        Index goes out of boundaries, or
+        the number of index given is not
+        the same as the number of dimensions.
+    ValueError
+        When there's no dimensions or the
+        dimension size is 0.
+
+    Examples
+    ========
+
+    >>> from pydatastructs import MultiDimensionalArray as MDA
+    >>> arr = MDA(int, 5, 6, 9)
+    >>> arr.fill(32)
+    >>> arr[3, 0, 0]
+    32
+    >>> arr[3, 0, 0] = 7
+    >>> arr[3, 0, 0]
+    7
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Array_data_structure#Multidimensional_arrays
+
+    """
+    __slots__ = ['_shape', '_data', '_dtype']
+
+    def __new__(cls, dtype=NoneType, *args, **kwargs):
+        if dtype is NoneType or not args:
+            raise ValueError("Array cannot be created due to incorrect"
+                             " information.")
+        if len(args) == 1:
+            obj = Array.__new__(cls)
+            obj._dtype = dtype
+            obj._shape = (1)
+            obj._data = [None] * args[0]
+            return obj
+
+        dimensions = args
+        for dimension in dimensions:
+            if dimension < 1:
+                raise ValueError("Array cannot be created due to incorrect"
+                                 " dimensions.")
+        n_dimensions = len(dimensions)
+        d_sizes = []
+        index = 0
+        while n_dimensions > 1:
+            size = dimensions[index]
+            for i in range(index,  len(dimensions) - 1):
+                size = size * dimension
+            d_sizes.append(size)
+            n_dimensions -= 1
+            index += 1
+        d_sizes.append(dimensions[index])
+        d_sizes.append(1)
+        obj = Array.__new__(cls)
+        obj._dtype = dtype
+        obj._shape = tuple(d_sizes)
+        obj._data = [None] * obj._shape[1] * dimensions[0]
+        return obj
+
+    @classmethod
+    def methods(cls):
+        return ['__new__', '__getitem__', '__setitem__', 'fill']
+
+    def __getitem__(self, indices):
+        self._compare_shape(indices)
+        if isinstance(indices, int):
+            return self._data[indices]
+        position = 0
+        for i in range(0, len(indices)):
+            position += self._shape[i+1] * indices[i]
+        return self._data[position]
+
+    def __setitem__(self, indices, element):
+        self._compare_shape(indices)
+        if isinstance(indices, int):
+            self._data[indices] = element
+        else:
+            position = 0
+            for i in range(0, len(indices)):
+                position += self._shape[i+1] * indices[i]
+            self._data[position] = element
+
+    def _compare_shape(self, indices):
+        if isinstance(indices, int):
+            if len(self._shape) > 1:
+                raise IndexError("Shape mismatch, current shape is %s" % self._shape)
+            return
+        if len(indices) != len(self._shape) - 1:
+            raise IndexError("Shape mismatch, current shape is %s" % self._shape)
+        for i in range(len(indices)):
+            if indices[i] > self._shape[i]:
+                raise IndexError("Index out of range.")
+
+    def __str__(self):
+        return str(self._data)
+
+    def fill(self, element):
+        element = self._dtype(element)
+        for i in range(len(self._data)):
+            self._data[i] = element
+
+    @property
+    def shape(self):
+        return  self._shape
 
 class DynamicArray(Array):
     """

pydatastructs/linear_data_structures/tests/test_arrays.py

@@ -1,5 +1,5 @@
 from pydatastructs.linear_data_structures import (
-    OneDimensionalArray, DynamicOneDimensionalArray)
+    OneDimensionalArray, DynamicOneDimensionalArray, MultiDimensionalArray)
 from pydatastructs.utils.raises_util import raises
 
 
@@ -21,6 +21,35 @@ def test_OneDimensionalArray():
     assert raises(TypeError, lambda: ODA(int, set([1, 2, 3])))
     assert raises(ValueError, lambda: ODA(int, 3, [1]))
 
+
+def test_MultiDimensionalArray():
+    array = MultiDimensionalArray(int, 5, 9, 3, 8)
+    assert array.shape == (5, 9, 3, 8)
+    array.fill(5)
+    array[1, 3, 2, 5] = 2.0
+    assert array
+    assert array[1, 3, 2, 5] == 2.0
+    assert array[1, 3, 0, 5] == 5
+    assert array[1, 2, 2, 5] == 5
+    assert array[2, 3, 2, 5] == 5
+    assert raises(IndexError, lambda: array[5])
+    assert raises(IndexError, lambda: array[4, 10])
+    assert raises(IndexError, lambda: array[-1])
+    assert raises(ValueError, lambda: MultiDimensionalArray())
+    assert raises(ValueError, lambda: MultiDimensionalArray(int))
+    assert raises(TypeError, lambda: MultiDimensionalArray(int, 5, 6, ""))
+    array = MultiDimensionalArray(int, 3, 2, 2)
+    array.fill(1)
+    array[0, 0, 0] = 0
+    array[0, 0, 1] = 0
+    array[1, 0, 0] = 0
+    array[2, 1, 1] = 0
+    assert str(array) == '[0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0]'
+    array = MultiDimensionalArray(int, 4)
+    array.fill(5)
+    array[3] = 3
+    assert array[3] == 3
+
 def test_DynamicOneDimensionalArray():
     DODA = DynamicOneDimensionalArray
     A = DODA(int, 0)

pydatastructs/utils/tests/test_code_quality.py

@@ -79,7 +79,7 @@ def _apis():
     pyds.DoublyLinkedList, pyds.SinglyLinkedList,
     pyds.SinglyCircularLinkedList,
     pyds.DoublyCircularLinkedList,
-    pyds.OneDimensionalArray,
+    pyds.OneDimensionalArray, pyds.MultiDimensionalArray,
     pyds.DynamicOneDimensionalArray,
     pyds.trees.BinaryTree, pyds.BinarySearchTree,
     pyds.AVLTree, pyds.SplayTree, pyds.BinaryTreeTraversal,