Well, after the mess my last project in Python ended up being, I’m committed this time to make the cleanest code possible.

Before I get any bad habits, I’d appreciate a second set of eyes on the code below.

If you see any bad directions I’m going down, or ways to make the code cleaner, I’d really appreciate being set on the right track now.

(See code in full context below.)

How would I make this code cleaner? (Pipeline operator? Recursion maybe?)

def calc_pyramid_prices_percents(prices, initial_percent) do

    total_column_percent = calc_total_column_percent(prices, initial_percent)
    total_pyramid_percent = calc_total_pyramid_percent(total_column_percent)
    [ initial_price | _ ] = prices
    total_distance = calc_total_distance(prices, initial_price)

    Enum.map(prices, fn(price) -> calc_price_percent(price, initial_price, \
        total_distance, initial_percent, total_pyramid_percent) end)
end

Is there a cleaner way to do this?

def calc_max_initial_percent(prices) do
    inverted_prices = Enum.reverse(prices)
    [d] = Enum.take((calc_pyramid_prices_percents(inverted_prices, 0)), -1) # get last price percent.
    d # Return only the number.
end

Do you see any red flags or better coding practices that should have been followed in the code in full context?

defmodule PyramidCalculator do
    @moduledoc """
    Calculates a price percents adding up to 100 that form a pyramid shape
    based on the relative distance of each price point from the initial price point.

    If initial percent is greater then number of prices / 100, an inverted pyramid is returned.

    ## IMPORTANT
    The first price in the price list must be the highest or lowest price in the list.
    List is returned unsorted.  Sort list ascending or descending order before invoking the pyramid calculator.
    """

    @doc """
    Returns a list of percents for each price point that would look like a pyramid
    based on the relative distance of each price point from the initial price point.
    
    ## Examples:

        ## Normal pyramid example:
        iex> prices = [1, 2, 3]
        iex> initial_percent = 10
        iex> PyramidCalculator.calc_pyramid_prices_percents(prices, initial_percent)
        [10.0, 33.33333333333333, 56.666666666666664]

        ## Inverted pyramid example:
        iex> prices = [1, 2, 3]
        iex> initial_percent = 40
        iex> PyramidCalculator.calc_pyramid_prices_percents(prices, initial_percent)
        [40.0, 33.333333333333336, 26.666666666666668]

        ## Asymentrical pyramid price point distances example:
        iex> prices = [1, 3, 7, 22]
        iex> initial_percent = 5
        iex> PyramidCalculator.calc_pyramid_prices_percents(prices, initial_percent)
        [5.0, 10.517241379310345, 21.551724137931036, 62.93103448275862]

    """
    def calc_pyramid_prices_percents(prices, initial_percent) do

        total_column_percent = calc_total_column_percent(prices, initial_percent)
        total_pyramid_percent = calc_total_pyramid_percent(total_column_percent)
        [ initial_price | _ ] = prices
        total_distance = calc_total_distance(prices, initial_price)

        Enum.map(prices, fn(price) -> calc_price_percent(price, initial_price, \
            total_distance, initial_percent, total_pyramid_percent) end)
    end

    @doc """
    Calculates the maximum the initial percent can be so that the final
    price point percent in the prices list is zero.

    ## Examples:

        iex> prices = [1, 2, 3]
        iex> PyramidCalculator.calc_max_initial_percent(prices)
        66.66666666666666

        iex> prices = [5, 10, 15, 20]
        iex> PyramidCalculator.calc_max_initial_percent(prices)
        50.0
    """
    def calc_max_initial_percent(prices) do
        inverted_prices = Enum.reverse(prices)
        [d] = Enum.take((calc_pyramid_prices_percents(inverted_prices, 0)), -1) # get last price percent.
        d # Return only the number.
    end

    @doc """
    Calculates a perfect column-shaped price percents based on number of price points.

    ## Examples:

        iex> prices = [1, 2, 3]
        iex> PyramidCalculator.calc_column_percent(prices)
        33.333333333333336

        iex> prices = [5, 11, 25, 44]
        iex> PyramidCalculator.calc_column_percent(prices)
        25.0
    """
    def calc_column_percent(prices), do: 100 / Enum.count(prices)

    defp calc_total_column_percent(prices, initial_percent), do: Enum.count(prices) * initial_percent
    
    # In case of an inverted pyramid, returns a negative total.
    # Which means pyramid percent will be subtracted from the
    # total column percent rather then added, on the final 
    # price percent calculation.
    defp calc_total_pyramid_percent(total_column_percent), do: 100 - total_column_percent
    
    defp calc_price_percent(price, initial_price, total_distance, \
        initial_percent, total_pyramid_percent) do
     
        ratio = calc_price_pyramid_ratio(initial_price, price, total_distance)  
        price_pyramid_percent = calc_price_pyramid_percent(ratio, total_pyramid_percent)

        initial_percent + price_pyramid_percent
    end

    defp calc_price_pyramid_ratio(initial_price, price, total_distance),  \
        do: abs(price - initial_price) / total_distance

    defp calc_price_pyramid_percent(ratio, total_pyramid_percent), do: ratio * total_pyramid_percent

    defp calc_total_distance(prices, initial_price), do: _sum_distance(prices, initial_price, 0)
    
    defp _sum_distance([], _initial_price, total_distance), do: total_distance
        
    defp _sum_distance( [ price_head | price_tail ], initial_price, total_distance) do
        _sum_distance(price_tail, initial_price, (total_distance + abs(price_head - initial_price)))
    end
end