A class implementing various scalar product functions. More...

#include <Scalar_Products_defs.hh>

Static Public Member Functions
static void	assign (Coefficient &z, const Linear_Expression &x, const Linear_Expression &y)
	Computes the scalar product of `x` and `y` and assigns it to `z`. More...

static void	assign (Coefficient &z, const Constraint &c, const Generator &g)
	Computes the scalar product of `c` and `g` and assigns it to `z`. More...

static void	assign (Coefficient &z, const Generator &g, const Constraint &c)
	Computes the scalar product of `g` and `c` and assigns it to `z`. More...

static void	assign (Coefficient &z, const Constraint &c, const Grid_Generator &gg)
	Computes the scalar product of `c` and `g` and assigns it to `z`. More...

static void	assign (Coefficient &z, const Grid_Generator &gg, const Congruence &cg)
	Computes the scalar product of `g` and `cg` and assigns it to `z`. More...

static void	assign (Coefficient &z, const Congruence &cg, const Grid_Generator &gg)
	Computes the scalar product of `cg` and `g` and assigns it to `z`. More...

static int	sign (const Linear_Expression &x, const Linear_Expression &y)
	Returns the sign of the scalar product between `x` and `y`. More...

static int	sign (const Constraint &c, const Generator &g)
	Returns the sign of the scalar product between `c` and `g`. More...

static int	sign (const Generator &g, const Constraint &c)
	Returns the sign of the scalar product between `g` and `c`. More...

static int	sign (const Constraint &c, const Grid_Generator &g)
	Returns the sign of the scalar product between `c` and `g`. More...

static void	reduced_assign (Coefficient &z, const Linear_Expression &x, const Linear_Expression &y)
	Computes the reduced scalar product of `x` and `y`, where the $\epsilon$ coefficient of `x` is ignored, and assigns the result to `z`. More...

static void	reduced_assign (Coefficient &z, const Constraint &c, const Generator &g)
	Computes the reduced scalar product of `c` and `g`, where the $\epsilon$ coefficient of `c` is ignored, and assigns the result to `z`. More...

static void	reduced_assign (Coefficient &z, const Generator &g, const Constraint &c)
	Computes the reduced scalar product of `g` and `c`, where the $\epsilon$ coefficient of `g` is ignored, and assigns the result to `z`. More...

static void	reduced_assign (Coefficient &z, const Grid_Generator &gg, const Congruence &cg)
	Computes the reduced scalar product of `g` and `cg`, where the $\epsilon$ coefficient of `g` is ignored, and assigns the result to `z`. More...

static int	reduced_sign (const Linear_Expression &x, const Linear_Expression &y)
	Returns the sign of the reduced scalar product of `x` and `y`, where the $\epsilon$ coefficient of `x` is ignored. More...

static int	reduced_sign (const Constraint &c, const Generator &g)
	Returns the sign of the reduced scalar product of `c` and `g`, where the $\epsilon$ coefficient of `c` is ignored. More...

static int	reduced_sign (const Generator &g, const Constraint &c)
	Returns the sign of the reduced scalar product of `g` and `c`, where the $\epsilon$ coefficient of `g` is ignored. More...

static void	homogeneous_assign (Coefficient &z, const Linear_Expression &x, const Linear_Expression &y)
	Computes the homogeneous scalar product of `x` and `y`, where the inhomogeneous terms are ignored, and assigns the result to `z`. More...

static void	homogeneous_assign (Coefficient &z, const Linear_Expression &e, const Generator &g)
	Computes the homogeneous scalar product of `e` and `g`, where the inhomogeneous terms are ignored, and assigns the result to `z`. More...

static void	homogeneous_assign (Coefficient &z, const Grid_Generator &gg, const Constraint &c)
	Computes the homogeneous scalar product of `gg` and `c`, where the inhomogeneous terms are ignored, and assigns the result to `z`. More...

