| Did you know ... | Search Documentation: |
 | Pack logtalk -- logtalk-3.77.0/docs/_sources/numberlistp_0.rst.txt |
- HOME
- DOWNLOAD
- DOCUMENTATION
- TUTORIALS
- Beginner▶
- Advanced▶
- Web applications▶
- Semantic web▶
- Graphics▶
- Machine learning▶
- External collections▶
- For packagers▶
- COMMUNITY
- COMMERCIAL
- WIKI
.. 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 <numberlist/0>`, :ref:`listp <listp/0>`, :ref:`varlistp <varlistp/0>`