Added C++ backend for Node, TreeNode, ArrayForTrees, BinaryTree and BinarySearchTree and all tree traversals implemented #556

Kishan-Ved · 2024-05-08T16:55:35Z

Related to: Google Summer of Code 2024, Kishan Ved

Related issues: #554 and #550

Progress:

Created the C++ backend for:

Node
TreeNode
ArrayForTrees
BinaryTree
Binary Search Tree

I am Speed!

C++ backend runs at an extremely fast speed, when compared to the Python backend. Here's an example:

def test_cpp_BST_speed():
    BST = BinarySearchTree
    import time
    b = BST()
    t1 = time.time()
    for node in range(-1000,1000):
        b.insert(node, node)
    t2 = time.time()
    b2 = BST(backend=Backend.CPP)
    t3 = time.time()
    for node in range(-1000,1000):
        b2.insert(node, node)
    t4 = time.time()
    print("Time taken by Python backend: ",t2-t1,"s")
    print("Time taken by C++ backend:    ",t4-t3,"s")
    
test_cpp_BST_speed()

Output

Time taken by Python backend:  6.889980792999268 s
Time taken by C++ backend:     0.8916661739349365 s

What's working (everything in the C++ backend):

TreeNode C++ backend test:

def test_cpp_TreeNode():
    n = TreeNode(1,100,backend=Backend.CPP)
    assert str(n) == "(None, 1, 100, None)"

BinaryTrees C++ backend test:

def test_cpp_BinaryTree():
    b = BinaryTree(1,100,backend=Backend.CPP)
    assert raises(NotImplementedError, b.insert) # Correctly throws NotImplementedError: This is an abstract method
    assert raises(NotImplementedError, b.delete) # Correctly throws NotImplementedError: This is an abstract method
    assert raises(NotImplementedError, b.search) # Correctly throws NotImplementedError: This is an abstract method
    assert str(b) == "[(None, 1, 100, None)]"

ArrayForTrees C++ backend test:

def test_cpp_ArrayForTrees():
    from pydatastructs.linear_data_structures._backend.cpp import _arrays
    from pydatastructs.utils._backend.cpp import _nodes
    AFT = _arrays.ArrayForTrees
    root = TreeNode(1, 100, backend=Backend.CPP)
    A = AFT(_nodes.TreeNode, [root])
    assert str(A) == "['(None, 1, 100, None)']"
    node = TreeNode(2, 200, backend=Backend.CPP)
    A.append(node)
    assert str(A) == "['(None, 1, 100, None)', '(None, 2, 200, None)']"

BinarySearchTree C++ backend test:

search()

def test_cpp_BinarySearchTree_search():
    b = BinarySearchTree(1,100, backend=Backend.CPP)
    assert str(b) == "[(None, 1, 100, None)]"
    assert b.search(1) == 0
    assert b.search(1,parent=False) == 0
    assert b.search(1,parent=True) == (0, None)

insert()

def test_cpp_BinarySearchTree_insert():
    BST = BinarySearchTree
    b = BST(8, 8, backend=Backend.CPP)
    b.insert(3, 3)
    b.insert(10, 10)
    b.insert(1, 1)
    b.insert(6, 6)
    b.insert(4, 4)
    b.insert(7, 7)
    b.insert(14, 14)
    b.insert(13, 13)
    assert str(b) == \
    ("[(1, 8, 8, 2), (3, 3, 3, 4), (None, 10, 10, 7), (None, 1, 1, None), "
    "(5, 6, 6, 6), (None, 4, 4, None), (None, 7, 7, None), (8, 14, 14, None), "
    "(None, 13, 13, None)]")

delete() , _simple_path(), lowest common ancestor _lca_1(), lowest common ancestor _lca_2(), rank(), select(), lower_bound and upper_bound

