Multi-dimensional array added

pydatastructs/linear_data_structures/__init__.py

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

pydatastructs/linear_data_structures/arrays.py

@@ -1,16 +1,19 @@
 from pydatastructs.utils.misc_util import _check_type, NoneType
 
 __all__ = [
-'OneDimensionalArray',
-'DynamicOneDimensionalArray'
+    'OneDimensionalArray',
+    'MultiDimensionalArray',
+    'DynamicOneDimensionalArray'
 ]
 
+
 class Array(object):
     '''
     Abstract class for arrays in pydatastructs.
     '''
     pass
 
+
 class OneDimensionalArray(Array):
     '''
     Represents one dimensional arrays.
@@ -68,18 +71,18 @@ class OneDimensionalArray(Array):
     def __new__(cls, dtype=NoneType, *args, **kwargs):
         if dtype is NoneType or len(args) not in (1, 2):
             raise ValueError("1D array cannot be created due to incorrect"
-                                " information.")
+                             " information.")
         obj = Array.__new__(cls)
         obj._dtype = dtype
         if len(args) == 2:
             if _check_type(args[0], list) and \
-                _check_type(args[1], int):
+                    _check_type(args[1], int):
                 for i in range(len(args[0])):
                     if _check_type(args[0][i], dtype) is False:
                         args[0][i] = dtype(args[0][i])
                 size, data = args[1], [arg for arg in args[0]]
             elif _check_type(args[1], list) and \
-                _check_type(args[0], int):
+                    _check_type(args[0], int):
                 for i in range(len(args[1])):
                     if _check_type(args[1][i], dtype) is False:
                         args[1][i] = dtype(args[1][i])
@@ -89,7 +92,7 @@ def __new__(cls, dtype=NoneType, *args, **kwargs):
                                 "expected type of data is list/tuple.")
             if size != len(data):
                 raise ValueError("Conflict in the size %s and length of data %s"
-                                 %(size, len(data)))
+                                 % (size, len(data)))
             obj._size, obj._data = size, data
 
         elif len(args) == 1:
@@ -102,7 +105,7 @@ def __new__(cls, dtype=NoneType, *args, **kwargs):
                     if _check_type(args[0][i], dtype) is False:
                         args[0][i] = dtype(args[0][i])
                 obj._size, obj._data = len(args[0]), \
-                                        [arg for arg in args[0]]
+                                       [arg for arg in args[0]]
             else:
                 raise TypeError("Expected type of size is int and "
                                 "expected type of data is list/tuple.")
@@ -133,13 +136,108 @@ 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.
+        size: int
+            The number of elements in the array.
+
+        Raises
+        ======
+        IndexError
+            Index goes out of boundaries
+        ValueError
+            When there's no dimensions or the dimension size is 0
+        TypeError
+            An argument is not what expected
+
+        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.2
+        >>> arr[3][0][0]
+        7
+
+        References
+        ==========
+
+        .. [1] https://en.wikipedia.org/wiki/Array_data_structure#Multidimensional_arrays
+        '''
+    __slots__ = ['_size', '_data', '_dtype']
+
+    def __new__(cls, dtype=NoneType, *args, **kwargs):
+        if dtype is NoneType or len(args) == (0):
+            raise ValueError("array cannot be created due to incorrect"
+                             " information.")
+        dimensions = list(args)
+        if dimensions[0] <= 0:
+            raise ValueError("array cannot be created due to incorrect"
+                             " number of dimensions.")
+        if len(dimensions) == 2:
+            obj = Array.__new__(cls)
+            obj._dtype = OneDimensionalArray
+            obj._size = dimensions.pop(0)
+            obj._data = [None] * obj._size
+            for i in range(obj._size):
+                obj._data[i] = MultiDimensionalArray(dtype, *dimensions)
+            return obj
+        elif len(dimensions) == 1:
+            return OneDimensionalArray(dtype, dimensions[0])
+        else:
+            obj = Array.__new__(cls)
+            obj._dtype = MultiDimensionalArray
+            obj._size = dimensions.pop(0)
+            obj._data = [None] * obj._size
+            for i in range(obj._size):
+                obj._data[i] = MultiDimensionalArray(dtype, *dimensions)
+            return obj
+
+    def __getitem__(self, idx):
+        if idx >= self._size or idx < 0:
+            raise IndexError("Index out of range.")
+        return self._data.__getitem__(idx)
+
+    def __setitem__(self, idx, element):
+        if idx >= self._size or idx < 0:
+            raise IndexError("Index out of range.")
+        if type(element) != self._data[0]._dtype:
+            raise TypeError("Unexpected item type.")
+        # Check the size of the element if it is, set it
+        if self.compare_size(element):
+            self._data[idx] = element
+        else:
+            raise TypeError("Unexpected item type.")
+
+    def compare_size(self, array):
+        if self._data[0]._size == array._size:
+            if array._dtype == MultiDimensionalArray:
+                return self._data[0].compare_size(array)
+            elif array._dtype == OneDimensionalArray:
+                if array[0]._dtype == self._data[0][0]._dtype:
+                    return True
+        return False
+
+    def fill(self, element):
+        for i in range(self._size):
+            self._data[i].fill(element)
 
 class DynamicArray(Array):
     """
     Abstract class for dynamic arrays.
     """
     pass
 
