arithmetic.cpp
Go to the documentation of this file.
/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
/*
* Main authors:
* Christian Schulte <schulte@gecode.org>
* Vincent Barichard <Vincent.Barichard@univ-angers.fr>
*
* Copyright:
* Christian Schulte, 2005
* Vincent Barichard, 2012
*
* This file is part of Gecode, the generic constraint
* development environment:
* http://www.gecode.org
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject to
* the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
* LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
* OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
* WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*
*/
#include "test/float.hh"
#include <gecode/minimodel.hh>
#include <cmath>
#include <algorithm>
namespace Test { namespace Float {
namespace Arithmetic {
class MultXYZ : public Test {
public:
MultXYZ(const std::string& s, const Gecode::FloatVal& d, Gecode::FloatNum st)
: Test("Arithmetic::Mult::XYZ::"+s,3,d,st,CPLT_ASSIGNMENT,false) {}
virtual MaybeType solution(const Assignment& x) const {
return eq(x[0] * x[1], x[2]);
}
virtual void post(Gecode::Space& home, Gecode::FloatVarArray& x) {
if (flip())
Gecode::mult(home, x[0], x[1], x[2]);
else
Gecode::rel(home, x[0] * x[1] == x[2]);
}
};
class MultXYZSol : public Test {
public:
MultXYZSol(const std::string& s, const Gecode::FloatVal& d, Gecode::FloatNum st)
: Test("Arithmetic::Mult::XYZ::Sol::"+s,3,d,st,EXTEND_ASSIGNMENT,false) {}
virtual MaybeType solution(const Assignment& x) const {
return eq(x[0] * x[1], x[2]);
}
virtual bool extendAssignement(Assignment& x) const {
Gecode::FloatVal d = x[0]*x[1];
if (Gecode::Float::subset(d, dom)) {
x.set(2, d);
return true;
} else {
return false;
}
}
virtual void post(Gecode::Space& home, Gecode::FloatVarArray& x) {
Gecode::mult(home, x[0], x[1], x[2]);
}
};
class MultXXY : public Test {
public:
MultXXY(const std::string& s, const Gecode::FloatVal& d, Gecode::FloatNum st)
: Test("Arithmetic::Mult::XXY::"+s,2,d,st,CPLT_ASSIGNMENT,false) {}
virtual MaybeType solution(const Assignment& x) const {
return eq(x[0] * x[0], x[1]);
}
virtual void post(Gecode::Space& home, Gecode::FloatVarArray& x) {
Gecode::mult(home, x[0], x[0], x[1]);
}
};
class MultXXYSol : public Test {
public:
MultXXYSol(const std::string& s, const Gecode::FloatVal& d, Gecode::FloatNum st)
: Test("Arithmetic::Mult::XXY::Sol::"+s,2,d,st,EXTEND_ASSIGNMENT,false) {}
virtual MaybeType solution(const Assignment& x) const {
return eq(x[0] * x[0], x[1]);
}
virtual bool extendAssignement(Assignment& x) const {
Gecode::FloatVal d = x[0]*x[0];
if (Gecode::Float::subset(d, dom)) {
x.set(1, d);
return true;
} else {
return false;
}
}
virtual void post(Gecode::Space& home, Gecode::FloatVarArray& x) {
Gecode::mult(home, x[0], x[0], x[1]);
}
};
class MultXYX : public Test {
public:
MultXYX(const std::string& s, const Gecode::FloatVal& d, Gecode::FloatNum st)
: Test("Arithmetic::Mult::XYX::"+s,2,d,st,CPLT_ASSIGNMENT,false) {}
virtual MaybeType solution(const Assignment& x) const {
return eq(x[0] * x[1], x[0]);
}
virtual void post(Gecode::Space& home, Gecode::FloatVarArray& x) {
Gecode::mult(home, x[0], x[1], x[0]);
}
};
class MultXYY : public Test {
public:
MultXYY(const std::string& s, const Gecode::FloatVal& d, Gecode::FloatNum st)
: Test("Arithmetic::Mult::XYY::"+s,2,d,st,CPLT_ASSIGNMENT,false) {}
virtual MaybeType solution(const Assignment& x) const {
return eq(x[0] * x[1], x[1]);
}
virtual void post(Gecode::Space& home, Gecode::FloatVarArray& x) {
Gecode::mult(home, x[0], x[1], x[1]);
}
};
class MultXXX : public Test {
public:
MultXXX(const std::string& s, const Gecode::FloatVal& d, Gecode::FloatNum st)
: Test("Arithmetic::Mult::XXX::"+s,1,d,st,CPLT_ASSIGNMENT,false) {}
virtual MaybeType solution(const Assignment& x) const {
return eq(x[0] * x[0], x[0]);
}
virtual void post(Gecode::Space& home, Gecode::FloatVarArray& x) {
Gecode::mult(home, x[0], x[0], x[0]);
}
};
class Div : public Test {
public:
Div(const std::string& s, const Gecode::FloatVal& d, Gecode::FloatNum st)
: Test("Arithmetic::Div::"+s,3,d,st,CPLT_ASSIGNMENT,false) {}
virtual MaybeType solution(const Assignment& x) const {
return eq(x[0] / x[1], x[2]);
}
virtual void post(Gecode::Space& home, Gecode::FloatVarArray& x) {
if (flip())
Gecode::div(home, x[0], x[1], x[2]);
else
Gecode::rel(home, x[0] / x[1] == x[2]);
}
};
class DivSol : public Test {
public:
DivSol(const std::string& s, const Gecode::FloatVal& d, Gecode::FloatNum st)
: Test("Arithmetic::Div::Sol::"+s,3,d,st,EXTEND_ASSIGNMENT,false) {}
virtual MaybeType solution(const Assignment& x) const {
return eq(x[0] / x[1], x[2]);
}
virtual bool extendAssignement(Assignment& x) const {
Gecode::FloatVal d = x[0]/x[1];
if (Gecode::Float::subset(d, dom)) {
x.set(2, d);
return true;
} else {
return false;
}
}
virtual void post(Gecode::Space& home, Gecode::FloatVarArray& x) {
Gecode::div(home, x[0], x[1], x[2]);
}
};
class SqrXY : public Test {
public:
SqrXY(const std::string& s, const Gecode::FloatVal& d, Gecode::FloatNum st)
: Test("Arithmetic::Sqr::XY::"+s,2,d,st,CPLT_ASSIGNMENT,false) {}
virtual MaybeType solution(const Assignment& x) const {
return eq(x[0] * x[0], x[1]);
}
virtual void post(Gecode::Space& home, Gecode::FloatVarArray& x) {
if (flip())
Gecode::sqr(home, x[0], x[1]);
else
Gecode::rel(home, sqr(x[0]) == x[1]);
}
};
class SqrXYSol : public Test {
public:
SqrXYSol(const std::string& s, const Gecode::FloatVal& d, Gecode::FloatNum st)
: Test("Arithmetic::Sqr::XY::Sol::"+s,2,d,st,EXTEND_ASSIGNMENT,false) {}
virtual MaybeType solution(const Assignment& x) const {
return eq(x[0] * x[0], x[1]);
}
virtual bool extendAssignement(Assignment& x) const {
Gecode::FloatVal d = sqr(x[0]);
if (Gecode::Float::subset(d, dom)) {
x.set(1, d);
return true;
} else {
return false;
}
}
virtual void post(Gecode::Space& home, Gecode::FloatVarArray& x) {
Gecode::sqr(home, x[0], x[1]);
}
};
class SqrXX : public Test {
public:
SqrXX(const std::string& s, const Gecode::FloatVal& d, Gecode::FloatNum st)
: Test("Arithmetic::Sqr::XX::"+s,1,d,st,CPLT_ASSIGNMENT,false) {}
virtual MaybeType solution(const Assignment& x) const {
return eq(x[0] * x[0], x[0]);
}
virtual void post(Gecode::Space& home, Gecode::FloatVarArray& x) {
Gecode::sqr(home, x[0], x[0]);
}
};
class SqrtXY : public Test {
public:
SqrtXY(const std::string& s, const Gecode::FloatVal& d, Gecode::FloatNum st)
: Test("Arithmetic::Sqrt::XY::"+s,2,d,st,CPLT_ASSIGNMENT,false) {}
virtual MaybeType solution(const Assignment& x) const {
switch (cmp(x[0], Gecode::FRT_GQ, 0.0)) {
case MT_FALSE: return MT_FALSE;
case MT_MAYBE: return MT_MAYBE;
default:
return eq(sqrt(x[0]), x[1]);
}
}
virtual void post(Gecode::Space& home, Gecode::FloatVarArray& x) {
if (flip())
Gecode::sqrt(home, x[0], x[1]);
else
Gecode::rel(home, sqrt(x[0]) == x[1]);
}
};
class SqrtXYSol : public Test {
public:
SqrtXYSol(const std::string& s, const Gecode::FloatVal& d, Gecode::FloatNum st)
: Test("Arithmetic::Sqrt::XY::Sol::"+s,2,d,st,EXTEND_ASSIGNMENT,false) {}
virtual MaybeType solution(const Assignment& x) const {
switch (cmp(x[0], Gecode::FRT_GQ, 0.0)) {
case MT_FALSE: return MT_FALSE;
case MT_MAYBE: return MT_MAYBE;
default:
return eq(sqrt(x[0]), x[1]);
}
}
virtual bool extendAssignement(Assignment& x) const {
Gecode::FloatVal d = sqrt(abs(x[0]));
if (Gecode::Float::subset(d, dom)) {
x.set(1, d);
return true;
} else {
return false;
}
}
virtual void post(Gecode::Space& home, Gecode::FloatVarArray& x) {
Gecode::sqrt(home, x[0], x[1]);
}
};
class SqrtXX : public Test {
public:
SqrtXX(const std::string& s, const Gecode::FloatVal& d, Gecode::FloatNum st)
: Test("Arithmetic::Sqrt::XX::"+s,1,d,st,CPLT_ASSIGNMENT,false) {}
virtual MaybeType solution(const Assignment& x) const {
switch (cmp(x[0], Gecode::FRT_GQ, 0.0)) {
case MT_FALSE: return MT_FALSE;
case MT_MAYBE: return MT_MAYBE;
default:
return eq(sqrt(x[0]), x[0]);
}
}
virtual void post(Gecode::Space& home, Gecode::FloatVarArray& x) {
Gecode::sqrt(home, x[0], x[0]);
}
};
class PowXY : public Test {
unsigned int n;
public:
PowXY(const std::string& s, const Gecode::FloatVal& d, unsigned int _n, Gecode::FloatNum st)
: Test("Arithmetic::Pow::N::"+str(_n)+"::XY::"+s,2,d,st,CPLT_ASSIGNMENT,false), n(_n) {}
virtual MaybeType solution(const Assignment& x) const {
return eq(pow(x[0],n), x[1]);
}
virtual void post(Gecode::Space& home, Gecode::FloatVarArray& x) {
if (flip())
Gecode::pow(home, x[0], n, x[1]);
else
Gecode::rel(home, pow(x[0],n) == x[1]);
}
};
class PowXYSol : public Test {
unsigned int n;
public:
PowXYSol(const std::string& s, const Gecode::FloatVal& d, unsigned int _n, Gecode::FloatNum st)
: Test("Arithmetic::Pow::N::"+str(_n)+"::XY::Sol::"+s,2,d,st,EXTEND_ASSIGNMENT,false), n(_n) {}
virtual MaybeType solution(const Assignment& x) const {
return eq(pow(x[0],n), x[1]);
}
virtual bool extendAssignement(Assignment& x) const {
Gecode::FloatVal d = pow(x[0],n);
if (Gecode::Float::subset(d, dom)) {
x.set(1, d);
return true;
} else {
return false;
}
}
virtual void post(Gecode::Space& home, Gecode::FloatVarArray& x) {
Gecode::pow(home, x[0], n, x[1]);
}
};
class PowXX : public Test {
unsigned int n;
public:
PowXX(const std::string& s, const Gecode::FloatVal& d, unsigned int _n, Gecode::FloatNum st)
: Test("Arithmetic::Pow::N::"+str(_n)+"::XX::"+s,1,d,st,CPLT_ASSIGNMENT,false) {}
virtual MaybeType solution(const Assignment& x) const {
return eq(pow(x[0],n), x[0]);
}
virtual void post(Gecode::Space& home, Gecode::FloatVarArray& x) {
Gecode::pow(home, x[0], n, x[0]);
}
};
class NRootXY : public Test {
unsigned int n;
public:
NRootXY(const std::string& s, const Gecode::FloatVal& d, unsigned int _n, Gecode::FloatNum st)
: Test("Arithmetic::NRoot::N::"+str(_n)+"::XY::"+s,2,d,st,CPLT_ASSIGNMENT,false), n(_n) {}
virtual MaybeType solution(const Assignment& x) const {
if ((n == 0) || (x[0].max() < 0.0))
return MT_FALSE;
return eq(nroot(x[0],n), x[1]);
}
virtual void post(Gecode::Space& home, Gecode::FloatVarArray& x) {
if (flip())
Gecode::nroot(home, x[0], n, x[1]);
else
Gecode::rel(home, nroot(x[0],n) == x[1]);
}
};
class NRootXYSol : public Test {
unsigned int n;
public:
NRootXYSol(const std::string& s, const Gecode::FloatVal& d, unsigned int _n, Gecode::FloatNum st)
: Test("Arithmetic::NRoot::N::"+str(_n)+"::XY::Sol::"+s,2,d,st,EXTEND_ASSIGNMENT,false), n(_n) {}
virtual MaybeType solution(const Assignment& x) const {
if ((n == 0) || (x[0].max() < 0.0))
return MT_FALSE;
return eq(nroot(x[0],n), x[1]);
}
virtual bool extendAssignement(Assignment& x) const {
if ((n == 0) || (x[0].max() < 0))
return false;
Gecode::FloatVal d = nroot(x[0],n);
if (Gecode::Float::subset(d, dom)) {
x.set(1, d);
return true;
} else {
return false;
}
}
virtual void post(Gecode::Space& home, Gecode::FloatVarArray& x) {
Gecode::nroot(home, x[0], n, x[1]);
}
};
class NRootXX : public Test {
unsigned int n;
public:
NRootXX(const std::string& s, const Gecode::FloatVal& d, unsigned int _n, Gecode::FloatNum st)
: Test("Arithmetic::NRoot::N::"+str(_n)+"::XX::"+s,1,d,st,CPLT_ASSIGNMENT,false) {}
virtual MaybeType solution(const Assignment& x) const {
if ((n == 0) || (x[0].max() < 0))
return MT_FALSE;
return eq(nroot(x[0],n), x[0]);
}
virtual void post(Gecode::Space& home, Gecode::FloatVarArray& x) {
Gecode::nroot(home, x[0], n, x[0]);
}
};
class AbsXY : public Test {
public:
AbsXY(const std::string& s, const Gecode::FloatVal& d, Gecode::FloatNum st)
: Test("Arithmetic::Abs::XY::"+s,2,d,st,CPLT_ASSIGNMENT,false) {}
virtual MaybeType solution(const Assignment& x) const {
return eq(abs(x[0]), x[1]);
}
virtual void post(Gecode::Space& home, Gecode::FloatVarArray& x) {
if (flip())
Gecode::abs(home, x[0], x[1]);
else
Gecode::rel(home, abs(x[0]) == x[1]);
}
};
class AbsXX : public Test {
public:
AbsXX(const std::string& s, const Gecode::FloatVal& d, Gecode::FloatNum st)
: Test("Arithmetic::Abs::XX::"+s,1,d,st,CPLT_ASSIGNMENT,false) {}
virtual MaybeType solution(const Assignment& x) const {
return eq(abs(x[0]), x[0]);
}
virtual void post(Gecode::Space& home, Gecode::FloatVarArray& x) {
Gecode::abs(home, x[0], x[0]);
}
};
class MinXYZ : public Test {
public:
MinXYZ(const std::string& s, const Gecode::FloatVal& d, Gecode::FloatNum st)
: Test("Arithmetic::Min::Bin::XYZ::"+s,3,d,st,CPLT_ASSIGNMENT,false) {}
virtual MaybeType solution(const Assignment& x) const {
return eq(min(x[0],x[1]), x[2]);
}
virtual void post(Gecode::Space& home, Gecode::FloatVarArray& x) {
if (flip())
Gecode::min(home, x[0], x[1], x[2]);
else
Gecode::rel(home, min(x[0],x[1]) == x[2]);
}
};
class MinXXY : public Test {
public:
MinXXY(const std::string& s, const Gecode::FloatVal& d, Gecode::FloatNum st)
: Test("Arithmetic::Min::Bin::XXY::"+s,2,d,st,CPLT_ASSIGNMENT,false) {}
virtual MaybeType solution(const Assignment& x) const {
return eq(min(x[0],x[0]), x[1]);
}
virtual void post(Gecode::Space& home, Gecode::FloatVarArray& x) {
Gecode::min(home, x[0], x[0], x[1]);
}
};
class MinXYX : public Test {
public:
MinXYX(const std::string& s, const Gecode::FloatVal& d, Gecode::FloatNum st)
: Test("Arithmetic::Min::Bin::XYX::"+s,2,d,st,CPLT_ASSIGNMENT,false) {}
virtual MaybeType solution(const Assignment& x) const {
return eq(min(x[0],x[1]), x[0]);
}
virtual void post(Gecode::Space& home, Gecode::FloatVarArray& x) {
Gecode::min(home, x[0], x[1], x[0]);
}
};
class MinXYY : public Test {
public:
MinXYY(const std::string& s, const Gecode::FloatVal& d, Gecode::FloatNum st)
: Test("Arithmetic::Min::Bin::XYY::"+s,2,d,st,CPLT_ASSIGNMENT,false) {}
virtual MaybeType solution(const Assignment& x) const {
return eq(min(x[0],x[1]), x[1]);
}
virtual void post(Gecode::Space& home, Gecode::FloatVarArray& x) {
Gecode::min(home, x[0], x[1], x[1]);
}
};
class MinXXX : public Test {
public:
MinXXX(const std::string& s, const Gecode::FloatVal& d, Gecode::FloatNum st)
: Test("Arithmetic::Min::Bin::XXX::"+s,1,d,st,CPLT_ASSIGNMENT,false) {}
virtual MaybeType solution(const Assignment& x) const {
return eq(min(x[0],x[0]), x[0]);
}
virtual void post(Gecode::Space& home, Gecode::FloatVarArray& x) {
Gecode::min(home, x[0], x[0], x[0]);
}
};
class MaxXYZ : public Test {
public:
MaxXYZ(const std::string& s, const Gecode::FloatVal& d, Gecode::FloatNum st)
: Test("Arithmetic::Max::Bin::XYZ::"+s,3,d,st,CPLT_ASSIGNMENT,false) {}
virtual MaybeType solution(const Assignment& x) const {
return eq(max(x[0],x[1]), x[2]);
}
virtual void post(Gecode::Space& home, Gecode::FloatVarArray& x) {
if (flip())
Gecode::max(home, x[0], x[1], x[2]);
else
Gecode::rel(home, max(x[0], x[1]) == x[2]);
}
};
class MaxXXY : public Test {
public:
MaxXXY(const std::string& s, const Gecode::FloatVal& d, Gecode::FloatNum st)
: Test("Arithmetic::Max::Bin::XXY::"+s,2,d,st,CPLT_ASSIGNMENT,false) {}
virtual MaybeType solution(const Assignment& x) const {
return eq(max(x[0],x[0]), x[1]);
}
virtual void post(Gecode::Space& home, Gecode::FloatVarArray& x) {
Gecode::max(home, x[0], x[0], x[1]);
}
};
class MaxXYX : public Test {
public:
MaxXYX(const std::string& s, const Gecode::FloatVal& d, Gecode::FloatNum st)
: Test("Arithmetic::Max::Bin::XYX::"+s,2,d,st,CPLT_ASSIGNMENT,false) {}
virtual MaybeType solution(const Assignment& x) const {
return eq(max(x[0],x[1]), x[0]);
}
virtual void post(Gecode::Space& home, Gecode::FloatVarArray& x) {
Gecode::max(home, x[0], x[1], x[0]);
}
};
class MaxXYY : public Test {
public:
MaxXYY(const std::string& s, const Gecode::FloatVal& d, Gecode::FloatNum st)
: Test("Arithmetic::Max::Bin::XYY::"+s,2,d,st,CPLT_ASSIGNMENT,false) {}
virtual MaybeType solution(const Assignment& x) const {
return eq(max(x[0],x[1]), x[1]);
}
virtual void post(Gecode::Space& home, Gecode::FloatVarArray& x) {
Gecode::max(home, x[0], x[1], x[1]);
}
};
class MaxXXX : public Test {
public:
MaxXXX(const std::string& s, const Gecode::FloatVal& d, Gecode::FloatNum st)
: Test("Arithmetic::Max::Bin::XXX::"+s,1,d,st,CPLT_ASSIGNMENT,false) {}
virtual MaybeType solution(const Assignment& x) const {
return eq(max(x[0],x[0]), x[0]);
}
virtual void post(Gecode::Space& home, Gecode::FloatVarArray& x) {
Gecode::max(home, x[0], x[0], x[0]);
}
};
class MinNary : public Test {
public:
MinNary(void)
: Test("Arithmetic::Min::Nary",4,-4,4,0.5,CPLT_ASSIGNMENT,false) {}
virtual MaybeType solution(const Assignment& x) const {
return eq(min(min(x[0],x[1]),x[2]), x[3]);
}
virtual void post(Gecode::Space& home, Gecode::FloatVarArray& x) {
Gecode::FloatVarArgs m(3);
m[0]=x[0]; m[1]=x[1]; m[2]=x[2];
if (flip())
Gecode::min(home, m, x[3]);
else
Gecode::rel(home, min(m) == x[3]);
}
};
class MinNaryShared : public Test {
public:
MinNaryShared(void)
: Test("Arithmetic::Min::Nary::Shared",3,-4,4,0.5,CPLT_ASSIGNMENT,false) {}
virtual MaybeType solution(const Assignment& x) const {
return eq(min(min(x[0],x[1]),x[2]), x[1]);
}
virtual void post(Gecode::Space& home, Gecode::FloatVarArray& x) {
Gecode::FloatVarArgs m(3);
m[0]=x[0]; m[1]=x[1]; m[2]=x[2];
Gecode::min(home, m, x[1]);
}
};
class MaxNary : public Test {
public:
MaxNary(void)
: Test("Arithmetic::Max::Nary",4,-4,4,0.5,CPLT_ASSIGNMENT,false) {}
virtual MaybeType solution(const Assignment& x) const {
return eq(max(max(x[0],x[1]),x[2]), x[3]);
}
virtual void post(Gecode::Space& home, Gecode::FloatVarArray& x) {
Gecode::FloatVarArgs m(3);
m[0]=x[0]; m[1]=x[1]; m[2]=x[2];
if (flip())
Gecode::max(home, m, x[3]);
else
Gecode::rel(home, max(m) == x[3]);
}
};
class MaxNaryShared : public Test {
public:
MaxNaryShared(void)
: Test("Arithmetic::Max::Nary::Shared",3,-4,4,0.5,CPLT_ASSIGNMENT,false) {}
virtual MaybeType solution(const Assignment& x) const {
return eq(max(max(x[0],x[1]),x[2]), x[1]);
}
virtual void post(Gecode::Space& home, Gecode::FloatVarArray& x) {
Gecode::FloatVarArgs m(3);
m[0]=x[0]; m[1]=x[1]; m[2]=x[2];
Gecode::max(home, m, x[1]);
}
};
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;
}
}}
// STATISTICS: test-float
Gecode::FloatVal
Float value type.
Definition float.hh:334
Gecode::FloatVarArgs
Passing float variables.
Definition float.hh:979
Gecode::FloatVarArray
Float variable array.
Definition float.hh:1030
Gecode::Space
Computation spaces.
Definition core.hpp:1742
Test::Float::Arithmetic::AbsXX
Test for absolute value constraint with shared variables
Definition arithmetic.cpp:526
Test::Float::Arithmetic::AbsXX::solution
virtual MaybeType solution(const Assignment &x) const
Test whether x is solution
Definition arithmetic.cpp:532
Test::Float::Arithmetic::AbsXX::AbsXX
AbsXX(const std::string &s, const Gecode::FloatVal &d, Gecode::FloatNum st)
Create and register test.
Definition arithmetic.cpp:529
Test::Float::Arithmetic::AbsXX::post
virtual void post(Gecode::Space &home, Gecode::FloatVarArray &x)
Post constraint on x.
Definition arithmetic.cpp:536
Test::Float::Arithmetic::AbsXY
Test for absolute value constraint
Definition arithmetic.cpp:507
Test::Float::Arithmetic::AbsXY::AbsXY
AbsXY(const std::string &s, const Gecode::FloatVal &d, Gecode::FloatNum st)
Create and register test.
Definition arithmetic.cpp:510
Test::Float::Arithmetic::AbsXY::solution
virtual MaybeType solution(const Assignment &x) const
Test whether x is solution
Definition arithmetic.cpp:513
Test::Float::Arithmetic::AbsXY::post
virtual void post(Gecode::Space &home, Gecode::FloatVarArray &x)
Post constraint on x.
Definition arithmetic.cpp:517
Test::Float::Arithmetic::DivSol
Test for division constraint when solution is ensured
Definition arithmetic.cpp:208
Test::Float::Arithmetic::DivSol::solution
virtual MaybeType solution(const Assignment &x) const
Test whether x is solution
Definition arithmetic.cpp:214
Test::Float::Arithmetic::DivSol::post
virtual void post(Gecode::Space &home, Gecode::FloatVarArray &x)
Post constraint on x.
Definition arithmetic.cpp:228
Test::Float::Arithmetic::DivSol::DivSol
DivSol(const std::string &s, const Gecode::FloatVal &d, Gecode::FloatNum st)
Create and register test.
Definition arithmetic.cpp:211
Test::Float::Arithmetic::DivSol::extendAssignement
virtual bool extendAssignement(Assignment &x) const
Extend assignment x.
Definition arithmetic.cpp:218
Test::Float::Arithmetic::Div
Test for division constraint
Definition arithmetic.cpp:189
Test::Float::Arithmetic::Div::post
virtual void post(Gecode::Space &home, Gecode::FloatVarArray &x)
Post constraint on x.
Definition arithmetic.cpp:199
Test::Float::Arithmetic::Div::Div
Div(const std::string &s, const Gecode::FloatVal &d, Gecode::FloatNum st)
Create and register test.
Definition arithmetic.cpp:192
Test::Float::Arithmetic::Div::solution
virtual MaybeType solution(const Assignment &x) const
Test whether x is solution
Definition arithmetic.cpp:195
Test::Float::Arithmetic::MaxNaryShared
Test for n-ary maximum constraint with shared variables
Definition arithmetic.cpp:768
Test::Float::Arithmetic::MaxNaryShared::post
virtual void post(Gecode::Space &home, Gecode::FloatVarArray &x)
Post constraint on x.
Definition arithmetic.cpp:778
Test::Float::Arithmetic::MaxNaryShared::MaxNaryShared
MaxNaryShared(void)
Create and register test.
Definition arithmetic.cpp:771
Test::Float::Arithmetic::MaxNaryShared::solution
virtual MaybeType solution(const Assignment &x) const
Test whether x is solution
Definition arithmetic.cpp:774
Test::Float::Arithmetic::MaxNary
Test for n-ary maximum constraint
Definition arithmetic.cpp:747
Test::Float::Arithmetic::MaxNary::MaxNary
MaxNary(void)
Create and register test.
Definition arithmetic.cpp:750
Test::Float::Arithmetic::MaxNary::post
virtual void post(Gecode::Space &home, Gecode::FloatVarArray &x)
Post constraint on x.
Definition arithmetic.cpp:757
Test::Float::Arithmetic::MaxNary::solution
virtual MaybeType solution(const Assignment &x) const
Test whether x is solution
Definition arithmetic.cpp:753
Test::Float::Arithmetic::MaxXXX
Test for binary maximum constraint with shared variables
Definition arithmetic.cpp:692
Test::Float::Arithmetic::MaxXXX::MaxXXX
MaxXXX(const std::string &s, const Gecode::FloatVal &d, Gecode::FloatNum st)
Create and register test.
Definition arithmetic.cpp:695
Test::Float::Arithmetic::MaxXXX::post
virtual void post(Gecode::Space &home, Gecode::FloatVarArray &x)
Post constraint on x.
Definition arithmetic.cpp:702
Test::Float::Arithmetic::MaxXXX::solution
virtual MaybeType solution(const Assignment &x) const
Test whether x is solution
Definition arithmetic.cpp:698
Test::Float::Arithmetic::MaxXXY
Test for binary maximum constraint with shared variables
Definition arithmetic.cpp:644
Test::Float::Arithmetic::MaxXXY::post
virtual void post(Gecode::Space &home, Gecode::FloatVarArray &x)
Post constraint on x.
Definition arithmetic.cpp:654
Test::Float::Arithmetic::MaxXXY::MaxXXY
MaxXXY(const std::string &s, const Gecode::FloatVal &d, Gecode::FloatNum st)
Create and register test.
Definition arithmetic.cpp:647
Test::Float::Arithmetic::MaxXXY::solution
virtual MaybeType solution(const Assignment &x) const
Test whether x is solution
Definition arithmetic.cpp:650
Test::Float::Arithmetic::MaxXYX
Test for binary maximum constraint with shared variables
Definition arithmetic.cpp:660
Test::Float::Arithmetic::MaxXYX::solution
virtual MaybeType solution(const Assignment &x) const
Test whether x is solution
Definition arithmetic.cpp:666
Test::Float::Arithmetic::MaxXYX::post
virtual void post(Gecode::Space &home, Gecode::FloatVarArray &x)
Post constraint on x.
Definition arithmetic.cpp:670
Test::Float::Arithmetic::MaxXYX::MaxXYX
MaxXYX(const std::string &s, const Gecode::FloatVal &d, Gecode::FloatNum st)
Create and register test.
Definition arithmetic.cpp:663
Test::Float::Arithmetic::MaxXYY
Test for binary maximum constraint with shared variables
Definition arithmetic.cpp:676
Test::Float::Arithmetic::MaxXYY::solution
virtual MaybeType solution(const Assignment &x) const
Test whether x is solution
Definition arithmetic.cpp:682
Test::Float::Arithmetic::MaxXYY::MaxXYY
MaxXYY(const std::string &s, const Gecode::FloatVal &d, Gecode::FloatNum st)
Create and register test.
Definition arithmetic.cpp:679
Test::Float::Arithmetic::MaxXYY::post
virtual void post(Gecode::Space &home, Gecode::FloatVarArray &x)
Post constraint on x.
Definition arithmetic.cpp:686
Test::Float::Arithmetic::MaxXYZ
Test for binary maximum constraint
Definition arithmetic.cpp:625
Test::Float::Arithmetic::MaxXYZ::MaxXYZ
MaxXYZ(const std::string &s, const Gecode::FloatVal &d, Gecode::FloatNum st)
Create and register test.
Definition arithmetic.cpp:628
Test::Float::Arithmetic::MaxXYZ::solution
virtual MaybeType solution(const Assignment &x) const
Test whether x is solution
Definition arithmetic.cpp:631
Test::Float::Arithmetic::MaxXYZ::post
virtual void post(Gecode::Space &home, Gecode::FloatVarArray &x)
Post constraint on x.
Definition arithmetic.cpp:635
Test::Float::Arithmetic::MinNaryShared
Test for n-ary minimmum constraint with shared variables
Definition arithmetic.cpp:729
Test::Float::Arithmetic::MinNaryShared::MinNaryShared
MinNaryShared(void)
Create and register test.
Definition arithmetic.cpp:732
Test::Float::Arithmetic::MinNaryShared::solution
virtual MaybeType solution(const Assignment &x) const
Test whether x is solution
Definition arithmetic.cpp:735
Test::Float::Arithmetic::MinNaryShared::post
virtual void post(Gecode::Space &home, Gecode::FloatVarArray &x)
Post constraint on x.
Definition arithmetic.cpp:739
Test::Float::Arithmetic::MinNary
Test for n-ary minimmum constraint
Definition arithmetic.cpp:708
Test::Float::Arithmetic::MinNary::solution
virtual MaybeType solution(const Assignment &x) const
Test whether x is solution
Definition arithmetic.cpp:714
Test::Float::Arithmetic::MinNary::post
virtual void post(Gecode::Space &home, Gecode::FloatVarArray &x)
Post constraint on x.
Definition arithmetic.cpp:718
Test::Float::Arithmetic::MinNary::MinNary
MinNary(void)
Create and register test.
Definition arithmetic.cpp:711
Test::Float::Arithmetic::MinXXX
Test for binary minimum constraint with shared variables
Definition arithmetic.cpp:609
Test::Float::Arithmetic::MinXXX::solution
virtual MaybeType solution(const Assignment &x) const
Test whether x is solution
Definition arithmetic.cpp:615
Test::Float::Arithmetic::MinXXX::MinXXX
MinXXX(const std::string &s, const Gecode::FloatVal &d, Gecode::FloatNum st)
Create and register test.
Definition arithmetic.cpp:612
Test::Float::Arithmetic::MinXXX::post
virtual void post(Gecode::Space &home, Gecode::FloatVarArray &x)
Post constraint on x.
Definition arithmetic.cpp:619
Test::Float::Arithmetic::MinXXY
Test for binary minimum constraint with shared variables
Definition arithmetic.cpp:561
Test::Float::Arithmetic::MinXXY::MinXXY
MinXXY(const std::string &s, const Gecode::FloatVal &d, Gecode::FloatNum st)
Create and register test.
Definition arithmetic.cpp:564
Test::Float::Arithmetic::MinXXY::post
virtual void post(Gecode::Space &home, Gecode::FloatVarArray &x)
Post constraint on x.
Definition arithmetic.cpp:571
Test::Float::Arithmetic::MinXXY::solution
virtual MaybeType solution(const Assignment &x) const
Test whether x is solution
Definition arithmetic.cpp:567
Test::Float::Arithmetic::MinXYX
Test for binary minimum constraint with shared variables
Definition arithmetic.cpp:577
Test::Float::Arithmetic::MinXYX::MinXYX
MinXYX(const std::string &s, const Gecode::FloatVal &d, Gecode::FloatNum st)
Create and register test.
Definition arithmetic.cpp:580
Test::Float::Arithmetic::MinXYX::solution
virtual MaybeType solution(const Assignment &x) const
Test whether x is solution
Definition arithmetic.cpp:583
Test::Float::Arithmetic::MinXYX::post
virtual void post(Gecode::Space &home, Gecode::FloatVarArray &x)
Post constraint on x.
Definition arithmetic.cpp:587
Test::Float::Arithmetic::MinXYY
Test for binary minimum constraint with shared variables
Definition arithmetic.cpp:593
Test::Float::Arithmetic::MinXYY::solution
virtual MaybeType solution(const Assignment &x) const
Test whether x is solution
Definition arithmetic.cpp:599
Test::Float::Arithmetic::MinXYY::MinXYY
MinXYY(const std::string &s, const Gecode::FloatVal &d, Gecode::FloatNum st)
Create and register test.
Definition arithmetic.cpp:596
Test::Float::Arithmetic::MinXYY::post
virtual void post(Gecode::Space &home, Gecode::FloatVarArray &x)
Post constraint on x.
Definition arithmetic.cpp:603
Test::Float::Arithmetic::MinXYZ
Test for binary minimum constraint
Definition arithmetic.cpp:542
Test::Float::Arithmetic::MinXYZ::solution
virtual MaybeType solution(const Assignment &x) const
Test whether x is solution
Definition arithmetic.cpp:548
Test::Float::Arithmetic::MinXYZ::post
virtual void post(Gecode::Space &home, Gecode::FloatVarArray &x)
Post constraint on x.
Definition arithmetic.cpp:552
Test::Float::Arithmetic::MinXYZ::MinXYZ
MinXYZ(const std::string &s, const Gecode::FloatVal &d, Gecode::FloatNum st)
Create and register test.
Definition arithmetic.cpp:545
Test::Float::Arithmetic::MultXXX
Test for multiplication constraint with shared variables
Definition arithmetic.cpp:173
Test::Float::Arithmetic::MultXXX::post
virtual void post(Gecode::Space &home, Gecode::FloatVarArray &x)
Post constraint on x.
Definition arithmetic.cpp:183
Test::Float::Arithmetic::MultXXX::solution
virtual MaybeType solution(const Assignment &x) const
Test whether x is solution
Definition arithmetic.cpp:179
Test::Float::Arithmetic::MultXXX::MultXXX
MultXXX(const std::string &s, const Gecode::FloatVal &d, Gecode::FloatNum st)
Create and register test.
Definition arithmetic.cpp:176
Test::Float::Arithmetic::MultXXYSol
Test for multiplication constraint with shared variables when solution is ensured
Definition arithmetic.cpp:115
Test::Float::Arithmetic::MultXXYSol::extendAssignement
virtual bool extendAssignement(Assignment &x) const
Extend assignment x.
Definition arithmetic.cpp:125
Test::Float::Arithmetic::MultXXYSol::MultXXYSol
MultXXYSol(const std::string &s, const Gecode::FloatVal &d, Gecode::FloatNum st)
Create and register test.
Definition arithmetic.cpp:118
Test::Float::Arithmetic::MultXXYSol::solution
virtual MaybeType solution(const Assignment &x) const
Test whether x is solution
Definition arithmetic.cpp:121
Test::Float::Arithmetic::MultXXYSol::post
virtual void post(Gecode::Space &home, Gecode::FloatVarArray &x)
Post constraint on x.
Definition arithmetic.cpp:135
Test::Float::Arithmetic::MultXXY
Test for multiplication constraint with shared variables
Definition arithmetic.cpp:99
Test::Float::Arithmetic::MultXXY::post
virtual void post(Gecode::Space &home, Gecode::FloatVarArray &x)
Post constraint on x.
Definition arithmetic.cpp:109
Test::Float::Arithmetic::MultXXY::solution
virtual MaybeType solution(const Assignment &x) const
Test whether x is solution
Definition arithmetic.cpp:105
Test::Float::Arithmetic::MultXXY::MultXXY
MultXXY(const std::string &s, const Gecode::FloatVal &d, Gecode::FloatNum st)
Create and register test.
Definition arithmetic.cpp:102
Test::Float::Arithmetic::MultXYX
Test for multiplication constraint with shared variables
Definition arithmetic.cpp:141
Test::Float::Arithmetic::MultXYX::post
virtual void post(Gecode::Space &home, Gecode::FloatVarArray &x)
Post constraint on x.
Definition arithmetic.cpp:151
Test::Float::Arithmetic::MultXYX::MultXYX
MultXYX(const std::string &s, const Gecode::FloatVal &d, Gecode::FloatNum st)
Create and register test.
Definition arithmetic.cpp:144
Test::Float::Arithmetic::MultXYX::solution
virtual MaybeType solution(const Assignment &x) const
Test whether x is solution
Definition arithmetic.cpp:147
Test::Float::Arithmetic::MultXYY
Test for multiplication constraint with shared variables
Definition arithmetic.cpp:157
Test::Float::Arithmetic::MultXYY::MultXYY
MultXYY(const std::string &s, const Gecode::FloatVal &d, Gecode::FloatNum st)
Create and register test.
Definition arithmetic.cpp:160
Test::Float::Arithmetic::MultXYY::solution
virtual MaybeType solution(const Assignment &x) const
Test whether x is solution
Definition arithmetic.cpp:163
Test::Float::Arithmetic::MultXYY::post
virtual void post(Gecode::Space &home, Gecode::FloatVarArray &x)
Post constraint on x.
Definition arithmetic.cpp:167
Test::Float::Arithmetic::MultXYZSol
Test for multiplication constraint when solution is ensured
Definition arithmetic.cpp:73
Test::Float::Arithmetic::MultXYZSol::solution
virtual MaybeType solution(const Assignment &x) const
Test whether x is solution
Definition arithmetic.cpp:79
Test::Float::Arithmetic::MultXYZSol::post
virtual void post(Gecode::Space &home, Gecode::FloatVarArray &x)
Post constraint on x.
Definition arithmetic.cpp:93
Test::Float::Arithmetic::MultXYZSol::extendAssignement
virtual bool extendAssignement(Assignment &x) const
Extend assignment x.
Definition arithmetic.cpp:83
Test::Float::Arithmetic::MultXYZSol::MultXYZSol
MultXYZSol(const std::string &s, const Gecode::FloatVal &d, Gecode::FloatNum st)
Create and register test.
Definition arithmetic.cpp:76
Test::Float::Arithmetic::MultXYZ
Test for multiplication constraint
Definition arithmetic.cpp:54
Test::Float::Arithmetic::MultXYZ::MultXYZ
MultXYZ(const std::string &s, const Gecode::FloatVal &d, Gecode::FloatNum st)
Create and register test.
Definition arithmetic.cpp:57
Test::Float::Arithmetic::MultXYZ::solution
virtual MaybeType solution(const Assignment &x) const
Test whether x is solution
Definition arithmetic.cpp:60
Test::Float::Arithmetic::MultXYZ::post
virtual void post(Gecode::Space &home, Gecode::FloatVarArray &x)
Post constraint on x.
Definition arithmetic.cpp:64
Test::Float::Arithmetic::NRootXX
Test for nroot constraint with shared variables
Definition arithmetic.cpp:488
Test::Float::Arithmetic::NRootXX::post
virtual void post(Gecode::Space &home, Gecode::FloatVarArray &x)
Post constraint on x.
Definition arithmetic.cpp:501
Test::Float::Arithmetic::NRootXX::NRootXX
NRootXX(const std::string &s, const Gecode::FloatVal &d, unsigned int _n, Gecode::FloatNum st)
Create and register test.
Definition arithmetic.cpp:492
Test::Float::Arithmetic::NRootXX::solution
virtual MaybeType solution(const Assignment &x) const
Test whether x is solution
Definition arithmetic.cpp:495
Test::Float::Arithmetic::NRootXYSol
Test for nroot constraint where solution is ensured
Definition arithmetic.cpp:457
Test::Float::Arithmetic::NRootXYSol::solution
virtual MaybeType solution(const Assignment &x) const
Test whether x is solution
Definition arithmetic.cpp:464
Test::Float::Arithmetic::NRootXYSol::extendAssignement
virtual bool extendAssignement(Assignment &x) const
Extend assignment x.
Definition arithmetic.cpp:470
Test::Float::Arithmetic::NRootXYSol::post
virtual void post(Gecode::Space &home, Gecode::FloatVarArray &x)
Post constraint on x.
Definition arithmetic.cpp:482
Test::Float::Arithmetic::NRootXYSol::NRootXYSol
NRootXYSol(const std::string &s, const Gecode::FloatVal &d, unsigned int _n, Gecode::FloatNum st)
Create and register test.
Definition arithmetic.cpp:461
Test::Float::Arithmetic::NRootXY
Test for nroot constraint
Definition arithmetic.cpp:435
Test::Float::Arithmetic::NRootXY::post
virtual void post(Gecode::Space &home, Gecode::FloatVarArray &x)
Post constraint on x.
Definition arithmetic.cpp:448
Test::Float::Arithmetic::NRootXY::NRootXY
NRootXY(const std::string &s, const Gecode::FloatVal &d, unsigned int _n, Gecode::FloatNum st)
Create and register test.
Definition arithmetic.cpp:439
Test::Float::Arithmetic::NRootXY::solution
virtual MaybeType solution(const Assignment &x) const
Test whether x is solution
Definition arithmetic.cpp:442
Test::Float::Arithmetic::PowXX
Test for pow constraint with shared variables
Definition arithmetic.cpp:418
Test::Float::Arithmetic::PowXX::post
virtual void post(Gecode::Space &home, Gecode::FloatVarArray &x)
Post constraint on x.
Definition arithmetic.cpp:429
Test::Float::Arithmetic::PowXX::PowXX
PowXX(const std::string &s, const Gecode::FloatVal &d, unsigned int _n, Gecode::FloatNum st)
Create and register test.
Definition arithmetic.cpp:422
Test::Float::Arithmetic::PowXX::solution
virtual MaybeType solution(const Assignment &x) const
Test whether x is solution
Definition arithmetic.cpp:425
Test::Float::Arithmetic::PowXYSol
Test for pow constraint where solution is ensured
Definition arithmetic.cpp:391
Test::Float::Arithmetic::PowXYSol::PowXYSol
PowXYSol(const std::string &s, const Gecode::FloatVal &d, unsigned int _n, Gecode::FloatNum st)
Create and register test.
Definition arithmetic.cpp:395
Test::Float::Arithmetic::PowXYSol::extendAssignement
virtual bool extendAssignement(Assignment &x) const
Extend assignment x.
Definition arithmetic.cpp:402
Test::Float::Arithmetic::PowXYSol::solution
virtual MaybeType solution(const Assignment &x) const
Test whether x is solution
Definition arithmetic.cpp:398
Test::Float::Arithmetic::PowXYSol::post
virtual void post(Gecode::Space &home, Gecode::FloatVarArray &x)
Post constraint on x.
Definition arithmetic.cpp:412
Test::Float::Arithmetic::PowXY
Test for pow constraint
Definition arithmetic.cpp:371
Test::Float::Arithmetic::PowXY::solution
virtual MaybeType solution(const Assignment &x) const
Test whether x is solution
Definition arithmetic.cpp:378
Test::Float::Arithmetic::PowXY::PowXY
PowXY(const std::string &s, const Gecode::FloatVal &d, unsigned int _n, Gecode::FloatNum st)
Create and register test.
Definition arithmetic.cpp:375
Test::Float::Arithmetic::PowXY::post
virtual void post(Gecode::Space &home, Gecode::FloatVarArray &x)
Post constraint on x.
Definition arithmetic.cpp:382
Test::Float::Arithmetic::SqrXX
Test for squaring constraint with shared variables
Definition arithmetic.cpp:279
Test::Float::Arithmetic::SqrXX::post
virtual void post(Gecode::Space &home, Gecode::FloatVarArray &x)
Post constraint on x.
Definition arithmetic.cpp:289
Test::Float::Arithmetic::SqrXX::SqrXX
SqrXX(const std::string &s, const Gecode::FloatVal &d, Gecode::FloatNum st)
Create and register test.
Definition arithmetic.cpp:282
Test::Float::Arithmetic::SqrXX::solution
virtual MaybeType solution(const Assignment &x) const
Test whether x is solution
Definition arithmetic.cpp:285
Test::Float::Arithmetic::SqrXYSol
Test for squaring constraint where solution is ensured
Definition arithmetic.cpp:253
Test::Float::Arithmetic::SqrXYSol::post
virtual void post(Gecode::Space &home, Gecode::FloatVarArray &x)
Post constraint on x.
Definition arithmetic.cpp:273
Test::Float::Arithmetic::SqrXYSol::SqrXYSol
SqrXYSol(const std::string &s, const Gecode::FloatVal &d, Gecode::FloatNum st)
Create and register test.
Definition arithmetic.cpp:256
Test::Float::Arithmetic::SqrXYSol::solution
virtual MaybeType solution(const Assignment &x) const
Test whether x is solution
Definition arithmetic.cpp:259
Test::Float::Arithmetic::SqrXYSol::extendAssignement
virtual bool extendAssignement(Assignment &x) const
Extend assignment x.
Definition arithmetic.cpp:263
Test::Float::Arithmetic::SqrXY
Test for squaring constraint
Definition arithmetic.cpp:234
Test::Float::Arithmetic::SqrXY::SqrXY
SqrXY(const std::string &s, const Gecode::FloatVal &d, Gecode::FloatNum st)
Create and register test.
Definition arithmetic.cpp:237
Test::Float::Arithmetic::SqrXY::solution
virtual MaybeType solution(const Assignment &x) const
Test whether x is solution
Definition arithmetic.cpp:240
Test::Float::Arithmetic::SqrXY::post
virtual void post(Gecode::Space &home, Gecode::FloatVarArray &x)
Post constraint on x.
Definition arithmetic.cpp:244
Test::Float::Arithmetic::SqrtXX
Test for square root constraint with shared variables
Definition arithmetic.cpp:350
Test::Float::Arithmetic::SqrtXX::post
virtual void post(Gecode::Space &home, Gecode::FloatVarArray &x)
Post constraint on x.
Definition arithmetic.cpp:365
Test::Float::Arithmetic::SqrtXX::SqrtXX
SqrtXX(const std::string &s, const Gecode::FloatVal &d, Gecode::FloatNum st)
Create and register test.
Definition arithmetic.cpp:353
Test::Float::Arithmetic::SqrtXX::solution
virtual MaybeType solution(const Assignment &x) const
Test whether x is solution
Definition arithmetic.cpp:356
Test::Float::Arithmetic::SqrtXYSol
Test for square root constraint where solution is ensured
Definition arithmetic.cpp:319
Test::Float::Arithmetic::SqrtXYSol::solution
virtual MaybeType solution(const Assignment &x) const
Test whether x is solution
Definition arithmetic.cpp:325
Test::Float::Arithmetic::SqrtXYSol::SqrtXYSol
SqrtXYSol(const std::string &s, const Gecode::FloatVal &d, Gecode::FloatNum st)
Create and register test.
Definition arithmetic.cpp:322
Test::Float::Arithmetic::SqrtXYSol::extendAssignement
virtual bool extendAssignement(Assignment &x) const
Extend assignment x.
Definition arithmetic.cpp:334
Test::Float::Arithmetic::SqrtXYSol::post
virtual void post(Gecode::Space &home, Gecode::FloatVarArray &x)
Post constraint on x.
Definition arithmetic.cpp:344
Test::Float::Arithmetic::SqrtXY
Test for square root constraint
Definition arithmetic.cpp:295
Test::Float::Arithmetic::SqrtXY::post
virtual void post(Gecode::Space &home, Gecode::FloatVarArray &x)
Post constraint on x.
Definition arithmetic.cpp:310
Test::Float::Arithmetic::SqrtXY::SqrtXY
SqrtXY(const std::string &s, const Gecode::FloatVal &d, Gecode::FloatNum st)
Create and register test.
Definition arithmetic.cpp:298
Test::Float::Arithmetic::SqrtXY::solution
virtual MaybeType solution(const Assignment &x) const
Test whether x is solution
Definition arithmetic.cpp:301
Test::Float::Assignment
Base class for assignments
Definition float.hh:80
Test::Float::Assignment::set
virtual void set(int i, const Gecode::FloatVal &val)=0
Set assignment to value val for variable i.
Test::Float::Test::eq
static MaybeType eq(Gecode::FloatVal x, Gecode::FloatVal y)
Whether x and y are equal.
Definition float.hpp:268
Test::Float::Test::cmp
static MaybeType cmp(Gecode::FloatVal x, Gecode::FloatRelType r, Gecode::FloatVal y)
Compare x and y with respect to r.
Definition float.hpp:235
Test::Float::Test::str
static std::string str(Gecode::FloatRelType frt)
Map float relation to string.
Definition float.hpp:194
Test::Float::Test::flip
bool flip(void)
Flip a coin and return true or false randomly.
Definition float.hpp:273
Test::Float::Test::dom
Gecode::FloatVal dom
Domain of variables.
Definition float.hh:249
Gecode::rel
void rel(Home home, FloatVar x0, FloatRelType frt, FloatVar x1)
Post propagator for .
Definition rel.cpp:68
Gecode::FloatNum
double FloatNum
Floating point number base type.
Definition float.hh:106
Gecode::FRT_GQ
@ FRT_GQ
Greater or equal ( ).
Definition float.hh:1073
minimodel.hh
Gecode::Float::subset
bool subset(const FloatVal &x, const FloatVal &y)
Definition val.hpp:490
Gecode::sqr
void sqr(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
Definition arithmetic.cpp:95
Gecode::min
void min(Home home, FloatVar x0, FloatVar x1, FloatVar x2)
Post propagator for .
Definition arithmetic.cpp:67
Gecode::abs
void abs(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
Definition arithmetic.cpp:41
Gecode::div
void div(Home home, FloatVar x0, FloatVar x1, FloatVar x2)
Post propagator for .
Definition arithmetic.cpp:127
Gecode::mult
void mult(Home home, FloatVar x0, FloatVar x1, FloatVar x2)
Post propagator for .
Definition arithmetic.cpp:88
Gecode::sqrt
void sqrt(Home home, FloatVar x0, FloatVar x1)
Post propagator for .
Definition arithmetic.cpp:102
Gecode::max
void max(Home home, FloatVar x0, FloatVar x1, FloatVar x2)
Post propagator for .
Definition arithmetic.cpp:49
Gecode::pow
void pow(Home home, FloatVar x0, int n, FloatVar x1)
Post propagator for for $n\geq 0$.
Definition arithmetic.cpp:109
Gecode::nroot
void nroot(Home home, FloatVar x0, int n, FloatVar x1)
Post propagator for for $n\geq 0$.
Definition arithmetic.cpp:118
Test::Float::Arithmetic
Tests for arithmetic constraints
Definition arithmetic.cpp:46
Test::Float::Arithmetic::abs_xy_b
AbsXY abs_xy_b("B", b, step)
Test::Float::Arithmetic::div_b
Div div_b("B", b, step)
Test::Float::Arithmetic::sqrt_xy_b
SqrtXY sqrt_xy_b("B", b, step)
Test::Float::Arithmetic::min_xyx_b
MinXYX min_xyx_b("B", b, step)
Test::Float::Arithmetic::mult_xyy_b
MultXYY mult_xyy_b("B", b, step)
Test::Float::Arithmetic::abs_xy_a
AbsXY abs_xy_a("A", a, step)
Test::Float::Arithmetic::pow_xx_b_3
PowXX pow_xx_b_3("B", b, 0, step)
Test::Float::Arithmetic::max_xyz_b
MaxXYZ max_xyz_b("B", b, step)
Test::Float::Arithmetic::min_xyy_a
MinXYY min_xyy_a("A", a, step)
Test::Float::Arithmetic::mult_xyy_c
MultXYY mult_xyy_c("C", c, step)
Test::Float::Arithmetic::nroot_xx_b_1
NRootXX nroot_xx_b_1("B", b, 2, step)
Test::Float::Arithmetic::max_xyz_c
MaxXYZ max_xyz_c("C", c, step)
Test::Float::Arithmetic::min_xxy_c
MinXXY min_xxy_c("C", c, step)
Test::Float::Arithmetic::nroot_xx_b_2
NRootXX nroot_xx_b_2("B", b, 3, step)
Test::Float::Arithmetic::min_nary
MinNary min_nary
Definition arithmetic.cpp:970
Test::Float::Arithmetic::div_sol_a
DivSol div_sol_a("A", a, step)
Test::Float::Arithmetic::sqrt_xy_sol_a
SqrtXYSol sqrt_xy_sol_a("A", a, step)
Test::Float::Arithmetic::nroot_xy_sol_c_3
NRootXYSol nroot_xy_sol_c_3("C", c, 0, step)
Test::Float::Arithmetic::sqr_xy_sol_b
SqrXYSol sqr_xy_sol_b("B", b, step)
Test::Float::Arithmetic::abs_xx_c
AbsXX abs_xx_c("C", c, step)
Test::Float::Arithmetic::pow_xx_b_2
PowXX pow_xx_b_2("B", b, 3, step)
Test::Float::Arithmetic::div_c
Div div_c("C", c, step)
Test::Float::Arithmetic::pow_xy_sol_b_1
PowXYSol pow_xy_sol_b_1("B", b, 2, step)
Test::Float::Arithmetic::max_s_nary
MaxNaryShared max_s_nary
Definition arithmetic.cpp:973
Test::Float::Arithmetic::sqr_xy_b
SqrXY sqr_xy_b("B", b, step)
Test::Float::Arithmetic::pow_xx_c_1
PowXX pow_xx_c_1("C", c, 2, step)
Test::Float::Arithmetic::sqrt_xy_sol_c
SqrtXYSol sqrt_xy_sol_c("C", c, step)
Test::Float::Arithmetic::c
Gecode::FloatVal c(-8, 8)
Test::Float::Arithmetic::pow_xy_b_2
PowXY pow_xy_b_2("B", b, 3, step)
Test::Float::Arithmetic::mult_xxy_c
MultXXY mult_xxy_c("C", c, step)
Test::Float::Arithmetic::nroot_xx_a_2
NRootXX nroot_xx_a_2("A", a, 3, step)
Test::Float::Arithmetic::pow_xy_sol_c_3
PowXYSol pow_xy_sol_c_3("C", c, 0, step)
Test::Float::Arithmetic::nroot_xy_sol_c_1
NRootXYSol nroot_xy_sol_c_1("C", c, 2, step)
Test::Float::Arithmetic::min_xyz_a
MinXYZ min_xyz_a("A", a, step)
Test::Float::Arithmetic::nroot_xy_sol_b_1
NRootXYSol nroot_xy_sol_b_1("B", b, 2, step)
Test::Float::Arithmetic::nroot_xy_a_1
NRootXY nroot_xy_a_1("A", a, 2, step)
Test::Float::Arithmetic::max_xyx_a
MaxXYX max_xyx_a("A", a, step)
Test::Float::Arithmetic::max_xyy_a
MaxXYY max_xyy_a("A", a, step)
Test::Float::Arithmetic::sqrt_xx_b
SqrtXX sqrt_xx_b("B", b, step)
Test::Float::Arithmetic::sqr_xx_c
SqrXX sqr_xx_c("C", c, step)
Test::Float::Arithmetic::min_xyx_a
MinXYX min_xyx_a("A", a, step)
Test::Float::Arithmetic::pow_xx_a_3
PowXX pow_xx_a_3("A", a, 0, step)
Test::Float::Arithmetic::pow_xy_c_2
PowXY pow_xy_c_2("C", c, 3, step)
Test::Float::Arithmetic::mult_xyz_b
MultXYZ mult_xyz_b("B", b, step)
Test::Float::Arithmetic::nroot_xy_b_2
NRootXY nroot_xy_b_2("B", b, 3, step)
Test::Float::Arithmetic::mult_xyx_a
MultXYX mult_xyx_a("A", a, step)
Test::Float::Arithmetic::mult_xyz_c
MultXYZ mult_xyz_c("C", c, step)
Test::Float::Arithmetic::mult_xyz_a
MultXYZ mult_xyz_a("A", a, step)
Test::Float::Arithmetic::mult_xxx_c
MultXXX mult_xxx_c("C", c, step)
Test::Float::Arithmetic::pow_xy_sol_a_1
PowXYSol pow_xy_sol_a_1("A", a, 2, step)
Test::Float::Arithmetic::mult_xyz_sol_c
MultXYZSol mult_xyz_sol_c("C", c, step)
Test::Float::Arithmetic::nroot_xy_b_3
NRootXY nroot_xy_b_3("B", b, 0, step)
Test::Float::Arithmetic::min_xxx_b
MinXXX min_xxx_b("B", b, step)
Test::Float::Arithmetic::min_xxy_b
MinXXY min_xxy_b("B", b, step)
Test::Float::Arithmetic::nroot_xy_c_1
NRootXY nroot_xy_c_1("C", c, 2, step)
Test::Float::Arithmetic::min_xyy_b
MinXYY min_xyy_b("B", b, step)
Test::Float::Arithmetic::min_xyy_c
MinXYY min_xyy_c("C", c, step)
Test::Float::Arithmetic::nroot_xx_c_3
NRootXX nroot_xx_c_3("C", c, 0, step)
Test::Float::Arithmetic::nroot_xy_c_2
NRootXY nroot_xy_c_2("C", c, 3, step)
Test::Float::Arithmetic::min_xyx_c
MinXYX min_xyx_c("C", c, step)
Test::Float::Arithmetic::sqrt_xy_c
SqrtXY sqrt_xy_c("C", c, step)
Test::Float::Arithmetic::sqr_xx_b
SqrXX sqr_xx_b("B", b, step)
Test::Float::Arithmetic::sqrt_xy_a
SqrtXY sqrt_xy_a("A", a, step)
Test::Float::Arithmetic::max_xxy_b
MaxXXY max_xxy_b("B", b, step)
Test::Float::Arithmetic::pow_xy_b_3
PowXY pow_xy_b_3("B", b, 0, step)
Test::Float::Arithmetic::nroot_xx_a_3
NRootXX nroot_xx_a_3("A", a, 0, step)
Test::Float::Arithmetic::sqrt_xy_sol_b
SqrtXYSol sqrt_xy_sol_b("B", b, step)
Test::Float::Arithmetic::b
Gecode::FloatVal b(9, 12)
Test::Float::Arithmetic::mult_xyx_b
MultXYX mult_xyx_b("B", b, step)
Test::Float::Arithmetic::max_xyz_a
MaxXYZ max_xyz_a("A", a, step)
Test::Float::Arithmetic::sqr_xy_sol_a
SqrXYSol sqr_xy_sol_a("A", a, step)
Test::Float::Arithmetic::pow_xy_sol_b_2
PowXYSol pow_xy_sol_b_2("B", b, 3, step)
Test::Float::Arithmetic::nroot_xy_sol_a_2
NRootXYSol nroot_xy_sol_a_2("A", a, 3, step)
Test::Float::Arithmetic::sqr_xx_a
SqrXX sqr_xx_a("A", a, step)
Test::Float::Arithmetic::pow_xy_sol_c_1
PowXYSol pow_xy_sol_c_1("C", c, 2, step)
Test::Float::Arithmetic::nroot_xy_sol_b_3
NRootXYSol nroot_xy_sol_b_3("B", b, 0, step)
Test::Float::Arithmetic::mult_xxy_sol_c
MultXXYSol mult_xxy_sol_c("C", c, step)
Test::Float::Arithmetic::max_xyy_b
MaxXYY max_xyy_b("B", b, step)
Test::Float::Arithmetic::pow_xy_a_1
PowXY pow_xy_a_1("A", a, 2, step)
Test::Float::Arithmetic::sqrt_xx_a
SqrtXX sqrt_xx_a("A", a, step)
Test::Float::Arithmetic::max_xxx_c
MaxXXX max_xxx_c("C", c, step)
Test::Float::Arithmetic::pow_xy_a_2
PowXY pow_xy_a_2("A", a, 3, step)
Test::Float::Arithmetic::nroot_xy_sol_b_2
NRootXYSol nroot_xy_sol_b_2("B", b, 3, step)
Test::Float::Arithmetic::a
Gecode::FloatVal a(-8, 5)
Test::Float::Arithmetic::sqr_xy_c
SqrXY sqr_xy_c("C", c, step)
Test::Float::Arithmetic::mult_xxy_sol_b
MultXXYSol mult_xxy_sol_b("B", b, step)
Test::Float::Arithmetic::div_sol_c
DivSol div_sol_c("C", c, step)
Test::Float::Arithmetic::pow_xx_a_2
PowXX pow_xx_a_2("A", a, 3, step)
Test::Float::Arithmetic::div_sol_b
DivSol div_sol_b("B", b, step)
Test::Float::Arithmetic::pow_xy_c_3
PowXY pow_xy_c_3("C", c, 0, step)
Test::Float::Arithmetic::nroot_xy_sol_a_3
NRootXYSol nroot_xy_sol_a_3("A", a, 0, step)
Test::Float::Arithmetic::max_xyx_b
MaxXYX max_xyx_b("B", b, step)
Test::Float::Arithmetic::max_xxy_c
MaxXXY max_xxy_c("C", c, step)
Test::Float::Arithmetic::min_s_nary
MinNaryShared min_s_nary
Definition arithmetic.cpp:971
Test::Float::Arithmetic::max_xxx_b
MaxXXX max_xxx_b("B", b, step)
Test::Float::Arithmetic::pow_xy_sol_b_3
PowXYSol pow_xy_sol_b_3("B", b, 0, step)
Test::Float::Arithmetic::nroot_xy_b_1
NRootXY nroot_xy_b_1("B", b, 2, step)
Test::Float::Arithmetic::pow_xy_sol_a_2
PowXYSol pow_xy_sol_a_2("A", a, 3, step)
Test::Float::Arithmetic::max_nary
MaxNary max_nary
Definition arithmetic.cpp:972
Test::Float::Arithmetic::mult_xxy_b
MultXXY mult_xxy_b("B", b, step)
Test::Float::Arithmetic::min_xxx_c
MinXXX min_xxx_c("C", c, step)
Test::Float::Arithmetic::mult_xyz_sol_b
MultXYZSol mult_xyz_sol_b("B", b, step)
Test::Float::Arithmetic::pow_xy_b_1
PowXY pow_xy_b_1("B", b, 2, step)
Test::Float::Arithmetic::abs_xy_c
AbsXY abs_xy_c("C", c, step)
Test::Float::Arithmetic::step
const Gecode::FloatNum step
Definition arithmetic.cpp:785
Test::Float::Arithmetic::min_xyz_b
MinXYZ min_xyz_b("B", b, step)
Test::Float::Arithmetic::mult_xyx_c
MultXYX mult_xyx_c("C", c, step)
Test::Float::Arithmetic::mult_xxx_a
MultXXX mult_xxx_a("A", a, step)
Test::Float::Arithmetic::min_xyz_c
MinXYZ min_xyz_c("C", c, step)
Test::Float::Arithmetic::nroot_xx_b_3
NRootXX nroot_xx_b_3("B", b, 0, step)
Test::Float::Arithmetic::mult_xxy_sol_a
MultXXYSol mult_xxy_sol_a("A", a, step)
Test::Float::Arithmetic::max_xyy_c
MaxXYY max_xyy_c("C", c, step)
Test::Float::Arithmetic::min_xxx_a
MinXXX min_xxx_a("A", a, step)
Test::Float::Arithmetic::pow_xy_a_3
PowXY pow_xy_a_3("A", a, 0, step)
Test::Float::Arithmetic::nroot_xy_a_2
NRootXY nroot_xy_a_2("A", a, 3, step)
Test::Float::Arithmetic::pow_xx_b_1
PowXX pow_xx_b_1("B", b, 2, step)
Test::Float::Arithmetic::mult_xxy_a
MultXXY mult_xxy_a("A", a, step)
Test::Float::Arithmetic::abs_xx_b
AbsXX abs_xx_b("B", b, step)
Test::Float::Arithmetic::nroot_xy_sol_a_1
NRootXYSol nroot_xy_sol_a_1("A", a, 2, step)
Test::Float::Arithmetic::pow_xx_c_2
PowXX pow_xx_c_2("C", c, 3, step)
Test::Float::Arithmetic::min_xxy_a
MinXXY min_xxy_a("A", a, step)
Test::Float::Arithmetic::div_a
Div div_a("A", a, step)
Test::Float::Arithmetic::mult_xyz_sol_a
MultXYZSol mult_xyz_sol_a("A", a, step)
Test::Float::Arithmetic::max_xyx_c
MaxXYX max_xyx_c("C", c, step)
Test::Float::Arithmetic::nroot_xy_sol_c_2
NRootXYSol nroot_xy_sol_c_2("C", c, 3, step)
Test::Float::Arithmetic::pow_xy_c_1
PowXY pow_xy_c_1("C", c, 2, step)
Test::Float::Arithmetic::pow_xy_sol_a_3
PowXYSol pow_xy_sol_a_3("A", a, 0, step)
Test::Float::Arithmetic::mult_xxx_b
MultXXX mult_xxx_b("B", b, step)
Test::Float::Arithmetic::nroot_xx_a_1
NRootXX nroot_xx_a_1("A", a, 2, step)
Test::Float::Arithmetic::sqr_xy_a
SqrXY sqr_xy_a("A", a, step)
Test::Float::Arithmetic::sqr_xy_sol_c
SqrXYSol sqr_xy_sol_c("C", c, step)
Test::Float::Arithmetic::nroot_xx_c_2
NRootXX nroot_xx_c_2("C", c, 3, step)
Test::Float::Arithmetic::pow_xx_c_3
PowXX pow_xx_c_3("C", c, 0, step)
Test::Float::Arithmetic::sqrt_xx_c
SqrtXX sqrt_xx_c("C", c, step)
Test::Float::Arithmetic::pow_xy_sol_c_2
PowXYSol pow_xy_sol_c_2("C", c, 3, step)
Test::Float::Arithmetic::nroot_xx_c_1
NRootXX nroot_xx_c_1("C", c, 2, step)
Test::Float::Arithmetic::max_xxy_a
MaxXXY max_xxy_a("A", a, step)
Test::Float::Arithmetic::abs_xx_a
AbsXX abs_xx_a("A", a, step)
Test::Float::Arithmetic::mult_xyy_a
MultXYY mult_xyy_a("A", a, step)
Test::Float::Arithmetic::pow_xx_a_1
PowXX pow_xx_a_1("A", a, 2, step)
Test::Float::Arithmetic::nroot_xy_c_3
NRootXY nroot_xy_c_3("C", c, 0, step)
Test::Float::Arithmetic::max_xxx_a
MaxXXX max_xxx_a("A", a, step)
Test::Float::Arithmetic::nroot_xy_a_3
NRootXY nroot_xy_a_3("A", a, 0, step)
Test::Float
Testing domain floats.
Definition float.cpp:43
Test::Float::EXTEND_ASSIGNMENT
@ EXTEND_ASSIGNMENT
Definition float.hh:64
Test::Float::CPLT_ASSIGNMENT
@ CPLT_ASSIGNMENT
Definition float.hh:62
Test::Float::MaybeType
MaybeType
Type for comparisons and solutions.
Definition float.hh:51
Test::Float::MT_MAYBE
@ MT_MAYBE
Definition float.hh:54
Test::Float::MT_FALSE
@ MT_FALSE
Definition float.hh:52
Test
General test support.
Definition afc.cpp:39
float.hh