static void	homogeneous_assign (Coefficient &z, const Grid_Generator &gg, const Congruence &cg)
	Computes the homogeneous scalar product of `g` and `cg`, where the inhomogeneous terms are ignored, and assigns the result to `z`. More...

static void	homogeneous_assign (Coefficient &z, const Linear_Expression &e, const Grid_Generator &g)
	Computes the homogeneous scalar product of `e` and `g`, where the inhomogeneous terms are ignored, and assigns the result to `z`. More...

static int	homogeneous_sign (const Linear_Expression &x, const Linear_Expression &y)
	Returns the sign of the homogeneous scalar product of `x` and `y`, where the inhomogeneous terms are ignored. More...

static int	homogeneous_sign (const Linear_Expression &e, const Generator &g)
	Returns the sign of the homogeneous scalar product of `e` and `g`, where the inhomogeneous terms are ignored. More...

static int	homogeneous_sign (const Linear_Expression &e, const Grid_Generator &g)
	Returns the sign of the homogeneous scalar product of `e` and `g`, where the inhomogeneous terms are ignored,. More...

static int	homogeneous_sign (const Grid_Generator &g, const Constraint &c)
	Returns the sign of the homogeneous scalar product of `g` and `c`, where the inhomogeneous terms are ignored,. More...

Detailed Description

A class implementing various scalar product functions.

When computing the scalar product of (Linear_Expression or Constraint or Generator) objects x and y, it is assumed that the space dimension of the first object x is less than or equal to the space dimension of the second object y.

Definition at line 44 of file Scalar_Products_defs.hh.

Member Function Documentation

void Parma_Polyhedra_Library::Scalar_Products::assign	(	Coefficient &	z,
		const Linear_Expression &	x,
		const Linear_Expression &	y
	)

static

Computes the scalar product of x and y and assigns it to z.

Definition at line 32 of file Scalar_Products.cc.

References Parma_Polyhedra_Library::Linear_Expression::scalar_product_assign().

Referenced by Parma_Polyhedra_Library::Grid_Generator_System::affine_image(), Parma_Polyhedra_Library::Generator_System::affine_image(), Parma_Polyhedra_Library::Polyhedron::conversion(), Parma_Polyhedra_Library::Polyhedron::relation_with(), Parma_Polyhedra_Library::Grid::relation_with(), Parma_Polyhedra_Library::Congruence_System::satisfies_all_congruences(), sign(), and Parma_Polyhedra_Library::Grid::simplify_using_context_assign().

                                                          {
   x.scalar_product_assign(z, y);
 }

void Parma_Polyhedra_Library::Scalar_Products::assign	(	Coefficient &	z,
		const Constraint &	c,
		const Generator &	g
	)

static

Computes the scalar product of c and g and assigns it to z.

Definition at line 39 of file Scalar_Products.cc.

References Parma_Polyhedra_Library::Boundary_NS::assign(), Parma_Polyhedra_Library::Constraint::expr, and Parma_Polyhedra_Library::Generator::expr.

                                                                       {
   assign(z, c.expr, g.expr);
 }

void Parma_Polyhedra_Library::Scalar_Products::assign	(	Coefficient &	z,
		const Generator &	g,
		const Constraint &	c
	)

static

Computes the scalar product of g and c and assigns it to z.

Definition at line 45 of file Scalar_Products.cc.

References Parma_Polyhedra_Library::Boundary_NS::assign(), Parma_Polyhedra_Library::Constraint::expr, and Parma_Polyhedra_Library::Generator::expr.

                                                                       {
   assign(z, g.expr, c.expr);
 }

void Parma_Polyhedra_Library::Scalar_Products::assign	(	Coefficient &	z,
		const Constraint &	c,
		const Grid_Generator &	gg
	)

static

Computes the scalar product of c and g and assigns it to z.

Definition at line 57 of file Scalar_Products.cc.

