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/russian.ex
# Generated by Snowball.Generator — do not edit by hand.
defmodule Text.Stemmer.Stemmers.Russian do
@moduledoc """
Snowball stemmer for russian.
Generated from the canonical Snowball algorithm source.
"""
alias Snowball.Runtime
alias Snowball.Grouping
# Groupings
@g_v Grouping.from_string("аеиоуыэюя")
# Among tables
@a_0 [
{"ейш", -1, 1, nil},
{"ь", -1, 3, nil},
{"ейше", -1, 1, nil},
{"н", -1, 2, nil}
]
@a_1 [
{"ост", -1, 1, nil},
{"ость", -1, 1, nil}
]
@a_2 [
{"у", -1, 1, nil},
{"ях", -1, 1, nil},
{"иях", 1, 1, nil},
{"ах", -1, 1, nil},
{"ы", -1, 1, nil},
{"ь", -1, 1, nil},
{"ю", -1, 1, nil},
{"ью", 6, 1, nil},
{"ию", 6, 1, nil},
{"я", -1, 1, nil},
{"ья", 9, 1, nil},
{"ия", 9, 1, nil},
{"а", -1, 1, nil},
{"ев", -1, 1, nil},
{"ов", -1, 1, nil},
{"е", -1, 1, nil},
{"ье", 15, 1, nil},
{"ие", 15, 1, nil},
{"и", -1, 1, nil},
{"еи", 18, 1, nil},
{"ии", 18, 1, nil},
{"ями", 18, 1, nil},
{"иями", 21, 1, nil},
{"ами", 18, 1, nil},
{"й", -1, 1, nil},
{"ей", 24, 1, nil},
{"ией", 25, 1, nil},
{"ий", 24, 1, nil},
{"ой", 24, 1, nil},
{"ям", -1, 1, nil},
{"иям", 29, 1, nil},
{"ам", -1, 1, nil},
{"ем", -1, 1, nil},
{"ием", 32, 1, nil},
{"ом", -1, 1, nil},
{"о", -1, 1, nil}
]
@a_3 [
{"ыт", -1, 2, nil},
{"ют", -1, 1, nil},
{"уют", 1, 2, nil},
{"ят", -1, 2, nil},
{"ет", -1, 1, nil},
{"ует", 4, 2, nil},
{"ит", -1, 2, nil},
{"ны", -1, 1, nil},
{"ены", 7, 2, nil},
{"ть", -1, 1, nil},
{"ыть", 9, 2, nil},
{"ить", 9, 2, nil},
{"ешь", -1, 1, nil},
{"ишь", -1, 2, nil},
{"ю", -1, 2, nil},
{"ую", 14, 2, nil},
{"ла", -1, 1, nil},
{"ыла", 16, 2, nil},
{"ила", 16, 2, nil},
{"на", -1, 1, nil},
{"ена", 19, 2, nil},
{"ете", -1, 1, nil},
{"ите", -1, 2, nil},
{"йте", -1, 1, nil},
{"уйте", 23, 2, nil},
{"ейте", 23, 2, nil},
{"ли", -1, 1, nil},
{"ыли", 26, 2, nil},
{"или", 26, 2, nil},
{"й", -1, 1, nil},
{"уй", 29, 2, nil},
{"ей", 29, 2, nil},
{"л", -1, 1, nil},
{"ыл", 32, 2, nil},
{"ил", 32, 2, nil},
{"ым", -1, 2, nil},
{"ем", -1, 1, nil},
{"им", -1, 2, nil},
{"н", -1, 1, nil},
{"ен", 38, 2, nil},
{"ло", -1, 1, nil},
{"ыло", 40, 2, nil},
{"ило", 40, 2, nil},
{"но", -1, 1, nil},
{"ено", 43, 2, nil},
{"нно", 43, 1, nil}
]
@a_4 [
{"сь", -1, 1, nil},
{"ся", -1, 1, nil}
]
@a_5 [
{"вш", -1, 1, nil},
{"ывш", 0, 2, nil},
{"ивш", 0, 2, nil},
{"щ", -1, 1, nil},
{"ющ", 3, 1, nil},
{"ующ", 4, 2, nil},
{"ем", -1, 1, nil},
{"нн", -1, 1, nil}
]
@a_6 [
{"ему", -1, 1, nil},
{"ому", -1, 1, nil},
{"ых", -1, 1, nil},
{"их", -1, 1, nil},
{"ую", -1, 1, nil},
{"юю", -1, 1, nil},
{"ею", -1, 1, nil},
{"ою", -1, 1, nil},
{"яя", -1, 1, nil},
{"ая", -1, 1, nil},
{"ые", -1, 1, nil},
{"ее", -1, 1, nil},
{"ие", -1, 1, nil},
{"ое", -1, 1, nil},
{"ыми", -1, 1, nil},
{"ими", -1, 1, nil},
{"ый", -1, 1, nil},
{"ей", -1, 1, nil},
{"ий", -1, 1, nil},
{"ой", -1, 1, nil},
{"ым", -1, 1, nil},
{"ем", -1, 1, nil},
{"им", -1, 1, nil},
{"ом", -1, 1, nil},
{"его", -1, 1, nil},
{"ого", -1, 1, nil}
]
@a_7 [
{"вшись", -1, 1, nil},
{"ывшись", 0, 2, nil},
{"ившись", 0, 2, nil},
{"в", -1, 1, nil},
{"ыв", 3, 2, nil},
{"ив", 3, 2, nil},
{"вши", -1, 1, nil},
{"ывши", 6, 2, nil},
{"ивши", 6, 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: %{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 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_tidy_up(%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 ->
{:ok, Runtime.slice_del(state)}
end).(state) do
{:ok, 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} ->
case (fn state ->
lift(state, Runtime.eq_s_b(state, "н"))
end).(state) do
{:ok, state} ->
{:ok, Runtime.slice_del(state)}
r -> r
end
end
r -> r
end
end
end
2 ->
case (fn state ->
lift(state, Runtime.eq_s_b(state, "н"))
end).(state) do
{:ok, state} ->
{:ok, Runtime.slice_del(state)}
r -> r
end
3 ->
{:ok, Runtime.slice_del(state)}
_ -> {:ok, state}
end
end
end).()
end
defp r_derivational(%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_R2(state)
end).(state) do
{:ok, state} ->
case result do
1 ->
{:ok, Runtime.slice_del(state)}
_ -> {:ok, state}
end
r -> r
end
end
end).()
end
defp r_noun(%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 ->
{:ok, Runtime.slice_del(state)}
_ -> {:ok, state}
end
end
end).()
end
defp r_verb(%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 result do
1 ->
case (fn state ->
snowball_or(state,
fn state ->
lift(state, Runtime.eq_s_b(state, "а"))
end,
fn state ->
lift(state, Runtime.eq_s_b(state, "я"))
end)
end).(state) do
{:ok, state} ->
{:ok, Runtime.slice_del(state)}
r -> r
end
2 ->
{:ok, Runtime.slice_del(state)}
_ -> {:ok, state}
end
end
end).()
end
defp r_reflexive(%Runtime{} = state) do
(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 result do
1 ->
{:ok, Runtime.slice_del(state)}
_ -> {:ok, state}
end
end
end).()
end
defp r_adjectival(%Runtime{} = state) do
case (fn state ->
r_adjective(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_5) do
:fail -> {:fail, state}
{%Runtime{} = s, result} ->
state = %{s | bra: s.cursor}
case result do
1 ->
case (fn state ->
snowball_or(state,
fn state ->
lift(state, Runtime.eq_s_b(state, "а"))
end,
fn state ->
lift(state, Runtime.eq_s_b(state, "я"))
end)
end).(state) do
{:ok, state} ->
{:ok, Runtime.slice_del(state)}
r -> r
end
2 ->
{:ok, Runtime.slice_del(state)}
_ -> {:ok, state}
end
end
end).()
end)}
r -> r
end
end
defp r_adjective(%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 result do
1 ->
{:ok, Runtime.slice_del(state)}
_ -> {:ok, state}
end
end
end).()
end
defp r_perfective_gerund(%Runtime{} = state) do
(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 result do
1 ->
case (fn state ->
snowball_or(state,
fn state ->
lift(state, Runtime.eq_s_b(state, "а"))
end,
fn state ->
lift(state, Runtime.eq_s_b(state, "я"))
end)
end).(state) do
{:ok, state} ->
{:ok, Runtime.slice_del(state)}
r -> r
end
2 ->
{:ok, Runtime.slice_del(state)}
_ -> {: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_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[: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 ->
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
r -> r
end
end
r -> r
end
end)}
end
end
end
defp r_stem(%Runtime{} = state) do
case (fn state ->
{:ok, snowball_do_f(state, fn state ->
(fn loop_fn ->
loop_fn.(loop_fn, state)
end).(fn loop_fn, state ->
case (fn state ->
case (fn state ->
(fn loop_fn ->
loop_fn.(loop_fn, state)
end).(fn loop_fn, state ->
v = state.cursor
case (fn state ->
case (fn state ->
{:ok, %{state | bra: state.cursor}}
end).(state) do
{:ok, state} ->
case (fn state ->
lift(state, Runtime.eq_s(state, "ё"))
end).(state) do
{:ok, state} ->
{:ok, %{state | ket: state.cursor}}
r -> r
end
end
end).(state) do
{:ok, s} -> {:ok, %{s | cursor: v}}
{:fail, _} ->
case next_codepoint(%{state | cursor: v}) do
{:ok, s} -> loop_fn.(loop_fn, s)
{:fail, _} -> {:fail, state}
end
end
end)
end).(state) do
{:ok, state} ->
{:ok, Runtime.slice_from(state, "е")}
r -> r
end
end).(state) do
{:ok, s} -> loop_fn.(loop_fn, s)
{:fail, s} -> {:ok, %{s | cursor: state.cursor}}
end
end)
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 ->
(fn ->
case (fn state ->
(fn ->
target = state.vars[:pV]
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} ->
old_lb = state.limit_backward
state = %{state | limit_backward: limit_state.cursor}
case (fn state ->
case (fn state ->
{:ok, snowball_do_b(state, fn state ->
snowball_or(state,
fn state ->
r_perfective_gerund(state)
end,
fn state ->
case (fn state ->
{:ok, snowball_try(state, fn state ->
r_reflexive(state)
end)}
end).(state) do
{:ok, state} ->
snowball_or(state,
fn state ->
snowball_or(state,
fn state ->
r_adjectival(state)
end,
fn state ->
r_verb(state)
end)
end,
fn state ->
r_noun(state)
end)
end
end)
end)}
end).(state) do
{:ok, state} ->
case (fn 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)}
end).(state) do
{:ok, state} ->
case (fn state ->
{:ok, snowball_do_b(state, fn state ->
r_derivational(state)
end)}
end).(state) do
{:ok, state} ->
{:ok, snowball_do_b(state, fn state ->
r_tidy_up(state)
end)}
end
end
end
end).(state) do
{:ok, s} -> {:ok, %{s | limit_backward: old_lb}}
end
end
end).()
end).(state)
{tag, %{s | cursor: old_cursor, limit_backward: old_lb}}
end).(state)
end
end
end
end