Test::Float::Arithmetic Namespace Reference

Tests for arithmetic constraints More...

## Classes

class | MultXYZ
| Test for multiplication constraint More...
class | MultXYZSol
| Test for multiplication constraint when solution is ensured More...
class | MultXXY
| Test for multiplication constraint with shared variables More...
class | MultXXYSol
| Test for multiplication constraint with shared variables when solution is ensured More...
class | MultXYX
| Test for multiplication constraint with shared variables More...
class | MultXYY
| Test for multiplication constraint with shared variables More...
class | MultXXX
| Test for multiplication constraint with shared variables More...
class | Div
| Test for division constraint More...
class | DivSol
| Test for division constraint when solution is ensured More...
class | SqrXY
| Test for squaring constraint More...
class | SqrXYSol
| Test for squaring constraint where solution is ensured More...
class | SqrXX
| Test for squaring constraint with shared variables More...
class | SqrtXY
| Test for square root constraint More...
class | SqrtXYSol
| Test for square root constraint where solution is ensured More...
class | SqrtXX
| Test for square root constraint with shared variables More...
class | PowXY
| Test for pow constraint More...
class | PowXYSol
| Test for pow constraint where solution is ensured More...
class | PowXX
| Test for pow constraint with shared variables More...
class | NRootXY
| Test for nroot constraint More...
class | NRootXYSol
| Test for nroot constraint where solution is ensured More...
class | NRootXX
| Test for nroot constraint with shared variables More...
class | AbsXY
| Test for absolute value constraint More...
class | AbsXX
| Test for absolute value constraint with shared variables More...
class | MinXYZ
| Test for binary minimum constraint More...
class | MinXXY
| Test for binary minimum constraint with shared variables More...
class | MinXYX
| Test for binary minimum constraint with shared variables More...
class | MinXYY
| Test for binary minimum constraint with shared variables More...
class | MinXXX
| Test for binary minimum constraint with shared variables More...
class | MaxXYZ
| Test for binary maximum constraint More...
class | MaxXXY
| Test for binary maximum constraint with shared variables More...
class | MaxXYX
| Test for binary maximum constraint with shared variables More...
class | MaxXYY
| Test for binary maximum constraint with shared variables More...
class | MaxXXX
| Test for binary maximum constraint with shared variables More...
class | MinNary
| Test for n-ary minimmum constraint More...
class | MinNaryShared
| Test for n-ary minimmum constraint with shared variables More...
class | MaxNary
| Test for n-ary maximum constraint More...
class | MaxNaryShared
| Test for n-ary maximum constraint with shared variables More...

## Variables

