resolved merge conflicts

Author: sHiVaNgI821

LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2019-2020 PyDataStructs Development Team
+Copyright (c) 2019-2021 PyDataStructs Development Team
 
 All rights reserved.
 

pydatastructs/linear_data_structures/algorithms.py

@@ -799,7 +799,7 @@ def is_ordered(array, **kwargs):
     Parameters
     ==========
 
-    array: Array
+    array: OneDimensionalArray
         The array which is to be checked for having
         specified ordering among its elements.
     start: int
@@ -847,55 +847,55 @@ def is_ordered(array, **kwargs):
             return False
     return True
 
-
 def upper_bound(array, value, **kwargs):
     """
-    Finds the index of the first occurence of an element greater than value according
-    to an order defined,in the given sorted OneDimensionalArray
+    Finds the index of the first occurence of an element greater than the given
+    value according to specified order, in the given OneDimensionalArray using a variation of binary search method.
 
     Parameters
-    ========
+    ==========
 
     array: OneDimensionalArray
-        The sorted array (sorted according to a custom comparator function) in which the
-        upper bound has to be found
-
-    start: int, optional
+        The array in which the upper bound has to be found.
+    start: int
         The staring index of the portion of the array in which the upper bound
-        of a given value has to be looked for
-
+        of a given value has to be looked for.
+        Optional, by default 0
     end: int, optional
         The ending index of the portion of the array in which the upper bound
-        of a given value has to be looked for
-
-    comp: boolean function, optional
-        A function that specifies the ordering of elements. By default, it takes two
-        parameters and returns True if 1st parameter is strictly smaller than
-        2nd parameter
+        of a given value has to be looked for.
+        Optional, by default the index
+        of the last position filled.
+    comp: lambda/function
+        The comparator which is to be used
+        for specifying the desired ordering.
+        Optional, by default, less than or
+        equal to is used for comparing two
+        values.
 
     Returns
     =======
 
-    output: int
-        Index of the upper bound of the given value in the given sorted OneDimensionalArray
+    index: int
+        Index of the upper bound of the given value in the given OneDimensionalArray.
 
     Examples
     ========
 
     >>> from pydatastructs import upper_bound, OneDimensionalArray as ODA
-    >>> arr = ODA(int, [4, 5, 5, 6, 7])
-    >>> upperBound = upper_bound(arr, 5, start = 0, end = 4)
-    >>> upperBound
+    >>> arr1 = ODA(int, [4, 5, 5, 6, 7])
+    >>> ub = upper_bound(arr1, 5, start=0, end=4)
+    >>> ub
     3
-    >>> arr = ODA(int, [7, 6, 5, 5, 4])
-    >>> upperBound = upper_bound(arr, 5, comp = lambda x, y: x > y)
-    >>> upperBound
+    >>> arr2 = ODA(int, [7, 6, 5, 5, 4])
+    >>> ub = upper_bound(arr2, 5, comp=lambda x, y: x > y)
+    >>> ub
     4
 
     Note
     ====
 
-    The OneDimensionalArray must be sorted beforehand
+    DynamicOneDimensionalArray objects may not work as expected.
     """
     start = kwargs.get('start', 0)
     end = kwargs.get('end', len(array))
@@ -913,56 +913,56 @@ def upper_bound(array, value, **kwargs):
             inclusive_end = mid - 1
     return index
 
-
 def lower_bound(array, value, **kwargs):
     """
     Finds the the index of the first occurence of an element which is not
-    less than value according to an order defined, in the given OneDimensionalArray
+    less than the given value according to specified order,
+    in the given OneDimensionalArray using a variation of binary search method.
 
     Parameters
-    ========
+    ==========
 
     array: OneDimensionalArray
-        The sorted array (sorted according to a custom comparator function)
-        in which the lower bound has to be found
-
-    start: int, optional
-        The staring index of the portion of the array in which the lower
-        bound of a given value has to be looked for. Default value is set to 0.
-
+        The array in which the lower bound has to be found.
+    start: int
+        The staring index of the portion of the array in which the upper bound
+        of a given value has to be looked for.
+        Optional, by default 0
     end: int, optional
-        The ending index of the portion of the array in which the lower
-        bound of a given value has to be looked for. Default value is set to
-        end of array, i.e., len(arr)
-
-    comp: boolean function, optional
-        A function that specifies the ordering of elements. By default, it takes two
-        parameters and returns True if 1st parameter is strictly smaller than
-        2nd parameter
+        The ending index of the portion of the array in which the upper bound
+        of a given value has to be looked for.
+        Optional, by default the index
+        of the last position filled.
+    comp: lambda/function
+        The comparator which is to be used
+        for specifying the desired ordering.
+        Optional, by default, less than or
+        equal to is used for comparing two
+        values.
 
     Returns
     =======
 
-    output: int
-        Index of the lower bound of the given value in the given sorted OneDimensionalArray
+    index: int
+        Index of the lower bound of the given value in the given OneDimensionalArray
 
     Examples
     ========
 
     >>> from pydatastructs import lower_bound, OneDimensionalArray as ODA
-    >>> arr = ODA(int, [4, 5, 5, 6, 7])
-    >>> lowerBound = lower_bound(arr, 5, end = 4, comp = lambda x, y : x < y)
-    >>> lowerBound
+    >>> arr1 = ODA(int, [4, 5, 5, 6, 7])
+    >>> lb = lower_bound(arr1, 5, end=4, comp=lambda x, y : x < y)
+    >>> lb
     1
     >>> arr = ODA(int, [7, 6, 5, 5, 4])
-    >>> lowerBound = lower_bound(arr, 5, start = 0, comp = lambda x, y : x > y)
-    >>> lowerBound
+    >>> lb = lower_bound(arr, 5, start=0, comp=lambda x, y : x > y)
+    >>> lb
     2
 
     Note
     ====
 
-    The OneDimensionalArray must be sorted beforehand
+    DynamicOneDimensionalArray objects may not work as expected.
     """
     start = kwargs.get('start', 0)
     end = kwargs.get('end', len(array))
@@ -980,7 +980,6 @@ def lower_bound(array, value, **kwargs):
             inclusive_end = mid - 1
     return index
 
-
 def longest_increasing_subsequence(array):
     """
     Returns the longest increasing subsequence (as a OneDimensionalArray) that

pydatastructs/linear_data_structures/tests/test_algorithms.py

@@ -159,7 +159,6 @@ def test_is_ordered():
     output = is_ordered(arr4)
     assert output == expected_result
 
-
 def test_upper_bound():
     ODA = OneDimensionalArray
     arr1 = ODA(int, [3, 3, 3])
@@ -245,7 +244,6 @@ def test_lower_bound():
     expected_result = 1
     assert expected_result == output
 
-
 def test_longest_increasing_subsequence():
     ODA = OneDimensionalArray