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:
(none)
Remarks:
(none)
Inherited public predicates:
(none)

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

statistics, sample, population