const Gecode::FloatNum | step = 0.15
Gecode::FloatVal | a (-8, 5)
Gecode::FloatVal | b (9, 12)
Gecode::FloatVal | c (-8, 8)
MultXXY | mult_xxy_a ("A", a, step)
MultXXY | mult_xxy_b ("B", b, step)
MultXXY | mult_xxy_c ("C", c, step)
MultXXYSol | mult_xxy_sol_a ("A", a, step)
MultXXYSol | mult_xxy_sol_b ("B", b, step)
MultXXYSol | mult_xxy_sol_c ("C", c, step)
MultXYX | mult_xyx_a ("A", a, step)
MultXYX | mult_xyx_b ("B", b, step)
MultXYX | mult_xyx_c ("C", c, step)
MultXYY | mult_xyy_a ("A", a, step)
MultXYY | mult_xyy_b ("B", b, step)
MultXYY | mult_xyy_c ("C", c, step)
MultXXX | mult_xxx_a ("A", a, step)
MultXXX | mult_xxx_b ("B", b, step)
MultXXX | mult_xxx_c ("C", c, step)
MultXYZ | mult_xyz_a ("A", a, step)
MultXYZ | mult_xyz_b ("B", b, step)
MultXYZ | mult_xyz_c ("C", c, step)
MultXYZSol | mult_xyz_sol_a ("A", a, step)
MultXYZSol | mult_xyz_sol_b ("B", b, step)
MultXYZSol | mult_xyz_sol_c ("C", c, step)
Div | div_a ("A", a, step)
Div | div_b ("B", b, step)
Div | div_c ("C", c, step)
DivSol | div_sol_a ("A", a, step)
DivSol | div_sol_b ("B", b, step)
DivSol | div_sol_c ("C", c, step)
SqrXY | sqr_xy_a ("A", a, step)
SqrXY | sqr_xy_b ("B", b, step)
SqrXY | sqr_xy_c ("C", c, step)
SqrXYSol | sqr_xy_sol_a ("A", a, step)
SqrXYSol | sqr_xy_sol_b ("B", b, step)
SqrXYSol | sqr_xy_sol_c ("C", c, step)
SqrXX | sqr_xx_a ("A", a, step)
SqrXX | sqr_xx_b ("B", b, step)
SqrXX | sqr_xx_c ("C", c, step)
SqrtXY | sqrt_xy_a ("A", a, step)
SqrtXY | sqrt_xy_b ("B", b, step)
SqrtXY | sqrt_xy_c ("C", c, step)
SqrtXYSol | sqrt_xy_sol_a ("A", a, step)
SqrtXYSol | sqrt_xy_sol_b ("B", b, step)
SqrtXYSol | sqrt_xy_sol_c ("C", c, step)
SqrtXX | sqrt_xx_a ("A", a, step)
SqrtXX | sqrt_xx_b ("B", b, step)
SqrtXX | sqrt_xx_c ("C", c, step)
PowXY | pow_xy_a_1 ("A", a, 2, step)
PowXY | pow_xy_b_1 ("B", b, 2, step)
PowXY | pow_xy_c_1 ("C", c, 2, step)
PowXYSol | pow_xy_sol_a_1 ("A", a, 2, step)
PowXYSol | pow_xy_sol_b_1 ("B", b, 2, step)
PowXYSol | pow_xy_sol_c_1 ("C", c, 2, step)
PowXX | pow_xx_a_1 ("A", a, 2, step)
PowXX | pow_xx_b_1 ("B", b, 2, step)
PowXX | pow_xx_c_1 ("C", c, 2, step)
PowXY | pow_xy_a_2 ("A", a, 3, step)
PowXY | pow_xy_b_2 ("B", b, 3, step)
PowXY | pow_xy_c_2 ("C", c, 3, step)
PowXYSol | pow_xy_sol_a_2 ("A", a, 3, step)
PowXYSol | pow_xy_sol_b_2 ("B", b, 3, step)
PowXYSol | pow_xy_sol_c_2 ("C", c, 3, step)
PowXX | pow_xx_a_2 ("A", a, 3, step)
PowXX | pow_xx_b_2 ("B", b, 3, step)
PowXX | pow_xx_c_2 ("C", c, 3, step)
PowXY | pow_xy_a_3 ("A", a, 0, step)
PowXY | pow_xy_b_3 ("B", b, 0, step)
PowXY | pow_xy_c_3 ("C", c, 0, step)
PowXYSol | pow_xy_sol_a_3 ("A", a, 0, step)
PowXYSol | pow_xy_sol_b_3 ("B", b, 0, step)
PowXYSol | pow_xy_sol_c_3 ("C", c, 0, step)
PowXX | pow_xx_a_3 ("A", a, 0, step)
PowXX | pow_xx_b_3 ("B", b, 0, step)
PowXX | pow_xx_c_3 ("C", c, 0, step)
NRootXY | nroot_xy_a_1 ("A", a, 2, step)
NRootXY | nroot_xy_b_1 ("B", b, 2, step)
NRootXY | nroot_xy_c_1 ("C", c, 2, step)
NRootXYSol | nroot_xy_sol_a_1 ("A", a, 2, step)
NRootXYSol | nroot_xy_sol_b_1 ("B", b, 2, step)
NRootXYSol | nroot_xy_sol_c_1 ("C", c, 2, step)
NRootXX | nroot_xx_a_1 ("A", a, 2, step)
NRootXX | nroot_xx_b_1 ("B", b, 2, step)
NRootXX | nroot_xx_c_1 ("C", c, 2, step)
NRootXY | nroot_xy_a_2 ("A", a, 3, step)
NRootXY | nroot_xy_b_2 ("B", b, 3, step)
NRootXY | nroot_xy_c_2 ("C", c, 3, step)
NRootXYSol | nroot_xy_sol_a_2 ("A", a, 3, step)
NRootXYSol | nroot_xy_sol_b_2 ("B", b, 3, step)
NRootXYSol | nroot_xy_sol_c_2 ("C", c, 3, step)
NRootXX | nroot_xx_a_2 ("A", a, 3, step)
NRootXX | nroot_xx_b_2 ("B", b, 3, step)
NRootXX | nroot_xx_c_2 ("C", c, 3, step)
NRootXY | nroot_xy_a_3 ("A", a, 0, step)
NRootXY | nroot_xy_b_3 ("B", b, 0, step)
NRootXY | nroot_xy_c_3 ("C", c, 0, step)
NRootXYSol | nroot_xy_sol_a_3 ("A", a, 0, step)
NRootXYSol | nroot_xy_sol_b_3 ("B", b, 0, step)
NRootXYSol | nroot_xy_sol_c_3 ("C", c, 0, step)
NRootXX | nroot_xx_a_3 ("A", a, 0, step)
NRootXX | nroot_xx_b_3 ("B", b, 0, step)
NRootXX | nroot_xx_c_3 ("C", c, 0, step)
AbsXY | abs_xy_a ("A", a, step)
AbsXY | abs_xy_b ("B", b, step)
AbsXY | abs_xy_c ("C", c, step)
AbsXX | abs_xx_a ("A", a, step)
AbsXX | abs_xx_b ("B", b, step)
AbsXX | abs_xx_c ("C", c, step)
MinXYZ | min_xyz_a ("A", a, step)
MinXYZ | min_xyz_b ("B", b, step)
MinXYZ | min_xyz_c ("C", c, step)
MinXXY | min_xxy_a ("A", a, step)
MinXXY | min_xxy_b ("B", b, step)
MinXXY | min_xxy_c ("C", c, step)
MinXYX | min_xyx_a ("A", a, step)
MinXYX | min_xyx_b ("B", b, step)
MinXYX | min_xyx_c ("C", c, step)
MinXYY | min_xyy_a ("A", a, step)
MinXYY | min_xyy_b ("B", b, step)
MinXYY | min_xyy_c ("C", c, step)
MinXXX | min_xxx_a ("A", a, step)
MinXXX | min_xxx_b ("B", b, step)
MinXXX | min_xxx_c ("C", c, step)
MaxXYZ | max_xyz_a ("A", a, step)
MaxXYZ | max_xyz_b ("B", b, step)
MaxXYZ | max_xyz_c ("C", c, step)
MaxXXY | max_xxy_a ("A", a, step)
MaxXXY | max_xxy_b ("B", b, step)
MaxXXY | max_xxy_c ("C", c, step)
MaxXYX | max_xyx_a ("A", a, step)
MaxXYX | max_xyx_b ("B", b, step)
MaxXYX | max_xyx_c ("C", c, step)
MaxXYY | max_xyy_a ("A", a, step)
MaxXYY | max_xyy_b ("B", b, step)
MaxXYY | max_xyy_c ("C", c, step)
MaxXXX | max_xxx_a ("A", a, step)
MaxXXX | max_xxx_b ("B", b, step)
MaxXXX | max_xxx_c ("C", c, step)
MinNary | min_nary
MinNaryShared | min_s_nary
MaxNary | max_nary
MaxNaryShared | max_s_nary

