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 ->
            {ok, V1@1} = case gleam_stats@math:pow(A, 2.0) of
                {ok, V1} -> {ok, V1};
                _try ->
                    erlang:error(#{gleam_error => assert,
                                   message => <<"Assertion pattern match failed"/utf8>>,
                                   value => _try,
                                   module => <<"gleam_stats/distributions/triangular"/utf8>>,
                                   function => <<"triangular_variance"/utf8>>,
                                   line => 109})
            end,
            {ok, V2@1} = case gleam_stats@math:pow(B, 2.0) of
                {ok, V2} -> {ok, V2};
                _try@1 ->
                    erlang:error(#{gleam_error => assert,
                                   message => <<"Assertion pattern match failed"/utf8>>,
                                   value => _try@1,
                                   module => <<"gleam_stats/distributions/triangular"/utf8>>,
                                   function => <<"triangular_variance"/utf8>>,
                                   line => 110})
            end,
            {ok, V3@1} = case gleam_stats@math:pow(C, 2.0) of
                {ok, V3} -> {ok, V3};
                _try@2 ->
                    erlang:error(#{gleam_error => assert,
                                   message => <<"Assertion pattern match failed"/utf8>>,
                                   value => _try@2,
                                   module => <<"gleam_stats/distributions/triangular"/utf8>>,
                                   function => <<"triangular_variance"/utf8>>,
                                   line => 111})
            end,
            _pipe@1 = (((((V1@1 + V2@1) + V3@1) - (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) ->
    do_triangular_pdf(X, A, B, C).

-spec do_triangular_pdf(float(), float(), float(), float()) -> {ok, float()} |
    {error, binary()}.
do_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) ->
    do_triangular_cdf(X, A, B, C).

-spec do_triangular_cdf(float(), float(), float(), float()) -> {ok, float()} |
    {error, binary()}.
do_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 ->
                            {ok, V@1} = case gleam_stats@math:pow(X - A, 2.0) of
                                {ok, V} -> {ok, V};
                                _try ->
                                    erlang:error(#{gleam_error => assert,
                                                   message => <<"Assertion pattern match failed"/utf8>>,
                                                   value => _try,
                                                   module => <<"gleam_stats/distributions/triangular"/utf8>>,
                                                   function => <<"do_triangular_cdf"/utf8>>,
                                                   line => 302})
                            end,
                            _pipe@2 = case ((B - A) * (C - A)) of
                                0.0 -> 0.0;
                                Gleam@denominator -> V@1 / Gleam@denominator
                            end,
                            {ok, _pipe@2};

                        false ->
                            case (C < X) andalso (X < B) of
                                true ->
                                    {ok, V@3} = case gleam_stats@math:pow(
                                        B
                                        - X,
                                        2.0
                                    ) of
                                        {ok, V@2} -> {ok, V@2};
                                        _try@1 ->
                                            erlang:error(
                                                    #{gleam_error => assert,
                                                      message => <<"Assertion pattern match failed"/utf8>>,
                                                      value => _try@1,
                                                      module => <<"gleam_stats/distributions/triangular"/utf8>>,
                                                      function => <<"do_triangular_cdf"/utf8>>,
                                                      line => 309}
                                                )
                                    end,
                                    _pipe@3 = 1.0 - (case ((B - A) * (B - C)) of
                                        0.0 -> 0.0;
                                        Gleam@denominator@1 -> V@3 / 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) ->
    do_triangular_random(Stream, A, B, C, M).

-spec do_triangular_random(
    gleam@iterator:iterator(integer()),
    float(),
    float(),
    float(),
    integer()
) -> {ok, {list(float()), gleam@iterator:iterator(integer())}} |
    {error, binary()}.
do_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 => <<"do_triangular_random"/utf8>>,
                                           line => 402})
                    end,
                    Numbers = begin
                        _pipe = gleam@pair:first(Out@1),
                        gleam@list:map(_pipe, fun(X) -> case X < Eval of
                                    true ->
                                        {ok, V@1} = case gleam_stats@math:pow(
                                            (X
                                            * (B
                                            - A))
                                            * (B
                                            - C),
                                            0.5
                                        ) of
                                            {ok, V} -> {ok, V};
                                            _try@1 ->
                                                erlang:error(
                                                        #{gleam_error => assert,
                                                          message => <<"Assertion pattern match failed"/utf8>>,
                                                          value => _try@1,
                                                          module => <<"gleam_stats/distributions/triangular"/utf8>>,
                                                          function => <<"do_triangular_random"/utf8>>,
                                                          line => 410}
                                                    )
                                        end,
                                        A + V@1;

                                    false ->
                                        {ok, V@3} = case gleam_stats@math:pow(
                                            ((1.0
                                            - X)
                                            * (B
                                            - A))
                                            * (B
                                            - C),
                                            0.5
                                        ) of
                                            {ok, V@2} -> {ok, V@2};
                                            _try@2 ->
                                                erlang:error(
                                                        #{gleam_error => assert,
                                                          message => <<"Assertion pattern match failed"/utf8>>,
                                                          value => _try@2,
                                                          module => <<"gleam_stats/distributions/triangular"/utf8>>,
                                                          function => <<"do_triangular_random"/utf8>>,
                                                          line => 414}
                                                    )
                                        end,
                                        B - V@3
                                end end)
                    end,
                    _pipe@1 = {Numbers, gleam@pair:second(Out@1)},
                    {ok, _pipe@1}
            end
    end.