**protocol**

`statisticsp`

Statistical calculations over a list of numbers protocol.

**Availability:**

`logtalk_load(statistics(loader))`

**Author:**Paulo Moura

**Version:**1:3:0

**Date:**2022-06-20

**Compilation flags:**

`static`

**Dependencies:**

**Remarks:**

**Inherited public predicates:**

## Public predicates

`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. Fails if the list is empty.

**Compilation flags:**

`static`

**Template:**

`sum(List,Sum)`

**Mode and number of proofs:**

`sum(+list(number),-number)`

- `zero_or_one`

`min/2`

Determines the minimum value in a list of numbers. Fails if the list is empty.

**Compilation flags:**

`static`

**Template:**

`min(List,Minimum)`

**Mode and number of proofs:**

`min(+list,-number)`

- `zero_or_one`

`max/2`

Determines the list maximum value in a list of numbers. Fails if the list is empty.

**Compilation flags:**

`static`

**Template:**

`max(List,Maximum)`

**Mode and number of proofs:**

`max(+list,-number)`

- `zero_or_one`

`min_max/3`

Determines the minimum and maximum values in a list of numbers. 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`

`range/2`

Range is the length of the smallest interval which contains all the numbers in List. Fails if the list is empty.

**Compilation flags:**

`static`

**Template:**

`range(List,Range)`

**Mode and number of proofs:**

`range(+list,-number)`

- `zero_or_one`

`arithmetic_mean/2`

Calculates the arithmetic mean of a list of numbers. Fails if the list is empty.

**Compilation flags:**

`static`

**Template:**

`arithmetic_mean(List,Mean)`

**Mode and number of proofs:**

`arithmetic_mean(+list(number),-float)`

- `zero_or_one`

`geometric_mean/2`

Calculates the geometric mean of a list of numbers. Fails if the list is empty.

**Compilation flags:**

`static`

**Template:**

`geometric_mean(List,Mean)`

**Mode and number of proofs:**

`geometric_mean(+list(number),-float)`

- `zero_or_one`

`harmonic_mean/2`

Calculates the harmonic mean of a list of numbers. Fails if the list is empty.

**Compilation flags:**

`static`

**Template:**

`harmonic_mean(List,Mean)`

**Mode and number of proofs:**

`harmonic_mean(+list(number),-float)`

- `zero_or_one`

`weighted_mean/3`

Calculates the weighted mean of a list of numbers. Fails if the list is empty or if the two lists have different lengths. Wights are assume to be non-negative.

**Compilation flags:**

`static`

**Template:**

`weighted_mean(Weights,List,Mean)`

**Mode and number of proofs:**

`weighted_mean(+list(number),+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`

`average_deviation/3`

Calculates the average absolute deviation of a list of numbers given a central tendency (e.g. mean, median, or mode). Fails if the list is empty.

**Compilation flags:**

`static`

**Template:**

`average_deviation(List,CentralTendency,Deviation)`

**Mode and number of proofs:**

`average_deviation(+list(number),+float,-float)`

- `zero_or_one`

`mean_deviation/2`

Calculates the mean absolute deviation of a list of numbers. Fails if the list is empty.

**Compilation flags:**

`static`

**Template:**

`mean_deviation(List,Deviation)`

**Mode and number of proofs:**

`mean_deviation(+list(number),-float)`

- `zero_or_one`

`median_deviation/2`

Calculates the median absolute deviation of a list of numbers. Fails if the list is empty.

**Compilation flags:**

`static`

**Template:**

`median_deviation(List,Deviation)`

**Mode and number of proofs:**

`median_deviation(+list(number),-float)`

- `zero_or_one`

`standard_deviation/2`

Calculates the standard deviation of a list of numbers. Fails if the list is empty.

**Compilation flags:**

`static`

**Template:**

`standard_deviation(List,Deviation)`

**Mode and number of proofs:**

`standard_deviation(+list(number),-float)`

- `zero_or_one`

`coefficient_of_variation/2`

Calculates the coefficient of variation of a list of numbers. Fails if the list is empty.

**Compilation flags:**

`static`

**Template:**

`coefficient_of_variation(List,Coefficient)`

**Mode and number of proofs:**

`coefficient_of_variation(+list(number),-float)`

- `zero_or_one`

`relative_standard_deviation/2`

Calculates the relative standard deviation of a list of numbers. Fails if the list is empty.

**Compilation flags:**

`static`

**Template:**

`relative_standard_deviation(List,Percentage)`

**Mode and number of proofs:**

`relative_standard_deviation(+list(number),-float)`

- `zero_or_one`

`skewness/2`

Calculates the (moment) skewness of a list of numbers. Fails if the list is empty.

**Compilation flags:**

`static`

**Template:**

`skewness(List,Skewness)`

**Mode and number of proofs:**

`skewness(+list(number),-float)`

- `zero_or_one`

`kurtosis/2`

Calculates the (excess) kurtosis of a list of numbers. Fails if the list is empty.

**Compilation flags:**

`static`

**Template:**

`kurtosis(List,Kurtosis)`

**Mode and number of proofs:**

`kurtosis(+list(number),-float)`

- `zero_or_one`

`variance/2`

Calculates the unbiased variance of a list of numbers. Fails if the list is empty.

**Compilation flags:**

`static`

**Template:**

`variance(List,Variance)`

**Mode and number of proofs:**

`variance(+list(number),-float)`

- `zero_or_one`

`z_normalization/2`

Normalizes a list of number such that for the resulting list the mean of is close to zero and the standard deviation is close to 1. Fails if the list is empty.

**Compilation flags:**

`static`

**Template:**

`z_normalization(List,NormalizedList)`

**Mode and number of proofs:**

`z_normalization(+list(number),-list(float))`

- `zero_or_one`

`fractile/3`

Calculates the smallest value in a list of numbers such that the list elements in its fraction `P`

are less or equal to that value (with `P`

in the open interval `(0.0, 1.0)`

). Fails if the list is empty.

**Compilation flags:**

`static`

**Template:**

`fractile(P,List,Fractile)`

**Mode and number of proofs:**

`fractile(+float,+list(integer),-integer)`

- `zero_or_one`

`fractile(+float,+list(float),-float)`

- `zero_or_one`

`valid/1`

Term is a closed list of numbers.

**Compilation flags:**

`static`

**Template:**

`valid(Term)`

**Mode and number of proofs:**

`valid(@nonvar)`

- `zero_or_one`

## Protected predicates

(none)

## Private predicates

(none)

## Operators

(none)

See also