## Detailed Description

Tests for arithmetic constraints

## Variable Documentation

## step

const Gecode::FloatNum Test::Float::Arithmetic::step = 0.15

Definition at line 785 of file arithmetic.cpp.

## a

Gecode::FloatVal Test::Float::Arithmetic::a(-8, 5) | ( | - | 8,
|  | 5 | )

## b

Gecode::FloatVal Test::Float::Arithmetic::b(9, 12) | ( | 9 | ,
|  | 12 | )

## c

Gecode::FloatVal Test::Float::Arithmetic::c(-8, 8) | ( | - | 8,
|  | 8 | )

## mult_xxy_a

MultXXY Test::Float::Arithmetic::mult_xxy_a("A", a, step) | ( | "A" | ,
|  | a | ,
|  | step | )

## mult_xxy_b

MultXXY Test::Float::Arithmetic::mult_xxy_b("B", b, step) | ( | "B" | ,
|  | b | ,
|  | step | )

## mult_xxy_c

MultXXY Test::Float::Arithmetic::mult_xxy_c("C", c, step) | ( | "C" | ,
|  | c | ,
|  | step | )

## mult_xxy_sol_a

MultXXYSol Test::Float::Arithmetic::mult_xxy_sol_a("A", a, step) | ( | "A" | ,
|  | a | ,
|  | step | )

## mult_xxy_sol_b

MultXXYSol Test::Float::Arithmetic::mult_xxy_sol_b("B", b, step) | ( | "B" | ,
|  | b | ,
|  | step | )

## mult_xxy_sol_c

MultXXYSol Test::Float::Arithmetic::mult_xxy_sol_c("C", c, step) | ( | "C" | ,
|  | c | ,
|  | step | )

## mult_xyx_a

MultXYX Test::Float::Arithmetic::mult_xyx_a("A", a, step) | ( | "A" | ,
|  | a | ,
|  | step | )

## mult_xyx_b

MultXYX Test::Float::Arithmetic::mult_xyx_b("B", b, step) | ( | "B" | ,
|  | b | ,
|  | step | )

## mult_xyx_c

MultXYX Test::Float::Arithmetic::mult_xyx_c("C", c, step) | ( | "C" | ,
|  | c | ,
|  | step | )

## mult_xyy_a

MultXYY Test::Float::Arithmetic::mult_xyy_a("A", a, step) | ( | "A" | ,
|  | a | ,
|  | step | )

## mult_xyy_b

MultXYY Test::Float::Arithmetic::mult_xyy_b("B", b, step) | ( | "B" | ,
|  | b | ,
|  | step | )

## mult_xyy_c

MultXYY Test::Float::Arithmetic::mult_xyy_c("C", c, step) | ( | "C" | ,
|  | c | ,
|  | step | )

## mult_xxx_a