def test_cpp_BST2():
    BST = BinarySearchTree
    b = BST(8, 8, backend=Backend.CPP)

    ##### insert() and delete() tests #####
    b.delete(8)
    b.insert(8, 8)
    b.insert(3, 3)
    b.insert(10, 10)
    b.insert(1, 1)
    b.insert(6, 6)
    b.insert(4, 4)
    b.insert(7, 7)
    b.insert(14, 14)
    b.insert(13, 13)
    # Explicit check for the __str__ method of Binary Trees Class
    assert str(b) == \
    ("[(1, 8, 8, 2), (3, 3, 3, 4), (None, 10, 10, 7), (None, 1, 1, None), "
    "(5, 6, 6, 6), (None, 4, 4, None), (None, 7, 7, None), (8, 14, 14, None), "
    "(None, 13, 13, None)]")

    ##### _simple_path() test #####
    path = b._simple_path(1,0)
    assert path[0] == 0
    assert path[1] == 1
    assert path[2] == 3

    ##### search() and delete() tests #####
    assert b.search(10) == 2
    assert b.search(-1) is None
    assert b.delete(13) is True
    assert b.delete(13) is None
    assert b.search(13) is None
    assert b.delete(10) is True
    assert b.search(10) is None
    assert b.delete(3) is True
    assert b.search(3) is None
    assert b.delete(13) is None
    assert str(b) == "[(1, 8, 8, 7), (3, 4, 4, 4), '', (None, 1, 1, None), (None, 6, 6, 6), '', (None, 7, 7, None), (None, 14, 14, None)]"

    b.delete(7)
    b.delete(6)
    assert b.delete(1, balancing_info=True) == 1
    b.delete(4)
    assert str(b) ==  "[(None, 8, 8, 2), '', (None, 14, 14, None)]"

    bc = BST(1, 1, backend=Backend.CPP)
    assert bc.insert(1, 2) is None
    assert bc.delete(1, balancing_info=True) is None

    b2 = BST(-8, 8, backend=Backend.CPP)
    b2.insert(-3, 3)
    b2.insert(-10, 10)
    b2.insert(-1, 1)
    b2.insert(-6, 6)
    b2.insert(-4, 4)
    b2.insert(-7, 7)
    b2.insert(-14, 14)
    b2.insert(-13, 13)
    assert str(b2) ==  "[(2, -8, 8, 1), (4, -3, 3, 3), (7, -10, 10, None), (None, -1, 1, None), (6, -6, 6, 5), (None, -4, 4, None), (None, -7, 7, None), (None, -14, 14, 8), (None, -13, 13, None)]"
    b2.delete(-13)
    assert str(b2) == "[(2, -8, 8, 1), (4, -3, 3, 3), (7, -10, 10, None), (None, -1, 1, None), (6, -6, 6, 5), (None, -4, 4, None), (None, -7, 7, None), (None, -14, 14, None)]"
    b2.delete(-10)
    b2.delete(-3)
    b2.delete(-13)
    assert str(b2) ==  "[(7, -8, 8, 1), (4, -1, 1, None), '', '', (6, -6, 6, 5), (None, -4, 4, None), (None, -7, 7, None), (None, -14, 14, None)]"

    bl1 = BST(backend=Backend.CPP)
    nodes = [50, 30, 90, 70, 100, 60, 80, 55, 20, 40, 15, 10, 16, 17, 18]
    for node in nodes:
        bl1.insert(node, node)
    assert str(bl1) == "[(1, 50, 50, 2), (8, 30, 30, 9), (3, 90, 90, 4), (5, 70, 70, 6), (None, 100, 100, None), (7, 60, 60, None), (None, 80, 80, None), (None, 55, 55, None), (10, 20, 20, None), (None, 40, 40, None), (11, 15, 15, 12), (None, 10, 10, None), (None, 16, 16, 13), (None, 17, 17, 14), (None, 18, 18, None)]"

    ##### lowest common ancestor _lca2_() tests #####
    assert bl1.lowest_common_ancestor(80, 55, 2) == 70
    assert bl1.lowest_common_ancestor(60, 70, 2) == 70
    assert bl1.lowest_common_ancestor(18, 18, 2) == 18
    assert bl1.lowest_common_ancestor(40, 90, 2) == 50

    assert bl1.lowest_common_ancestor(18, 10, 2) == 15
    assert bl1.lowest_common_ancestor(55, 100, 2) == 90
    assert bl1.lowest_common_ancestor(16, 80, 2) == 50
    assert bl1.lowest_common_ancestor(30, 55, 2) == 50

    assert raises(ValueError, lambda: bl1.lowest_common_ancestor(60, 200, 2))
    assert raises(ValueError, lambda: bl1.lowest_common_ancestor(200, 60, 2))
    assert raises(ValueError, lambda: bl1.lowest_common_ancestor(-3, 4, 2))

    bl2 = BST(backend=Backend.CPP)
    nodes = [50, 30, 90, 70, 100, 60, 80, 55, 20, 40, 15, 10, 16, 17, 18]
    for node in nodes:
        bl2.insert(node, node)
    assert str(bl2) == "[(1, 50, 50, 2), (8, 30, 30, 9), (3, 90, 90, 4), (5, 70, 70, 6), (None, 100, 100, None), (7, 60, 60, None), (None, 80, 80, None), (None, 55, 55, None), (10, 20, 20, None), (None, 40, 40, None), (11, 15, 15, 12), (None, 10, 10, None), (None, 16, 16, 13), (None, 17, 17, 14), (None, 18, 18, None)]"

    ##### lowest common ancestor _lca1_() tests #####
    assert bl2.lowest_common_ancestor(80, 55, 1) == 70
    assert bl2.lowest_common_ancestor(60, 70, 1) == 70
    assert bl2.lowest_common_ancestor(18, 18, 1) == 18
    assert bl2.lowest_common_ancestor(40, 90, 1) == 50

    assert bl2.lowest_common_ancestor(18, 10, 1) == 15
    assert bl2.lowest_common_ancestor(55, 100, 1) == 90
    assert bl2.lowest_common_ancestor(16, 80, 1) == 50
    assert bl2.lowest_common_ancestor(30, 55, 1) == 50

    assert raises(ValueError, lambda: bl2.lowest_common_ancestor(60, 200, 1))
    assert raises(ValueError, lambda: bl2.lowest_common_ancestor(200, 60, 1))
    assert raises(ValueError, lambda: bl2.lowest_common_ancestor(-3, 4, 1))

    ##### rank() tests #####
    assert bl2.rank(18) == 5
    assert bl2.rank(10) == 1
    rank_list = [2, 2, 4, 4, 5, 4, 5, 3, 2, 3, 2, 1, 3, 4, 5]
    for i,node in enumerate(nodes):
        assert bl2.rank(node) == rank_list[i]
    assert bl2.rank(200) is None

    ##### select() tests #####
    select_list = [10, 50, 55, 90, 100]
    for i in range(5):
        assert bl2.select(i+1).key == select_list[i]

    b3 = BST(backend=Backend.CPP)
    b3.insert(10, 10)
    b3.insert(18, 18)
    b3.insert(7, 7)

    ##### upper_bound() tests #####
    assert b3.upper_bound(9) == 10
    assert b3.upper_bound(7) == 10
    assert b3.upper_bound(-1) == 7
    assert b3.upper_bound(20) is None

    ##### lower_bound() tests #####
    assert b3.lower_bound(9) == 10
    assert b3.lower_bound(7) == 7
    assert b3.lower_bound(-1) == 7
    assert b3.lower_bound(20) is None

