protocol

# `numberlistp`

List of numbers protocol.

Availability:
`logtalk_load(types(loader))`
Author: Paulo Moura
Version: 1:11:0
Date: 2026-02-23
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`

### `softmax/2`

Computes the softmax of a list of floats, returning a probability distribution.

Compilation flags:
`static`
Template:
`softmax(Floats,Softmax)`
Mode and number of proofs:
`softmax(+list(float),-list(float))` - `one`

### `softmax/3`

Computes the softmax of a list of floats with the given temperature, returning a probability distribution.

Compilation flags:
`static`
Template:
`softmax(Floats,Temperature,Softmax)`
Mode and number of proofs:
`softmax(+list(float),+positive_float,-list(float))` - `one`
Remarks:

> - `Temperature > 1.0`: Makes the distribution more uniform.

> - `Temperature < 1.0`: Makes the distribution more concentrated on the largest values.

> - `Temperature = 1.0`: Standard softmax behavior.

### `linear_regression/4`

Computes the simple linear regression for the given lists of X and Y coordinates, returning the slope and the intercept. Fails if the lists have less than two elements, are not of the same length, or if all X values are the same.

Compilation flags:
`static`
Template:
`linear_regression(Xs,Ys,Slope,Intercept)`
Mode and number of proofs:
`linear_regression(+list(number),+list(number),-float,-float)` - `zero_or_one`

## Protected predicates

(none)

## Private predicates

(none)

## Operators

(none)

See also

numberlist, listp, varlistp