I want to print my binary tree in the following manner:
10
6 12
5 7 11 13
I have written code for insertion of nodes but can't able to write for printing the tree. so please help on this . My code is :
class Node:
def __init__(self,data):
self.data=data
self.left=None
self.right=None
self.parent=None
class binarytree:
def __init__(self):
self.root=None
self.size=0
def insert(self,data):
if self.root==None:
self.root=Node(data)
else:
current=self.root
while 1:
if data < current.data:
if current.left:
current=current.left
else:
new=Node(data)
current.left=new
break;
elif data > current.data:
if current.right:
current=current.right
else:
new=Node(data)
current.right=new
break;
else:
break
b=binarytree()
Here's my attempt, using recursion, and keeping track of the size of each node and the size of children.
class BstNode:
def __init__(self, key):
self.key = key
self.right = None
self.left = None
def insert(self, key):
if self.key == key:
return
elif self.key < key:
if self.right is None:
self.right = BstNode(key)
else:
self.right.insert(key)
else: # self.key > key
if self.left is None:
self.left = BstNode(key)
else:
self.left.insert(key)
def display(self):
lines, *_ = self._display_aux()
for line in lines:
print(line)
def _display_aux(self):
"""Returns list of strings, width, height, and horizontal coordinate of the root."""
# No child.
if self.right is None and self.left is None:
line = '%s' % self.key
width = len(line)
height = 1
middle = width // 2
return [line], width, height, middle
# Only left child.
if self.right is None:
lines, n, p, x = self.left._display_aux()
s = '%s' % self.key
u = len(s)
first_line = (x + 1) * ' ' + (n - x - 1) * '_' + s
second_line = x * ' ' + '/' + (n - x - 1 + u) * ' '
shifted_lines = [line + u * ' ' for line in lines]
return [first_line, second_line] + shifted_lines, n + u, p + 2, n + u // 2
# Only right child.
if self.left is None:
lines, n, p, x = self.right._display_aux()
s = '%s' % self.key
u = len(s)
first_line = s + x * '_' + (n - x) * ' '
second_line = (u + x) * ' ' + '\\' + (n - x - 1) * ' '
shifted_lines = [u * ' ' + line for line in lines]
return [first_line, second_line] + shifted_lines, n + u, p + 2, u // 2
# Two children.
left, n, p, x = self.left._display_aux()
right, m, q, y = self.right._display_aux()
s = '%s' % self.key
u = len(s)
first_line = (x + 1) * ' ' + (n - x - 1) * '_' + s + y * '_' + (m - y) * ' '
second_line = x * ' ' + '/' + (n - x - 1 + u + y) * ' ' + '\\' + (m - y - 1) * ' '
if p < q:
left += [n * ' '] * (q - p)
elif q < p:
right += [m * ' '] * (p - q)
zipped_lines = zip(left, right)
lines = [first_line, second_line] + [a + u * ' ' + b for a, b in zipped_lines]
return lines, n + m + u, max(p, q) + 2, n + u // 2
import random
b = BstNode(50)
for _ in range(50):
b.insert(random.randint(0, 100))
b.display()
Example output:
__50_________________________________________
/ \
________________________43_ ________________________99
/ \ /
_9_ 48 ____________67_____________________
/ \ / \
3 11_________ 54___ ______96_
/ \ \ \ / \
0 8 ____26___________ 61___ ________88___ 97
/ \ / \ / \
14_ __42 56 64_ 75_____ 92_
/ \ / / \ / \ / \
13 16_ 33_ 63 65_ 72 81_ 90 94
\ / \ \ / \
25 __31 41 66 80 87
/ /
28_ 76
\
29
class Node(object):
def __init__(self, value, left=None, right=None):
self.value = value
self.left = left
self.right = right
def printTree(node, level=0):
if node != None:
printTree(node.left, level + 1)
print(' ' * 4 * level + '-> ' + str(node.value))
printTree(node.right, level + 1)
t = Node(1, Node(2, Node(4, Node(7)),Node(9)), Node(3, Node(5), Node(6)))
printTree(t)
output:
-> 7
-> 4
-> 2
-> 9
-> 1
-> 5
-> 3
-> 6
What you're looking for is breadth-first traversal, which lets you traverse a tree level by level. Basically, you use a queue to keep track of the nodes you need to visit, adding children to the back of the queue as you go (as opposed to adding them to the front of a stack). Get that working first.
After you do that, then you can figure out how many levels the tree has (log2(node_count) + 1) and use that to estimate whitespace. If you want to get the whitespace exactly right, you can use other data structures to keep track of how many spaces you need per level. A smart estimation using number of nodes and levels should be enough, though.
I am leaving here a stand-alone version of #J. V.'s code. If anyone wants to grab his/her own binary tree and pretty print it, pass the root node and you are good to go.
If necessary, change val, left and right parameters according to your node definition.
def print_tree(root, val="val", left="left", right="right"):
def display(root, val=val, left=left, right=right):
"""Returns list of strings, width, height, and horizontal coordinate of the root."""
# No child.
if getattr(root, right) is None and getattr(root, left) is None:
line = '%s' % getattr(root, val)
width = len(line)
height = 1
middle = width // 2
return [line], width, height, middle
# Only left child.
if getattr(root, right) is None:
lines, n, p, x = display(getattr(root, left))
s = '%s' % getattr(root, val)
u = len(s)
first_line = (x + 1) * ' ' + (n - x - 1) * '_' + s
second_line = x * ' ' + '/' + (n - x - 1 + u) * ' '
shifted_lines = [line + u * ' ' for line in lines]
return [first_line, second_line] + shifted_lines, n + u, p + 2, n + u // 2
# Only right child.
if getattr(root, left) is None:
lines, n, p, x = display(getattr(root, right))
s = '%s' % getattr(root, val)
u = len(s)
first_line = s + x * '_' + (n - x) * ' '
second_line = (u + x) * ' ' + '\\' + (n - x - 1) * ' '
shifted_lines = [u * ' ' + line for line in lines]
return [first_line, second_line] + shifted_lines, n + u, p + 2, u // 2
# Two children.
left, n, p, x = display(getattr(root, left))
right, m, q, y = display(getattr(root, right))
s = '%s' % getattr(root, val)
u = len(s)
first_line = (x + 1) * ' ' + (n - x - 1) * '_' + s + y * '_' + (m - y) * ' '
second_line = x * ' ' + '/' + (n - x - 1 + u + y) * ' ' + '\\' + (m - y - 1) * ' '
if p < q:
left += [n * ' '] * (q - p)
elif q < p:
right += [m * ' '] * (p - q)
zipped_lines = zip(left, right)
lines = [first_line, second_line] + [a + u * ' ' + b for a, b in zipped_lines]
return lines, n + m + u, max(p, q) + 2, n + u // 2
lines, *_ = display(root, val, left, right)
for line in lines:
print(line)
print_tree(root)
__7
/ \
___10_ 3
/ \
_19 13
/ \
9 8_
/ \ \
4 0 12
Simple solution with no recursion
def PrintTree(root):
def height(root):
return 1 + max(height(root.left), height(root.right)) if root else -1
nlevels = height(root)
width = pow(2,nlevels+1)
q=[(root,0,width,'c')]
levels=[]
while(q):
node,level,x,align= q.pop(0)
if node:
if len(levels)<=level:
levels.append([])
levels[level].append([node,level,x,align])
seg= width//(pow(2,level+1))
q.append((node.left,level+1,x-seg,'l'))
q.append((node.right,level+1,x+seg,'r'))
for i,l in enumerate(levels):
pre=0
preline=0
linestr=''
pstr=''
seg= width//(pow(2,i+1))
for n in l:
valstr= str(n[0].val)
if n[3]=='r':
linestr+=' '*(n[2]-preline-1-seg-seg//2)+ '¯'*(seg +seg//2)+'\\'
preline = n[2]
if n[3]=='l':
linestr+=' '*(n[2]-preline-1)+'/' + '¯'*(seg+seg//2)
preline = n[2] + seg + seg//2
pstr+=' '*(n[2]-pre-len(valstr))+valstr #correct the potition acording to the number size
pre = n[2]
print(linestr)
print(pstr)
Sample output
1
/¯¯¯¯¯¯ ¯¯¯¯¯¯\
2 3
/¯¯¯ ¯¯¯\ /¯¯¯ ¯¯¯\
4 5 6 7
/¯ ¯\ /¯ /¯
8 9 10 12
I enhanced Prashant Shukla answer to print the nodes on the same level in the same line without spaces.
class Node(object):
def __init__(self, value, left=None, right=None):
self.value = value
self.left = left
self.right = right
def __str__(self):
return str(self.value)
def traverse(root):
current_level = [root]
while current_level:
print(' '.join(str(node) for node in current_level))
next_level = list()
for n in current_level:
if n.left:
next_level.append(n.left)
if n.right:
next_level.append(n.right)
current_level = next_level
t = Node(1, Node(2, Node(4, Node(7)), Node(9)), Node(3, Node(5), Node(6)))
traverse(t)
Just use this small method of print2DTree:
class bst:
def __init__(self, value):
self.value = value
self.right = None
self.left = None
def insert(root, key):
if not root:
return bst(key)
if key >= root.value:
root.right = insert(root.right, key)
elif key < root.value:
root.left = insert(root.left, key)
return root
def insert_values(root, values):
for value in values:
root = insert(root, value)
return root
def print2DTree(root, space=0, LEVEL_SPACE = 5):
if (root == None): return
space += LEVEL_SPACE
print2DTree(root.right, space)
# print() # neighbor space
for i in range(LEVEL_SPACE, space): print(end = " ")
print("|" + str(root.value) + "|<")
print2DTree(root.left, space)
root = insert_values(None, [8, 4, 12, 2, 6, 10, 14, 1, 3, 5, 7, 9, 11, 13, 15])
print2DTree(root)
Results:
code Explanation:
by using the BFS get the lists of list contains elements of each level
number of white spaces at any level = (max number of element in tree)//2^level
maximum number of elements of h height tree = 2^h -1; considering root level height as 1
print the value and white spaces
find my Riple.it link here print-bst-tree
def bfs(node,level=0,res=[]):
if level<len(res):
if node:
res[level].append(node.value)
else:
res[level].append(" ")
else:
if node:
res.append([node.value])
else:
res.append([" "])
if not node:
return
bfs(node.left,level+1,res)
bfs(node.right,level+1,res)
return res
def printTree(node):
treeArray = bfs(node)
h = len(treeArray)
whiteSpaces = (2**h)-1
def printSpaces(n):
for i in range(n):
print(" ",end="")
for level in treeArray:
whiteSpaces = whiteSpaces//2
for i,x in enumerate(level):
if i==0:
printSpaces(whiteSpaces)
print(x,end="")
printSpaces(1+2*whiteSpaces)
print()
#driver Code
printTree(root)
#output
class magictree:
def __init__(self, parent=None):
self.parent = parent
self.level = 0 if parent is None else parent.level + 1
self.attr = []
self.rows = []
def add(self, value):
tr = magictree(self)
tr.attr.append(value)
self.rows.append(tr)
return tr
def printtree(self):
def printrows(rows):
for i in rows:
print("{}{}".format(i.level * "\t", i.attr))
printrows(i.rows)
printrows(self.rows)
tree = magictree()
group = tree.add("company_1")
group.add("emp_1")
group.add("emp_2")
emp_3 = group.add("emp_3")
group = tree.add("company_2")
group.add("emp_5")
group.add("emp_6")
group.add("emp_7")
emp_3.add("pencil")
emp_3.add("pan")
emp_3.add("scotch")
tree.printtree()
result:
['company_1']
['emp_1']
['emp_2']
['emp_3']
['pencil']
['pan']
['scotch']
['company_2']
['emp_5']
['emp_6']
['emp_7']
As I came to this question from Google (and I bet many others did too), here is binary tree that has multiple children, with a print function (__str__ which is called when doing str(object_var) and print(object_var)).
Code:
from typing import Union, Any
class Node:
def __init__(self, data: Any):
self.data: Any = data
self.children: list = []
def insert(self, data: Any):
self.children.append(Node(data))
def __str__(self, top: bool=True) -> str:
lines: list = []
lines.append(str(self.data))
for child in self.children:
for index, data in enumerate(child.__str__(top=False).split("\n")):
data = str(data)
space_after_line = " " * index
if len(lines)-1 > index:
lines[index+1] += " " + data
if top:
lines[index+1] += space_after_line
else:
if top:
lines.append(data + space_after_line)
else:
lines.append(data)
for line_number in range(1, len(lines) - 1):
if len(lines[line_number + 1]) > len(lines[line_number]):
lines[line_number] += " " * (len(lines[line_number + 1]) - len(lines[line_number]))
lines[0] = " " * int((len(max(lines, key=len)) - len(str(self.data))) / 2) + lines[0]
return '\n'.join(lines)
def hasChildren(self) -> bool:
return bool(self.children)
def __getitem__(self, pos: Union[int, slice]):
return self.children[pos]
And then a demo:
# Demo
root = Node("Languages Good For")
root.insert("Serverside Web Development")
root.insert("Clientside Web Development")
root.insert("For Speed")
root.insert("Game Development")
root[0].insert("Python")
root[0].insert("NodeJS")
root[0].insert("Ruby")
root[0].insert("PHP")
root[1].insert("CSS + HTML + Javascript")
root[1].insert("Typescript")
root[1].insert("SASS")
root[2].insert("C")
root[2].insert("C++")
root[2].insert("Java")
root[2].insert("C#")
root[3].insert("C#")
root[3].insert("C++")
root[0][0].insert("Flask")
root[0][0].insert("Django")
root[0][1].insert("Express")
root[0][2].insert("Ruby on Rails")
root[0][0][0].insert(1.1)
root[0][0][0].insert(2.1)
print(root)
This is part of my own implementation of BST. The ugly part of this problem is that you have to know the space that your children occupies before you can print out yourself. Because you can have very big numbers like 217348746327642386478832541267836128736..., but also small numbers like 10, so if you have a parent-children relationship between these two, then it can potentially overlap with your other child. Therefore, we need to first go through the children, make sure we get how much space they are having, then we use that information to construct ourself.
def __str__(self):
h = self.getHeight()
rowsStrs = ["" for i in range(2 * h - 1)]
# return of helper is [leftLen, curLen, rightLen] where
# leftLen = children length of left side
# curLen = length of keyStr + length of "_" from both left side and right side
# rightLen = children length of right side.
# But the point of helper is to construct rowsStrs so we get the representation
# of this BST.
def helper(node, curRow, curCol):
if(not node): return [0, 0, 0]
keyStr = str(node.key)
keyStrLen = len(keyStr)
l = helper(node.l, curRow + 2, curCol)
rowsStrs[curRow] += (curCol -len(rowsStrs[curRow]) + l[0] + l[1] + 1) * " " + keyStr
if(keyStrLen < l[2] and (node.r or (node.p and node.p.l == node))):
rowsStrs[curRow] += (l[2] - keyStrLen) * "_"
if(l[1]):
rowsStrs[curRow + 1] += (len(rowsStrs[curRow + 2]) - len(rowsStrs[curRow + 1])) * " " + "/"
r = helper(node.r, curRow + 2, len(rowsStrs[curRow]) + 1)
rowsStrs[curRow] += r[0] * "_"
if(r[1]):
rowsStrs[curRow + 1] += (len(rowsStrs[curRow]) - len(rowsStrs[curRow + 1])) * " " + "\\"
return [l[0] + l[1] + 1, max(l[2] - keyStrLen, 0) + keyStrLen + r[0], r[1] + r[2] + 1]
helper(self.head, 0, 0)
res = "\n".join(rowsStrs)
#print("\n\n\nStart of BST:****************************************")
#print(res)
#print("End of BST:****************************************")
#print("BST height: ", h, ", BST size: ", self.size)
return res
Here's some examples of running this:
[26883404633, 10850198033, 89739221773, 65799970852, 6118714998, 31883432186, 84275473611, 25958013736, 92141734773, 91725885198, 131191476, 81453208197, 41559969292, 90704113213, 6886252839]
26883404633___________________________________________
/ \
10850198033__ 89739221773___________________________
/ \ / \
6118714998_ 25958013736 65799970852_______________ 92141734773
/ \ / \ /
131191476 6886252839 31883432186_ 84275473611 91725885198
\ / /
41559969292 81453208197 90704113213
Another example:
['rtqejfxpwmggfro', 'viwmdmpedzwvvxalr', 'mvvjmkdcdpcfb', 'ykqehfqbpcjfd', 'iuuujkmdcle', 'nzjbyuvlodahlpozxsc', 'wdjtqoygcgbt', 'aejduciizj', 'gzcllygjekujzcovv', 'naeivrsrfhzzfuirq', 'lwhcjbmcfmrsnwflezxx', 'gjdxphkpfmr', 'nartcxpqqongr', 'pzstcbohbrb', 'ykcvidwmouiuz']
rtqejfxpwmggfro____________________
/ \
mvvjmkdcdpcfb_____________________________ viwmdmpedzwvvxalr_______________
/ \ \
iuuujkmdcle_________ nzjbyuvlodahlpozxsc_ ykqehfqbpcjfd
/ \ / \ /
aejduciizj_____________ lwhcjbmcfmrsnwflezxx naeivrsrfhzzfuirq_ pzstcbohbrb wdjtqoygcgbt_
\ \ \
gzcllygjekujzcovv nartcxpqqongr ykcvidwmouiuz
/
gjdxphkpfmr
Here's a 2-pass solution with no recursion for general binary trees where each node has a value that "fits" within the allotted space (values closer to the root have more room to spare). (Pass 0 computes the tree height).
'''
0: 0
1: 1 2
2: 3 4 5 6
3: 7 8 9 a b c d e
h: 4
N: 2**4 - 1 <--| 2**0 + 2**1 + 2**2 + 2**3
'''
import math
def t2_lvl( i): return int(math.log2(i+1)) if 0<i else 0 # #meta map the global idx to the lvl
def t2_i2base(i): return (1<<t2_lvl(i))-1 # #meta map the global idx to the local idx (ie. the idx of elem 0 in the lvl at idx #i)
def t2_l2base(l): return (1<< l) -1 # #meta map the lvl to the local idx (ie. the idx of elem 0 in lvl #l)
class Tree2: # #meta a 2-tree is a tree with at most 2 sons per dad
def __init__(self, v=None):
self.v = v
self.l = None
self.r = None
def __str__(self): return f'{self.v}'
def t2_show(tree:Tree2): # #meta 2-pass fn. in the 1st pass we compute the height
if not tree: return
q0 = [] # perm queue
q1 = [] # temp queue
# pass 0
h = 0 # height is the number of lvls
q0.append((tree,0))
q1.append((tree,0))
while q1:
n,i = q1.pop(0)
h = max(h, t2_lvl(i))
if n.l: l=(n.l, 2*i+1); q0.append(l); q1.append(l)
if n.r: r=(n.r, 2*i+2); q0.append(r); q1.append(r)
h += 1 # nlvls
N = 2**h - 1 # nelems (for a perfect tree of this height)
W = 1 # elem width
# pass 1
print(f'\n\x1b[31m{h} \x1b[32m{len(q0)}\x1b[0m')
print(f'{0:1x}\x1b[91m:\x1b[0m',end='')
for idx,(n,i) in enumerate(q0):
l = t2_lvl(i) # lvl
b = (1<<l)-1 # base
s0 = (N // (2**(l+1)))
s1 = (N // (2**(l+0)))
s = 3+1 + s0 + (i-b)*(s1+1) # absolute 1-based position (from the beginning of line)
w = int(2**(h-l-2)) # width (around the element) (to draw the surrounding #-)
# print(f'{i:2x} {l} {i-b} {s0:2x} {s1:2x} {s:2x} {w:x} {n.v:02x}')
if 0<idx and t2_lvl(q0[idx-1][1])!=l: print(f'\n{l:1x}\x1b[91m:\x1b[0m',end='') # new level: go to the next line
print(f"\x1b[{s-w}G{w*'-'}\x1b[1G", end='')
print(f"\x1b[{s}G{n.v:1x}\x1b[1G", end='') # `\x1b[XG` is an ANSI escape code that moves the cursor to column X
print(f"\x1b[{s+W}G{w*'-'}\x1b[1G", end='')
print()
And an example:
tree = Tree2(0)
tree.l = Tree2(1)
tree.r = Tree2(2)
tree.l.l = Tree2(3)
tree.r.l = Tree2(4)
tree.r.r = Tree2(5)
tree.l.l.l = Tree2(3)
tree.r.l.l = Tree2(6)
tree.r.l.r = Tree2(7)
tree.l.l.l.l = Tree2(3)
tree.r.l.l.l = Tree2(8)
tree.r.l.l.r = Tree2(9)
t2_show(tree)
Output:
5 12
0: --------0--------
1: ----1---- ----2----
2: --3-- --4-- --5--
3: -3- -6- -7-
4: 3 8 9
Another output example:
7 127
0: --------------------------------0--------------------------------
1: ----------------1---------------- ----------------2----------------
2: --------3-------- --------4-------- --------5-------- --------6--------
3: ----7---- ----8---- ----9---- ----a---- ----b---- ----c---- ----d---- ----e----
4: --f-- --0-- --1-- --2-- --3-- --4-- --5-- --6-- --7-- --8-- --9-- --a-- --b-- --c-- --d-- --e--
5: -f- -0- -1- -2- -3- -4- -5- -6- -7- -8- -9- -a- -b- -c- -d- -e- -f- -0- -1- -2- -3- -4- -5- -6- -7- -8- -9- -a- -b- -c- -d- -e-
6: f 0 1 2 3 4 5 6 7 8 9 a b c d e f 0 1 2 3 4 5 6 7 8 9 a b c d e f 0 1 2 3 4 5 6 7 8 9 a b c d e f 0 1 2 3 4 5 6 7 8 9 a b c d e
Record Each Level Separately using Breadth First Approach
You can use a breadth first traversal and record node values in a dictionary using level as key. This helps next when you want to print each level in a new line. If you maintain a count of nodes processed, you can find current node's level (since it's a binary tree) using -
level = math.ceil(math.log(count + 1, 2) - 1)
Sample Code
Here's my code using the above method (along with some helpful variables like point_span & line_space which you can modify as you like). I used my custom Queue class, but you can also use a list for maintaining queue.
def pretty_print(self):
q, current, count, level, data = Queue(), self.root, 1, 0, {}
while current:
level = math.ceil(math.log(count + 1, 2) - 1)
if data.get(level) is None:
data[level] = []
data[level].append(current.value)
count += 1
if current.left:
q.enqueue(current.left)
if current.right:
q.enqueue(current.right)
current = q.dequeue()
point_span, line_space = 8, 4
line_width = int(point_span * math.pow(2, level))
for l in range(level + 1):
current, string = data[l], ''
for c in current:
string += str(c).center(line_width // len(current))
print(string + '\n' * line_space)
And here's how the output looks:
Similar question is being answered over here This may help following code will print in this format
>>>
1
2 3
4 5 6
7
>>>
Code for this is as below :
class Node(object):
def __init__(self, value, left=None, right=None):
self.value = value
self.left = left
self.right = right
def traverse(rootnode):
thislevel = [rootnode]
a = ' '
while thislevel:
nextlevel = list()
a = a[:len(a)/2]
for n in thislevel:
print a+str(n.value),
if n.left: nextlevel.append(n.left)
if n.right: nextlevel.append(n.right)
print
thislevel = nextlevel
t = Node(1, Node(2, Node(4, Node(7)),Node(9)), Node(3, Node(5), Node(6)))
traverse(t)
Edited code gives result in this format :
>>>
1
2 3
4 9 5 6
7
>>>
This is just a trick way to do what you want their maybe a proper method for that I suggest you to dig more into it.
This is the non syntax error code, but i cant seem to fix the recursion error. need some help here. the algorithm based on matlab, i've read the tutorial on matlab but i can seem to figure out which part did i miss.
import numpy as npy
blt = int(raw_input("Input the boundary layer thickness = "))
deleta = float(raw_input("Input the step size of boundary layer thickness = "))
np = int((blt/deleta) + 1)
stop = 1
k=1
l=2
g=2
eselon = 0.00001
def eta(j,k):
if j == 1 and k == 1:
return 0
else:
return eta(j-1,k) + deleta;
deta = deleta
def etanp():
return eta(np,k)
def f(j,k):
return -eta(np,1)*etab2 + etanp()*etab1 + eta(j,1)
def u(j,k):
return -3*etab1 + 2*etab +1
def v(j,k):
return (-6/etanp()*etab + (2/etanp()))
def fb(j,k):
return 0.5 * (f(j,k) + f(j-1,k))
def ub(j,k):
return 0.5 * (u(j,k) + u(j-1,k))
def vb(j,k):
return 0.5*(v(j,k) + v(j-1,k))
def fvb(j,k):
return fb(j,k)*vb(j,k)
def uub(j,k):
return ub(j,k) * ub(j,k)
def a1(j,k):
return 1 + 0.5*deta *fb(j,k)
def a2(j,k):
return -1 + 0.5*deta *fb(j,k)
def a3(j,k):
return 0.5 * deta * vb(j,k)
def a4(j,k):
return a3(j,k)
def a5(j,k):
return -1 * deta * ub(j,k)
def a6(j,k):
return a5(j,k)
def r1(j,k):
return f(j-1,k) - f(j,k) + deta * ub(j,k)
def r2(j,k):
return u(j-1,k) - u(j,k) + deta * vb(j,k)
def r3(j,k):
return v(j-1,k)-v(j,k) - deta *((fvb(j,k)*uub(j,k)))-deta
def AJ(j,k):
if j == 2:
return npy.matrix([[0,1,0],[-0.5*deta,0,-0.5*deta],[a2(2,k), a3(2,k), a1(2,k)]])
else:
return npy.matrix([[-0.5*deta,0,0],[-1,0,-0.5*deta],[a6(j,k),a3(j,k),a1(j,k)]])
def BJ(j,k):
return npy.matrix([[0,-1,0],[0,0,-0.5*deta],[0,a4(j,k),a2(j,k)]])
def CJ(j,k):
return npy.matrix([[-0.5*deta,0,0],[1,0,0],[a5(j,k),0,0]])
def alfa(j,k):
if j == 2:
return AJ(2,k)
else:
return AJ(j,k) - (BJ(j,k)*gamma(j-1,k))
def gamma(j,k):
if j == 2:
return npy.matrix.I((alfa(2,k))*CJ(2,k))
else:
return npy.matrix.I((alfa(j,k))*CJ(j,k))
def rr(j,k):
return npy.matrix([[r1(j,k)],[r2(j,k)],[r3(j,k)]])
def ww(j,k):
if j == 2:
return npy.matrix.I(AJ(2,k)*rr(2,k))
else:
return npy.matrix.I((alfa(j,k))*(rr(j,k)-(BJ(j,k)*ww(j-1,k))))
def dell(j,k):
if j == np:
return ww(np,k)
else:
return ww(j,k) - (gamma(j,k)*dell(j+1,k))
def delf(j,k):
if j == 1:
return 0
elif j == 2:
return dell(2,k)[1,0]
else:
return dell(j,k)
def delu(j,k):
if j == 1 or j == np:
return 0
elif j == np-1:
return dell(j,k)[0,0]
def delv(j,k):
if j == 1:
return dell(2,k)[0,0]
elif j == 2:
return dell(2,k)[2,0]
else:
return dell(j,k)[2,0]
def ffinal(j,l):
return f(j,k) + delf(j,k)
def ufinal(j,l):
return u(j,k) + delu(j,k)
def vfinal(j,l):
return v(j,k) + delv(j,k)
# Beginning of calculation for Keller-Box
while stop > eselon:
eta(1,1)
for j in range (2,np):
eta(j,k)
# Initial condition
etab = eta(j,k) / eta(np,k)
etab1 = etab**2
etab2 = etab**3
for j in range (1,np):
deta
f(j,1)
u(j,1)
v(j,1)
# Current value of Central Differentiation
for j in range (2,np):
fb(j,k)
ub(j,k)
vb(j,k)
fvb(j,k)
uub(j,k)
a1(j,k)
a2(j,k)
a3(j,k)
r1(j,k)
r2(j,k)
r3(j,k)
# Matrices Value for A1, Aj, Bj, and CJ
CJ(j,k)
AJ(j,k)
BJ(j,k)
# Recursion: Forward Sweeping
for j in range (3,np):
alfa(j,k)
gamma(j,k)
for j in range(2,np):
rr(j,k)
for j in range(3,np):
ww(j,k)
# Recursion: Backward Sweeping
for j in range (np-1,2,-1):
dell(j,k)
for j in range (np,3,-1):
delu(j-1,k)
delf(j,k)
delv(j,k)
# Newton's Method
for j in range (1,np):
ffinal(j,l)
ufinal(j,l)
vfinal(j,l)
# Check the convergence of iteration
stop = npy.abs(delv(1,k))
kmax = k
k =+ 1
cfrex = vfinal(1,kmax)
print cfrex
Here's the referential that i used from mathlab
*******************************************************************
Input
*******************************************************************
blt = input ('Input the boundary layer thickness = ');
deleta=0.1; %input('Input the step size of boundary layer thickness=');
np = (blt / deleta)+ 1;
pr = 7; %input ('Input the prandtl number = ');
K = 0; %input ('Input the material parameter K = ');
lambda = 1; %input ('Input the mixed convection parameter = ');
stop = 1.0; k = 1; eselon = 0.00001;
while stop > eselon
eta(1,1) = 0.0;
for j = 2:np
eta(j,1) = eta(j-1,1) + deleta;
end
*******************************************************************
Initial Condition for f, u, v, h, p, s, t
*******************************************************************
etanpq = eta(np,1)/3;
etau15 = 1/eta(np,1);
etau16 = 2/eta(np,1);
etanp = eta(np,1);
for j =1:np
deta(j,k)= deleta;
etab = eta(j,1)/eta(np,1);
etab1 = etab^2;
etab2 = etab^3;
etau152 = etau15^2;
etau162 = etau16^2;
f(j,1) = -etanpq * etab2 + etanp * etab1;
u(j,1) = -etab1 + 2 * etab;
v(j,1) = -etau16 * etab + etau16;
h(j,1) = etau15 * etab - etau15;
p(j,1) = etau152;
s(j,1) = -eta(j,1) + eta(j,1) * etab;
t(j,1) = -1 + 2 * etab;
end
*******************************************************************
Current Central Differention Value
*******************************************************************
for j = 2:np
fb(j,k) = 0.5*(f(j,k) + f(j-1,k));
ub(j,k) = 0.5*(u(j,k) + u(j-1,k));
vb(j,k) = 0.5*(v(j,k) + v(j-1,k));
hb(j,k) = 0.5*(h(j,k) + h(j-1,k));
pb(j,k) = 0.5*(p(j,k) + p(j-1,k));
sb(j,k) = 0.5*(s(j,k) + s(j-1,k));
tb(j,k) = 0.5*(t(j,k) + t(j-1,k));
fvb(j,k) = fb(j,k) * vb(j,k);
uub(j,k) = ub(j,k) ^ 2;
pfb(j,k) = pb(j,k) * fb(j,k);
hub(j,k) = hb(j,k) * ub(j,k);
tfb(j,k) = tb(j,k) * fb(j,k);
sub(j,k) = sb(j,k) * ub(j,k);
*******************************************************************
Momentum Differential Equation
*******************************************************************
a1(j,k) = (1.0 + K) + 0.5 * deta(j,k) * fb(j,k);
a2(j,k) = -(1.0 + K) + 0.5 * deta(j,k) * fb(j,k);
a3(j,k) = 0.5 * deta(j,k) * vb(j,k);
a4(j,k) = a3(j,k);
a5(j,k) = -1 * deta(j,k) * ub(j,k);
a6(j,k) = a5(j,k);
a7(j,k) = 0.5 * K * deta(j,k);
a8(j,k) = a7(j,k);
a9(j,k) = 0.5 * lambda * deta(j,k);
a10(j,k) = a9(j,k);
*******************************************************************
Angel Differential
*******************************************************************
b1(j,k) = (1 + K/2) + 0.5 * deta(j,k) * fb(j,k);
b2(j,k) = -(1 + K/2) + 0.5 * deta(j,k) * fb(j,k);
b3(j,k) = 0.5 * deta(j,k) * pb(j,k);
b4(j,k) = b3(j,k);
b5(j,k) = -0.5 * deta(j,k) * hb(j,k);
b6(j,k) = b5(j,k);
b7(j,k) = -0.5 * deta(j,k) * ub(j,k) - K * deta(j,k);
b8(j,k) = b7(j,k);
b9(j,k) = -0.5 * K * deta(j,k);
b10(j,k) = b9(j,k);
*******************************************************************
Energy Differential
*******************************************************************
c1(j,k) = 1/pr + 0.5 * deta(j,k) * fb(j,k);
c2(j,k) = -1/pr + 0.5 * deta(j,k) * fb(j,k);
c3(j,k) = 0.5 * deta(j,k) * tb(j,k);
c4(j,k) = c3(j,k);
c5(j,k) = -0.5 * deta(j,k) * sb(j,k);
c6(j,k) = c5(j,k);
c7(j,k) = -0.5 * deta(j,k) * ub(j,k);
c8(j,k) = c7(j,k);
*******************************************************************
Definition value of rj-1/2
*******************************************************************
r1(j,k) = f(j-1,k) - f(j,k) + deta(j,k) * ub(j,k);
r2(j,k) = u(j-1,k) - u(j,k) + deta(j,k) * vb(j,k);
r3(j,k) = h(j-1,k) - h(j,k) + deta(j,k) * pb(j,k);
r4(j,k) = s(j-1,k) - s(j,k) + deta(j,k) * tb(j,k);
r5(j,k) = (1.0 + K) * (v(j-1,k) - v(j,k)) - deta(j,k) * fvb(j,k) -...
deta(j,k)+ deta(j,k) * uub(j,k) - K * deta(j,k)...
* pb(j,k) - lambda * deta(j,k) * sb(j,k);
r6(j,k) = (1 + K/2) * (p(j-1,k) - p(j,k)) - deta(j,k) * pfb(j,k) + ...
deta(j,k) * hub(j,k) + 2 * K * deta(j,k) * hb(j,k) + ...
K * deta(j,k) * vb(j,k);
r7(j,k) = 1/pr * (t(j-1,k) - t(j,k)) - deta(j,k) * tfb(j,k) +...
deta(j,k) * sub(j,k);
end
*******************************************************************
Matrices Value A1, Aj, Bj, Cj
*******************************************************************
a{2,k} = [0 0 0 1 0 0 0 ;...
-0.5 * deta(2,k) 0 0 0 -0.5 * deta(2,k) 0 0;...
0 -0.5 * deta(2,k) 0 0 0 -0.5 * deta(2,k) 0;...
0 0 -1 0 0 0 -0.5 * deta(2,k);...
a2(2,k) a8(2,k) a10(2,k) a3(2,k) a1(2,k) a7(2,k) 0;...
b10(2,k) b2(2,k) 0 b3(2,k) b9(2,k) b1(2,k) 0;...
0 0 c8(2,k) c3(2,k) 0 0 c1(2,k)];
for j = 3:np
a{j,k} = [-0.5 * deta(j,k) 0 0 1 0 0 0 ;...
-1 0 0 0 -0.5 * deta(j,k) 0 0 ;...
0 -1 0 0 0 -0.5 * deta(j,k) 0 ;...
0 0 -1 0 0 0 -0.5 * deta(j,k);...
a6(j,k) 0 a10(j,k) a3(j,k) a1(j,k) a7(j,k) 0;...
b6(j,k) b8(j,k) 0 b3(j,k) b9(j,k) b1(j,k) 0;...
c6(j,k) 0 c8(j,k) c3(j,k) 0 0 c1(j,k)];
b{j,k} = [0 0 0 -1 0 0 0 ;...
0 0 0 0 -0.5 * deta(j,k) 0 0;...
0 0 0 0 0 -0.5 * deta(j,k) 0;...
0 0 0 0 0 0 -0.5 * deta(j,k);...
0 0 0 a4(j,k) a2(j,k) a8(j,k) 0;...
0 0 0 b4(j,k) b10(j,k) b2(j,k) 0;...
0 0 0 c4(j,k) 0 0 c2(j,k)];
end
for j = 2:np
c{j,k} = [-0.5 * deta(j,k) 0 0 0 0 0 0 ;...
1 0 0 0 0 0 0;...
0 1 0 0 0 0 0;...
0 0 1 0 0 0 0;...
a5(j,k) 0 a9(j,k) 0 0 0 0;...
b5(j,k) b7(j,k) 0 0 0 0 0;...
c5(j,k) 0 c7(j,k) 0 0 0 0];
end
*******************************************************************
Recursion of block Elimination
*******************************************************************
Forward Sweeping
*******************************************************************
alfa{2,k} = a{2,k};
gamma{2,k} = inv(alfa{2,k}) * c{2,k};
for j = 3:np
alfa{j,k} = a{j,k} - (b{j,k} * gamma{j-1,k});
gamma{j,k} = inv(alfa{j,k}) * c{j,k};
end
for j = 2:np
rr{j,k} = [r1(j,k); r2(j,k); r3(j,k); r4(j,k); r5(j,k); r6(j,k);...
r7(j,k)];
end
ww{2,k} = inv(alfa{2,k}) * rr{2,k};
for j = 3:np
ww{j,k} = inv(alfa{j,k}) * (rr{j,k} - (b{j,k} * ww{j-1,k}));
end
*******************************************************************
Backward Sweeping
*******************************************************************
delf(1,k) = 0.0;
delu(1,k) = 0.0;
delh(1,k) = 0.0;
delt(1,k) = 0.0;
delu(np,k) = 0.0;
delh(np,k) = 0.0;
dels(np,k) = 0.0;
dell{np,k} = ww{np,k};
for j = np-1:-1:2
dell{j,k} = ww{j,k} -(gamma{j,k} * dell{j+1,k});
end
delv(1,k) = dell{2,k}(1,1);
delp(1,k) = dell{2,k}(2,1);
dels(1,k) = dell{2,k}(3,1);
delf(2,k) = dell{2,k}(4,1);
delv(2,k) = dell{2,k}(5,1);
delp(2,k) = dell{2,k}(6,1);
delt(2,k) = dell{2,k}(7,1);
for j = np:-1:3
delu(j-1,k) = dell{j,k}(1,1);
delh(j-1,k) = dell{j,k}(2,1);
dels(j-1,k) = dell{j,k}(3,1);
delf(j,k) = dell{j,k}(4,1);
delv(j,k) = dell{j,k}(5,1);
delp(j,k) = dell{j,k}(6,1);
delt(j,k) = dell{j,k}(7,1);
end
*******************************************************************
Newton method
*******************************************************************
for j = 1:np
f(j,k+1) = f(j,k) + delf(j,k);
u(j,k+1) = u(j,k) + delu(j,k);
v(j,k+1) = v(j,k) + delv(j,k);
h(j,k+1) = h(j,k) + delh(j,k);
p(j,k+1) = p(j,k) + delp(j,k);
s(j,k+1) = s(j,k) + dels(j,k);
t(j,k+1) = t(j,k) + delt(j,k);
h(j,k+1) = -0.5 * v(j,k+1);
end
*******************************************************************
Convergence Check
*******************************************************************
stop = abs(delv(1,k));
kmax = k;
k = k + 1;
end
*******************************************************************
Skin Friction and Nusselt Number
*******************************************************************
cfrex = v(1,kmax)
nuxrex = 1/s(1,kmax)
nuxrex2 = s(1,kmax)
however, my case of study covers only the f, u and v, therefore, there are some changes on the initial condition. and many others part.
The infinite recursion will occur in these two functions:
def alfa(j,k):
return AJ(j,k) - (BJ(j,k)*gamma(j,k))
def gamma(j,k):
return npy.matrix.I((alfa(g,k))*CJ(g,k))
Each of which calls the other one under any circumstances. So, alfa calls gamma which calls alfa which calls gamma and so on forever.
We can see this if we add a print statement:
def alfa(j,k):
print 'alfa({},{}) called'.format(j,k)
return AJ(j,k) - (BJ(j,k)*gamma(j,k))
def gamma(j,k):
print 'gamma({},{}) called'.format(j,k)
return npy.matrix.I((alfa(g,k))*CJ(g,k))
Then we can see that this is what happens:
In [199]: alfa(3,1)
alfa(3,1) called
gamma(3,1) called
alfa(2,1) called
gamma(2,1) called
alfa(2,1) called
gamma(2,1) called
alfa(2,1) called
gamma(2,1) called
alfa(2,1) called
gamma(2,1) called
alfa(2,1) called
gamma(2,1) called
alfa(2,1) called
gamma(2,1) called
alfa(2,1) called
gamma(2,1) called
alfa(2,1) called
gamma(2,1) called
alfa(2,1) called
gamma(2,1) called
alfa(2,1) called
gamma(2,1) called
alfa(2,1) called
gamma(2,1) called
alfa(2,1) called
gamma(2,1) called
... and so on