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