References Parma_Polyhedra_Library::Boundary_NS::assign(), Parma_Polyhedra_Library::Constraint::expr, and Parma_Polyhedra_Library::Grid_Generator::expr.

                                                        {
   assign(z, c.expr, gg.expr);
 }

void Parma_Polyhedra_Library::Scalar_Products::assign	(	Coefficient &	z,
		const Grid_Generator &	gg,
		const Congruence &	cg
	)

static

Computes the scalar product of g and cg and assigns it to z.

Definition at line 51 of file Scalar_Products.cc.

References Parma_Polyhedra_Library::Congruence::expr, Parma_Polyhedra_Library::Grid_Generator::expr, Parma_Polyhedra_Library::Linear_Expression::scalar_product_assign(), and Parma_Polyhedra_Library::Grid_Generator::space_dimension().

                                                                              {
   gg.expr.scalar_product_assign(z, cg.expr, 0, gg.space_dimension() + 1);
 }

void Parma_Polyhedra_Library::Scalar_Products::assign	(	Coefficient &	z,
		const Congruence &	cg,
		const Grid_Generator &	gg
	)

static

Computes the scalar product of cg and g and assigns it to z.

Definition at line 64 of file Scalar_Products.cc.

References Parma_Polyhedra_Library::Congruence::expr, Parma_Polyhedra_Library::Grid_Generator::expr, Parma_Polyhedra_Library::Linear_Expression::scalar_product_assign(), Parma_Polyhedra_Library::Congruence::space_dimension(), and Parma_Polyhedra_Library::Grid_Generator::space_dimension().

                                                                              {
   // Scalar product is only defined if `cg' and `gg' are
   // dimension-compatible.
   PPL_ASSERT(cg.space_dimension() <= gg.space_dimension());
   cg.expr.scalar_product_assign(z, gg.expr);
 }

void Parma_Polyhedra_Library::Scalar_Products::homogeneous_assign	(	Coefficient &	z,
		const Linear_Expression &	x,
		const Linear_Expression &	y
	)

static

Computes the homogeneous scalar product of x and y, where the inhomogeneous terms are ignored, and assigns the result to z.

Definition at line 93 of file Scalar_Products.cc.

References Parma_Polyhedra_Library::Linear_Expression::scalar_product_assign(), and Parma_Polyhedra_Library::Linear_Expression::space_dimension().

Referenced by Parma_Polyhedra_Library::Polyhedron::frequency(), Parma_Polyhedra_Library::Grid::frequency_no_check(), homogeneous_assign(), homogeneous_sign(), Parma_Polyhedra_Library::Grid::max_min(), and Parma_Polyhedra_Library::Polyhedron::max_min().

                                                                      {
   // Scalar product is only defined  if `x' and `y' are
   // dimension-compatible.
   PPL_ASSERT(x.space_dimension() <= y.space_dimension());
   x.scalar_product_assign(z, y, 1, x.space_dimension() + 1);
 }

void Parma_Polyhedra_Library::Scalar_Products::homogeneous_assign	(	Coefficient &	z,
		const Linear_Expression &	e,
		const Generator &	g
	)

inlinestatic

Computes the homogeneous scalar product of e and g, where the inhomogeneous terms are ignored, and assigns the result to z.

Definition at line 92 of file Scalar_Products_inlines.hh.

References Parma_Polyhedra_Library::Generator::expr, and homogeneous_assign().

                                                         {
   homogeneous_assign(z, e, g.expr);
 }

void Parma_Polyhedra_Library::Scalar_Products::homogeneous_assign	(	Coefficient &	z,
		const Grid_Generator &	gg,
		const Constraint &	c
	)

static

Computes the homogeneous scalar product of gg and c, where the inhomogeneous terms are ignored, and assigns the result to z.

Definition at line 113 of file Scalar_Products.cc.