…er needed

czgdp1807

Excellent work. I have left only one question.

pydatastructs/trees/tests/benchmarks/test_binary_trees.py

czgdp1807

Other than this, its ready from my side.

pydatastructs/trees/tests/benchmarks/test_binary_trees.py

czgdp1807 · 2024-06-02T08:50:31Z

pydatastructs/trees/tests/test_binary_trees.py

+
+    b.delete(-13)
+    b.delete(-10)
+    b.delete(-3)
+    b.delete(-13)


Why these assert are removed? You said something about it in chat.

The correct return value is True (as delete operation happens). It works correctly on my local (which has Python 3.8), but only for the Python 3.8 CI, return value is None. I have opened up an issue for this: #558

czgdp1807 · 2024-06-02T08:51:39Z

I have skimmed through all the changes. Requested one change and left one question.

Kishan-Ved · 2024-06-02T10:32:27Z

I have skimmed through all the changes. Requested one change and left one question.

I have updated the benchmarks tests, but now, as we pass the same tree to insert(), search() and delete(), we can run them only once (and not 4 times and then take the min). This is because every time we run the functions f, g or h, the actual tree (which was passed as a parameter) is modified.

pydatastructs/trees/_backend/cpp/BinarySearchTree.hpp

czgdp1807 · 2024-06-02T10:42:53Z

