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/irish.ex
# Generated by Snowball.Generator — do not edit by hand.
defmodule Text.Stemmer.Stemmers.Irish do
@moduledoc """
Snowball stemmer for irish.
Generated from the canonical Snowball algorithm source.
"""
alias Snowball.Runtime
alias Snowball.Grouping
# Groupings
@g_v Grouping.from_string("aeiouáéÃóú")
# Among tables
@a_0 [
{"imid", -1, 1, nil},
{"aimid", 0, 1, nil},
{"Ãmid", -1, 1, nil},
{"aÃmid", 2, 1, nil},
{"adh", -1, 2, nil},
{"eadh", 4, 2, nil},
{"faidh", -1, 1, nil},
{"fidh", -1, 1, nil},
{"áil", -1, 2, nil},
{"ain", -1, 2, nil},
{"tear", -1, 2, nil},
{"tar", -1, 2, nil}
]
@a_1 [
{"óideacha", -1, 6, nil},
{"patacha", -1, 5, nil},
{"achta", -1, 1, nil},
{"arcachta", 2, 2, nil},
{"eachta", 2, 1, nil},
{"grafaÃochta", -1, 4, nil},
{"paite", -1, 5, nil},
{"ach", -1, 1, nil},
{"each", 7, 1, nil},
{"óideach", 8, 6, nil},
{"gineach", 8, 3, nil},
{"patach", 7, 5, nil},
{"grafaÃoch", -1, 4, nil},
{"pataigh", -1, 5, nil},
{"óidigh", -1, 6, nil},
{"achtúil", -1, 1, nil},
{"eachtúil", 15, 1, nil},
{"gineas", -1, 3, nil},
{"ginis", -1, 3, nil},
{"acht", -1, 1, nil},
{"arcacht", 19, 2, nil},
{"eacht", 19, 1, nil},
{"grafaÃocht", -1, 4, nil},
{"arcachtaÃ", -1, 2, nil},
{"grafaÃochtaÃ", -1, 4, nil}
]
@a_2 [
{"Ãochta", -1, 1, nil},
{"aÃochta", 0, 1, nil},
{"ire", -1, 2, nil},
{"aire", 2, 2, nil},
{"abh", -1, 1, nil},
{"eabh", 4, 1, nil},
{"ibh", -1, 1, nil},
{"aibh", 6, 1, nil},
{"amh", -1, 1, nil},
{"eamh", 8, 1, nil},
{"imh", -1, 1, nil},
{"aimh", 10, 1, nil},
{"Ãocht", -1, 1, nil},
{"aÃocht", 12, 1, nil},
{"irÃ", -1, 2, nil},
{"airÃ", 14, 2, nil}
]
@a_3 [
{"b'", -1, 4, nil},
{"bh", -1, 14, nil},
{"bhf", 1, 9, nil},
{"bp", -1, 11, nil},
{"ch", -1, 15, nil},
{"d'", -1, 2, nil},
{"d'fh", 5, 3, nil},
{"dh", -1, 16, nil},
{"dt", -1, 13, nil},
{"fh", -1, 17, nil},
{"gc", -1, 7, nil},
{"gh", -1, 18, nil},
{"h-", -1, 1, nil},
{"m'", -1, 4, nil},
{"mb", -1, 6, nil},
{"mh", -1, 19, nil},
{"n-", -1, 1, nil},
{"nd", -1, 8, nil},
{"ng", -1, 10, nil},
{"ph", -1, 20, nil},
{"sh", -1, 5, nil},
{"t-", -1, 1, nil},
{"th", -1, 21, nil},
{"ts", -1, 12, 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, p2: 0, pV: 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 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 r_verb_sfx(%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 result do
1 ->
case (fn state ->
r_RV(state)
end).(state) do
{:ok, state} ->
{:ok, Runtime.slice_del(state)}
r -> r
end
2 ->
case (fn state ->
r_R1(state)
end).(state) do
{:ok, state} ->
{:ok, Runtime.slice_del(state)}
r -> r
end
_ -> {:ok, state}
end
end
end).()
end
defp r_deriv(%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 result do
1 ->
case (fn state ->
r_R2(state)
end).(state) do
{:ok, state} ->
{:ok, Runtime.slice_del(state)}
r -> r
end
2 ->
{:ok, Runtime.slice_from(state, "arc")}
3 ->
{:ok, Runtime.slice_from(state, "gin")}
4 ->
{:ok, Runtime.slice_from(state, "graf")}
5 ->
{:ok, Runtime.slice_from(state, "paite")}
6 ->
{:ok, Runtime.slice_from(state, "óid")}
_ -> {:ok, state}
end
end
end).()
end
defp r_noun_sfx(%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 result do
1 ->
case (fn state ->
r_R1(state)
end).(state) do
{:ok, state} ->
{:ok, Runtime.slice_del(state)}
r -> r
end
2 ->
case (fn state ->
r_R2(state)
end).(state) do
{:ok, state} ->
{:ok, Runtime.slice_del(state)}
r -> r
end
_ -> {:ok, state}
end
end
end).()
end
defp r_R2(%Runtime{} = state) do
if state.vars[:p2] <= state.cursor, do: {:ok, state}, else: {:fail, state}
end
defp r_R1(%Runtime{} = state) do
if state.vars[:p1] <= state.cursor, do: {:ok, state}, else: {:fail, state}
end
defp r_RV(%Runtime{} = state) do
if state.vars[:pV] <= state.cursor, do: {:ok, state}, else: {:fail, state}
end
defp r_mark_regions(%Runtime{} = state) do
case (fn state ->
{:ok, put_in(state.vars[:pV], state.limit)}
end).(state) do
{:ok, state} ->
case (fn state ->
{:ok, put_in(state.vars[:p1], state.limit)}
end).(state) do
{:ok, state} ->
case (fn state ->
{:ok, put_in(state.vars[:p2], state.limit)}
end).(state) do
{:ok, state} ->
{:ok, snowball_do_f(state, 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} ->
case (fn state ->
{:ok, put_in(state.vars[:pV], state.cursor)}
end).(state) do
{:ok, 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} ->
case (fn state ->
{:ok, put_in(state.vars[:p1], state.cursor)}
end).(state) do
{:ok, 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} ->
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[:p2], state.cursor)}
r -> r
end
r -> r
end
end
r -> r
end
end
r -> r
end
end)}
end
end
end
end
defp r_initial_morph(%Runtime{} = state) do
(fn ->
state = %{state | bra: state.cursor}
case Runtime.find_among(state, @a_3) do
:fail -> {:fail, state}
{%Runtime{} = s, result} ->
state = %{s | ket: s.cursor}
case result do
1 ->
{:ok, Runtime.slice_del(state)}
2 ->
{:ok, Runtime.slice_del(state)}
3 ->
{:ok, Runtime.slice_from(state, "f")}
4 ->
{:ok, Runtime.slice_del(state)}
5 ->
{:ok, Runtime.slice_from(state, "s")}
6 ->
{:ok, Runtime.slice_from(state, "b")}
7 ->
{:ok, Runtime.slice_from(state, "c")}
8 ->
{:ok, Runtime.slice_from(state, "d")}
9 ->
{:ok, Runtime.slice_from(state, "f")}
10 ->
{:ok, Runtime.slice_from(state, "g")}
11 ->
{:ok, Runtime.slice_from(state, "p")}
12 ->
{:ok, Runtime.slice_from(state, "s")}
13 ->
{:ok, Runtime.slice_from(state, "t")}
14 ->
{:ok, Runtime.slice_from(state, "b")}
15 ->
{:ok, Runtime.slice_from(state, "c")}
16 ->
{:ok, Runtime.slice_from(state, "d")}
17 ->
{:ok, Runtime.slice_from(state, "f")}
18 ->
{:ok, Runtime.slice_from(state, "g")}
19 ->
{:ok, Runtime.slice_from(state, "m")}
20 ->
{:ok, Runtime.slice_from(state, "p")}
21 ->
{:ok, Runtime.slice_from(state, "t")}
_ -> {:ok, state}
end
end
end).()
end
defp r_stem(%Runtime{} = state) do
case (fn state ->
{:ok, snowball_do_f(state, fn state ->
r_initial_morph(state)
end)}
end).(state) do
{:ok, state} ->
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_noun_sfx(state)
end)}
end).(state) do
{:ok, state} ->
case (fn state ->
{:ok, snowball_do_b(state, fn state ->
r_deriv(state)
end)}
end).(state) do
{:ok, state} ->
{:ok, snowball_do_b(state, fn state ->
r_verb_sfx(state)
end)}
end
end
end).(state)
{tag, %{s | cursor: old_cursor, limit_backward: old_lb}}
end).(state)
end
end
end
end