References Parma_Polyhedra_Library::Constraint::expr, Parma_Polyhedra_Library::Grid_Generator::expr, Parma_Polyhedra_Library::Linear_Expression::scalar_product_assign(), Parma_Polyhedra_Library::Constraint::space_dimension(), and Parma_Polyhedra_Library::Grid_Generator::space_dimension().

                                                               {
   // Scalar product is only defined if `gg' and `c' are
   // dimension-compatible.
   PPL_ASSERT(gg.space_dimension() <= c.space_dimension());
   gg.expr.scalar_product_assign(z, c.expr, 1, gg.space_dimension() + 1);
 }

void Parma_Polyhedra_Library::Scalar_Products::homogeneous_assign	(	Coefficient &	z,
		const Grid_Generator &	gg,
		const Congruence &	cg
	)

static

Computes the homogeneous scalar product of g and cg, where the inhomogeneous terms are ignored, and assigns the result to z.

Definition at line 103 of file Scalar_Products.cc.

References Parma_Polyhedra_Library::Congruence::expr, Parma_Polyhedra_Library::Grid_Generator::expr, Parma_Polyhedra_Library::Linear_Expression::scalar_product_assign(), Parma_Polyhedra_Library::Congruence::space_dimension(), and Parma_Polyhedra_Library::Grid_Generator::space_dimension().

                                                                {
   // Scalar product is only defined if `gg' and `cg' are
   // dimension-compatible.
   PPL_ASSERT(gg.space_dimension() <= cg.space_dimension());
   gg.expr.scalar_product_assign(z, cg.expr, 1, gg.space_dimension() + 1);
 }

void Parma_Polyhedra_Library::Scalar_Products::homogeneous_assign	(	Coefficient &	z,
		const Linear_Expression &	e,
		const Grid_Generator &	g
	)

inlinestatic

Computes the homogeneous scalar product of e and g, where the inhomogeneous terms are ignored, and assigns the result to z.

Definition at line 99 of file Scalar_Products_inlines.hh.

References Parma_Polyhedra_Library::Grid_Generator::expr, and homogeneous_assign().

                                                              {
   homogeneous_assign(z, e, g.expr);
 }

int Parma_Polyhedra_Library::Scalar_Products::homogeneous_sign	(	const Linear_Expression &	x,
		const Linear_Expression &	y
	)

inlinestatic

Returns the sign of the homogeneous scalar product of x and y, where the inhomogeneous terms are ignored.

Definition at line 51 of file Scalar_Products_inlines.hh.

References homogeneous_assign(), PPL_DIRTY_TEMP_COEFFICIENT, and Parma_Polyhedra_Library::Boundary_NS::sgn().

Referenced by Parma_Polyhedra_Library::Polyhedron::bounds(), Parma_Polyhedra_Library::Grid::bounds_no_check(), and homogeneous_sign().

                                                               {
   PPL_DIRTY_TEMP_COEFFICIENT(z);
   homogeneous_assign(z, x, y);
   return sgn(z);
 }

int Parma_Polyhedra_Library::Scalar_Products::homogeneous_sign	(	const Linear_Expression &	e,
		const Generator &	g
	)

inlinestatic

Returns the sign of the homogeneous scalar product of e and g, where the inhomogeneous terms are ignored.

Definition at line 106 of file Scalar_Products_inlines.hh.

References Parma_Polyhedra_Library::Generator::expr, and homogeneous_sign().

                                                       {
   return homogeneous_sign(e, g.expr);
 }

int Parma_Polyhedra_Library::Scalar_Products::homogeneous_sign	(	const Linear_Expression &	e,
		const Grid_Generator &	g
	)

inlinestatic

Returns the sign of the homogeneous scalar product of e and g, where the inhomogeneous terms are ignored,.

Definition at line 112 of file Scalar_Products_inlines.hh.

References Parma_Polyhedra_Library::Grid_Generator::expr, and homogeneous_sign().

                                                            {
   return homogeneous_sign(e, g.expr);
 }

