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::sign(const Constraint& c, const Grid_Generator& g) {
00070 TEMP_INTEGER(z);
00071 assign(z, c, g);
00072 return sgn(z);
00073 }
00074
00075 inline int
00076 Scalar_Products::reduced_sign(const Constraint& c, const Generator& g) {
00077 return reduced_sign(static_cast<const Linear_Row&>(c),
00078 static_cast<const Linear_Row&>(g));
00079 }
00080
00081 inline int
00082 Scalar_Products::reduced_sign(const Generator& g, const Constraint& c) {
00083 return reduced_sign(static_cast<const Linear_Row&>(g),
00084 static_cast<const Linear_Row&>(c));
00085 }
00086
00087 inline void
00088 Scalar_Products::homogeneous_assign(Coefficient& z,
00089 const Linear_Expression& e,
00090 const Generator& g) {
00091 homogeneous_assign(z,
00092 static_cast<const Linear_Row&>(e),
00093 static_cast<const Linear_Row&>(g));
00094 }
00095
00096 inline void
00097 Scalar_Products::homogeneous_assign(Coefficient& z,
00098 const Linear_Expression& e,
00099 const Grid_Generator& g) {
00100 homogeneous_assign(z,
00101 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 Generator& g) {
00108 return homogeneous_sign(static_cast<const Linear_Row&>(e),
00109 static_cast<const Linear_Row&>(g));
00110 }
00111
00112 inline int
00113 Scalar_Products::homogeneous_sign(const Linear_Expression& e,
00114 const Grid_Generator& g) {
00115 return homogeneous_sign(static_cast<const Linear_Row&>(e),
00116 static_cast<const Linear_Row&>(g));
00117 }
00118
00119 inline int
00120 Scalar_Products::homogeneous_sign(const Grid_Generator& g,
00121 const Constraint& c) {
00122 TEMP_INTEGER(z);
00123 homogeneous_assign(z, g, c);
00124 return sgn(z);
00125 }
00126
00127 inline
00128 Topology_Adjusted_Scalar_Product_Sign
00129 ::Topology_Adjusted_Scalar_Product_Sign(const Constraint& c)
00130 : sps_fp(c.is_necessarily_closed()
00131 ? static_cast<SPS_type>(&Scalar_Products::sign)
00132 : static_cast<SPS_type>(&Scalar_Products::reduced_sign)) {
00133 }
00134
00135 inline
00136 Topology_Adjusted_Scalar_Product_Sign
00137 ::Topology_Adjusted_Scalar_Product_Sign(const Generator& g)
00138 : sps_fp(g.is_necessarily_closed()
00139 ? static_cast<SPS_type>(&Scalar_Products::sign)
00140 : static_cast<SPS_type>(&Scalar_Products::reduced_sign)) {
00141 }
00142
00143 inline int
00144 Topology_Adjusted_Scalar_Product_Sign::operator()(const Constraint& c,
00145 const Generator& g) const {
00146 assert(c.space_dimension() <= g.space_dimension());
00147 assert(sps_fp == (c.is_necessarily_closed()
00148 ? static_cast<SPS_type>(&Scalar_Products::sign)
00149 : static_cast<SPS_type>(&Scalar_Products::reduced_sign)));
00150 return sps_fp(static_cast<const Linear_Row&>(c),
00151 static_cast<const Linear_Row&>(g));
00152 }
00153
00154 inline int
00155 Topology_Adjusted_Scalar_Product_Sign::operator()(const Generator& g,
00156 const Constraint& c) const {
00157 assert(g.space_dimension() <= c.space_dimension());
00158 assert(sps_fp == (g.is_necessarily_closed()
00159 ? static_cast<SPS_type>(&Scalar_Products::sign)
00160 : static_cast<SPS_type>(&Scalar_Products::reduced_sign)));
00161 return sps_fp(static_cast<const Linear_Row&>(g),
00162 static_cast<const Linear_Row&>(c));
00163 }
00164
00165 }
00166
00167 #endif // !defined(PPL_Scalar_Products_inlines_hh)