00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023 #ifndef PPL_Scalar_Products_inlines_hh
00024 #define PPL_Scalar_Products_inlines_hh 1
00025
00026 #include "Linear_Row.defs.hh"
00027 #include "Linear_Expression.defs.hh"
00028 #include "Constraint.defs.hh"
00029 #include "Generator.defs.hh"
00030 #include "Congruence.defs.hh"
00031 #include "Grid_Generator.defs.hh"
00032
00033 namespace Parma_Polyhedra_Library {
00034
00035 inline int
00036 Scalar_Products::sign(const Linear_Row& x, const Linear_Row& y) {
00037 TEMP_INTEGER(z);
00038 assign(z, x, y);
00039 return sgn(z);
00040 }
00041
00042 inline int
00043 Scalar_Products::reduced_sign(const Linear_Row& x, const Linear_Row& y) {
00044 TEMP_INTEGER(z);
00045 reduced_assign(z, x, y);
00046 return sgn(z);
00047 }
00048
00049 inline int
00050 Scalar_Products::homogeneous_sign(const Linear_Row& x, const Linear_Row& y) {
00051 TEMP_INTEGER(z);
00052 homogeneous_assign(z, x, y);
00053 return sgn(z);
00054 }
00055
00056 inline int
00057 Scalar_Products::sign(const Constraint& c, const Generator& g) {
00058 return sign(static_cast<const Linear_Row&>(c),
00059 static_cast<const Linear_Row&>(g));
00060 }
00061
00062 inline int
00063 Scalar_Products::sign(const Generator& g, const Constraint& c) {
00064 return sign(static_cast<const Linear_Row&>(g),
00065 static_cast<const Linear_Row&>(c));
00066 }
00067
00068 inline int
00069 Scalar_Products::reduced_sign(const Constraint& c, const Generator& g) {
00070 return reduced_sign(static_cast<const Linear_Row&>(c),
00071 static_cast<const Linear_Row&>(g));
00072 }
00073
00074 inline int
00075 Scalar_Products::reduced_sign(const Generator& g, const Constraint& c) {
00076 return reduced_sign(static_cast<const Linear_Row&>(g),
00077 static_cast<const Linear_Row&>(c));
00078 }
00079
00080 inline void
00081 Scalar_Products::homogeneous_assign(Coefficient& z,
00082 const Linear_Expression& e,
00083 const Generator& g) {
00084 homogeneous_assign(z,
00085 static_cast<const Linear_Row&>(e),
00086 static_cast<const Linear_Row&>(g));
00087 }
00088
00089 inline void
00090 Scalar_Products::homogeneous_assign(Coefficient& z,
00091 const Linear_Expression& e,
00092 const Grid_Generator& g) {
00093 homogeneous_assign(z,
00094 static_cast<const Linear_Row&>(e),
00095 static_cast<const Linear_Row&>(g));
00096 }
00097
00098 inline int
00099 Scalar_Products::homogeneous_sign(const Linear_Expression& e,
00100 const Generator& g) {
00101 return homogeneous_sign(static_cast<const Linear_Row&>(e),
00102 static_cast<const Linear_Row&>(g));
00103 }
00104
00105 inline int
00106 Scalar_Products::homogeneous_sign(const Linear_Expression& e,
00107 const Grid_Generator& g) {
00108 return homogeneous_sign(static_cast<const Linear_Row&>(e),
00109 static_cast<const Linear_Row&>(g));
00110 }
00111
00112 inline
00113 Topology_Adjusted_Scalar_Product_Sign
00114 ::Topology_Adjusted_Scalar_Product_Sign(const Constraint& c)
00115 : sps_fp(c.is_necessarily_closed()
00116 ? static_cast<SPS_type>(&Scalar_Products::sign)
00117 : static_cast<SPS_type>(&Scalar_Products::reduced_sign)) {
00118 }
00119
00120 inline
00121 Topology_Adjusted_Scalar_Product_Sign
00122 ::Topology_Adjusted_Scalar_Product_Sign(const Generator& g)
00123 : sps_fp(g.is_necessarily_closed()
00124 ? static_cast<SPS_type>(&Scalar_Products::sign)
00125 : static_cast<SPS_type>(&Scalar_Products::reduced_sign)) {
00126 }
00127
00128 inline int
00129 Topology_Adjusted_Scalar_Product_Sign::operator()(const Constraint& c,
00130 const Generator& g) const {
00131 assert(c.space_dimension() <= g.space_dimension());
00132 assert(sps_fp == (c.is_necessarily_closed()
00133 ? static_cast<SPS_type>(&Scalar_Products::sign)
00134 : static_cast<SPS_type>(&Scalar_Products::reduced_sign)));
00135 return sps_fp(static_cast<const Linear_Row&>(c),
00136 static_cast<const Linear_Row&>(g));
00137 }
00138
00139 inline int
00140 Topology_Adjusted_Scalar_Product_Sign::operator()(const Generator& g,
00141 const Constraint& c) const {
00142 assert(g.space_dimension() <= c.space_dimension());
00143 assert(sps_fp == (g.is_necessarily_closed()
00144 ? static_cast<SPS_type>(&Scalar_Products::sign)
00145 : static_cast<SPS_type>(&Scalar_Products::reduced_sign)));
00146 return sps_fp(static_cast<const Linear_Row&>(g),
00147 static_cast<const Linear_Row&>(c));
00148 }
00149
00150 }
00151
00152 #endif // !defined(PPL_Scalar_Products_inlines_hh)