+
 class DynamicOneDimensionalArray(DynamicArray, OneDimensionalArray):
     """
     Represents dynamic one dimensional arrays.
@@ -252,7 +350,7 @@ def append(self, el):
 
     def delete(self, idx):
         if idx <= self._last_pos_filled and idx >= 0 and \
-            self[idx] is not None:
+                self[idx] is not None:
             self[idx] = None
             self._num -= 1
             if self._last_pos_filled == idx:
@@ -262,7 +360,6 @@ def delete(self, idx):
     @property
     def size(self):
         return self._size
-
     def __str__(self):
         to_be_printed = ['' for i in range(self._last_pos_filled + 1)]
         for i in range(self._last_pos_filled + 1):
@@ -283,10 +380,11 @@ class ArrayForTrees(DynamicOneDimensionalArray):
 
     pydatastructs.linear_data_structures.arrays.DynamicOneDimensionalArray
     """
+
     def _modify(self):
-        if self._num/self._size < self._load_factor:
+        if self._num / self._size < self._load_factor:
             new_indices = dict()
-            arr_new = OneDimensionalArray(self._dtype, 2*self._num + 1)
+            arr_new = OneDimensionalArray(self._dtype, 2 * self._num + 1)
             j = 0
             for i in range(self._last_pos_filled + 1):
                 if self[i] is not None:

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,24 @@ def test_OneDimensionalArray():
     assert raises(TypeError, lambda: ODA(int, set([1, 2, 3])))
     assert raises(ValueError, lambda: ODA(int, 3, [1]))
 
+def test_MultiDimensionalArray():
+    MDA = MultiDimensionalArray
+    A = MDA(int, 5, 9, 3, 8)
+    A.fill(5)
+    A[1][3][2][5] = 2.0
+    assert A
+    assert A[1][3][2][5] == 2.0
+    assert A[1][3][1][5] == 5
+    assert A[0][3][2][5] == 5
+    assert A[1][3][2][0] == 5
+    assert raises(IndexError, lambda: A[5])
+    assert raises(IndexError, lambda: A[4][10])
+    assert raises(IndexError, lambda: A[-1])
+    assert raises(ValueError, lambda: MDA())
+    assert raises(ValueError, lambda: MDA(int))
+    assert raises(ValueError, lambda: MDA(int, 0))
+    assert raises(TypeError, lambda: MDA(int, 5, 6, ""))
+
 def test_DynamicOneDimensionalArray():
     DODA = DynamicOneDimensionalArray
     A = DODA(int, 0)