FP:名詞も動詞も辞書化、同名リレーでクリーンに更新
このワークシートはMath by Codeの一部です。
フラクタルなコンポジット構造を探索するビジター
コンポジットは名前をつける、変える、木構造を表示するなどの共通規格書の子として、ノード（フォルダ）とリーフ（ファイル）をぶら下げらえる。すると、ファイル構造のユーザは同じAPIでファイル構造を変えていけたね。
ビジターはお客様ではなく、特別の使命を託された工作員だった。コンポジットはフラクタル構造なので、情報を得るためのAPIとしてAcceptをつけて、工作員が来た時の行動を決めておくことで調査に協力できるようにしていた。
そんな2種類のデザインパタン、コンポジットとビジターは、FP化によってどうなるのだろう。
１．ファイルシステムはFP化でクラスから辞書に変わる。
＜OOP:Composite＞
まずCompositeのOOP版です。
＜ファイル探索・操作の実装＞
# ==========================================
# 【共通規格】ファイルもフォルダも等価に扱うための抽象クラス
# ==========================================
class FileSystemNode:
"""【要素】ノード（フォルダ）でもリーフ（ファイル）でも同じ方法で扱える共通仕様"""
def __init__(self, name):
self.name = name
def getName(self):
return self.name
def reName(self, new_name):
self.name = new_name
def add(self, node):
raise NotImplementedError("端末要素（ファイル）の下に、要素を追加することはできません。")
def remove(self, node):
raise NotImplementedError("端末要素（ファイル）から、要素を削除することはできません。")
def show_tree(self, depth=0):
"""ツリー構造を画面に表示するための共通メソッド"""
raise NotImplementedError()
# ==========================================
# 【末端（リーフ）】中身が「ファイル」のクラス
# ==========================================
class FileLeaf(FileSystemNode):
"""＜末端＞を表す具体的なクラス"""
def __init__(self, name, size):
super().__init__(name)
self.size = size # ファイル固有の属性
def show_tree(self, depth=0):
# インデントをつけてファイル名を表示
print(" " * depth + f"・{self.getName()} ({self.size}KB)")
# ==========================================
# 【複合体（コンポジット）】中身が「フォルダ」のクラス
# ==========================================
class FolderComposite(FileSystemNode):
"""＜木＞を表す具体的なクラス。自分の中にさらに＜要素＞の集合体を持つ"""
def __init__(self, name):
super().__init__(name)
self.children = [] # 【自己参照の受け皿】FileSystemNode（ファイルかフォルダ）を格納するリスト
def add(self, node: FileSystemNode):
"""xsが末端でなければ、xを追加する"""
self.children.append(node)
return self # メソッドチェーン（連続追加）ができるように自分を返す
def remove(self, node: FileSystemNode):
"""xsにxがあれば、xを取り除く（どの階層であっても、見つけたら削除）"""
if node in self.children:
self.children.remove(node)
return True
# 自分の直下になければ、さらに下層のフォルダ（自己相似）に「xを持ってる？」と探索をお願いする
for child in self.children:
if isinstance(child, FolderComposite):
if child.remove(node):
return True
return False
def show_tree(self, depth=0):
"""フォルダの中身を再帰的に全件走査して表示する（フラクタル展開）"""
print(" " * depth + f"□{self.getName()}/")
for child in self.children:
# 相手がファイルかフォルダかを一切気にせず、同じ「show_tree」を呼び出すだけ！
child.show_tree(depth + 1)
# ==========================================
# 【実行・ユーザー側のコード】部分と全体を一様に操作する
# ==========================================
print("コンポジットアルゴリズムスタート：\n")
# 1. PCでおなじみの木構造（ファイルシステム）を構築
root_dir = FolderComposite("デザインパタン")
gener_dir = FolderComposite("生成系")
behav_dir = FolderComposite("振る舞い系")
# 端末要素（ファイル）の作成
file_a = FileLeaf("f a c t o r y .py", 12)
file_b = FileLeaf("m e d i a t o r .py", 45)
file_c = FileLeaf("i t e r a t o r .py", 8)
# フォルダ構造へ追加（どの階層でも、上がxs、真下がxの関係）
root_dir.add(gener_dir).add(behav_dir)
gener_dir.add(file_a)
behav_dir.add(file_b).add(file_c)
print("--- 1. 最初に構築したツリー構造を表示 ---")
root_dir.show_tree()
print("\n--- 2. 名前の変更（reName）を『ファイル』と『フォルダ』に一様に適用 ---")
# ユーザーは相手がリーフかノードかを意識せず、全く同じメソッドを叩ける
gener_dir.reName("工場系") # フォルダの名前変更
file_c.reName("List Access Interface .py") # ファイルの名前変更
root_dir.show_tree()
print("\n--- 3. 要素の削除（remove）を発動 ---")
print(f"削除実行： {file_c.getName()} を消去します。")
root_dir.remove(file_c) # ルートフォルダに丸投げすれば、下層まで勝手に探して消してくれる
root_dir.show_tree()
[OUT]
コンポジットアルゴリズムスタート：
--- 1. 最初に構築したツリー構造を表示 ---
□デザインパタン/
□生成系/
・f a c t o r y .py (12KB)
□振る舞い系/
・m e d i a t o r .py (45KB)
・i t e r a t o r .py (8KB)
--- 2. 名前の変更（reName）を『ファイル』と『フォルダ』に一様に適用 ---
□デザインパタン/
□工場系/
・f a c t o r y .py (12KB)
□振る舞い系/
・m e d i a t o r .py (45KB)
・List Access Interface .py (8KB)
--- 3. 要素の削除（remove）を発動 ---
削除実行： List Access Interface .py を消去します。
□デザインパタン/
□工場系/
・f a c t o r y .py (12KB)
□振る舞い系/
・m e d i a t o r .py (45KB)
＜FP:Composite＞
フラクタル構造、木構造の可能なオブジェクト
と言えば、辞書ですね。
まずデータ（名詞）です。
ファイルは数値（サイズ）、フォルダdicは辞書という構造の辞書を初期値initial_treeで 作ります。
次は処理（動詞）です。
処理関数も辞書にして管理関数辞書fs_operatorsとします。この発想は今まで何度も使いましたね。
処理辞書は、管理名をキーにしたラムダ式にしましょう。
管理対象となるtreeに対する操作self_funcができます。☆は操作パラメータです。
"管理名": lambda self_func, tree,☆が１つのラムダ式の形式です。
例えば
管理名＝renameなら、ツリー構造のキーｋと値ｖに対して、
☆＝old_name, new_nameとしましょう。
ツリーのキーkをみてold_nameならnew_nameとして、old_nameでないときはｋのままを対象ノード
そのツリーノードに対して、
もしｖがフォルダつまり、isinstance(v, dict)ならば
self_func(self_func, v, old_name, new_name)のように同じことをフォルダvに対して繰り返し、
そうでないなら、掘り下げないでファイルｖを読み取りましょう。
管理名＝removeなら、☆＝target_nameとして、同様に作れますね。
ファイル構造initial_treeというデータと管理関数辞書fs_operatorsを投げるとフレームワークの親玉関数がファイル構造を新オブジェクトとしてリレーするというFP化が思いつきますね。
親玉関数execute_fsは動詞としての管理名op_typeを文字列で受け取り、その引数は*argsで可変で受け取ります。op = fs_operators[op_type]とすることで、opに処理関数が格納されます。
もう一つの親玉関数show_tree(tree: dict, depth=0)は、子分の関数がいなくても、isinstance(tree, dict)で
再帰的に進めます。
データ（名詞）も辞書、処理（動詞）も辞書。
FPは辞書だらけになります。
# Composite FP
# ==========================================
# 1. データ（名詞）の定義：完全な入れ子辞書
# ==========================================
initial_tree = {
"デザインパタン": {
"生成系": {
"factory.py": 12
},
"振る舞い系": {
"mediator.py": 45,
"iterator.py": 8
}
}
}
# ==========================================
# 2. 処理（動詞）の定義：管理関数辞書（ラムダのパック）
# ==========================================
# フラクタル構造（木）を再帰的に巡り、元のデータを破壊せずに「新築」して返す関数群
fs_operators = {
"rename": lambda self_func, tree, old_name, new_name: {
(new_name if k == old_name else k): (
self_func(self_func, v, old_name, new_name) if isinstance(v, dict) else v
) for k, v in tree.items()
},
"remove": lambda self_func, tree, target_name: {
k: (self_func(self_func, v, target_name) if isinstance(v, dict) else v)
for k, v in tree.items() if k != target_name
}
}
# ==========================================
# 3. フレームワーク（親玉関数）：再帰の仲介
# ==========================================
def execute_fs(tree: dict, op_type: str, *args) -> dict:
"""管理関数辞書から動詞を取り出し、再帰のトリガーを引く親玉関数"""
op = fs_operators[op_type]
return op(op, tree, *args)
def show_tree(tree: dict, depth=0):
"""木構造をきれいに画面に描画する純粋表示関数"""
for k, v in tree.items():
if isinstance(v, dict):
print(" " * depth + f"□{k}/")
show_tree(v, depth + 1)
else:
print(" " * depth + f"・{k} ({v}KB)")
# ==========================================
# 4. 実行（不変なツリーの歴史のバケツリレー）
# ==========================================
tree_v0 = initial_tree
print("--- 1. 最初に構築したツリー構造を表示 ---")
show_tree(tree_v0)
print("\n--- 2. 名前の変更（rename）を発動：『生成系』➔『工場系』へ ---")
# 元の tree_v0 は一切壊さず、新築された tree_v1 をリレーする
tree_v1 = execute_fs(tree_v0, "rename", "生成系", "工場系")
show_tree(tree_v1)
print("\n--- 3. 要素の削除（remove）を発動：『iterator.py』を消去 ---")
# tree_v1 からさらに新しい tree_v2 を新築
tree_v2 = execute_fs(tree_v1, "remove", "iterator.py")
show_tree(tree_v2)
print("\n【歴史の証明：ステートトラベル】")
print("イミュータブルな状態作成ではタイムトラベルができるはず。")
print(f"tree_v1の中に iterator.py は存在するか？ ➔ {'iterator.py' in tree_v1['デザインパタン']['振る舞い系']}")
[OUT]
--- 1. 最初に構築したツリー構造を表示 ---
□デザインパタン/
□生成系/
・factory.py (12KB)
□振る舞い系/
・mediator.py (45KB)
・iterator.py (8KB)
--- 2. 名前の変更（rename）を発動：『生成系』➔『工場系』へ ---
□デザインパタン/
□工場系/
・factory.py (12KB)
□振る舞い系/
・mediator.py (45KB)
・iterator.py (8KB)
--- 3. 要素の削除（remove）を発動：『iterator.py』を消去 ---
□デザインパタン/
□工場系/
・factory.py (12KB)
□振る舞い系/
・mediator.py (45KB)
【歴史の証明：ステートトラベル】
イミュータブルな状態作成ではタイムトラベルができるはず。
tree_v1の中に iterator.py は存在するか？ ➔ True
op(op, tree, *args)というように、
自己参照文により、管理処理名と管理処理を同名して返します。
これは、「同名でnewして何が悪い」であった新オブジェクトの作成と同じロジックですね。
ラムダ式には名前がありません。self_funcはイミュータブルな世界では使い捨てになります。
外側に関数名を持たないラムダ式だからこそ、
自分自身（関数オブジェクト）opを同名の引数opとして次の階層へ新築リレーしていくことで、
一切の破壊なしにフラクタルなフォルダの奥深くへと潜ることができるのですね。
２．ファイルシステムも工作員もFP化で辞書になる
＜OOP:Visitor＞
つぎに、ファイルシステムというフラクタル構造に特命をもって全件捜索するVisitorのOOP版を
思い起こしましょう。
# ==========================================
# Composite構造＋窓口
# ==========================================
class FileSystemNode:
"""共通規格：名前の管理と、工作員を受け入れる窓口（accept）を定義"""
def __init__(self, name):
self.name = name
def getName(self):
return self.name
def accept(self, agent):
raise NotImplementedError()
class FileLeaf(FileSystemNode):
"""[末端] を表すファイルクラス"""
def __init__(self, name, size):
super().__init__(name)
self.size = size
def accept(self, agent):
# 工作員がファイルに接触した瞬間、自身のデータを工作員に調べさせる
# 戻り値として、自身のファイルサイズを親（フォルダ）に返す
return agent.visit_file(self)
class FolderComposite(FileSystemNode):
"""[木] を表すフォルダクラス"""
def __init__(self, name):
super().__init__(name)
self.children = []
def add(self, node):
self.children.append(node)
return self
def accept(self, agent):
# 1. まずはフォルダに入ったことを工作員に通知する（行きがけの処理）
agent.visit_folder(self)
# 2. [再帰的巡回] フォルダの中にある子どもたちへ、工作員を次々と突入させる
# 各子どもたちが持っているサイズをボトムアップで回収し、合計（マージ）していく
total_sub_size = 0
for child in self.children:
total_sub_size += child.accept(agent)
# 3. すべての子どもの調査が終わったら、工作員にそのフォルダの最終報告をさせる（帰りがけの処理）
# このフォルダの合計サイズを、さらに上位の親フォルダへと返していく
return agent.visit_folder_post(self, total_sub_size)
# ==========================================
# 【工作員の共通規格】共通のインターフェース
# ==========================================
class AgentInterface:
"""すべての特命工作員が必ず持つ能力（メソッド）"""
def visit_file(self, file_node): raise NotImplementedError()
def visit_folder(self, folder_node): raise NotImplementedError()
def visit_folder_post(self, folder_node, sub_size): raise NotImplementedError()
def show_result(self): raise NotImplementedError()
# ==========================================
# 【特命工作員A】フォルダごとに合計サイズを計算して表示する任務（修正版）
# ==========================================
class SizeAggregationAgent(AgentInterface):
"""工作員A：ボトムアップで各フォルダの「中身すべての合計サイズ」を暴く職人"""
def __init__(self):
# 各フォルダの最終的な集計結果を記録する辞書
self.results = {}
def visit_folder(self, folder_node):
# 行きがけ：特に何もする必要はありません（通過通知のみ）
pass
def visit_file(self, file_node):
# ファイルを発見：そのファイルのサイズをそのまま上に返す
return file_node.size
def visit_folder_post(self, folder_node, sub_size):
# 帰りがけ：子どもたちの合計サイズを記録し、さらに上の親フォルダへとそのサイズを引き渡す
self.results[folder_node.getName()] = sub_size
return sub_size
def show_result(self):
# 最後に、蓄積されたすべてのフォルダの集計結果を報告
print(" --- フォルダサイズの集計 ---")
for folder_name, total_size in self.results.items():
print(f" □ {folder_name} 内の合計: {total_size} KB")
# ==========================================
# 【特命工作員B】サイズの大きい順にファイルランキングを表示する任務
# ==========================================
class SizeRankingAgent(AgentInterface):
"""工作員B：森全体をくまなくスキャンし、巨大なファイルの上位ランキングを抽出する"""
def __init__(self):
self.file_list = [] # 発見したすべての(ファイル名, サイズ)を記録する
def visit_folder(self, folder_node):
pass
def visit_file(self, file_node):
# ファイルを見つけたら、名前とサイズをメモに記録してサイズを上に返す
self.file_list.append((file_node.getName(), file_node.size))
return file_node.size
def visit_folder_post(self, folder_node, sub_size):
# ランキング班は、合計サイズを上の親に引き渡す案内係だけを行う
return sub_size
def show_result(self):
# メモに集まったファイルを、サイズが大きい順（降順）にソーティング
ranking = sorted(self.file_list, key=lambda x: x[1], reverse=True)
print(" --- ファイルサイズでかいTOP3 ---")
for idx, (name, size) in enumerate(ranking[:3], 1):
print(f" No.{idx}: {name} ({size} KB)")
# ==========================================
# 【作動テスト】コンポジットの森に、工作員を順次投入
# ==========================================
print("=== Visitor Agent Algorithm: Start ===\n")
# 1. コンポジットの森の構築
root_dir = FolderComposite("デザインパタン")
gener_dir = FolderComposite("工場")
behav_dir = FolderComposite("行動")
file_a = FileLeaf("f a c t o r y .py", 12)
file_b = FileLeaf("m e d i a t o r .py", 45)
file_c = FileLeaf("i t e r a t o r .py", 8)
file_af = FileLeaf("f a c t o r y Fat .py", 123)
file_bf = FileLeaf("m e d i a t o r Fat .py", 456)
file_cf = FileLeaf("i t e r a t o r Fat .py", 89)
root_dir.add(gener_dir).add(behav_dir)
gener_dir.add(file_a).add(file_af)
behav_dir.add(file_b).add(file_c).add(file_bf).add(file_cf)
print("[特命 1] ")
agent_A = SizeAggregationAgent()
root_dir.accept(agent_A) # ルートから突入agent_A.show_result() # 結果報告
print("\n" + "="*50 + "\n")
print("[特命 2]")
agent_B = SizeRankingAgent()
root_dir.accept(agent_B) # ルートから突入
agent_B.show_result() # 結果報告
[OUT]
=== Visitor Agent Algorithm: Start ===
[特命 1]
--- フォルダサイズの集計 ---
□ 工場 内の合計: 135 KB
□ 行動 内の合計: 598 KB
□ デザインパタン 内の合計: 733 KB
==================================================
[特命 2]
--- ファイルサイズでかいTOP3 ---
No.1: m e d i a t o r Fat .py (456 KB)
No.2: f a c t o r y Fat .py (123 KB)
No.3: i t e r a t o r Fat .py (89 KB)
＜FP:Visitor＞
ファイルシステムの状態管理自体が関数辞書で実現できてました。
だから、特命工作員Visitorも子クラスではなく、
ただのバラバラの関数にしてそれをまたグループ化して辞書にしてファイルシステムに送り込めば、
それぞれが目的達成してくれそうですね。
まず、ファイルシステムをroot_treeという名前の辞書データにしよう。
次に特命工作員A自体も辞書agent_A_ops にします。
ファイルアクセス時は、name, sizeからタプル(size,{})を返すラムダ式で処理します。
フォルダ帰りがけは、name, total_size, children_dictsからtotal_sizeを返すラムダ式ですが、
**children_dictsというスプレッドしてnameを変えて再帰的にたし上げたtotal_sizeを返します。
次に特命工作員Bは辞書agent_B_ops にします。
ファイルアクセス時は、name, sizeから(size,[(name,size)])を返すラムダ式で処理します。フォルダ帰りがけは、name, total_size, children_listsからtotal_sizeと集まったリストchildren_lists上に丸投げします。
親玉関数はvisit_fsはフォルダ名と中身を同名リレーでイミュータブルな世界で工作員agentで調査します。
引数はself_func, dir_nameの文字列, sub_treeの辞書, agentで、返り値は（サイズ、レコード）のタプルです。その処理手順は、次のようにしましょう。
current_total_size = 0で先頭で初期化します。記録メモaccumulated_record は工作員の種別に応じて初期化します。
このあとはfor文でループすればよいですね。ツリーのキーk、値ｖに対して、
ファルダアクセス時はself_func(self_func, k, v, agent)でリレーして潜りながら、タプルを取得しては、
(child_size, child_record）から、current_total_sizeに child_sizeを加算したあと、
帰りがけにはフォルダなら記録メモaccumulated_record もchild_recordもフラットに展開して合体したものを、同名の新記録メモとしますが、ファイルならば、child_recordを追加します。
ファイルアクセス時は工作員のファイルアクセス時のタプル(child_size, child_record)を取得して、サイズchild_sizeを加算します。記録メモが工作員Bが使うリストの場合は記録child_recordの追加もしましょう。
この階層の調査の最後にはフォルダの帰りがけ処理をして返すことで、上向きリレーが続きますね。
# Visitor FP
# ==========================================
# 1. 対象データ（名詞）：完全な入れ子辞書（Composite構造）
# ==========================================
root_tree = {
"デザインパタン": {
"工場": {
"factory.py": 12,
"factoryFat.py": 123
},
"行動": {
"mediator.py": 45,
"iterator.py": 8,
"mediatorFat.py": 456,
"iteratorFat.py": 89
}
}
}
# ==========================================
# 2. 特命工作員（動詞）の定義：作戦関数をパックした辞書
# ==========================================
# 【特命 1】各フォルダの合計サイズを集計・記録する作戦辞書
agent_A_ops = {
# ファイル接触時：(自身のサイズ, 下位のフォルダ記録辞書)
"file_op": lambda name, size: (size, {}),
# フォルダの帰りがけ：(このフォルダの合計サイズ, 統合された記録辞書)
"folder_post_op": lambda name, total_size, children_dicts: (
total_size,
{**children_dicts, name: total_size} # 新しい歴史をマージして上に投げる
)
}
# 【特命 2】ファイルサイズでかいリストを上へと回収する作戦辞書
agent_B_ops = {
# ファイル接触時：(自身のサイズ, 自身のペアを包んだリスト)
"file_op": lambda name, size: (size, [(name, size)]),
# フォルダの帰りがけ：(このフォルダの合計サイズ, 統合されたフラットなリスト)
"folder_post_op": lambda name, total_size, children_lists: (
total_size,
children_lists # 集まったリストをそのまま上に投げる
)
}
# ==========================================
# 3. フレームワーク（親玉関数）：フォルダ名と中身を同名リレー
# ==========================================
def visit_fs(self_func, dir_name: str, sub_tree: dict, agent: dict) -> tuple:
"""
【Visitor親玉関数】
「現在のフォルダ名」と「その中身の辞書」を正しく見つめながら、一切の破壊なしに潜る。
"""
current_total_size = 0
# 工作員のタイプ（特命1なら辞書、特命2ならリスト）に合わせて初期の記録用バケツを新築
accumulated_record = {} if agent == agent_A_ops else []
for k, v in sub_tree.items():
if isinstance(v, dict):
# フォルダを発見：自分自身(self_func)、フォルダ名(k)、その中身(v)を同名リレー！
child_size, child_record = self_func(self_func, k, v, agent)
current_total_size += child_size
# 帰ってきた下層の歴史（オブジェクト）を、元のデータを壊さずに統合
if isinstance(accumulated_record, dict):
accumulated_record = {**accumulated_record, **child_record}
else:
accumulated_record = accumulated_record + child_record
else:
# ファイルを発見：工作員のファイル作戦オブジェクトを発動
child_size, child_record = agent["file_op"](k, v)
current_total_size += child_size
if isinstance(accumulated_record, list):
accumulated_record = accumulated_record + child_record
# この階層の走査がすべて終わったら（帰りがけ）、工作員の最終報告処理を叩いて上にリレー！
return agent["folder_post_op"](dir_name, current_total_size, accumulated_record)
# ==========================================
# 4. 実行（工作員たちの任務遂行）
# ==========================================
print("=== Visitor Agent Algorithm: Start ===\n")
print("[特命 1] ")
# ルートのフォルダ名「"Root"」の代わりに、最上位の辞書をバラして外側から起動
root_name = list(root_tree.keys())[0]
root_content = root_tree[root_name]
# 同名リレーのトリガーを引く
_, total_folder_sizes = visit_fs(visit_fs, root_name, root_content, agent_A_ops)
print(" --- フォルダサイズの集計 ---")
for folder_name, total_size in total_folder_sizes.items():
print(f" □ {folder_name} 内の合計: {total_size} KB")
print("\n" + "="*50 + "\n")
print("[特命 2]")
_, all_files_flat = visit_fs(visit_fs, root_name, root_content, agent_B_ops)
# 帰ってきた「クリーンに新築されたフラットなリスト」をサイズ順にソートして3つ切り出す
ranking = sorted(all_files_flat, key=lambda x: x[1], reverse=True)
print(" --- ファイルサイズでかいTOP3 ---")
for idx, (name, size) in enumerate(ranking[:3], 1):
print(f" No.{idx}: {name} ({size} KB)")
３．振り返り
＜振り返り＞
コンポジットパターン
名詞initial_treeと動詞fs_operatorsを辞書にした。
フレームワークexecute_fsの中でself_funcを
同名リレーop(op, tree, *args)をした。
ビルダパターン
名詞root_treeと動詞agent_A_ops、agent_B_opsを辞書にした。
フレームワークvisit_fsの中で、self_funcを
同名リレーself_func(self_func, k, v, agent)をした。
相似形の設計だね。
名詞も動詞も辞書になり、
同名の新規オブジェクトの連続作成によるリレー、
同名リレーで記録メモをクリーンに更新できたね。
同名上書きや、同名自己参照という一見裏技に見える新オブジェクト名の意図的な生成が、
名詞と動詞の辞書たちの安全を守っていたんだね。
課題：geogaraの再帰パタンはどんな特徴があるかを調べよう。
再帰構造、再帰関数はgeogebraでどうなっているのだろうか。
再帰関数といえば、リカージョンの構造は表だってありません。
代わりに反復コマンドという意味あいの
Iterationコマンドがあります。
f(x) = x^2として、
Iteration(f, 3,2)で、(3^2)^2=81が求められるわけです。
電卓の代わりですね。
また、IterationListコマンドがありました。
fibをやろうでも取り組んだように、
数列生成のための漸化式コマンドです。
IterationList(a+b,a,b,{1,1},30)でフィボナッチ数列が、
terationList(a+b,a,b,{2,1},30)でリュカ数列が、
IterationList(a+b+c,a,b,c,{0,0,1},30)でトリボナッチ数列数列が、
Sequence(fibo(k+1)/fibo(k),k, 1,20)で黄金比の数列が、
カンタンに生成できた。
また、lst=Sequence(100)をつくり、
b=Product(lst)で100！がこの2行で計算できてしまう。
このgeobebraの軽快さは、電卓代わり程度という割り切りが必要だ。
自分は使ったことがなかったが、
さすがに図形代数、Geogebraならではの、数列ならぬ点列生成もできてしまう。
A = (0,0)
B = (8,0)
IterationList(Midpoint(A, C), C, {B}, 3)
C 0 => B= (8,0)
C 1 = >Midpoint ( A , C 0 )=(4,0)
C 2 = >Midpoint ( A , C 1 )=(2,0)
C 3 => Midpoint ( A , C 2 ) =(1,0)
ができるはず。
再帰とえば、ファイル構造ではなく、フラクタルそのもの、
フラクタル図形がある。
タイトルは「フラクタルはバケツリレー」
シェルピンスキーのギャスケットを作りたければ、
A=(0,0)
B=(1,0)
Polygon(A,B,3)で決まる点がC
H={A,B,C}
D=Midpoint(B,C)
E=Midpoint(C,A)
F=Midpoint(A,B)
中点はよいとしてもDilateという相似縮小コマンドを探して、対称性を利用して、縮小の視点を
リストから探して、順次縮小三角形を作っていくことになる。
変数は重複したり、For文が使えないので、
定数のような順次縮小の命令を並べるのがせいぜいだ。
S1=SequencePolygon(Dilate(D,((1)/(2)),Element(H,k)),Dilate(E,((1)/(2)),Element(H,k)),Dilate(F,((1)/(2)),Element(H,k))),k,1,3)
S2=SequenceDilate(S1,((1)/(2)),Element(H,k)),k,1,3)
S3=SequenceDilate(S2,((1)/(2)),Element(H,k)),k,1,3)
S4=SequenceDilate(S3,((1)/(2)),Element(H,k)),k,1,3)
S5=SequenceDilate(S4,((1)/(2)),Element(H,k)),k,1,3)
S6=SequenceDilate(S5,((1)/(2)),Element(H,k)),k,1,3)
それでも、副作用のないバケツリレーをしているといえばしている。
もとの点は残しているのだから。