MultXXX Test::Float::Arithmetic::mult_xxx_a("A", a, step) | ( | "A" | ,
|  | a | ,
|  | step | )

## mult_xxx_b

MultXXX Test::Float::Arithmetic::mult_xxx_b("B", b, step) | ( | "B" | ,
|  | b | ,
|  | step | )

## mult_xxx_c

MultXXX Test::Float::Arithmetic::mult_xxx_c("C", c, step) | ( | "C" | ,
|  | c | ,
|  | step | )

## mult_xyz_a

MultXYZ Test::Float::Arithmetic::mult_xyz_a("A", a, step) | ( | "A" | ,
|  | a | ,
|  | step | )

## mult_xyz_b

MultXYZ Test::Float::Arithmetic::mult_xyz_b("B", b, step) | ( | "B" | ,
|  | b | ,
|  | step | )

## mult_xyz_c

MultXYZ Test::Float::Arithmetic::mult_xyz_c("C", c, step) | ( | "C" | ,
|  | c | ,
|  | step | )

## mult_xyz_sol_a

MultXYZSol Test::Float::Arithmetic::mult_xyz_sol_a("A", a, step) | ( | "A" | ,
|  | a | ,
|  | step | )

## mult_xyz_sol_b

MultXYZSol Test::Float::Arithmetic::mult_xyz_sol_b("B", b, step) | ( | "B" | ,
|  | b | ,
|  | step | )

## mult_xyz_sol_c

MultXYZSol Test::Float::Arithmetic::mult_xyz_sol_c("C", c, step) | ( | "C" | ,
|  | c | ,
|  | step | )

## div_a

Div Test::Float::Arithmetic::div_a("A", a, step) | ( | "A" | ,
|  | a | ,
|  | step | )

## div_b

Div Test::Float::Arithmetic::div_b("B", b, step) | ( | "B" | ,
|  | b | ,
|  | step | )

## div_c

Div Test::Float::Arithmetic::div_c("C", c, step) | ( | "C" | ,
|  | c | ,
|  | step | )

## div_sol_a

DivSol Test::Float::Arithmetic::div_sol_a("A", a, step) | ( | "A" | ,
|  | a | ,
|  | step | )

## div_sol_b

DivSol Test::Float::Arithmetic::div_sol_b("B", b, step) | ( | "B" | ,
|  | b | ,
|  | step | )

## div_sol_c

DivSol Test::Float::Arithmetic::div_sol_c("C", c, step) | ( | "C" | ,
|  | c | ,
|  | step | )

## sqr_xy_a

SqrXY Test::Float::Arithmetic::sqr_xy_a("A", a, step) | ( | "A" | ,
|  | a | ,
|  | step | )

## sqr_xy_b

SqrXY Test::Float::Arithmetic::sqr_xy_b("B", b, step) | ( | "B" | ,
|  | b | ,
|  | step | )

## sqr_xy_c

SqrXY Test::Float::Arithmetic::sqr_xy_c("C", c, step) | ( | "C" | ,
|  | c | ,
|  | step | )

## sqr_xy_sol_a

SqrXYSol Test::Float::Arithmetic::sqr_xy_sol_a("A", a, step) | ( | "A" | ,
|  | a | ,
|  | step | )

## sqr_xy_sol_b

SqrXYSol Test::Float::Arithmetic::sqr_xy_sol_b("B", b, step) | ( | "B" | ,
|  | b | ,
|  | step | )

## sqr_xy_sol_c

SqrXYSol Test::Float::Arithmetic::sqr_xy_sol_c("C", c, step) | ( | "C" | ,
|  | c | ,
|  | step | )

## sqr_xx_a

SqrXX Test::Float::Arithmetic::sqr_xx_a("A", a, step) | ( | "A" | ,
|  | a | ,
|  | step | )

## sqr_xx_b

SqrXX Test::Float::Arithmetic::sqr_xx_b("B", b, step) | ( | "B" | ,
|  | b | ,
|  | step | )

## sqr_xx_c

SqrXX Test::Float::Arithmetic::sqr_xx_c("C", c, step) | ( | "C" | ,
|  | c | ,
|  | step | )

## sqrt_xy_a

SqrtXY Test::Float::Arithmetic::sqrt_xy_a("A", a, step) | ( | "A" | ,
|  | a | ,
|  | step | )

## sqrt_xy_b

SqrtXY Test::Float::Arithmetic::sqrt_xy_b("B", b, step) | ( | "B" | ,
|  | b | ,
|  | step | )

## sqrt_xy_c

SqrtXY Test::Float::Arithmetic::sqrt_xy_c("C", c, step) | ( | "C" | ,
|  | c | ,
|  | step | )

## sqrt_xy_sol_a

SqrtXYSol Test::Float::Arithmetic::sqrt_xy_sol_a("A", a, step) | ( | "A" | ,
|  | a | ,
|  | step | )

## sqrt_xy_sol_b