pydatastructs/trees/_backend/cpp/BinarySearchTree.hpp

+    PyObject* walk = PyTuple_GetItem(tup, 0);
+    PyObject* parent = PyTuple_GetItem(tup, 1);
+    Py_INCREF(Py_None);
+    PyObject* a = Py_None;


May be this never got updated?

Try setting it to PyObject* a = NULL; That should raise an error, if it never gets updated.

The value of a is set properly. I checked by printing the value of a (after the statement where it should be updated).

Check all the points where this function returns None.

czgdp1807 · 2024-06-02T18:43:23Z

pydatastructs/trees/_backend/cpp/BinarySearchTree.hpp

+    Py_INCREF(Py_None);
+    PyObject* a = Py_None;
+    if (walk == Py_None) {
+        Py_RETURN_NONE;


This is one point where the return None can happen.

Yes, I did that.

czgdp1807 · 2024-06-02T18:43:43Z

pydatastructs/trees/_backend/cpp/BinarySearchTree.hpp

+
+    if (balancing_info != Py_None) {
+        if (PyLong_AsLong(balancing_info) == 1) {
+            return a;


This is another point. Add print statements and check.

Tried that too

czgdp1807

Thanks for this. Great work.

BST insert(), search() working

2e8edc2

Kishan-Ved marked this pull request as draft May 8, 2024 17:04

Kishan-Ved and others added 28 commits May 9, 2024 11:20

moved files to proper location and added extension: setup2.py no long…

ae518a5

…er needed

commented out setup2.py to check if CI passes

ae2ca7f

removed whitespaces at line ends

e3e57c7

removed setup2.py

90669a2

reinterpret cast for BST

68c94ce

reinterpret cast for PyObject

5248055

added _extension.py file for trees

15167fd

name changed from BST.BST to BST

4827d6d

check key and data for BST()

e94ec24

Value error message corrected

ef1142b

wi[p

37d8262

worked on BinaryTree.hpp, done except TreeNode and ArrayForTrees class

2a78d84

Added C++ backend for Node class

46a65cf

Added C++ backend for TreeNode class

da8fb74

Added TreeNode() to BinaryTree.hpp

b0f44b2

Added C++ backend for ArrayForTrees

0665403

added trees.cpp file

b9c1974

updated _extensions.py file in trees

2fef090

removed test.py

e2d2fc0

ArrayForTrees added to arrays.cpp

fbfd73f

added include<map> in ArrayForTrees

a06bc24

added using namespace std to ArrayForTrees

fe04d43

checking by replacing ArrayForTrees by DynamicOneDimensionalArray

51b86a6

ArrayForTrees restored as before

2426869

Added member struct for ArrayForTrees

0ffcfb5

PyMemberDef for ArrayForTrees

a3a3d1d

Added TreeNode to ArrayForTrees

ccd97a5

fixed a small include error

d480bb9

Kishan-Ved added 2 commits May 31, 2024 11:58

added postorder traversal in C++ backend and its tests

83c74dc

Added breadth first search in C++ backend and its tests

8026a90

Kishan-Ved changed the title ~~Added C++ backend for Node, TreeNode, ArrayForTrees, BinaryTree and BinarySearchTree~~ Added C++ backend for Node, TreeNode, ArrayForTrees, BinaryTree and BinarySearchTree and all tree traversals implemented May 31, 2024

Kishan-Ved added 3 commits May 31, 2024 12:18

All tree travsersals done in C++ backend

8dd7f65

benchmark tests updated

2f0cea7

removed print

7a9e27f

czgdp1807 reviewed Jun 2, 2024

View reviewed changes

pydatastructs/trees/tests/benchmarks/test_binary_trees.py Outdated Show resolved Hide resolved

czgdp1807 requested changes Jun 2, 2024

View reviewed changes

czgdp1807 reviewed Jun 2, 2024

View reviewed changes

Added separate benchmark tests for BST insert, search and delete

39aa94a

czgdp1807 reviewed Jun 2, 2024

View reviewed changes

Kishan-Ved added 8 commits June 2, 2024 20:31

CI check, changed to Py_True

a7da43c

CI check, changed to Py_True

9d20577

minor update

5e904c9

minor update

5f4253f

Check CI return

575b43a

Check CI return

6efc3e5

Check CI return

b1d197a

back to original

c6aa701

Kishan-Ved requested a review from czgdp1807 June 2, 2024 18:10

czgdp1807 reviewed Jun 2, 2024

View reviewed changes

small update

d01c8de

Kishan-Ved requested a review from czgdp1807 June 3, 2024 07:06

Kishan-Ved added 2 commits June 3, 2024 16:24

check

e2fad1e

Added support for b.tree

ab1dce8

czgdp1807 approved these changes Jun 3, 2024

View reviewed changes

czgdp1807 merged commit 557f86b into codezonediitj:main Jun 3, 2024
7 checks passed

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Added C++ backend for Node, TreeNode, ArrayForTrees, BinaryTree and BinarySearchTree and all tree traversals implemented #556

Added C++ backend for Node, TreeNode, ArrayForTrees, BinaryTree and BinarySearchTree and all tree traversals implemented #556

Kishan-Ved commented May 8, 2024 •

edited

Loading

czgdp1807 left a comment

czgdp1807 left a comment

czgdp1807 Jun 2, 2024

Kishan-Ved Jun 2, 2024

czgdp1807 commented Jun 2, 2024

Kishan-Ved commented Jun 2, 2024 •

edited

Loading

czgdp1807 Jun 2, 2024

czgdp1807 Jun 2, 2024

Kishan-Ved Jun 2, 2024

czgdp1807 Jun 2, 2024

czgdp1807 Jun 2, 2024

Kishan-Ved Jun 2, 2024

czgdp1807 Jun 2, 2024

Kishan-Ved Jun 2, 2024

czgdp1807 left a comment

Added C++ backend for Node, TreeNode, ArrayForTrees, BinaryTree and BinarySearchTree and all tree traversals implemented #556

Added C++ backend for Node, TreeNode, ArrayForTrees, BinaryTree and BinarySearchTree and all tree traversals implemented #556

Conversation

Kishan-Ved commented May 8, 2024 • edited Loading

Progress:

Created the C++ backend for:

I am Speed!

Output

What's working (everything in the C++ backend):

czgdp1807 left a comment

Choose a reason for hiding this comment

czgdp1807 left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

czgdp1807 commented Jun 2, 2024

Kishan-Ved commented Jun 2, 2024 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

czgdp1807 left a comment

Choose a reason for hiding this comment

Kishan-Ved commented May 8, 2024 •

edited

Loading

Kishan-Ved commented Jun 2, 2024 •

edited

Loading