Skip to content

armgit / manim

Public Imported from GitHub
0

A community-maintained Python framework for creating mathematical animations.

Tree can unfold in both default and sorted mode, animating btw them does not yet work as intended

Ben Hambrecht52305dc3fe56
diff --git a/active_projects/eop/chapter1.py b/active_projects/eop/chapter1.py
index 2803bc6ec..0cf28dc4c 100644
--- a/active_projects/eop/chapter1.py
+++ b/active_projects/eop/chapter1.py
@@ -12,6 +12,24 @@ GRADE_COLOR_1 = COLOR_HEADS = RED
GRADE_COLOR_2 = COLOR_TAILS = BLUE
+def binary(i):
+ if i == 0:
+ return []
+ j = i
+ binary_array = []
+ while j > 0:
+ jj = j/2
+ if jj > 0:
+ binary_array.append(j % 2)
+ else:
+ binary_array.append(1)
+ j = jj
+ return binary_array[::-1]
+
+
+def nb_of_ones(i):
+ return binary(i).count(1)
+
class PiCreatureCoin(VMobject):
CONFIG = {
@@ -277,21 +295,148 @@ class TallyStack(VGroup):
stack1 = HeadsStack(size = self.nb_heads, coin_thickness = self.coin_thickness)
stack2 = TailsStack(size = self.nb_tails, coin_thickness = self.coin_thickness)
stack2.next_to(stack1, RIGHT, buff = SMALL_BUFF)
+ stack2.align_to(stack1, DOWN)
self.add(stack1, stack2)
+
+
+
+class CoinFlipTree(VGroup):
+ CONFIG = {
+ "total_width": 12,
+ "level_height": 0.8,
+ "nb_levels": 4,
+ "sort_until_level": 3
+ }
+
+ def __init__(self, **kwargs):
+
+ VGroup.__init__(self, **kwargs)
+
+ self.rows = []
+ for n in range(self.nb_levels + 1):
+ if n <= self.sort_until_level:
+ self.create_row(n, sorted = True)
+ else:
+ self.create_row(n, sorted = False)
+
+
+ for row in self.rows:
+ for leaf in row:
+ dot = Dot()
+ dot.move_to(leaf[0])
+ line = Line(leaf[2], leaf[0])
+ if leaf[2][0] > leaf[0][0]:
+ line_color = COLOR_HEADS
+ else:
+ line_color = COLOR_TAILS
+ line.set_stroke(color = line_color)
+ group = VGroup()
+ group.add(dot)
+ group.add_to_back(line)
+ self.add(group)
+
+
+
+
+ def create_row(self, level, sorted = True):
+
+ if level == 0:
+ new_row = [[ORIGIN,0,ORIGIN]] # is its own parent
+ self.rows.append(new_row)
+ return
+
+ previous_row = self.rows[level - 1]
+ new_row = []
+ dx = float(self.total_width) / (2 ** level)
+ x = - 0.5 * self.total_width + 0.5 * dx
+ y = - self.level_height * level
+ for root in previous_row:
+ root_point = root[0]
+ root_tally = root[1]
+ for i in range(2): # 0 = heads = left, 1 = tails = right
+ leaf = x * RIGHT + y * UP
+ new_row.append([leaf, root_tally + i, root_point]) # leaf and its parent
+ x += dx
+
+ #print "tallies for row", level, ":", [new_row[i][1] for i in range(2**level)]
+
+ if sorted:
+ # sort the new_row by its tallies
+ sorted_row = []
+ x = - 0.5 * self.total_width + 0.5 * dx
+ for i in range(level + 1):
+ for leaf in new_row:
+ if leaf[1] == i:
+ sorted_leaf = leaf
+ sorted_leaf[0][0] = x
+ x += dx
+ sorted_row.append(leaf)
+ print "sorted roots:", [sorted_row[i][2][0] for i in range(2**level)]
+ self.rows.append(sorted_row)
+ else:
+ self.rows.append(new_row)
+
+
+
+
class TestScene(Scene):
def construct(self):
- #seq = CoinSequence(["H", "T", "T", "H"])
+ #seq = CoinSequence(["H", "T", "T", "H"]).move_to(2 * LEFT)
#self.add(seq)
- stack = TallyStack(4,5, coin_thickness = COIN_THICKNESS)
- self.add(stack)
+ #stack = TallyStack(4,7, coin_thickness = COIN_THICKNESS)
+ #self.add(stack)
+
+ tree = CoinFlipTree(nb_levels = 7, sort_until_level = 0)
+ tree.move_to(ORIGIN)
+ self.add(tree)
+
+ for i in range(1, 8):
+ new_tree = CoinFlipTree(nb_levels = 7, sort_until_level = i)
+ new_tree.move_to(ORIGIN)
+ self.play(Transform(tree, new_tree))
+ self.wait()
self.wait()
+
+
+class CoinFlipBranchToAreaScene(Scene):
+
+ def construct(self):
+
+ pass
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
class AreaSplittingScene(Scene):