protocol

numberlistp¶

List of numbers protocol.

Author: Paulo Moura
Version: 1.6
Date: 2019/3/2
Compilation flags:
static
Dependencies:
(none)
Remarks:
(none)

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

(none)

(none)

(none)