SqrtXYSol Test::Float::Arithmetic::sqrt_xy_sol_b("B", b, step) | ( | "B" | ,
|  | b | ,
|  | step | )

## sqrt_xy_sol_c

SqrtXYSol Test::Float::Arithmetic::sqrt_xy_sol_c("C", c, step) | ( | "C" | ,
|  | c | ,
|  | step | )

## sqrt_xx_a

SqrtXX Test::Float::Arithmetic::sqrt_xx_a("A", a, step) | ( | "A" | ,
|  | a | ,
|  | step | )

## sqrt_xx_b

SqrtXX Test::Float::Arithmetic::sqrt_xx_b("B", b, step) | ( | "B" | ,
|  | b | ,
|  | step | )

## sqrt_xx_c

SqrtXX Test::Float::Arithmetic::sqrt_xx_c("C", c, step) | ( | "C" | ,
|  | c | ,
|  | step | )

## pow_xy_a_1

PowXY Test::Float::Arithmetic::pow_xy_a_1("A", a, 2, step) | ( | "A" | ,
|  | a | ,
|  | 2 | ,
|  | step | )

## pow_xy_b_1

PowXY Test::Float::Arithmetic::pow_xy_b_1("B", b, 2, step) | ( | "B" | ,
|  | b | ,
|  | 2 | ,
|  | step | )

## pow_xy_c_1

PowXY Test::Float::Arithmetic::pow_xy_c_1("C", c, 2, step) | ( | "C" | ,
|  | c | ,
|  | 2 | ,
|  | step | )

## pow_xy_sol_a_1

PowXYSol Test::Float::Arithmetic::pow_xy_sol_a_1("A", a, 2, step) | ( | "A" | ,
|  | a | ,
|  | 2 | ,
|  | step | )

## pow_xy_sol_b_1

PowXYSol Test::Float::Arithmetic::pow_xy_sol_b_1("B", b, 2, step) | ( | "B" | ,
|  | b | ,
|  | 2 | ,
|  | step | )

## pow_xy_sol_c_1

PowXYSol Test::Float::Arithmetic::pow_xy_sol_c_1("C", c, 2, step) | ( | "C" | ,
|  | c | ,
|  | 2 | ,
|  | step | )

## pow_xx_a_1

PowXX Test::Float::Arithmetic::pow_xx_a_1("A", a, 2, step) | ( | "A" | ,
|  | a | ,
|  | 2 | ,
|  | step | )

## pow_xx_b_1

PowXX Test::Float::Arithmetic::pow_xx_b_1("B", b, 2, step) | ( | "B" | ,
|  | b | ,
|  | 2 | ,
|  | step | )

## pow_xx_c_1

PowXX Test::Float::Arithmetic::pow_xx_c_1("C", c, 2, step) | ( | "C" | ,
|  | c | ,
|  | 2 | ,
|  | step | )

## pow_xy_a_2

PowXY Test::Float::Arithmetic::pow_xy_a_2("A", a, 3, step) | ( | "A" | ,
|  | a | ,
|  | 3 | ,
|  | step | )

## pow_xy_b_2

PowXY Test::Float::Arithmetic::pow_xy_b_2("B", b, 3, step) | ( | "B" | ,
|  | b | ,
|  | 3 | ,
|  | step | )

## pow_xy_c_2

PowXY Test::Float::Arithmetic::pow_xy_c_2("C", c, 3, step) | ( | "C" | ,
|  | c | ,
|  | 3 | ,
|  | step | )

## pow_xy_sol_a_2

PowXYSol Test::Float::Arithmetic::pow_xy_sol_a_2("A", a, 3, step) | ( | "A" | ,
|  | a | ,
|  | 3 | ,
|  | step | )

## pow_xy_sol_b_2

PowXYSol Test::Float::Arithmetic::pow_xy_sol_b_2("B", b, 3, step) | ( | "B" | ,
|  | b | ,
|  | 3 | ,
|  | step | )

## pow_xy_sol_c_2

PowXYSol Test::Float::Arithmetic::pow_xy_sol_c_2("C", c, 3, step) | ( | "C" | ,
|  | c | ,
|  | 3 | ,
|  | step | )

## pow_xx_a_2

PowXX Test::Float::Arithmetic::pow_xx_a_2("A", a, 3, step) | ( | "A" | ,
|  | a | ,
|  | 3 | ,
|  | step | )

## pow_xx_b_2

PowXX Test::Float::Arithmetic::pow_xx_b_2("B", b, 3, step) | ( | "B" | ,
|  | b | ,
|  | 3 | ,
|  | step | )

## pow_xx_c_2

PowXX Test::Float::Arithmetic::pow_xx_c_2("C", c, 3, step) | ( | "C" | ,
|  | c | ,
|  | 3 | ,
|  | step | )

## pow_xy_a_3

