A crappy way to compare different word search algorithms.

word_search_times.gd

extends Node2D

func load_str_array() -> PackedStringArray:
	var packed_str_array : PackedStringArray = []
	var file = FileAccess.open("res://dictionary.txt", FileAccess.READ)
	var content = file.get_as_text()
	packed_str_array = content.split("\n", false)
	return packed_str_array

func load_dict() -> Dictionary:
	var dict : Dictionary = {}
	var file = FileAccess.open("res://dictionary.txt", FileAccess.READ)
	var content := file.get_as_text().split("\n", false)
	for word in content:
		dict[word] = 1
	return dict

func load_regex() -> String:
	var file = FileAccess.open("res://dictionary.txt", FileAccess.READ)
	return "\n" + file.get_as_text() + "\n"

func in_regex(str : String, word : String) -> bool:
	var regex = RegEx.new()
	regex.compile("\n{0}\n".format([word]))
	return regex.search(str) != null

func in_str_array(packed_str_array : PackedStringArray, word: String) -> bool:
	return word in packed_str_array

func in_str_array_bsearch(packed_str_array : PackedStringArray, word: String) -> bool:
	return packed_str_array[packed_str_array.bsearch(word)] == word

func in_dict(dict : Dictionary, word: String) -> bool:
	return word in dict

func timed_call(c : Callable) -> float:
	var time_start = Time.get_ticks_usec()
	c.call()
	return Time.get_ticks_usec() - time_start

func test(load_func : Callable, check_func : Callable, name : String, use_load_func : bool = true) -> void:
	const LOAD_ITERATIONS := 10
	const CHECK_ITERATIONS := 100
	
	var db = load_func.call()
	if db == null:
		push_error("load_func failed, returned null.")
	var should_be_true = check_func.call(db, "cat")
	if not should_be_true:
		push_error("check_func failed: returned false for 'cat'.")
	var should_be_false = check_func.call(db, "jklasfd")
	if should_be_false:
		push_error("check_func failed: returned true for 'jklasfd'.")

	var average_load_time : float = -1
	var time_start := Time.get_ticks_usec()
	if use_load_func:
		for i in LOAD_ITERATIONS:
			load_func.call()
		average_load_time = (Time.get_ticks_usec() - time_start) / float(LOAD_ITERATIONS)
	
	time_start = Time.get_ticks_usec()
	for i in CHECK_ITERATIONS:
		check_func.call(db, "cat")
	var average_valid_time := (Time.get_ticks_usec() - time_start) / float(CHECK_ITERATIONS)
	
	time_start = Time.get_ticks_usec()
	for i in CHECK_ITERATIONS:
		check_func.call(db, "jklasfd")
	var average_invalid_time := (Time.get_ticks_usec() - time_start) / float(CHECK_ITERATIONS)
	
	print("-----------------")
	print("Testing: " + name + "\n-----------------")
	if use_load_func:
		print("  Average Load Time:       %fmsec" % [average_load_time / 1000.0])
	print("  Valid Word CheckTime:    %fmsec" % [average_valid_time / 1000.0])
	print("  Invalid Word Check Time: %fmsec" % [average_invalid_time / 1000.0])
	print("-----------------")

func _ready() -> void:
	test(load_str_array, in_str_array, "PackedStringArray")
	test(load_str_array, in_str_array_bsearch, "PackedStringArray - bsearch", false)
	test(load_dict, in_dict, "Dictionary")
	test(load_regex, in_regex, "Regex")