int Parma_Polyhedra_Library::Scalar_Products::homogeneous_sign	(	const Grid_Generator &	g,
		const Constraint &	c
	)

inlinestatic

Returns the sign of the homogeneous scalar product of g and c, where the inhomogeneous terms are ignored,.

Definition at line 118 of file Scalar_Products_inlines.hh.

References homogeneous_assign(), PPL_DIRTY_TEMP_COEFFICIENT, and Parma_Polyhedra_Library::Boundary_NS::sgn().

                                                        {
   PPL_DIRTY_TEMP_COEFFICIENT(z);
   homogeneous_assign(z, g, c);
   return sgn(z);
 }

void Parma_Polyhedra_Library::Scalar_Products::reduced_assign	(	Coefficient &	z,
		const Linear_Expression &	x,
		const Linear_Expression &	y
	)

static

Computes the reduced scalar product of x and y, where the $\epsilon$ coefficient of x is ignored, and assigns the result to z.

Definition at line 73 of file Scalar_Products.cc.

References Parma_Polyhedra_Library::Linear_Expression::scalar_product_assign(), and Parma_Polyhedra_Library::Linear_Expression::space_dimension().

Referenced by reduced_sign().

                                                                  {
   // The reduced scalar product is only defined
   // if `y' has enough coefficients.
   PPL_ASSERT(x.space_dimension() - 1 <= y.space_dimension());
   x.scalar_product_assign(z, y, 0, x.space_dimension());
 }

static void Parma_Polyhedra_Library::Scalar_Products::reduced_assign	(	Coefficient &	z,
		const Constraint &	c,
		const Generator &	g
	)

static

Computes the reduced scalar product of c and g, where the $\epsilon$ coefficient of c is ignored, and assigns the result to z.

static void Parma_Polyhedra_Library::Scalar_Products::reduced_assign	(	Coefficient &	z,
		const Generator &	g,
		const Constraint &	c
	)

static

Computes the reduced scalar product of g and c, where the $\epsilon$ coefficient of g is ignored, and assigns the result to z.

void Parma_Polyhedra_Library::Scalar_Products::reduced_assign	(	Coefficient &	z,
		const Grid_Generator &	gg,
		const Congruence &	cg
	)

static

Computes the reduced scalar product of g and cg, where the $\epsilon$ coefficient of g is ignored, and assigns the result to z.

Definition at line 83 of file Scalar_Products.cc.

References Parma_Polyhedra_Library::Congruence::expr, Parma_Polyhedra_Library::Grid_Generator::expr, Parma_Polyhedra_Library::Linear_Expression::scalar_product_assign(), Parma_Polyhedra_Library::Congruence::space_dimension(), and Parma_Polyhedra_Library::Grid_Generator::space_dimension().

                                                            {
   // The reduced scalar product is only defined
   // if `cg' has enough coefficients.
   PPL_ASSERT(gg.space_dimension() <= cg.space_dimension());
   gg.expr.scalar_product_assign(z, cg.expr, 0, gg.space_dimension());
 }

int Parma_Polyhedra_Library::Scalar_Products::reduced_sign	(	const Linear_Expression &	x,
		const Linear_Expression &	y
	)

inlinestatic

Returns the sign of the reduced scalar product of x and y, where the $\epsilon$ coefficient of x is ignored.

Definition at line 43 of file Scalar_Products_inlines.hh.

References PPL_DIRTY_TEMP_COEFFICIENT, reduced_assign(), and Parma_Polyhedra_Library::Boundary_NS::sgn().

Referenced by Parma_Polyhedra_Library::Polyhedron::BHZ09_NNC_poly_hull_assign_if_exact(), Parma_Polyhedra_Library::Polyhedron::is_included_in(), Parma_Polyhedra_Library::Topology_Adjusted_Scalar_Product_Sign::operator()(), reduced_sign(), Parma_Polyhedra_Library::Generator_System::relation_with(), and Parma_Polyhedra_Library::Grid::relation_with().

                                                           {
   PPL_DIRTY_TEMP_COEFFICIENT(z);
   reduced_assign(z, x, y);
   return sgn(z);
 }

