protocol

# `numberlistp`

List of numbers protocol.

Author: Paulo Moura
Version: 1:6:0
Date: 2019-03-02
Compilation flags:
`static`
Dependencies:
(none)
Remarks:
(none)
Inherited public predicates:
(none)

- Public predicates

  - `max/2`

  - `min/2`

  - `product/2`

  - `sum/2`

  - `average/2`

  - `euclidean_norm/2`

  - `chebyshev_norm/2`

  - `manhattan_norm/2`

  - `euclidean_distance/3`

  - `chebyshev_distance/3`

  - `manhattan_distance/3`

  - `scalar_product/3`

  - `normalize_range/2`

  - `normalize_range/4`

  - `normalize_unit/2`

  - `normalize_scalar/2`

  - `rescale/3`

- Protected predicates

- Private predicates

- Operators

## Public predicates

### `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/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`

### `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`

### `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`

## Protected predicates

(none)

## Private predicates

(none)

## Operators

(none)

See also

numberlist, listp, varlistp