Packages
text_stemmer
0.1.0
Pre-compiled Snowball stemmers for Elixir. Ships 36 stemming algorithms covering a wide range of natural languages, accessible through a single `Text.Stemmer.stem/2` entry point.
Current section
Files
Jump to
Current section
Files
lib/text/stemmer/stemmers/hungarian.ex
# Generated by Snowball.Generator — do not edit by hand.
defmodule Text.Stemmer.Stemmers.Hungarian do
@moduledoc """
Snowball stemmer for hungarian.
Generated from the canonical Snowball algorithm source.
"""
alias Snowball.Runtime
alias Snowball.Grouping
# Groupings
@g_v Grouping.from_string("aeiouáéÃóöőúüű")
# Among tables
@a_0 [
{"id", -1, 10, nil},
{"aid", 0, 9, nil},
{"jaid", 1, 6, nil},
{"eid", 0, 9, nil},
{"jeid", 3, 6, nil},
{"áid", 0, 7, nil},
{"éid", 0, 8, nil},
{"i", -1, 15, nil},
{"ai", 7, 14, nil},
{"jai", 8, 11, nil},
{"ei", 7, 14, nil},
{"jei", 10, 11, nil},
{"ái", 7, 12, nil},
{"éi", 7, 13, nil},
{"itek", -1, 24, nil},
{"eitek", 14, 21, nil},
{"jeitek", 15, 20, nil},
{"éitek", 14, 23, nil},
{"ik", -1, 29, nil},
{"aik", 18, 26, nil},
{"jaik", 19, 25, nil},
{"eik", 18, 26, nil},
{"jeik", 21, 25, nil},
{"áik", 18, 27, nil},
{"éik", 18, 28, nil},
{"ink", -1, 20, nil},
{"aink", 25, 17, nil},
{"jaink", 26, 16, nil},
{"eink", 25, 17, nil},
{"jeink", 28, 16, nil},
{"áink", 25, 18, nil},
{"éink", 25, 19, nil},
{"aitok", -1, 21, nil},
{"jaitok", 32, 20, nil},
{"áitok", -1, 22, nil},
{"im", -1, 5, nil},
{"aim", 35, 4, nil},
{"jaim", 36, 1, nil},
{"eim", 35, 4, nil},
{"jeim", 38, 1, nil},
{"áim", 35, 2, nil},
{"éim", 35, 3, nil}
]
@a_1 [
{"a", -1, 18, nil},
{"ja", 0, 17, nil},
{"d", -1, 16, nil},
{"ad", 2, 13, nil},
{"ed", 2, 13, nil},
{"od", 2, 13, nil},
{"ád", 2, 14, nil},
{"éd", 2, 15, nil},
{"öd", 2, 13, nil},
{"e", -1, 18, nil},
{"je", 9, 17, nil},
{"nk", -1, 4, nil},
{"unk", 11, 1, nil},
{"ánk", 11, 2, nil},
{"énk", 11, 3, nil},
{"ünk", 11, 1, nil},
{"uk", -1, 8, nil},
{"juk", 16, 7, nil},
{"ájuk", 17, 5, nil},
{"ük", -1, 8, nil},
{"jük", 19, 7, nil},
{"éjük", 20, 6, nil},
{"m", -1, 12, nil},
{"am", 22, 9, nil},
{"em", 22, 9, nil},
{"om", 22, 9, nil},
{"ám", 22, 10, nil},
{"ém", 22, 11, nil},
{"o", -1, 18, nil},
{"á", -1, 19, nil},
{"é", -1, 20, nil}
]
@a_2 [
{"éi", -1, 7, nil},
{"áéi", 0, 6, nil},
{"ééi", 0, 5, nil},
{"é", -1, 9, nil},
{"ké", 3, 4, nil},
{"aké", 4, 1, nil},
{"eké", 4, 1, nil},
{"oké", 4, 1, nil},
{"áké", 4, 3, nil},
{"éké", 4, 2, nil},
{"öké", 4, 1, nil},
{"éé", 3, 8, nil}
]
@a_3 [
{"k", -1, 7, nil},
{"ak", 0, 4, nil},
{"ek", 0, 6, nil},
{"ok", 0, 5, nil},
{"ák", 0, 1, nil},
{"ék", 0, 2, nil},
{"ök", 0, 3, nil}
]
@a_4 [
{"á", -1, 1, nil},
{"é", -1, 2, nil}
]
@a_5 [
{"stul", -1, 2, nil},
{"astul", 0, 1, nil},
{"ástul", 0, 3, nil},
{"stül", -1, 2, nil},
{"estül", 3, 1, nil},
{"éstül", 3, 4, nil}
]
@a_6 [
{"án", -1, 2, nil},
{"én", -1, 1, nil},
{"ánként", -1, 3, nil}
]
@a_7 [
{"ba", -1, -1, nil},
{"ra", -1, -1, nil},
{"be", -1, -1, nil},
{"re", -1, -1, nil},
{"ig", -1, -1, nil},
{"nak", -1, -1, nil},
{"nek", -1, -1, nil},
{"val", -1, -1, nil},
{"vel", -1, -1, nil},
{"ul", -1, -1, nil},
{"ből", -1, -1, nil},
{"ről", -1, -1, nil},
{"től", -1, -1, nil},
{"nál", -1, -1, nil},
{"nél", -1, -1, nil},
{"ból", -1, -1, nil},
{"ról", -1, -1, nil},
{"tól", -1, -1, nil},
{"ül", -1, -1, nil},
{"n", -1, -1, nil},
{"an", 19, -1, nil},
{"ban", 20, -1, nil},
{"en", 19, -1, nil},
{"ben", 22, -1, nil},
{"képpen", 22, -1, nil},
{"on", 19, -1, nil},
{"ön", 19, -1, nil},
{"képp", -1, -1, nil},
{"kor", -1, -1, nil},
{"t", -1, -1, nil},
{"at", 29, -1, nil},
{"et", 29, -1, nil},
{"ként", 29, -1, nil},
{"anként", 32, -1, nil},
{"enként", 32, -1, nil},
{"onként", 32, -1, nil},
{"ot", 29, -1, nil},
{"ért", 29, -1, nil},
{"öt", 29, -1, nil},
{"hez", -1, -1, nil},
{"hoz", -1, -1, nil},
{"höz", -1, -1, nil},
{"vá", -1, -1, nil},
{"vé", -1, -1, nil}
]
@a_8 [
{"al", -1, 1, nil},
{"el", -1, 2, nil}
]
@a_9 [
{"bb", -1, -1, nil},
{"cc", -1, -1, nil},
{"dd", -1, -1, nil},
{"ff", -1, -1, nil},
{"gg", -1, -1, nil},
{"jj", -1, -1, nil},
{"kk", -1, -1, nil},
{"ll", -1, -1, nil},
{"mm", -1, -1, nil},
{"nn", -1, -1, nil},
{"pp", -1, -1, nil},
{"rr", -1, -1, nil},
{"ccs", -1, -1, nil},
{"ss", -1, -1, nil},
{"zzs", -1, -1, nil},
{"tt", -1, -1, nil},
{"vv", -1, -1, nil},
{"ggy", -1, -1, nil},
{"lly", -1, -1, nil},
{"nny", -1, -1, nil},
{"tty", -1, -1, nil},
{"ssz", -1, -1, nil},
{"zz", -1, -1, nil}
]
@a_10 [
{"á", -1, 1, nil},
{"é", -1, 2, nil}
]
@doc """
Stem a word.
### Arguments
* `word` is a UTF-8 binary.
### Returns
* The stemmed UTF-8 binary.
"""
@spec stem(binary()) :: binary()
def stem(word) when is_binary(word) do
state = Runtime.new(word) |> init_vars()
state = run_stem(state)
Runtime.assign_to(state)
end
defp init_vars(state), do: %{state | vars: %{p1: 0}}
defp run_stem(%Runtime{} = state) do
{_, state} = r_stem(state)
state
end
# Snowball runtime helpers.
defp snowball_do_f(state, fun) do
saved_c = state.cursor
{_, s} = fun.(state)
%{s | cursor: saved_c}
end
defp snowball_do_b(state, fun) do
rel = state.limit - state.cursor
{_, s} = fun.(state)
%{s | cursor: s.limit - rel}
end
defp snowball_test_b(state, fun) do
rel = state.limit - state.cursor
case fun.(state) do
{:ok, s} -> {:ok, %{s | cursor: s.limit - rel}}
{:fail, s} -> {:fail, %{s | cursor: s.limit - rel}}
end
end
defp snowball_or(state, fun1, fun2) do
rel = state.limit - state.cursor
case fun1.(state) do
{:ok, s} -> {:ok, s}
{:fail, s} -> fun2.(%{s | cursor: s.limit - rel})
end
end
defp lift(state, :fail), do: {:fail, state}
defp lift(_state, %Runtime{} = s), do: {:ok, s}
defp next_codepoint(%Runtime{cursor: c, limit: lim, current: cur} = state) do
case Runtime.codepoint_at(cur, c, lim) do
{_cp, size} -> {:ok, %{state | cursor: c + size}}
:error -> {:fail, state}
end
end
defp next_codepoint_b(%Runtime{cursor: c, limit_backward: lb, current: cur} = state) do
case Runtime.codepoint_before(cur, c, lb) do
{_cp, size} -> {:ok, %{state | cursor: c - size}}
:error -> {:fail, state}
end
end
defp r_plur_owner(%Runtime{} = state) do
(fn ->
state = %{state | ket: state.cursor}
case Runtime.find_among_b(state, @a_0) do
:fail -> {:fail, state}
{%Runtime{} = s, result} ->
state = %{s | bra: s.cursor}
case (fn state ->
r_R1(state)
end).(state) do
{:ok, state} ->
case result do
1 ->
{:ok, Runtime.slice_del(state)}
2 ->
{:ok, Runtime.slice_from(state, "a")}
3 ->
{:ok, Runtime.slice_from(state, "e")}
4 ->
{:ok, Runtime.slice_del(state)}
5 ->
{:ok, Runtime.slice_del(state)}
6 ->
{:ok, Runtime.slice_del(state)}
7 ->
{:ok, Runtime.slice_from(state, "a")}
8 ->
{:ok, Runtime.slice_from(state, "e")}
9 ->
{:ok, Runtime.slice_del(state)}
10 ->
{:ok, Runtime.slice_del(state)}
11 ->
{:ok, Runtime.slice_del(state)}
12 ->
{:ok, Runtime.slice_from(state, "a")}
13 ->
{:ok, Runtime.slice_from(state, "e")}
14 ->
{:ok, Runtime.slice_del(state)}
15 ->
{:ok, Runtime.slice_del(state)}
16 ->
{:ok, Runtime.slice_del(state)}
17 ->
{:ok, Runtime.slice_del(state)}
18 ->
{:ok, Runtime.slice_from(state, "a")}
19 ->
{:ok, Runtime.slice_from(state, "e")}
20 ->
{:ok, Runtime.slice_del(state)}
21 ->
{:ok, Runtime.slice_del(state)}
22 ->
{:ok, Runtime.slice_from(state, "a")}
23 ->
{:ok, Runtime.slice_from(state, "e")}
24 ->
{:ok, Runtime.slice_del(state)}
25 ->
{:ok, Runtime.slice_del(state)}
26 ->
{:ok, Runtime.slice_del(state)}
27 ->
{:ok, Runtime.slice_from(state, "a")}
28 ->
{:ok, Runtime.slice_from(state, "e")}
29 ->
{:ok, Runtime.slice_del(state)}
_ -> {:ok, state}
end
r -> r
end
end
end).()
end
defp r_sing_owner(%Runtime{} = state) do
(fn ->
state = %{state | ket: state.cursor}
case Runtime.find_among_b(state, @a_1) do
:fail -> {:fail, state}
{%Runtime{} = s, result} ->
state = %{s | bra: s.cursor}
case (fn state ->
r_R1(state)
end).(state) do
{:ok, state} ->
case result do
1 ->
{:ok, Runtime.slice_del(state)}
2 ->
{:ok, Runtime.slice_from(state, "a")}
3 ->
{:ok, Runtime.slice_from(state, "e")}
4 ->
{:ok, Runtime.slice_del(state)}
5 ->
{:ok, Runtime.slice_from(state, "a")}
6 ->
{:ok, Runtime.slice_from(state, "e")}
7 ->
{:ok, Runtime.slice_del(state)}
8 ->
{:ok, Runtime.slice_del(state)}
9 ->
{:ok, Runtime.slice_del(state)}
10 ->
{:ok, Runtime.slice_from(state, "a")}
11 ->
{:ok, Runtime.slice_from(state, "e")}
12 ->
{:ok, Runtime.slice_del(state)}
13 ->
{:ok, Runtime.slice_del(state)}
14 ->
{:ok, Runtime.slice_from(state, "a")}
15 ->
{:ok, Runtime.slice_from(state, "e")}
16 ->
{:ok, Runtime.slice_del(state)}
17 ->
{:ok, Runtime.slice_del(state)}
18 ->
{:ok, Runtime.slice_del(state)}
19 ->
{:ok, Runtime.slice_from(state, "a")}
20 ->
{:ok, Runtime.slice_from(state, "e")}
_ -> {:ok, state}
end
r -> r
end
end
end).()
end
defp r_owned(%Runtime{} = state) do
(fn ->
state = %{state | ket: state.cursor}
case Runtime.find_among_b(state, @a_2) do
:fail -> {:fail, state}
{%Runtime{} = s, result} ->
state = %{s | bra: s.cursor}
case (fn state ->
r_R1(state)
end).(state) do
{:ok, state} ->
case result do
1 ->
{:ok, Runtime.slice_del(state)}
2 ->
{:ok, Runtime.slice_from(state, "e")}
3 ->
{:ok, Runtime.slice_from(state, "a")}
4 ->
{:ok, Runtime.slice_del(state)}
5 ->
{:ok, Runtime.slice_from(state, "e")}
6 ->
{:ok, Runtime.slice_from(state, "a")}
7 ->
{:ok, Runtime.slice_del(state)}
8 ->
{:ok, Runtime.slice_from(state, "e")}
9 ->
{:ok, Runtime.slice_del(state)}
_ -> {:ok, state}
end
r -> r
end
end
end).()
end
defp r_plural(%Runtime{} = state) do
(fn ->
state = %{state | ket: state.cursor}
case Runtime.find_among_b(state, @a_3) do
:fail -> {:fail, state}
{%Runtime{} = s, result} ->
state = %{s | bra: s.cursor}
case (fn state ->
r_R1(state)
end).(state) do
{:ok, state} ->
case result do
1 ->
{:ok, Runtime.slice_from(state, "a")}
2 ->
{:ok, Runtime.slice_from(state, "e")}
3 ->
{:ok, Runtime.slice_del(state)}
4 ->
{:ok, Runtime.slice_del(state)}
5 ->
{:ok, Runtime.slice_del(state)}
6 ->
{:ok, Runtime.slice_del(state)}
7 ->
{:ok, Runtime.slice_del(state)}
_ -> {:ok, state}
end
r -> r
end
end
end).()
end
defp r_factive(%Runtime{} = state) do
case (fn state ->
(fn ->
state = %{state | ket: state.cursor}
case Runtime.find_among_b(state, @a_4) do
:fail -> {:fail, state}
{%Runtime{} = s, result} ->
state = %{s | bra: s.cursor}
case (fn state ->
r_R1(state)
end).(state) do
{:ok, state} ->
case result do
1 ->
r_double(state)
2 ->
r_double(state)
_ -> {:ok, state}
end
r -> r
end
end
end).()
end).(state) do
{:ok, state} ->
case (fn state ->
{:ok, Runtime.slice_del(state)}
end).(state) do
{:ok, state} ->
r_undouble(state)
end
r -> r
end
end
defp r_case_other(%Runtime{} = state) do
(fn ->
state = %{state | ket: state.cursor}
case Runtime.find_among_b(state, @a_5) do
:fail -> {:fail, state}
{%Runtime{} = s, result} ->
state = %{s | bra: s.cursor}
case (fn state ->
r_R1(state)
end).(state) do
{:ok, state} ->
case result do
1 ->
{:ok, Runtime.slice_del(state)}
2 ->
{:ok, Runtime.slice_del(state)}
3 ->
{:ok, Runtime.slice_from(state, "a")}
4 ->
{:ok, Runtime.slice_from(state, "e")}
_ -> {:ok, state}
end
r -> r
end
end
end).()
end
defp r_case_special(%Runtime{} = state) do
(fn ->
state = %{state | ket: state.cursor}
case Runtime.find_among_b(state, @a_6) do
:fail -> {:fail, state}
{%Runtime{} = s, result} ->
state = %{s | bra: s.cursor}
case (fn state ->
r_R1(state)
end).(state) do
{:ok, state} ->
case result do
1 ->
{:ok, Runtime.slice_from(state, "e")}
2 ->
{:ok, Runtime.slice_from(state, "a")}
3 ->
{:ok, Runtime.slice_from(state, "a")}
_ -> {:ok, state}
end
r -> r
end
end
end).()
end
defp r_case(%Runtime{} = state) do
case (fn state ->
(fn ->
state = %{state | ket: state.cursor}
case Runtime.find_among_b(state, @a_7) do
:fail -> {:fail, state}
{%Runtime{} = s, _result} ->
state = %{s | bra: s.cursor}
case (fn state ->
r_R1(state)
end).(state) do
{:ok, state} ->
{:ok, state}
r -> r
end
end
end).()
end).(state) do
{:ok, state} ->
case (fn state ->
{:ok, Runtime.slice_del(state)}
end).(state) do
{:ok, state} ->
r_v_ending(state)
end
r -> r
end
end
defp r_instrum(%Runtime{} = state) do
case (fn state ->
(fn ->
state = %{state | ket: state.cursor}
case Runtime.find_among_b(state, @a_8) do
:fail -> {:fail, state}
{%Runtime{} = s, result} ->
state = %{s | bra: s.cursor}
case (fn state ->
r_R1(state)
end).(state) do
{:ok, state} ->
case result do
1 ->
r_double(state)
2 ->
r_double(state)
_ -> {:ok, state}
end
r -> r
end
end
end).()
end).(state) do
{:ok, state} ->
case (fn state ->
{:ok, Runtime.slice_del(state)}
end).(state) do
{:ok, state} ->
r_undouble(state)
end
r -> r
end
end
defp r_undouble(%Runtime{} = state) do
case (fn state ->
next_codepoint_b(state)
end).(state) do
{:ok, state} ->
case (fn state ->
{:ok, %{state | ket: state.cursor}}
end).(state) do
{:ok, state} ->
case (fn state ->
(fn ->
n = 1
Enum.reduce_while(1..max(n, 0)//1, {:ok, state}, fn _, {:ok, s} ->
case next_codepoint_b(s) do
{:ok, s2} -> {:cont, {:ok, s2}}
{:fail, _} -> {:halt, {:fail, state}}
end
end)
end).()
end).(state) do
{:ok, state} ->
case (fn state ->
{:ok, %{state | bra: state.cursor}}
end).(state) do
{:ok, state} ->
{:ok, Runtime.slice_del(state)}
end
r -> r
end
end
r -> r
end
end
defp r_double(%Runtime{} = state) do
snowball_test_b(state, fn state ->
(fn ->
case Runtime.find_among_b(state, @a_9) do
:fail -> {:fail, state}
{%Runtime{} = s, _} -> {:ok, s}
end
end).()
end)
end
defp r_v_ending(%Runtime{} = state) do
(fn ->
state = %{state | ket: state.cursor}
case Runtime.find_among_b(state, @a_10) do
:fail -> {:fail, state}
{%Runtime{} = s, result} ->
state = %{s | bra: s.cursor}
case (fn state ->
r_R1(state)
end).(state) do
{:ok, state} ->
case result do
1 ->
{:ok, Runtime.slice_from(state, "a")}
2 ->
{:ok, Runtime.slice_from(state, "e")}
_ -> {:ok, state}
end
r -> r
end
end
end).()
end
defp r_R1(%Runtime{} = state) do
if state.vars[:p1] <= state.cursor, do: {:ok, state}, else: {:fail, state}
end
defp r_mark_regions(%Runtime{} = state) do
case (fn state ->
{:ok, put_in(state.vars[:p1], state.limit)}
end).(state) do
{:ok, state} ->
snowball_or(state,
fn state ->
case (fn state ->
lift(state, Runtime.in_grouping(state, @g_v))
end).(state) do
{:ok, state} ->
{:ok, snowball_do_f(state, fn state ->
case (fn state ->
case Runtime.go_in_grouping(state, @g_v) do
:fail -> {:fail, state}
%Runtime{} = s -> next_codepoint(s)
end
end).(state) do
{:ok, state} ->
{:ok, put_in(state.vars[:p1], state.cursor)}
r -> r
end
end)}
r -> r
end
end,
fn state ->
case (fn state ->
case Runtime.go_out_grouping(state, @g_v) do
:fail -> {:fail, state}
%Runtime{} = s -> next_codepoint(s)
end
end).(state) do
{:ok, state} ->
{:ok, put_in(state.vars[:p1], state.cursor)}
r -> r
end
end)
end
end
defp r_stem(%Runtime{} = state) do
case (fn state ->
{:ok, snowball_do_f(state, fn state ->
r_mark_regions(state)
end)}
end).(state) do
{:ok, state} ->
(fn state ->
old_cursor = state.cursor
old_lb = state.limit_backward
state = %{state | cursor: state.limit, limit_backward: old_cursor}
{tag, s} = (fn state ->
case (fn state ->
{:ok, snowball_do_b(state, fn state ->
r_instrum(state)
end)}
end).(state) do
{:ok, state} ->
case (fn state ->
{:ok, snowball_do_b(state, fn state ->
r_case(state)
end)}
end).(state) do
{:ok, state} ->
case (fn state ->
{:ok, snowball_do_b(state, fn state ->
r_case_special(state)
end)}
end).(state) do
{:ok, state} ->
case (fn state ->
{:ok, snowball_do_b(state, fn state ->
r_case_other(state)
end)}
end).(state) do
{:ok, state} ->
case (fn state ->
{:ok, snowball_do_b(state, fn state ->
r_factive(state)
end)}
end).(state) do
{:ok, state} ->
case (fn state ->
{:ok, snowball_do_b(state, fn state ->
r_owned(state)
end)}
end).(state) do
{:ok, state} ->
case (fn state ->
{:ok, snowball_do_b(state, fn state ->
r_sing_owner(state)
end)}
end).(state) do
{:ok, state} ->
case (fn state ->
{:ok, snowball_do_b(state, fn state ->
r_plur_owner(state)
end)}
end).(state) do
{:ok, state} ->
{:ok, snowball_do_b(state, fn state ->
r_plural(state)
end)}
end
end
end
end
end
end
end
end
end).(state)
{tag, %{s | cursor: old_cursor, limit_backward: old_lb}}
end).(state)
end
end
end