gelman

-module(gelman@internal@nonempty@transform).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/gelman/internal/nonempty/transform.gleam").
-export([find_winsorization_bounds/3, winsorize/3]).
-export_type([place_holder/0]).

-if(?OTP_RELEASE >= 27).
-define(MODULEDOC(Str), -moduledoc(Str)).
-define(DOC(Str), -doc(Str)).
-else.
-define(MODULEDOC(Str), -compile([])).
-define(DOC(Str), -compile([])).
-endif.

?MODULEDOC(false).

-type place_holder() :: {filled, float()} | unfilled.

-file("src/gelman/internal/nonempty/transform.gleam", 30).
?DOC(false).
-spec find_winsorization_bounds(list({float(), integer()}), float(), float()) -> {float(),
    float()}.
find_winsorization_bounds(Xs, Left, Right) ->
    Filled = begin
        _pipe = Xs,
        _pipe@1 = gelman@internal@helpers:take_pairs(_pipe),
        gleam@list:fold_until(
            _pipe@1,
            {unfilled, unfilled},
            fun(Acc, Tup) -> case Acc of
                    {{filled, X}, {filled, Y}} ->
                        {stop, {{filled, X}, {filled, Y}}};

                    _ ->
                        Xprime = case erlang:element(1, Acc) of
                            {filled, X@1} ->
                                {filled, X@1};

                            unfilled ->
                                case begin
                                    _pipe@2 = Left,
                                    gelman@internal@helpers:lies_between(
                                        _pipe@2,
                                        erlang:element(
                                            2,
                                            erlang:element(1, Tup)
                                        ),
                                        erlang:element(
                                            2,
                                            erlang:element(2, Tup)
                                        )
                                    )
                                end of
                                    true ->
                                        {filled,
                                            erlang:element(
                                                1,
                                                erlang:element(2, Tup)
                                            )};

                                    false ->
                                        unfilled
                                end
                        end,
                        Yprime = case erlang:element(2, Acc) of
                            {filled, X@2} ->
                                {filled, X@2};

                            unfilled ->
                                case begin
                                    _pipe@3 = Right,
                                    gelman@internal@helpers:lies_between(
                                        _pipe@3,
                                        erlang:element(
                                            2,
                                            erlang:element(1, Tup)
                                        ),
                                        erlang:element(
                                            2,
                                            erlang:element(2, Tup)
                                        )
                                    )
                                end of
                                    true ->
                                        {filled,
                                            erlang:element(
                                                1,
                                                erlang:element(1, Tup)
                                            )};

                                    false ->
                                        unfilled
                                end
                        end,
                        {continue, {Xprime, Yprime}}
                end end
        )
    end,
    {X@4, Y@2} = case Filled of
        {{filled, X@3}, {filled, Y@1}} -> {X@3, Y@1};
        _assert_fail ->
            erlang:error(#{gleam_error => let_assert,
                        message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                        file => <<?FILEPATH/utf8>>,
                        module => <<"gelman/internal/nonempty/transform"/utf8>>,
                        function => <<"find_winsorization_bounds"/utf8>>,
                        line => 62,
                        value => _assert_fail,
                        start => 1607,
                        'end' => 1650,
                        pattern_start => 1618,
                        pattern_end => 1641})
    end,
    {X@4, Y@2}.

-file("src/gelman/internal/nonempty/transform.gleam", 7).
?DOC(false).
-spec winsorize(list(float()), float(), float()) -> list(float()).
winsorize(Xs, Left, Right) ->
    N = erlang:length(Xs),
    N_float = erlang:float(N),
    Sortedwithrank = begin
        _pipe = Xs,
        _pipe@1 = gleam@list:sort(_pipe, fun gleam@float:compare/2),
        gleam@list:zip(_pipe@1, gleam@list:range(0, N))
    end,
    Lfrac = gelman@internal@helpers:get_fractional_index(Left, N_float),
    Rfrac = gelman@internal@helpers:get_fractional_index(Right, N_float),
    {Lbound, Rbound} = begin
        _pipe@2 = Sortedwithrank,
        find_winsorization_bounds(_pipe@2, Lfrac, Rfrac)
    end,
    _pipe@3 = Xs,
    gleam@list:map(_pipe@3, fun(X) -> case X of
                X@1 when X@1 < Lbound ->
                    Lbound;

                X@2 when X@2 > Rbound ->
                    Rbound;

                _ ->
                    X
            end end).