PowXY Test::Float::Arithmetic::pow_xy_a_3("A", a, 0, step) | ( | "A" | ,
|  | a | ,
|  | 0 | ,
|  | step | )

## pow_xy_b_3

PowXY Test::Float::Arithmetic::pow_xy_b_3("B", b, 0, step) | ( | "B" | ,
|  | b | ,
|  | 0 | ,
|  | step | )

## pow_xy_c_3

PowXY Test::Float::Arithmetic::pow_xy_c_3("C", c, 0, step) | ( | "C" | ,
|  | c | ,
|  | 0 | ,
|  | step | )

## pow_xy_sol_a_3

PowXYSol Test::Float::Arithmetic::pow_xy_sol_a_3("A", a, 0, step) | ( | "A" | ,
|  | a | ,
|  | 0 | ,
|  | step | )

## pow_xy_sol_b_3

PowXYSol Test::Float::Arithmetic::pow_xy_sol_b_3("B", b, 0, step) | ( | "B" | ,
|  | b | ,
|  | 0 | ,
|  | step | )

## pow_xy_sol_c_3

PowXYSol Test::Float::Arithmetic::pow_xy_sol_c_3("C", c, 0, step) | ( | "C" | ,
|  | c | ,
|  | 0 | ,
|  | step | )

## pow_xx_a_3

PowXX Test::Float::Arithmetic::pow_xx_a_3("A", a, 0, step) | ( | "A" | ,
|  | a | ,
|  | 0 | ,
|  | step | )

## pow_xx_b_3

PowXX Test::Float::Arithmetic::pow_xx_b_3("B", b, 0, step) | ( | "B" | ,
|  | b | ,
|  | 0 | ,
|  | step | )

## pow_xx_c_3

PowXX Test::Float::Arithmetic::pow_xx_c_3("C", c, 0, step) | ( | "C" | ,
|  | c | ,
|  | 0 | ,
|  | step | )

## nroot_xy_a_1

NRootXY Test::Float::Arithmetic::nroot_xy_a_1("A", a, 2, step) | ( | "A" | ,
|  | a | ,
|  | 2 | ,
|  | step | )

## nroot_xy_b_1

NRootXY Test::Float::Arithmetic::nroot_xy_b_1("B", b, 2, step) | ( | "B" | ,
|  | b | ,
|  | 2 | ,
|  | step | )

## nroot_xy_c_1

NRootXY Test::Float::Arithmetic::nroot_xy_c_1("C", c, 2, step) | ( | "C" | ,
|  | c | ,
|  | 2 | ,
|  | step | )

## nroot_xy_sol_a_1

NRootXYSol Test::Float::Arithmetic::nroot_xy_sol_a_1("A", a, 2, step) | ( | "A" | ,
|  | a | ,
|  | 2 | ,
|  | step | )

## nroot_xy_sol_b_1

NRootXYSol Test::Float::Arithmetic::nroot_xy_sol_b_1("B", b, 2, step) | ( | "B" | ,
|  | b | ,
|  | 2 | ,
|  | step | )

## nroot_xy_sol_c_1

NRootXYSol Test::Float::Arithmetic::nroot_xy_sol_c_1("C", c, 2, step) | ( | "C" | ,
|  | c | ,
|  | 2 | ,
|  | step | )

## nroot_xx_a_1

NRootXX Test::Float::Arithmetic::nroot_xx_a_1("A", a, 2, step) | ( | "A" | ,
|  | a | ,
|  | 2 | ,
|  | step | )

## nroot_xx_b_1

NRootXX Test::Float::Arithmetic::nroot_xx_b_1("B", b, 2, step) | ( | "B" | ,
|  | b | ,
|  | 2 | ,
|  | step | )

## nroot_xx_c_1

NRootXX Test::Float::Arithmetic::nroot_xx_c_1("C", c, 2, step) | ( | "C" | ,
|  | c | ,
|  | 2 | ,
|  | step | )

## nroot_xy_a_2

NRootXY Test::Float::Arithmetic::nroot_xy_a_2("A", a, 3, step) | ( | "A" | ,
|  | a | ,
|  | 3 | ,
|  | step | )

## nroot_xy_b_2

NRootXY Test::Float::Arithmetic::nroot_xy_b_2("B", b, 3, step) | ( | "B" | ,
|  | b | ,
|  | 3 | ,
|  | step | )

## nroot_xy_c_2

NRootXY Test::Float::Arithmetic::nroot_xy_c_2("C", c, 3, step) | ( | "C" | ,
|  | c | ,
|  | 3 | ,
|  | step | )

## nroot_xy_sol_a_2

NRootXYSol Test::Float::Arithmetic::nroot_xy_sol_a_2("A", a, 3, step) | ( | "A" | ,
|  | a | ,
|  | 3 | ,
|  | step | )

## nroot_xy_sol_b_2

