4.2.3.4. Float FlatZinc builtins

In this section: array_float_element, array_var_float_element, float_abs, float_acos, float_acosh, float_asin, float_asinh, float_atan, float_atanh, float_cos, float_cosh, float_div, float_eq, float_eq_reif, float_exp, float_le, float_le_reif, float_lin_eq, float_lin_eq_reif, float_lin_le, float_lin_le_reif, float_lin_lt, float_lin_lt_reif, float_lin_ne, float_lin_ne_reif, float_ln, float_log10, float_log2, float_lt, float_lt_reif, float_max, float_min, float_ne, float_ne_reif, float_plus, float_pow, float_sin, float_sinh, float_sqrt, float_tan, float_tanh, float_times, int2float.

array_float_element

predicate array_float_element(var int: idx,
                              array [int] of float: xs,
                              var float: y)

Constrains xs[idx] = y

array_var_float_element

predicate array_var_float_element(var int: idx,
                                  array [int] of var float: xs,
                                  var float: y)

Constrains xs[idx] = y

float_abs

predicate float_abs(var float: x, var float: y)

Constrains y to be the absolute value of x

float_acos

predicate float_acos(var float: x, var float: y)

Constrains y = acos(x)

float_acosh

predicate float_acosh(var float: x, var float: y)

Constrains y = acosh(x)

float_asin

predicate float_asin(var float: x, var float: y)

Constrains y = asin(x)

float_asinh

predicate float_asinh(var float: x, var float: y)

Constrains y = asinh(x)

float_atan

predicate float_atan(var float: x, var float: y)

Constrains y = atan(x)

float_atanh

predicate float_atanh(var float: x, var float: y)

Constrains y = atanh(x)

float_cos

predicate float_cos(var float: x, var float: y)

Constrains y = cos(x)

float_cosh

predicate float_cosh(var float: x, var float: y)

Constrains y = cosh(x)

float_div

predicate float_div(var float: x, var float: y, var float: z)

Constrains x / y = z

float_eq

predicate float_eq(var float: x, var float: y)

Constrains x = y

float_eq_reif

predicate float_eq_reif(var float: x, var float: y, var bool: b)

Constrains b \(\leftrightarrow\) (x = y)

float_exp

predicate float_exp(var float: x, var float: y)

Constrains y = exp(x)

float_le

predicate float_le(var float: x, var float: y)

Constrains x ≤ y

float_le_reif

predicate float_le_reif(var float: x, var float: y, var bool: b)

Constrains b \(\leftrightarrow\) (x ≤ y)

float_lin_eq

predicate float_lin_eq(array [int] of float: as,
                       array [int] of var float: xs,
                       float: y)

Constrains \({\bf y} = \sum_i {\bf as}[i]*{\bf xs}[i]\)

float_lin_eq_reif

predicate float_lin_eq_reif(array [int] of float: as,
                            array [int] of var float: xs,
                            float: y,
                            var bool: b)

Constrains \({\bf b} \leftrightarrow ({\bf y} = \sum_i {\bf as}[i]*{\bf xs}[i])\)

float_lin_le

predicate float_lin_le(array [int] of float: as,
                       array [int] of var float: xs,
                       float: y)

Constrains \(\sum_i {\bf as}[i]*{\bf xs}[i] \leq {\bf y}\)

float_lin_le_reif

predicate float_lin_le_reif(array [int] of float: as,
                            array [int] of var float: xs,
                            float: y,
                            var bool: b)

Constrains \({\bf b} \leftrightarrow (\sum_i {\bf as}[i]*{\bf xs}[i] \leq {\bf y})\)

float_lin_lt

predicate float_lin_lt(array [int] of float: as,
                       array [int] of var float: xs,
                       float: y)

Constrains \(\sum_i {\bf as}[i]*{\bf xs}[i] < {\bf y}\)

float_lin_lt_reif

predicate float_lin_lt_reif(array [int] of float: as,
                            array [int] of var float: xs,
                            float: y,
                            var bool: b)

Constrains \({\bf b} \leftrightarrow (\sum_i {\bf as}[i]*{\bf xs}[i] < {\bf y})\)

float_lin_ne

predicate float_lin_ne(array [int] of float: as,
                       array [int] of var float: xs,
                       float: y)

Constrains \({\bf y} \neq \sum_i {\bf as}[i]*{\bf xs}[i]\)

float_lin_ne_reif

predicate float_lin_ne_reif(array [int] of float: as,
                            array [int] of var float: xs,
                            float: y,
                            var bool: b)

Constrains \({\bf b} \leftrightarrow ({\bf y} \neq \sum_i {\bf as}[i]*{\bf xs}[i])\)

float_ln

predicate float_ln(var float: x, var float: y)

Constrains y = ln(x)

float_log10

predicate float_log10(var float: x, var float: y)

Constrains y = log<sub>10</sub>(x)

float_log2

predicate float_log2(var float: x, var float: y)

Constrains y = log<sub>2</sub>(x)

float_lt

predicate float_lt(var float: x, var float: y)

Constrains x < y

float_lt_reif

predicate float_lt_reif(var float: x, var float: y, var bool: b)

Constrains b \(\leftrightarrow\) (x < y)

float_max

predicate float_max(var float: x, var float: y, var float: z)

Constrains max(x, y) = z

float_min

predicate float_min(var float: x, var float: y, var float: z)

Constrains min(x, y) = z

float_ne

predicate float_ne(var float: x, var float: y)

Constrains x ≠ y

float_ne_reif

predicate float_ne_reif(var float: x, var float: y, var bool: b)

Constrains b \(\leftrightarrow\) (x ≠ y)

float_plus

predicate float_plus(var float: x, var float: y, var float: z)

Constrains x + y = z

float_pow

predicate float_pow(var float: x, var float: y, var float: z)

Constrains z = \({\bf x} ^ {{\bf y}}\)

float_sin

predicate float_sin(var float: x, var float: y)

Constrains y = sin(x)

float_sinh

predicate float_sinh(var float: x, var float: y)

Constrains y = sinh(x)

float_sqrt

predicate float_sqrt(var float: x, var float: y)

Constrains \({\bf y} = \sqrt{{\bf x}}\)

float_tan

predicate float_tan(var float: x, var float: y)

Constrains y = tan(x)

float_tanh

predicate float_tanh(var float: x, var float: y)

Constrains y = tanh(x)

float_times

predicate float_times(var float: x, var float: y, var float: z)

Constrains x * y = z

int2float

predicate int2float(var int: x, var float: y)

Constrains y=x