gleam_stats

-module(gleam_stats@distributions@triangular).
-compile(no_auto_import).

-export([triangular_mean/3, triangular_variance/3, triangular_pdf/4, triangular_cdf/4, triangular_random/5]).

-spec check_triangular_parameters(float(), float(), float()) -> {ok, boolean()} |
    {error, binary()}.
check_triangular_parameters(A, B, C) ->
    case A =< B of
        false ->
            _pipe = <<"Invalid input arugment: a > b. Valid input is a <= b."/utf8>>,
            {error, _pipe};

        true ->
            case A =< C of
                false ->
                    _pipe@1 = <<"Invalid input argument: a > c. Valid input is a <= c <= b."/utf8>>,
                    {error, _pipe@1};

                true ->
                    case C =< B of
                        false ->
                            _pipe@2 = <<"Invalid input argument: c > b. Valid input is a <= c <= b."/utf8>>,
                            {error, _pipe@2};

                        true ->
                            _pipe@3 = true,
                            {ok, _pipe@3}
                    end
            end
    end.

-spec triangular_mean(float(), float(), float()) -> {ok, float()} |
    {error, binary()}.
triangular_mean(A, B, C) ->
    case check_triangular_parameters(A, B, C) of
        {error, String} ->
            _pipe = String,
            {error, _pipe};

        _@1 ->
            _pipe@1 = ((A + B) + C) / 3.0,
            {ok, _pipe@1}
    end.

-spec triangular_variance(float(), float(), float()) -> {ok, float()} |
    {error, binary()}.
triangular_variance(A, B, C) ->
    case check_triangular_parameters(A, B, C) of
        {error, String} ->
            _pipe = String,
            {error, _pipe};

        _@1 ->
            _pipe@1 = (((((gleam@float:power(A, 2.0) + gleam@float:power(B, 2.0)) + gleam@float:power(
                C,
                2.0
            )) - (A * B)) - (A * C)) - (B * C)) / 18.0,
            {ok, _pipe@1}
    end.

-spec triangular_pdf(float(), float(), float(), float()) -> {ok, float()} |
    {error, binary()}.
triangular_pdf(X, A, B, C) ->
    case check_triangular_parameters(A, B, C) of
        {error, String} ->
            _pipe = String,
            {error, _pipe};

        _@1 ->
            case X < A of
                true ->
                    _pipe@1 = 0.0,
                    {ok, _pipe@1};

                false ->
                    case (A =< X) andalso (X < C) of
                        true ->
                            _pipe@2 = case ((B - A) * (C - A)) of
                                0.0 -> 0.0;
                                Gleam@denominator -> (2.0 * (X - A)) / Gleam@denominator
                            end,
                            {ok, _pipe@2};

                        false ->
                            case X =:= C of
                                true ->
                                    _pipe@3 = case (B - A) of
                                        0.0 -> 0.0;
                                        Gleam@denominator@1 -> 2.0 / Gleam@denominator@1
                                    end,
                                    {ok, _pipe@3};

                                false ->
                                    case (C < X) andalso (X =< B) of
                                        true ->
                                            _pipe@4 = case ((B - A) * (B - C)) of
                                                0.0 -> 0.0;
                                                Gleam@denominator@2 -> (2.0 * (B - X)) / Gleam@denominator@2
                                            end,
                                            {ok, _pipe@4};

                                        false ->
                                            _pipe@5 = 0.0,
                                            {ok, _pipe@5}
                                    end
                            end
                    end
            end
    end.

-spec triangular_cdf(float(), float(), float(), float()) -> {ok, float()} |
    {error, binary()}.
triangular_cdf(X, A, B, C) ->
    case check_triangular_parameters(A, B, C) of
        {error, String} ->
            _pipe = String,
            {error, _pipe};

        _@1 ->
            case X =< A of
                true ->
                    _pipe@1 = 0.0,
                    {ok, _pipe@1};

                false ->
                    case (A < X) andalso (X =< C) of
                        true ->
                            _pipe@2 = case ((B - A) * (C - A)) of
                                0.0 -> 0.0;
                                Gleam@denominator -> gleam@float:power(
                                    X
                                    - A,
                                    2.0
                                ) / Gleam@denominator
                            end,
                            {ok, _pipe@2};

                        false ->
                            case (C < X) andalso (X < B) of
                                true ->
                                    _pipe@3 = 1.0 - (case ((B - A) * (B - C)) of
                                        0.0 -> 0.0;
                                        Gleam@denominator@1 -> gleam@float:power(
                                            B
                                            - X,
                                            2.0
                                        ) / Gleam@denominator@1
                                    end),
                                    {ok, _pipe@3};

                                false ->
                                    _pipe@4 = 1.0,
                                    {ok, _pipe@4}
                            end
                    end
            end
    end.

-spec triangular_random(
    gleam@iterator:iterator(integer()),
    float(),
    float(),
    float(),
    integer()
) -> {ok, {list(float()), gleam@iterator:iterator(integer())}} |
    {error, binary()}.
triangular_random(Stream, A, B, C, M) ->
    case check_triangular_parameters(A, B, C) of
        {error, String} ->
            {error, String};

        _@1 ->
            case M > 0 of
                false ->
                    {error,
                     <<"Invalid input arugment: m < 0. Valid input is m > 0."/utf8>>};

                true ->
                    Eval = case (B - A) of
                        0.0 -> 0.0;
                        Gleam@denominator -> (C - A) / Gleam@denominator
                    end,
                    {ok, Out@1} = case gleam_stats@distributions@uniform:uniform_random(
                        Stream,
                        0.0,
                        1.0,
                        M
                    ) of
                        {ok, Out} -> {ok, Out};
                        _try ->
                            erlang:error(#{gleam_error => assert,
                                           message => <<"Assertion pattern match failed"/utf8>>,
                                           value => _try,
                                           module => <<"gleam_stats/distributions/triangular"/utf8>>,
                                           function => <<"triangular_random"/utf8>>,
                                           line => 306})
                    end,
                    Numbers = begin
                        _pipe = gleam@pair:first(Out@1),
                        gleam@list:map(_pipe, fun(X) -> case X < Eval of
                                    true ->
                                        A + gleam@float:power(
                                            (X
                                            * (B
                                            - A))
                                            * (B
                                            - C),
                                            0.5
                                        );

                                    false ->
                                        B - gleam@float:power(
                                            ((1.0
                                            - X)
                                            * (B
                                            - A))
                                            * (B
                                            - C),
                                            0.5
                                        )
                                end end)
                    end,
                    _pipe@1 = {Numbers, gleam@pair:second(Out@1)},
                    {ok, _pipe@1}
            end
    end.