int Parma_Polyhedra_Library::Scalar_Products::reduced_sign	(	const Constraint &	c,
		const Generator &	g
	)

inlinestatic

Returns the sign of the reduced scalar product of c and g, where the $\epsilon$ coefficient of c is ignored.

Definition at line 76 of file Scalar_Products_inlines.hh.

References Parma_Polyhedra_Library::Constraint::expr, Parma_Polyhedra_Library::Generator::expr, Parma_Polyhedra_Library::Constraint::is_necessarily_closed(), and reduced_sign().

                                                                      {
   // The reduced scalar product is only defined if the topology of `c' is
   // NNC.
   PPL_ASSERT(!c.is_necessarily_closed());
   return reduced_sign(c.expr, g.expr);
 }

int Parma_Polyhedra_Library::Scalar_Products::reduced_sign	(	const Generator &	g,
		const Constraint &	c
	)

inlinestatic

Returns the sign of the reduced scalar product of g and c, where the $\epsilon$ coefficient of g is ignored.

Definition at line 84 of file Scalar_Products_inlines.hh.

References Parma_Polyhedra_Library::Constraint::expr, Parma_Polyhedra_Library::Generator::expr, Parma_Polyhedra_Library::Constraint::is_necessarily_closed(), and reduced_sign().

                                                                      {
   // The reduced scalar product is only defined if the topology of `g' is
   // NNC.
   PPL_ASSERT(!c.is_necessarily_closed());
   return reduced_sign(g.expr, c.expr);
 }

int Parma_Polyhedra_Library::Scalar_Products::sign	(	const Linear_Expression &	x,
		const Linear_Expression &	y
	)

inlinestatic

Returns the sign of the scalar product between x and y.

Definition at line 36 of file Scalar_Products_inlines.hh.

References assign(), PPL_DIRTY_TEMP_COEFFICIENT, and Parma_Polyhedra_Library::Boundary_NS::sgn().

                                                                             {
   PPL_DIRTY_TEMP_COEFFICIENT(z);
   assign(z, x, y);
   return sgn(z);
 }

int Parma_Polyhedra_Library::Scalar_Products::sign	(	const Constraint &	c,
		const Generator &	g
	)

inlinestatic

Returns the sign of the scalar product between c and g.

Definition at line 59 of file Scalar_Products_inlines.hh.

References Parma_Polyhedra_Library::Constraint::expr, Parma_Polyhedra_Library::Generator::expr, and sign().

                                                              {
   return sign(c.expr, g.expr);
 }

int Parma_Polyhedra_Library::Scalar_Products::sign	(	const Generator &	g,
		const Constraint &	c
	)

inlinestatic

Returns the sign of the scalar product between g and c.

Definition at line 64 of file Scalar_Products_inlines.hh.

References Parma_Polyhedra_Library::Constraint::expr, Parma_Polyhedra_Library::Generator::expr, and sign().

                                                              {
   return sign(g.expr, c.expr);
 }

int Parma_Polyhedra_Library::Scalar_Products::sign	(	const Constraint &	c,
		const Grid_Generator &	g
	)

inlinestatic

Returns the sign of the scalar product between c and g.

Definition at line 69 of file Scalar_Products_inlines.hh.

References assign(), PPL_DIRTY_TEMP_COEFFICIENT, and Parma_Polyhedra_Library::Boundary_NS::sgn().

                                                                   {
   PPL_DIRTY_TEMP_COEFFICIENT(z);
   assign(z, c, g);
   return sgn(z);
 }

The documentation for this class was generated from the following files:

Static Public Member Functions

Detailed Description

Member Function Documentation