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)

Public predicates

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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)

See also

numberlist, listp, varlistp