.. index:: numberlistp .. _numberlistp/0: .. rst-class:: right **protocol** ``numberlistp`` =============== List of numbers protocol. | **Availability:** | ``logtalk_load(types(loader))`` | **Author:** Paulo Moura | **Version:** 1:9:0 | **Date:** 2023-12-10 | **Compilation flags:** | ``static`` | **Dependencies:** | (none) | **Remarks:** | (none) | **Inherited public predicates:** | (none) .. contents:: :local: :backlinks: top Public predicates ----------------- .. index:: min/2 .. _numberlistp/0::min/2: ``min/2`` ^^^^^^^^^ Determines the minimum value in a list using arithmetic order. Fails if the list is empty. | **Compilation flags:** | ``static`` | **Template:** | ``min(List,Minimum)`` | **Mode and number of proofs:** | ``min(+list(number),-number)`` - ``zero_or_one`` ------------ .. index:: max/2 .. _numberlistp/0::max/2: ``max/2`` ^^^^^^^^^ Determines the list maximum value using arithmetic order. Fails if the list is empty. | **Compilation flags:** | ``static`` | **Template:** | ``max(List,Maximum)`` | **Mode and number of proofs:** | ``max(+list(number),-number)`` - ``zero_or_one`` ------------ .. index:: min_max/3 .. _numberlistp/0::min_max/3: ``min_max/3`` ^^^^^^^^^^^^^ Determines the minimum and maximum values in a list using arithmetic order. Fails if the list is empty. | **Compilation flags:** | ``static`` | **Template:** | ``min_max(List,Minimum,Maximum)`` | **Mode and number of proofs:** | ``min_max(+list(number),-number,-number)`` - ``zero_or_one`` ------------ .. index:: product/2 .. _numberlistp/0::product/2: ``product/2`` ^^^^^^^^^^^^^ Calculates the product of all list numbers. Fails if the list is empty. | **Compilation flags:** | ``static`` | **Template:** | ``product(List,Product)`` | **Mode and number of proofs:** | ``product(+list(number),-number)`` - ``zero_or_one`` ------------ .. index:: sum/2 .. _numberlistp/0::sum/2: ``sum/2`` ^^^^^^^^^ Calculates the sum of all list numbers. Returns the integer zero if the list is empty. | **Compilation flags:** | ``static`` | **Template:** | ``sum(List,Sum)`` | **Mode and number of proofs:** | ``sum(+list(number),-number)`` - ``one`` ------------ .. index:: average/2 .. _numberlistp/0::average/2: ``average/2`` ^^^^^^^^^^^^^ Calculates the average (i.e., arithmetic mean) of a list of numbers. Fails if the list is empty. | **Compilation flags:** | ``static`` | **Template:** | ``average(List,Average)`` | **Mode and number of proofs:** | ``average(+list(number),-float)`` - ``zero_or_one`` ------------ .. index:: median/2 .. _numberlistp/0::median/2: ``median/2`` ^^^^^^^^^^^^ Calculates the median of a list of numbers. Fails if the list is empty. | **Compilation flags:** | ``static`` | **Template:** | ``median(List,Median)`` | **Mode and number of proofs:** | ``median(+list(number),-float)`` - ``zero_or_one`` ------------ .. index:: modes/2 .. _numberlistp/0::modes/2: ``modes/2`` ^^^^^^^^^^^ Returns the list of modes of a list of numbers in ascending order. Fails if the list is empty. | **Compilation flags:** | ``static`` | **Template:** | ``modes(List,Modes)`` | **Mode and number of proofs:** | ``modes(+list(number),-list(number))`` - ``zero_or_one`` ------------ .. index:: euclidean_norm/2 .. _numberlistp/0::euclidean_norm/2: ``euclidean_norm/2`` ^^^^^^^^^^^^^^^^^^^^ Calculates the Euclidean norm of a list of numbers. Fails if the list is empty. | **Compilation flags:** | ``static`` | **Template:** | ``euclidean_norm(List,Norm)`` | **Mode and number of proofs:** | ``euclidean_norm(+list(number),-float)`` - ``zero_or_one`` ------------ .. index:: chebyshev_norm/2 .. _numberlistp/0::chebyshev_norm/2: ``chebyshev_norm/2`` ^^^^^^^^^^^^^^^^^^^^ Calculates the Chebyshev norm of a list of numbers. Fails if the list is empty. | **Compilation flags:** | ``static`` | **Template:** | ``chebyshev_norm(List,Norm)`` | **Mode and number of proofs:** | ``chebyshev_norm(+list(integer),-integer)`` - ``zero_or_one`` | ``chebyshev_norm(+list(float),-float)`` - ``zero_or_one`` ------------ .. index:: manhattan_norm/2 .. _numberlistp/0::manhattan_norm/2: ``manhattan_norm/2`` ^^^^^^^^^^^^^^^^^^^^ Calculates the Manhattan norm of a list of numbers. Fails if the list is empty. | **Compilation flags:** | ``static`` | **Template:** | ``manhattan_norm(List,Norm)`` | **Mode and number of proofs:** | ``manhattan_norm(+list(integer),-integer)`` - ``zero_or_one`` | ``manhattan_norm(+list(float),-float)`` - ``zero_or_one`` ------------ .. index:: euclidean_distance/3 .. _numberlistp/0::euclidean_distance/3: ``euclidean_distance/3`` ^^^^^^^^^^^^^^^^^^^^^^^^ Calculates the Euclidean distance between two lists of numbers. Fails if the two lists are empty or not of the same length. | **Compilation flags:** | ``static`` | **Template:** | ``euclidean_distance(List1,List2,Distance)`` | **Mode and number of proofs:** | ``euclidean_distance(+list(number),+list(number),-float)`` - ``zero_or_one`` ------------ .. index:: chebyshev_distance/3 .. _numberlistp/0::chebyshev_distance/3: ``chebyshev_distance/3`` ^^^^^^^^^^^^^^^^^^^^^^^^ Calculates the Chebyshev distance between two lists of numbers. Fails if the two lists are empty or not of the same length. | **Compilation flags:** | ``static`` | **Template:** | ``chebyshev_distance(List1,List2,Distance)`` | **Mode and number of proofs:** | ``chebyshev_distance(+list(integer),+list(integer),-integer)`` - ``zero_or_one`` | ``chebyshev_distance(+list(float),+list(float),-float)`` - ``zero_or_one`` ------------ .. index:: manhattan_distance/3 .. _numberlistp/0::manhattan_distance/3: ``manhattan_distance/3`` ^^^^^^^^^^^^^^^^^^^^^^^^ Calculates the Manhattan distance between two lists of numbers. Fails if the two lists are empty or not of the same length. | **Compilation flags:** | ``static`` | **Template:** | ``manhattan_distance(List1,List2,Distance)`` | **Mode and number of proofs:** | ``manhattan_distance(+list(integer),+list(integer),-integer)`` - ``zero_or_one`` | ``manhattan_distance(+list(float),+list(float),-float)`` - ``zero_or_one`` ------------ .. index:: scalar_product/3 .. _numberlistp/0::scalar_product/3: ``scalar_product/3`` ^^^^^^^^^^^^^^^^^^^^ Calculates the scalar product of two lists of numbers. Fails if the two lists are empty or not of the same length. | **Compilation flags:** | ``static`` | **Template:** | ``scalar_product(List1,List2,Product)`` | **Mode and number of proofs:** | ``scalar_product(+list(integer),+list(integer),-integer)`` - ``zero_or_one`` | ``scalar_product(+list(float),+list(float),-float)`` - ``zero_or_one`` ------------ .. index:: normalize_range/2 .. _numberlistp/0::normalize_range/2: ``normalize_range/2`` ^^^^^^^^^^^^^^^^^^^^^ Normalizes a list of numbers into the ``[0.0,1.0]`` range. Caller must handle arithmetic exceptions if the input list if not normalizable. | **Compilation flags:** | ``static`` | **Template:** | ``normalize_range(List,NormalizedList)`` | **Mode and number of proofs:** | ``normalize_range(+list(number),-list(float))`` - ``one`` ------------ .. index:: normalize_range/4 .. _numberlistp/0::normalize_range/4: ``normalize_range/4`` ^^^^^^^^^^^^^^^^^^^^^ Normalizes a list of numbers into the given range. Caller must handle arithmetic exceptions if the input list if not normalizable. | **Compilation flags:** | ``static`` | **Template:** | ``normalize_range(List,Minimum,Maximum,NormalizedList)`` | **Mode and number of proofs:** | ``normalize_range(+list(number),+number,+number,-list(float))`` - ``one`` ------------ .. index:: normalize_unit/2 .. _numberlistp/0::normalize_unit/2: ``normalize_unit/2`` ^^^^^^^^^^^^^^^^^^^^ Normalizes a list of numbers returning its unit vector (i.e., a list with Euclidean norm equal to one). Caller must handle arithmetic exceptions if the input list if not normalizable. | **Compilation flags:** | ``static`` | **Template:** | ``normalize_unit(List,NormalizedList)`` | **Mode and number of proofs:** | ``normalize_unit(+list(number),-list(float))`` - ``one`` ------------ .. index:: normalize_scalar/2 .. _numberlistp/0::normalize_scalar/2: ``normalize_scalar/2`` ^^^^^^^^^^^^^^^^^^^^^^ Normalizes a list of numbers such that the sum of all numbers is equal to one. Caller must handle arithmetic exceptions if the input list if not normalizable. | **Compilation flags:** | ``static`` | **Template:** | ``normalize_scalar(List,NormalizedList)`` | **Mode and number of proofs:** | ``normalize_scalar(+list(number),-list(float))`` - ``one`` ------------ .. index:: rescale/3 .. _numberlistp/0::rescale/3: ``rescale/3`` ^^^^^^^^^^^^^ Rescales all numbers in a list by the given factor. | **Compilation flags:** | ``static`` | **Template:** | ``rescale(List,Factor,RescaledList)`` | **Mode and number of proofs:** | ``rescale(+list(integer),+integer,-list(integer))`` - ``one`` | ``rescale(+list(number),+float,-list(float))`` - ``one`` ------------ .. index:: least_common_multiple/2 .. _numberlistp/0::least_common_multiple/2: ``least_common_multiple/2`` ^^^^^^^^^^^^^^^^^^^^^^^^^^^ Computes the least common multiple of a list of two or more positive integers. Fails if the list is empty or contains a single element. Fails also if any of the elements is zero. May require backend support for unbound integer arithmetic. | **Compilation flags:** | ``static`` | **Template:** | ``least_common_multiple(Integers,LeastCommonMultiple)`` | **Mode and number of proofs:** | ``least_common_multiple(+list(positive_integer),-positive_integer)`` - ``zero_or_one`` ------------ Protected predicates -------------------- (none) Private predicates ------------------ (none) Operators --------- (none) .. seealso:: :ref:`numberlist `, :ref:`listp `, :ref:`varlistp `