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/polish.ex
# Generated by Snowball.Generator — do not edit by hand.
defmodule Text.Stemmer.Stemmers.Polish do
@moduledoc """
Snowball stemmer for polish.
Generated from the canonical Snowball algorithm source.
"""
alias Snowball.Runtime
alias Snowball.Grouping
# Groupings
@g_v Grouping.from_string("aąeęioóuy")
# Among tables
@a_0 [
{"ń", -1, 2, nil},
{"ć", -1, 1, nil},
{"ś", -1, 3, nil},
{"ź", -1, 4, nil}
]
@a_1 [
{"byście", -1, 1, nil},
{"bym", -1, 1, nil},
{"by", -1, 1, nil},
{"byśmy", -1, 1, nil},
{"byś", -1, 1, nil}
]
@a_2 [
{"ąc", -1, 1, nil},
{"ając", 0, 1, nil},
{"sząc", 0, 2, nil},
{"sz", -1, 1, nil},
{"iejsz", 3, 1, nil}
]
defp a_3 do
[
{"a", -1, 8, fn state -> case r_R1(state) do {:ok, s} -> s; _ -> :fail end end},
{"ąca", 0, 6, nil},
{"ająca", 1, 6, nil},
{"sząca", 1, 7, nil},
{"ia", 0, 8, fn state -> case r_R1(state) do {:ok, s} -> s; _ -> :fail end end},
{"sza", 0, 6, nil},
{"iejsza", 5, 6, nil},
{"ała", 0, 1, nil},
{"iała", 7, 1, nil},
{"iła", 0, 1, nil},
{"ąc", -1, 1, nil},
{"ając", 10, 1, nil},
{"e", -1, 8, fn state -> case r_R1(state) do {:ok, s} -> s; _ -> :fail end end},
{"ące", 12, 6, nil},
{"ające", 13, 6, nil},
{"szące", 13, 7, nil},
{"ie", 12, 8, fn state -> case r_R1(state) do {:ok, s} -> s; _ -> :fail end end},
{"cie", 16, 1, nil},
{"acie", 17, 1, nil},
{"ecie", 17, 1, nil},
{"icie", 17, 1, nil},
{"ajcie", 17, 1, nil},
{"liście", 17, 4, nil},
{"aliście", 22, 1, nil},
{"ieliście", 22, 1, nil},
{"iliście", 22, 1, nil},
{"łyście", 17, 4, nil},
{"ałyście", 26, 1, nil},
{"iałyście", 27, 1, nil},
{"iłyście", 26, 1, nil},
{"sze", 12, 6, nil},
{"iejsze", 30, 6, nil},
{"ach", -1, 8, fn state -> case r_R1(state) do {:ok, s} -> s; _ -> :fail end end},
{"iach", 32, 8, fn state -> case r_R1(state) do {:ok, s} -> s; _ -> :fail end end},
{"ich", -1, 5, nil},
{"ych", -1, 5, nil},
{"i", -1, 8, fn state -> case r_R1(state) do {:ok, s} -> s; _ -> :fail end end},
{"ali", 36, 1, nil},
{"ieli", 36, 1, nil},
{"ili", 36, 1, nil},
{"ami", 36, 8, fn state -> case r_R1(state) do {:ok, s} -> s; _ -> :fail end end},
{"iami", 40, 8, fn state -> case r_R1(state) do {:ok, s} -> s; _ -> :fail end end},
{"imi", 36, 5, nil},
{"ymi", 36, 5, nil},
{"owi", 36, 8, fn state -> case r_R1(state) do {:ok, s} -> s; _ -> :fail end end},
{"iowi", 44, 8, fn state -> case r_R1(state) do {:ok, s} -> s; _ -> :fail end end},
{"aj", -1, 1, nil},
{"ej", -1, 5, nil},
{"iej", 47, 5, nil},
{"am", -1, 1, nil},
{"ałam", 49, 1, nil},
{"iałam", 50, 1, nil},
{"iłam", 49, 1, nil},
{"em", -1, 8, fn state -> case r_R1(state) do {:ok, s} -> s; _ -> :fail end end},
{"iem", 53, 8, fn state -> case r_R1(state) do {:ok, s} -> s; _ -> :fail end end},
{"ałem", 53, 1, nil},
{"iałem", 55, 1, nil},
{"iłem", 53, 1, nil},
{"im", -1, 5, nil},
{"om", -1, 8, fn state -> case r_R1(state) do {:ok, s} -> s; _ -> :fail end end},
{"iom", 59, 8, fn state -> case r_R1(state) do {:ok, s} -> s; _ -> :fail end end},
{"ym", -1, 5, nil},
{"o", -1, 8, fn state -> case r_R1(state) do {:ok, s} -> s; _ -> :fail end end},
{"ego", 62, 5, nil},
{"iego", 63, 5, nil},
{"ało", 62, 1, nil},
{"iało", 65, 1, nil},
{"iło", 62, 1, nil},
{"u", -1, 8, fn state -> case r_R1(state) do {:ok, s} -> s; _ -> :fail end end},
{"iu", 68, 8, fn state -> case r_R1(state) do {:ok, s} -> s; _ -> :fail end end},
{"emu", 68, 5, nil},
{"iemu", 70, 5, nil},
{"ów", -1, 8, fn state -> case r_R1(state) do {:ok, s} -> s; _ -> :fail end end},
{"y", -1, 5, nil},
{"amy", 73, 1, nil},
{"emy", 73, 1, nil},
{"imy", 73, 1, nil},
{"liśmy", 73, 4, nil},
{"aliśmy", 77, 1, nil},
{"ieliśmy", 77, 1, nil},
{"iliśmy", 77, 1, nil},
{"łyśmy", 73, 4, nil},
{"ałyśmy", 81, 1, nil},
{"iałyśmy", 82, 1, nil},
{"iłyśmy", 81, 1, nil},
{"ały", 73, 1, nil},
{"iały", 85, 1, nil},
{"iły", 73, 1, nil},
{"asz", -1, 1, nil},
{"esz", -1, 1, nil},
{"isz", -1, 1, nil},
{"ał", -1, 1, nil},
{"iał", 91, 1, nil},
{"ił", -1, 1, nil},
{"ą", -1, 8, fn state -> case r_R1(state) do {:ok, s} -> s; _ -> :fail end end},
{"ącą", 94, 6, nil},
{"ającą", 95, 6, nil},
{"szącą", 95, 7, nil},
{"ią", 94, 8, fn state -> case r_R1(state) do {:ok, s} -> s; _ -> :fail end end},
{"ają", 94, 1, nil},
{"szą", 94, 3, nil},
{"iejszą", 100, 6, nil},
{"ać", -1, 1, nil},
{"ieć", -1, 1, nil},
{"ić", -1, 1, nil},
{"ąć", -1, 1, nil},
{"aść", -1, 1, nil},
{"eść", -1, 1, nil},
{"ę", -1, 1, nil},
{"szę", 108, 2, nil},
{"łaś", -1, 4, nil},
{"ałaś", 110, 1, nil},
{"iałaś", 111, 1, nil},
{"iłaś", 110, 1, nil},
{"łeś", -1, 4, nil},
{"ałeś", 114, 1, nil},
{"iałeś", 115, 1, nil},
{"iłeś", 114, 1, nil}
]
end
@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_try(state, fun) do
rel = state.limit - state.cursor
case fun.(state) do
{:ok, s} -> s
{:fail, s} -> %{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 r_normalize_consonant(%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 ->
(fn state ->
saved_c = state.cursor
case (fn state ->
if state.cursor <= state.limit_backward, do: {:ok, state}, else: {:fail, state}
end).(state) do
{:ok, s} -> {:fail, %{s | cursor: saved_c}}
{:fail, s} -> {:ok, %{s | cursor: saved_c}}
end
end).(state)
end).(state) do
{:ok, state} ->
case result do
1 ->
{:ok, Runtime.slice_from(state, "c")}
2 ->
{:ok, Runtime.slice_from(state, "n")}
3 ->
{:ok, Runtime.slice_from(state, "s")}
4 ->
{:ok, Runtime.slice_from(state, "z")}
_ -> {:ok, state}
end
r -> r
end
end
end).()
end
defp r_remove_endings(%Runtime{} = state) do
case (fn state ->
{:ok, snowball_do_b(state, fn state ->
(fn ->
old_limit = state.limit_backward
case (fn state ->
(fn ->
target = state.vars[:p1]
if target < state.limit_backward or target > state.limit do
{:fail, state}
else
{:ok, %{state | cursor: target}}
end
end).()
end).(state) do
{:fail, _} -> {:fail, state}
{:ok, limit_state} ->
state = %{state | ket: state.cursor, limit_backward: limit_state.cursor}
case Runtime.find_among_b(state, @a_1) do
:fail -> {:fail, %{state | limit_backward: old_limit}}
{%Runtime{} = s, result} ->
state = %{s | bra: s.cursor, limit_backward: old_limit}
case result do
1 ->
{:ok, Runtime.slice_del(state)}
_ -> {:ok, state}
end
end
end
end).()
end)}
end).(state) do
{:ok, state} ->
case (fn state ->
(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 result do
1 ->
{:ok, Runtime.slice_del(state)}
2 ->
{:ok, Runtime.slice_from(state, "s")}
3 ->
snowball_or(state,
fn state ->
case (fn state ->
snowball_test_b(state, fn state ->
r_R1(state)
end)
end).(state) do
{:ok, state} ->
{:ok, Runtime.slice_del(state)}
r -> r
end
end,
fn state ->
{:ok, Runtime.slice_from(state, "s")}
end)
4 ->
{:ok, Runtime.slice_from(state, "ł")}
5 ->
case (fn state ->
{:ok, Runtime.slice_del(state)}
end).(state) do
{:ok, state} ->
{:ok, snowball_try(state, fn state ->
(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 ->
{:ok, Runtime.slice_del(state)}
2 ->
{:ok, Runtime.slice_from(state, "s")}
_ -> {:ok, state}
end
end
end).()
end)}
end
6 ->
{:ok, Runtime.slice_del(state)}
7 ->
{:ok, Runtime.slice_from(state, "s")}
8 ->
{:ok, Runtime.slice_del(state)}
_ -> {:ok, state}
end
end
end).()
end).(state) do
{:ok, state} ->
{:ok, snowball_try(state, fn state ->
case (fn state ->
{:ok, %{state | ket: state.cursor}}
end).(state) do
{:ok, state} ->
case (fn state ->
lift(state, Runtime.eq_s_b(state, "'"))
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
end)}
r -> r
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} ->
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[:p1], state.cursor)}
r -> r
end
r -> r
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} ->
snowball_or(state,
fn state ->
case (fn state ->
(fn ->
n = 2
Enum.reduce_while(1..max(n, 0)//1, {:ok, state}, fn _, {:ok, s} ->
case next_codepoint(s) do
{:ok, s2} -> {:cont, {:ok, s2}}
{:fail, _} -> {:halt, {:fail, state}}
end
end)
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 ->
r_remove_endings(state)
end).(state)
{tag, %{s | cursor: old_cursor, limit_backward: old_lb}}
end).(state)
r -> r
end
end,
fn 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 ->
r_normalize_consonant(state)
end).(state)
{tag, %{s | cursor: old_cursor, limit_backward: old_lb}}
end).(state)
end)
end
end
end