NRootXYSol Test::Float::Arithmetic::nroot_xy_sol_b_2("B", b, 3, step) | ( | "B" | ,
|  | b | ,
|  | 3 | ,
|  | step | )

## nroot_xy_sol_c_2

NRootXYSol Test::Float::Arithmetic::nroot_xy_sol_c_2("C", c, 3, step) | ( | "C" | ,
|  | c | ,
|  | 3 | ,
|  | step | )

## nroot_xx_a_2

NRootXX Test::Float::Arithmetic::nroot_xx_a_2("A", a, 3, step) | ( | "A" | ,
|  | a | ,
|  | 3 | ,
|  | step | )

## nroot_xx_b_2

NRootXX Test::Float::Arithmetic::nroot_xx_b_2("B", b, 3, step) | ( | "B" | ,
|  | b | ,
|  | 3 | ,
|  | step | )

## nroot_xx_c_2

NRootXX Test::Float::Arithmetic::nroot_xx_c_2("C", c, 3, step) | ( | "C" | ,
|  | c | ,
|  | 3 | ,
|  | step | )

## nroot_xy_a_3

NRootXY Test::Float::Arithmetic::nroot_xy_a_3("A", a, 0, step) | ( | "A" | ,
|  | a | ,
|  | 0 | ,
|  | step | )

## nroot_xy_b_3

NRootXY Test::Float::Arithmetic::nroot_xy_b_3("B", b, 0, step) | ( | "B" | ,
|  | b | ,
|  | 0 | ,
|  | step | )

## nroot_xy_c_3

NRootXY Test::Float::Arithmetic::nroot_xy_c_3("C", c, 0, step) | ( | "C" | ,
|  | c | ,
|  | 0 | ,
|  | step | )

## nroot_xy_sol_a_3

NRootXYSol Test::Float::Arithmetic::nroot_xy_sol_a_3("A", a, 0, step) | ( | "A" | ,
|  | a | ,
|  | 0 | ,
|  | step | )

## nroot_xy_sol_b_3

NRootXYSol Test::Float::Arithmetic::nroot_xy_sol_b_3("B", b, 0, step) | ( | "B" | ,
|  | b | ,
|  | 0 | ,
|  | step | )

## nroot_xy_sol_c_3

NRootXYSol Test::Float::Arithmetic::nroot_xy_sol_c_3("C", c, 0, step) | ( | "C" | ,
|  | c | ,
|  | 0 | ,
|  | step | )

## nroot_xx_a_3

NRootXX Test::Float::Arithmetic::nroot_xx_a_3("A", a, 0, step) | ( | "A" | ,
|  | a | ,
|  | 0 | ,
|  | step | )

## nroot_xx_b_3

NRootXX Test::Float::Arithmetic::nroot_xx_b_3("B", b, 0, step) | ( | "B" | ,
|  | b | ,
|  | 0 | ,
|  | step | )

## nroot_xx_c_3

NRootXX Test::Float::Arithmetic::nroot_xx_c_3("C", c, 0, step) | ( | "C" | ,
|  | c | ,
|  | 0 | ,
|  | step | )

## abs_xy_a

AbsXY Test::Float::Arithmetic::abs_xy_a("A", a, step) | ( | "A" | ,
|  | a | ,
|  | step | )

## abs_xy_b

AbsXY Test::Float::Arithmetic::abs_xy_b("B", b, step) | ( | "B" | ,
|  | b | ,
|  | step | )

## abs_xy_c

AbsXY Test::Float::Arithmetic::abs_xy_c("C", c, step) | ( | "C" | ,
|  | c | ,
|  | step | )

## abs_xx_a

AbsXX Test::Float::Arithmetic::abs_xx_a("A", a, step) | ( | "A" | ,
|  | a | ,
|  | step | )

## abs_xx_b

AbsXX Test::Float::Arithmetic::abs_xx_b("B", b, step) | ( | "B" | ,
|  | b | ,
|  | step | )

## abs_xx_c

AbsXX Test::Float::Arithmetic::abs_xx_c("C", c, step) | ( | "C" | ,
|  | c | ,
|  | step | )

## min_xyz_a

MinXYZ Test::Float::Arithmetic::min_xyz_a("A", a, step) | ( | "A" | ,
|  | a | ,
|  | step | )

## min_xyz_b

MinXYZ Test::Float::Arithmetic::min_xyz_b("B", b, step) | ( | "B" | ,
|  | b | ,
|  | step | )

## min_xyz_c

MinXYZ Test::Float::Arithmetic::min_xyz_c("C", c, step) | ( | "C" | ,
|  | c | ,
|  | step | )

## min_xxy_a

MinXXY Test::Float::Arithmetic::min_xxy_a("A", a, step) | ( | "A" | ,
|  | a | ,
|  | step | )

## min_xxy_b

MinXXY Test::Float::Arithmetic::min_xxy_b("B", b, step) | ( | "B" | ,
|  | b | ,
|  | step | )

