defmodule Dmp.DebugUtils do
@moduledoc """
Utilities for debugging bitarrays.
"""
use Bitwise, only_operators: true
@doc """
Formats the `alphabet` bitarray into a list of lines, showing binary values.
## Examples
iex> DebugUtils.debug_alphabet("aba", %{?a => 5, ?b => 2})
[
" alphabet: a b a",
" a 5: 1 0 1",
" b 2: 0 1 0"
]
"""
@spec debug_alphabet(String.t(), Dmp.Match.alpha()) :: [String.t()]
def debug_alphabet(pattern, s) do
pattern_length = String.length(pattern)
data =
String.codepoints(pattern)
|> Enum.sort()
|> Enum.dedup()
|> Enum.map(fn ch -> alphabet_line(ch, s, pattern_length) end)
[alphabet_header(pattern) | data]
end
defp alphabet_header(pattern) do
line = [" alphabet:" | String.codepoints(pattern)]
Enum.join(line, " ")
end
defp alphabet_line(ch, s, pattern_length) do
ord = String.to_charlist(ch) |> List.first()
value = Map.get(s, ord, 0)
valstr = to_string(value) |> String.pad_leading(12)
bits = bitmap_to_list(value, pattern_length)
line = [" ", ch, valstr <> ":"] ++ bits
Enum.join(line, " ")
end
@doc """
Formats the `rd` bitarray into a list of lines, showing binary values.
* `d` - Error level for the bitarray.
* `start` - Lowest index that has been calculated.
* `best_loc` - Index in the text where the best match has been found.
## Examples
iex> DebugUtils.debug_rd("abc", "add", 0, %{1 => 5, 2 => 7, -1 => 3}, 1, 2)
[
"rd_j^0 pattern: a d d",
" 0* _ 0: 0 0 0",
" 1 a 5: 1 0 1",
" 2 b 7: 1 1 1",
" 3@ c 0: 0 0 0",
" 4 _ 0: 0 0 0"
]
"""
@spec debug_rd(
String.t(),
String.t(),
non_neg_integer(),
Dmp.Match.bitap_array(),
non_neg_integer(),
integer()
) :: [String.t()]
def debug_rd(text, pattern, d, rd, start \\ 0, best_loc \\ -1) do
pattern_length = String.length(pattern)
rd_size = max(String.length(text) + 2, Map.fetch!(rd, -1))
data =
Enum.map(0..(rd_size - 1), fn j ->
ch =
if j == 0 do
nil
else
String.at(text, j - 1)
end
rd_j_line(ch, j, rd, pattern_length, start, best_loc)
end)
[rd_header(d, pattern) | data]
end
defp rd_header(d, pattern) do
dstr = "rd_j^#{d}" |> String.pad_trailing(7)
line = ["#{dstr} pattern:" | String.codepoints(pattern)]
Enum.join(line, " ")
end
defp rd_j_line(nil, j, rd, pattern_length, start, best_loc) do
rd_j_line("_", j, rd, pattern_length, start, best_loc)
end
defp rd_j_line(ch, j, rd, pattern_length, start, best_loc) do
value = Map.get(rd, j, 0)
valstr = to_string(value) |> String.pad_leading(12)
jstr = to_string(j) |> String.pad_leading(2)
jstr =
cond do
best_loc != -1 && j - 1 == best_loc ->
jstr <> "@"
j < start ->
jstr <> "*"
true ->
jstr <> " "
end
bits = bitmap_to_list(value, pattern_length)
line = [jstr, ch, valstr <> ":"] ++ bits
Enum.join(line, " ")
end
@doc """
Returns a list of "codepoints" (single-character strings)
showing the base-2 value of `value`.
A minimum of `padding` elements are returned.
"""
@spec bitmap_to_list(non_neg_integer(), non_neg_integer()) :: [String.t()]
def bitmap_to_list(value, padding \\ 0) do
encode_bit_loop(value, "")
|> String.pad_leading(padding, "0")
|> String.codepoints()
end
defp encode_bit_loop(v, acc) do
acc =
if (v &&& 1) == 0 do
"0" <> acc
else
"1" <> acc
end
v = v >>> 1
if v == 0 do
acc
else
encode_bit_loop(v, acc)
end
end
end