4.2.3.4. Float FlatZinc builtins

In this section: array_float_element, array_float_maximum, array_float_minimum, array_var_float_element, float_abs, float_acos, float_acosh, float_asin, float_asinh, float_atan, float_atanh, float_ceil, float_cos, float_cosh, float_div, float_dom, float_eq, float_eq_reif, float_exp, float_floor, float_in, float_in_reif, 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_round, float_sin, float_sinh, float_sqrt, float_tan, float_tanh, float_times, int2float.

array_float_element

predicate array_float_element(var int: b,
                              array [int] of float: as,
                              var float: c)
Constrains as[b] = c

array_float_maximum

predicate array_float_maximum(var int: m, array [int] of var int: x)
Constrains m to be the maximum value of the (non-empty) array x

array_float_minimum

predicate array_float_minimum(var int: m, array [int] of var int: x)
Constrains m to be the minimum value of the (non-empty) array x

array_var_float_element

predicate array_var_float_element(var int: b,
                                  array [int] of var float: as,
                                  var float: c)
Constrains as[b] = c

float_abs

predicate float_abs(var float: a, var float: b)
Constrains b to be the absolute value of a

float_acos

predicate float_acos(var float: a, var float: b)
Constrains b = acos(a)

float_acosh

predicate float_acosh(var float: a, var float: b)
Constrains b = acosh(a)

float_asin

predicate float_asin(var float: a, var float: b)
Constrains b = asin(a)

float_asinh

predicate float_asinh(var float: a, var float: b)
Constrains b = asinh(a)

float_atan

predicate float_atan(var float: a, var float: b)
Constrains b = atan(a)

float_atanh

predicate float_atanh(var float: a, var float: b)
Constrains b = atanh(a)

float_ceil

predicate float_ceil(var float: x, var int: y)
Constrains \({\bf y} = \lceil{ {\bf x}} \rceil\)

float_cos

predicate float_cos(var float: a, var float: b)
Constrains b = cos(a)

float_cosh

predicate float_cosh(var float: a, var float: b)
Constrains b = cosh(a)

float_div

predicate float_div(var float: a, var float: b, var float: c)
Constrains a / b = c

float_dom

predicate float_dom(var float: x, array [int] of float: as)
Constrains the domain of x using the values in as, using each pair of values as[2*i-1]..as[2*i] for i in 1..n/2 as a possible range

float_eq

predicate float_eq(var float: a, var float: b)
Constrains a = b

float_eq_reif

predicate float_eq_reif(var float: a, var float: b, var bool: r)
Constrains r \(\leftrightarrow\) (a = b)

float_exp

predicate float_exp(var float: a, var float: b)
Constrains b = exp(a)

float_floor

predicate float_floor(var float: x, var int: y)
Constrains \({\bf y} = \lfloor{ {\bf x}} \rfloor\)

float_in

predicate float_in(var float: a, float: b, float: c)
Constrains \({\bf a} \in\ [ {\bf b}, {\bf c} ]\)

float_in_reif

predicate float_in_reif(var float: a, float: b, float: c, var bool: r)
Constrains r \(\leftrightarrow\) \({\bf a} \in\ [ {\bf b}, {\bf c} ]\)

float_le

predicate float_le(var float: a, var float: b)
Constrains ab

float_le_reif

predicate float_le_reif(var float: a, var float: b, var bool: r)
Constrains r \(\leftrightarrow\) (ab)

float_lin_eq

predicate float_lin_eq(array [int] of float: as,
                       array [int] of var float: bs,
                       float: c)
Constrains \({\bf c} = \sum_i {\bf as}[i]*{\bf bs}[i]\)

float_lin_eq_reif

predicate float_lin_eq_reif(array [int] of float: as,
                            array [int] of var float: bs,
                            float: c,
                            var bool: r)
Constrains \({\bf r} \leftrightarrow ({\bf c} = \sum_i {\bf as}[i]*{\bf bs}[i])\)

float_lin_le

predicate float_lin_le(array [int] of float: as,
                       array [int] of var float: bs,
                       float: c)
Constrains \(\sum_i {\bf as}[i]*{\bf bs}[i] \leq {\bf c}\)

float_lin_le_reif

predicate float_lin_le_reif(array [int] of float: as,
                            array [int] of var float: bs,
                            float: c,
                            var bool: r)
Constrains \({\bf r} \leftrightarrow (\sum_i {\bf as}[i]*{\bf bs}[i] \leq {\bf c})\)

float_lin_lt

predicate float_lin_lt(array [int] of float: as,
                       array [int] of var float: bs,
                       float: c)
Constrains \(\sum_i {\bf as}[i]*{\bf bs}[i] < {\bf c}\)

float_lin_lt_reif

predicate float_lin_lt_reif(array [int] of float: as,
                            array [int] of var float: bs,
                            float: c,
                            var bool: r)
Constrains \({\bf r} \leftrightarrow (\sum_i {\bf as}[i]*{\bf bs}[i] < {\bf c})\)

float_lin_ne

predicate float_lin_ne(array [int] of float: as,
                       array [int] of var float: bs,
                       float: c)
Constrains \({\bf c} \neq \sum_i {\bf as}[i]*{\bf bs}[i]\)

float_lin_ne_reif

predicate float_lin_ne_reif(array [int] of float: as,
                            array [int] of var float: bs,
                            float: c,
                            var bool: r)
Constrains \({\bf r} \leftrightarrow ({\bf c} \neq \sum_i {\bf as}[i]*{\bf bs}[i])\)

float_ln

predicate float_ln(var float: a, var float: b)
Constrains b = ln(a)

float_log10

predicate float_log10(var float: a, var float: b)
Constrains b = log<sub>10</sub>(a)

float_log2

predicate float_log2(var float: a, var float: b)
Constrains b = log<sub>2</sub>(a)

float_lt

predicate float_lt(var float: a, var float: b)
Constrains a < b

float_lt_reif

predicate float_lt_reif(var float: a, var float: b, var bool: r)
Constrains r \(\leftrightarrow\) (a < b)

float_max

predicate float_max(var float: a, var float: b, var float: c)
Constrains max(a, b) = c

float_min

predicate float_min(var float: a, var float: b, var float: c)
Constrains min(a, b) = c

float_ne

predicate float_ne(var float: a, var float: b)
Constrains ab

float_ne_reif

predicate float_ne_reif(var float: a, var float: b, var bool: r)
Constrains r \(\leftrightarrow\) (ab)

float_plus

predicate float_plus(var float: a, var float: b, var float: c)
Constrains a + b = c

float_pow

predicate float_pow(var float: x, var float: y, var float: z)
Constrains z = \({\bf x} ^ {{\bf y}}\)

float_round

predicate float_round(var float: x, var int: y)
Constrains that y is the nearest integer to x

float_sin

predicate float_sin(var float: a, var float: b)
Constrains b = sin(a)

float_sinh

predicate float_sinh(var float: a, var float: b)
Constrains b = sinh(a)

float_sqrt

predicate float_sqrt(var float: a, var float: b)
Constrains \({\bf b} = \sqrt{{\bf a}}\)

float_tan

predicate float_tan(var float: a, var float: b)
Constrains b = tan(a)

float_tanh

predicate float_tanh(var float: a, var float: b)
Constrains b = tanh(a)

float_times

predicate float_times(var float: a, var float: b, var float: c)
Constrains a * b = c

int2float

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