## min_xxy_c

MinXXY Test::Float::Arithmetic::min_xxy_c("C", c, step) | ( | "C" | ,
|  | c | ,
|  | step | )

## min_xyx_a

MinXYX Test::Float::Arithmetic::min_xyx_a("A", a, step) | ( | "A" | ,
|  | a | ,
|  | step | )

## min_xyx_b

MinXYX Test::Float::Arithmetic::min_xyx_b("B", b, step) | ( | "B" | ,
|  | b | ,
|  | step | )

## min_xyx_c

MinXYX Test::Float::Arithmetic::min_xyx_c("C", c, step) | ( | "C" | ,
|  | c | ,
|  | step | )

## min_xyy_a

MinXYY Test::Float::Arithmetic::min_xyy_a("A", a, step) | ( | "A" | ,
|  | a | ,
|  | step | )

## min_xyy_b

MinXYY Test::Float::Arithmetic::min_xyy_b("B", b, step) | ( | "B" | ,
|  | b | ,
|  | step | )

## min_xyy_c

MinXYY Test::Float::Arithmetic::min_xyy_c("C", c, step) | ( | "C" | ,
|  | c | ,
|  | step | )

## min_xxx_a

MinXXX Test::Float::Arithmetic::min_xxx_a("A", a, step) | ( | "A" | ,
|  | a | ,
|  | step | )

## min_xxx_b

MinXXX Test::Float::Arithmetic::min_xxx_b("B", b, step) | ( | "B" | ,
|  | b | ,
|  | step | )

## min_xxx_c

MinXXX Test::Float::Arithmetic::min_xxx_c("C", c, step) | ( | "C" | ,
|  | c | ,
|  | step | )

## max_xyz_a

MaxXYZ Test::Float::Arithmetic::max_xyz_a("A", a, step) | ( | "A" | ,
|  | a | ,
|  | step | )

## max_xyz_b

MaxXYZ Test::Float::Arithmetic::max_xyz_b("B", b, step) | ( | "B" | ,
|  | b | ,
|  | step | )

## max_xyz_c

MaxXYZ Test::Float::Arithmetic::max_xyz_c("C", c, step) | ( | "C" | ,
|  | c | ,
|  | step | )

## max_xxy_a

MaxXXY Test::Float::Arithmetic::max_xxy_a("A", a, step) | ( | "A" | ,
|  | a | ,
|  | step | )

## max_xxy_b

MaxXXY Test::Float::Arithmetic::max_xxy_b("B", b, step) | ( | "B" | ,
|  | b | ,
|  | step | )

## max_xxy_c

MaxXXY Test::Float::Arithmetic::max_xxy_c("C", c, step) | ( | "C" | ,
|  | c | ,
|  | step | )

## max_xyx_a

MaxXYX Test::Float::Arithmetic::max_xyx_a("A", a, step) | ( | "A" | ,
|  | a | ,
|  | step | )

## max_xyx_b

MaxXYX Test::Float::Arithmetic::max_xyx_b("B", b, step) | ( | "B" | ,
|  | b | ,
|  | step | )

## max_xyx_c

MaxXYX Test::Float::Arithmetic::max_xyx_c("C", c, step) | ( | "C" | ,
|  | c | ,
|  | step | )

## max_xyy_a

MaxXYY Test::Float::Arithmetic::max_xyy_a("A", a, step) | ( | "A" | ,
|  | a | ,
|  | step | )

## max_xyy_b

MaxXYY Test::Float::Arithmetic::max_xyy_b("B", b, step) | ( | "B" | ,
|  | b | ,
|  | step | )

## max_xyy_c

MaxXYY Test::Float::Arithmetic::max_xyy_c("C", c, step) | ( | "C" | ,
|  | c | ,
|  | step | )

## max_xxx_a

MaxXXX Test::Float::Arithmetic::max_xxx_a("A", a, step) | ( | "A" | ,
|  | a | ,
|  | step | )

## max_xxx_b

MaxXXX Test::Float::Arithmetic::max_xxx_b("B", b, step) | ( | "B" | ,
|  | b | ,
|  | step | )

## max_xxx_c

MaxXXX Test::Float::Arithmetic::max_xxx_c("C", c, step) | ( | "C" | ,
|  | c | ,
|  | step | )

## min_nary

MinNary Test::Float::Arithmetic::min_nary

Definition at line 970 of file arithmetic.cpp.

## min_s_nary

MinNaryShared Test::Float::Arithmetic::min_s_nary

Definition at line 971 of file arithmetic.cpp.

## max_nary

MaxNary Test::Float::Arithmetic::max_nary

Definition at line 972 of file arithmetic.cpp.

## max_s_nary

MaxNaryShared Test::Float::Arithmetic::max_s_nary

Definition at line 973 of file arithmetic.cpp.