codac2_MatrixBase_addons_IntervalMatrixBase.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	degenerate_mat(op)
	Helper macro to create a matrix from a specific operation applied to each interval element.

Functions
template<typename U = Scalar>
double	volume () const
	Computes the volume of the interval matrix.
bool	is_empty () const
	Checks whether the interval matrix is empty.
template<typename U = Scalar>
auto	lb () const
	Returns a matrix containing the lower bounds of each interval element.
template<typename U = Scalar>
auto	ub () const
	Returns a matrix containing the upper bounds of each interval element.
template<typename U = Scalar>
auto	mid () const
	Returns a matrix containing the midpoints of each interval element.
template<typename U = Scalar>
auto	mag () const
	Returns a matrix containing the magnitudes of each interval element.
template<typename U = Scalar>
auto	mig () const
	Returns a matrix containing the mignitudes of each interval element.
template<typename U = Scalar>
auto	smag () const
	Returns a matrix containing the signed magnitudes of each interval element.
template<typename U = Scalar>
auto	smig () const
	Returns a matrix containing the signed mignitudes of each interval element.
template<typename U = Scalar>
auto	rand () const
	Returns a matrix with random values chosen inside each interval element.
template<typename U = Scalar>
auto	rad () const
	Returns a matrix containing the radii of each interval element.
template<typename U = Scalar>
auto	diam () const
	Returns a matrix containing the diameters of each interval element.
double	min_rad () const
	Returns the minimum radius among the interval elements.
double	max_rad () const
	Returns the maximum radius among the interval elements.
double	min_diam () const
	Returns the minimum diameter among the interval elements.
double	max_diam () const
	Returns the maximum diameter among the interval elements.
Index	min_diam_index () const
	Returns the index of the element with the minimum diameter.
Index	max_diam_index () const
	Returns the index of the element with the maximum diameter.
Index	extr_diam_index (bool min) const
	Returns the index of the element with the minimum or maximum diameter.
bool	contains (const Matrix< double, RowsAtCompileTime, ColsAtCompileTime > &x) const
	Checks if this interval matrix contains the specified matrix x.
template<typename OtherDerived>
bool	contains (const MatrixBase< OtherDerived > &x) const
	Template version to check containment of a matrix with arbitrary derived type.
template<typename T>
bool	_contains (const T &x) const
	Internal helper function to check containment.
bool	interior_contains (const Matrix< double, RowsAtCompileTime, ColsAtCompileTime > &x) const
	Checks if the interior of this interval matrix contains the specified matrix x.
template<typename OtherDerived>
bool	interior_contains (const MatrixBase< OtherDerived > &x) const
	Template version to check interior containment of a matrix with arbitrary derived type.
template<typename T>
bool	_interior_contains (const T &x) const
	Internal helper function to check interior containment.
bool	is_unbounded () const
	Checks if the interval matrix contains any unbounded intervals.
bool	is_degenerated () const
	Checks if the interval matrix is degenerated.
bool	is_flat () const
	Checks if the interval matrix is flat.
bool	intersects (const Matrix< codac2::Interval, RowsAtCompileTime, ColsAtCompileTime > &x) const
	Checks whether this matrix intersects with another matrix of intervals.
template<typename OtherDerived>
bool	intersects (const MatrixBase< OtherDerived > &x) const
	Checks whether this matrix intersects with another Eigen-compatible matrix.
template<typename OtherDerived>
bool	_intersects (const MatrixBase< OtherDerived > &x) const
	Internal helper that performs intersection checking.
bool	is_disjoint (const Matrix< codac2::Interval, RowsAtCompileTime, ColsAtCompileTime > &x) const
	Checks if this matrix is disjoint with another matrix of intervals.
template<typename OtherDerived>
bool	is_disjoint (const MatrixBase< OtherDerived > &x) const
	Checks if this matrix is disjoint with another matrix of compatible type.
template<typename OtherDerived>
bool	_is_disjoint (const MatrixBase< OtherDerived > &x) const
	Internal helper for disjointness checking.
bool	overlaps (const Matrix< codac2::Interval, RowsAtCompileTime, ColsAtCompileTime > &x) const
	Checks whether this matrix overlaps with another.
template<typename OtherDerived>
bool	overlaps (const MatrixBase< OtherDerived > &x) const
	Checks whether this matrix overlaps with another matrix of compatible type.
template<typename OtherDerived>
bool	_overlaps (const MatrixBase< OtherDerived > &x) const
	Internal helper to check overlap.
bool	is_subset (const Matrix< codac2::Interval, RowsAtCompileTime, ColsAtCompileTime > &x) const
	Checks whether this matrix is a subset of another interval matrix.
template<typename OtherDerived>
bool	is_subset (const MatrixBase< OtherDerived > &x) const
	Checks whether this matrix is a subset of another matrix (Eigen-compatible).
template<typename T>
bool	_is_subset (const T &x) const
	Internal helper for subset check.
bool	is_strict_subset (const Matrix< codac2::Interval, RowsAtCompileTime, ColsAtCompileTime > &x) const
	Checks whether this matrix is a strict subset of another matrix.
template<typename OtherDerived>
bool	is_strict_subset (const MatrixBase< OtherDerived > &x) const
	Checks whether this matrix is a strict subset of another matrix (Eigen-compatible).
template<typename T>
bool	_is_strict_subset (const T &x) const
	Internal helper for strict subset check.
bool	is_interior_subset (const Matrix< codac2::Interval, RowsAtCompileTime, ColsAtCompileTime > &x) const
	Checks whether this matrix is an interior subset of another.
template<typename OtherDerived>
bool	is_interior_subset (const MatrixBase< OtherDerived > &x) const
	Checks whether this matrix is an interior subset of another matrix (Eigen-compatible).
template<typename OtherDerived>
bool	_is_interior_subset (const MatrixBase< OtherDerived > &x) const
	Internal helper for interior subset checking.
bool	is_strict_interior_subset (const Matrix< codac2::Interval, RowsAtCompileTime, ColsAtCompileTime > &x) const
	Checks whether this matrix is a strict interior subset of another matrix.
template<typename OtherDerived>
bool	is_strict_interior_subset (const MatrixBase< OtherDerived > &x) const
	Checks whether this matrix is a strict interior subset of another Eigen-compatible matrix.
template<typename OtherDerived>
bool	_is_strict_interior_subset (const MatrixBase< OtherDerived > &x) const
	Internal helper for strict interior subset relation.
bool	is_superset (const Matrix< codac2::Interval, RowsAtCompileTime, ColsAtCompileTime > &x) const
	Checks whether this matrix is a superset of another interval matrix.
template<typename OtherDerived>
bool	is_superset (const MatrixBase< OtherDerived > &x) const
	Checks whether this matrix is a superset of another Eigen-compatible matrix.
template<typename OtherDerived>
bool	_is_superset (const MatrixBase< OtherDerived > &x) const
	Internal helper for superset check.
bool	is_strict_superset (const Matrix< codac2::Interval, RowsAtCompileTime, ColsAtCompileTime > &x) const
	Checks whether this matrix is a strict superset of another matrix.
template<typename OtherDerived>
bool	is_strict_superset (const MatrixBase< OtherDerived > &x) const
	Checks whether this matrix is a strict superset of an Eigen-compatible matrix.
template<typename OtherDerived>
bool	_is_strict_superset (const MatrixBase< OtherDerived > &x) const
	Internal helper for strict superset check.
bool	is_bisectable () const
	Checks whether at least one interval in the matrix is bisectable.
bool	has_integer_bounds () const
	Checks whether all intervals in the matrix have integer lower and upper bounds.

Detailed Description

This class reuses some of the functions developed for ibex::IntervalMatrixBase. The original IBEX code is revised in modern C++ and adapted to the template structure proposed in Codac, based on the Eigen library. See ibex::IntervalMatrixBase (IBEX lib, author: Gilles Chabert)

This file is included in the declaration of Eigen::MatrixBase, thanks to the preprocessor token EIGEN_MATRIXBASE_PLUGIN. See: https://eigen.tuxfamily.org/dox/TopicCustomizing_Plugins.html and the file codac2_matrices.h

---

Date

2024

Author

Simon Rohou, Gilles Chabert

Copyright

Copyright 2023 Codac Team

License: GNU Lesser General Public License (LGPL)

Function Documentation

volume()

template<typename U = Scalar>

double volume ( ) const

inline

Computes the volume of the interval matrix.

The volume is computed as the sum of the diameters of each interval element. If any interval is unbounded, returns positive infinity. If the matrix is empty or any interval is degenerated, returns 0.

Precondition

The Scalar type must satisfy the IsIntervalDomain concept.

Returns

The computed volume as a double precision floating point number.

{
  if(this->is_empty())
    return 0.;
 
  double v = 0.;
  for(Index i = 0 ; i < this->rows() ; i++)
    for(Index j = 0 ; j < this->cols() ; j++)
    {
      if((*this)(i,j).is_unbounded()) return codac2::oo;
      if((*this)(i,j).is_degenerated()) return 0.;
      v += std::log((*this)(i,j).diam());
    }
  return std::exp(v);
}

is_empty()

bool is_empty ( ) const

inline

Checks whether the interval matrix is empty.

An interval matrix is considered empty if any of its elements is empty.

Returns

true if any element interval is empty, false otherwise.

{
  for(Index i = 0 ; i < rows() ; i++)
    for(Index j = 0 ; j < cols() ; j++)
      if((*this)(i,j).is_empty())
        return true;
  return false;
}

lb()

template<typename U = Scalar>

auto lb ( ) const

inline

Returns a matrix containing the lower bounds of each interval element.

Returns

A matrix of doubles where each element is the lower bound of the corresponding interval.

{
  degenerate_mat(lb);
}

ub()

template<typename U = Scalar>

auto ub ( ) const

inline

Returns a matrix containing the upper bounds of each interval element.

Returns

A matrix of doubles where each element is the upper bound of the corresponding interval.

{
  degenerate_mat(ub);
}

mid()

template<typename U = Scalar>

auto mid ( ) const

inline

Returns a matrix containing the midpoints of each interval element.

The midpoint is the average of the lower and upper bounds.

Returns

A matrix of doubles where each element is the midpoint of the corresponding interval.

{
  degenerate_mat(mid);
}

mag()

template<typename U = Scalar>

auto mag ( ) const

inline

Returns a matrix containing the magnitudes of each interval element.

The magnitude is max(|lower bound|, |upper bound|).

Returns

A matrix of doubles with the magnitudes of each interval.

{
  degenerate_mat(mag);
}

mig()

template<typename U = Scalar>

auto mig ( ) const

inline

Returns a matrix containing the mignitudes of each interval element.

Returns

A matrix of doubles with the mignitudes of each interval.

{
  degenerate_mat(mig);
}

smag()

template<typename U = Scalar>

auto smag ( ) const

inline

Returns a matrix containing the signed magnitudes of each interval element.

The signed magnitude is lower bound if |lower bound|>|upper bound|, upper bound otherwise.

Returns

A matrix of doubles with the signed magnitudes of each interval.

{
  degenerate_mat(smag);
}

smig()

template<typename U = Scalar>

auto smig ( ) const

inline

Returns a matrix containing the signed mignitudes of each interval element.

Returns

A matrix of doubles with the signed mignitudes of each interval.

{
  degenerate_mat(smig);
}

rand()

template<typename U = Scalar>

auto rand ( ) const

inline

Returns a matrix with random values chosen inside each interval element.

Each element in the resulting matrix is a random number uniformly sampled inside the interval.

Returns

A matrix of doubles containing random samples within each interval.

{
  degenerate_mat(rand);
}

rad()

template<typename U = Scalar>

auto rad ( ) const

inline

Returns a matrix containing the radii of each interval element.

The radius is half the diameter of the interval.

Returns

A matrix of doubles with the radii of each interval.

{
  degenerate_mat(rad);
}

diam()

template<typename U = Scalar>

auto diam ( ) const

inline

Returns a matrix containing the diameters of each interval element.

The diameter is the difference between upper and lower bounds.

Returns

A matrix of doubles with the diameters of each interval.

{
  degenerate_mat(diam);
}

min_rad()

double min_rad ( ) const

inline

Returns the minimum radius among the interval elements.

Returns

The smallest radius value in the matrix.

{
  return coeff(this->extr_diam_index(true)).rad();
}

max_rad()

double max_rad ( ) const

inline

Returns the maximum radius among the interval elements.

Returns

The largest radius value in the matrix.

{
  return coeff(this->extr_diam_index(false)).rad();
}

min_diam()

double min_diam ( ) const

inline

Returns the minimum diameter among the interval elements.

Returns

The smallest diameter value in the matrix.

{
  return coeff(this->extr_diam_index(true)).diam();
}

max_diam()

double max_diam ( ) const

inline

Returns the maximum diameter among the interval elements.

Returns

The largest diameter value in the matrix.

{
  return coeff(this->extr_diam_index(false)).diam();
}

min_diam_index()

Index min_diam_index ( ) const

inline

Returns the index of the element with the minimum diameter.

Returns

The index of the matrix element with the smallest diameter.

{
  return this->extr_diam_index(true);
}

max_diam_index()

Index max_diam_index ( ) const

inline

Returns the index of the element with the maximum diameter.

Returns

The index of the matrix element with the largest diameter.

{
  return this->extr_diam_index(false);
}

extr_diam_index()

Index extr_diam_index ( bool min ) const

inline

Returns the index of the element with the minimum or maximum diameter.

Searches the matrix elements for the interval with either the smallest or largest diameter, depending on the min flag.

This method handles unbounded intervals specially:

• If looking for minimum diameter, unbounded intervals are ignored unless no bounded intervals exist.
• If looking for maximum diameter, unbounded intervals are considered.

Parameters

min	If true, returns the index of the element with minimum diameter; otherwise maximum diameter.

Returns

Index of the element with the minimum or maximum diameter.

Precondition

The matrix must not be empty (diameter undefined otherwise).

{
  // This code originates from the ibex-lib
  // See: ibex_TemplateVector.h
  // Author: Gilles Chabert
 
  double d = min ? codac2::oo : -1; // -1 to be sure that even a 0-diameter interval can be selected
  int selected_index = -1;
  bool unbounded = false;
  assert_release(!this->is_empty() && "Diameter of an empty IntervalVector is undefined");
 
  Index i;
 
  for(i = 0 ; i < this->size() ; i++) 
  {
    if(coeff(i).is_unbounded()) 
    {
      unbounded = true;
      if(!min) break;
    }
    else
    {
      double w = coeff(i).diam();
      if(min ? w<d : w>d)
      {
        selected_index = i;
        d = w;
      }
    }
  }
 
  if(min && selected_index == -1)
  {
    assert(unbounded);
    // the selected interval is the first one.
    i = 0;
  }
 
  // The unbounded intervals are not considered if we look for the minimal diameter
  // and some bounded intervals have been found (selected_index!=-1)
  if(unbounded && (!min || selected_index == -1))
  {
    double pt = min ? -codac2::oo : codac2::oo; // keep the point less/most distant from +oo (we normalize if the lower bound is -oo)
    selected_index = i;
 
    for(; i < this->size() ; i++)
    {
      if(coeff(i).lb() == -codac2::oo)
      {
        if(coeff(i).ub() == codac2::oo)
          if(!min)
          {
            selected_index = i;
            break;
          }
 
        if((min && (-coeff(i).ub() > pt)) || (!min && (-coeff(i).ub() < pt)))
        {
          selected_index = i;
          pt = -coeff(i).ub();
        }
      }
 
      else if(coeff(i).ub() == codac2::oo)
        if((min && (coeff(i).lb() > pt)) || (!min && (coeff(i).lb() < pt)))
        {
          selected_index = i;
          pt = coeff(i).lb();
        }
    }
  }
 
  return selected_index;
}

contains() [1/2]

bool contains ( const Matrix< double, RowsAtCompileTime, ColsAtCompileTime > & x ) const

inline

Checks if this interval matrix contains the specified matrix x.

This means every element of x is contained in the corresponding interval element of this matrix.

Parameters

x	The matrix to test for containment.

Returns

true if every element of x is contained within the corresponding interval element.

{
  return _contains(x);
}

contains() [2/2]

template<typename OtherDerived>

bool contains ( const MatrixBase< OtherDerived > & x ) const

inline

Template version to check containment of a matrix with arbitrary derived type.

Parameters

x	The matrix to test.

Returns

true if this interval matrix contains x.

{
  return _contains(x);
}

interior_contains() [1/2]

bool interior_contains ( const Matrix< double, RowsAtCompileTime, ColsAtCompileTime > & x ) const

inline

Checks if the interior of this interval matrix contains the specified matrix x.

The interior containment means strict containment, not just boundary.

Parameters

x	The matrix to test.

Returns

true if the interior of this matrix contains x.

{
  return _interior_contains(x);
}

interior_contains() [2/2]

template<typename OtherDerived>

bool interior_contains ( const MatrixBase< OtherDerived > & x ) const

inline

Template version to check interior containment of a matrix with arbitrary derived type.

Parameters

x	The matrix to test.

Returns

true if interior contains x.

{
  return _interior_contains(x);
}

is_unbounded()

bool is_unbounded ( ) const

inline

Checks if the interval matrix contains any unbounded intervals.

Returns

true if any interval element is unbounded, false otherwise.

{
  if(this->is_empty()) return false;
  for(Index i = 0 ; i < this->rows() ; i++)
    for(Index j = 0 ; j < this->cols() ; j++)
      if((*this)(i,j).is_unbounded())
        return true;
  return false;
}

is_degenerated()

bool is_degenerated ( ) const

inline

Checks if the interval matrix is degenerated.

An interval matrix is degenerated if all its elements are degenerated intervals.

Returns

true if all interval elements are degenerated.

{
  for(Index i = 0 ; i < this->rows() ; i++)
    for(Index j = 0 ; j < this->cols() ; j++)
      if(!(*this)(i,j).is_degenerated())
        return false;
  return true;
}

is_flat()

bool is_flat ( ) const

inline

Checks if the interval matrix is flat.

A matrix is considered flat if at least one of its intervals is degenerated (i.e., has zero diameter), or if the matrix is empty.

Returns

true if the matrix is empty or contains at least one degenerated interval.

{
  if(this->is_empty()) return true;
  for(Index i = 0 ; i < this->rows() ; i++)
    for(Index j = 0 ; j < this->cols() ; j++)
      if((*this)(i,j).is_degenerated()) // don't use diam() because of roundoff
        return true;
  return false;
}

intersects() [1/2]

bool intersects ( const Matrix< codac2::Interval, RowsAtCompileTime, ColsAtCompileTime > & x ) const

inline

Checks whether this matrix intersects with another matrix of intervals.

Intersection means that every corresponding interval pair from both matrices has a non-empty intersection.

Parameters

x	A matrix of intervals of the same size.

Returns

true if all corresponding elements intersect, false otherwise.

{
  return _intersects(x);
}

intersects() [2/2]

template<typename OtherDerived>

bool intersects ( const MatrixBase< OtherDerived > & x ) const

inline

Checks whether this matrix intersects with another Eigen-compatible matrix.

Parameters

x	The matrix to test for intersection.

Returns

true if all corresponding interval elements intersect, false otherwise.

{
  return _intersects(x);
}

is_disjoint() [1/2]

bool is_disjoint ( const Matrix< codac2::Interval, RowsAtCompileTime, ColsAtCompileTime > & x ) const

inline

Checks if this matrix is disjoint with another matrix of intervals.

Disjoint means there exists at least one interval pair that does not intersect.

Parameters

x	A matrix of intervals.

Returns

true if at least one pair of intervals is disjoint, false otherwise.

{
  return _is_disjoint(x);
}

is_disjoint() [2/2]

template<typename OtherDerived>

bool is_disjoint ( const MatrixBase< OtherDerived > & x ) const

inline

Checks if this matrix is disjoint with another matrix of compatible type.

Parameters

x	The matrix to test.

Returns

true if at least one pair of corresponding intervals is disjoint, false otherwise.

{
  return _is_disjoint(x);
}

overlaps() [1/2]

bool overlaps ( const Matrix< codac2::Interval, RowsAtCompileTime, ColsAtCompileTime > & x ) const

inline

Checks whether this matrix overlaps with another.

Overlap requires that all interval pairs overlap.

Parameters

x	The matrix of intervals to test overlap against.

Returns

true if all corresponding intervals overlap.

{
  return _overlaps(x);
}

overlaps() [2/2]

template<typename OtherDerived>

bool overlaps ( const MatrixBase< OtherDerived > & x ) const

inline

Checks whether this matrix overlaps with another matrix of compatible type.

Parameters

x	The matrix to test overlap against.

Returns

true if all interval pairs overlap.

{
  return _overlaps(x);
}

is_subset() [1/2]

bool is_subset ( const Matrix< codac2::Interval, RowsAtCompileTime, ColsAtCompileTime > & x ) const

inline

Checks whether this matrix is a subset of another interval matrix.

Each interval element of this matrix must be a subset of the corresponding interval in x. An empty matrix is considered a subset of any matrix of the same size.

Parameters

x	A matrix of intervals.

Returns

true if all elements of this matrix are subsets of those in x.

{
  return _is_subset(x);
}

is_subset() [2/2]

template<typename OtherDerived>

bool is_subset ( const MatrixBase< OtherDerived > & x ) const

inline

Checks whether this matrix is a subset of another matrix (Eigen-compatible).

Parameters

x	The matrix to check against.

Returns

true if all elements are subsets.

{
  return _is_subset(x);
}

is_strict_subset() [1/2]

bool is_strict_subset ( const Matrix< codac2::Interval, RowsAtCompileTime, ColsAtCompileTime > & x ) const

inline

Checks whether this matrix is a strict subset of another matrix.

A strict subset means it is a subset and at least one element is strictly contained (not equal).

Parameters

x	The matrix to compare to.

Returns

true if this matrix is strictly contained in x.

{
  return _is_strict_subset(x);
}

is_strict_subset() [2/2]

template<typename OtherDerived>

bool is_strict_subset ( const MatrixBase< OtherDerived > & x ) const

inline

Checks whether this matrix is a strict subset of another matrix (Eigen-compatible).

Parameters

x	The matrix to compare to.

Returns

true if strictly contained.

{
  return _is_strict_subset(x);
}

is_interior_subset() [1/2]

bool is_interior_subset ( const Matrix< codac2::Interval, RowsAtCompileTime, ColsAtCompileTime > & x ) const

inline

Checks whether this matrix is an interior subset of another.

Every interval in this matrix must be strictly inside (in the interior of) the corresponding one in x.

Parameters

x	The matrix to check against.

Returns

true if this matrix is an interior subset of x.

{
  return _is_interior_subset(x);
}

is_interior_subset() [2/2]

template<typename OtherDerived>

bool is_interior_subset ( const MatrixBase< OtherDerived > & x ) const

inline

Checks whether this matrix is an interior subset of another matrix (Eigen-compatible).

Parameters

x	The matrix to compare with.

Returns

true if each element is in the interior of the corresponding one in x.

{
  return _is_interior_subset(x);
}

is_strict_interior_subset() [1/2]

bool is_strict_interior_subset ( const Matrix< codac2::Interval, RowsAtCompileTime, ColsAtCompileTime > & x ) const

inline

Checks whether this matrix is a strict interior subset of another matrix.

A strict interior subset means that each interval in this matrix lies strictly within the interior of the corresponding interval in x.

Parameters

x	The matrix to compare against.

Returns

true if every interval in this matrix is strictly inside the corresponding interval in x.

{
  return _is_strict_interior_subset(x);
}

is_strict_interior_subset() [2/2]

template<typename OtherDerived>

bool is_strict_interior_subset ( const MatrixBase< OtherDerived > & x ) const

inline

Checks whether this matrix is a strict interior subset of another Eigen-compatible matrix.

Parameters

x	The matrix to compare with.

Returns

true if all intervals are strictly inside the corresponding intervals in x.

{
  return _is_strict_interior_subset(x);
}

is_superset() [1/2]

bool is_superset ( const Matrix< codac2::Interval, RowsAtCompileTime, ColsAtCompileTime > & x ) const

inline

Checks whether this matrix is a superset of another interval matrix.

This means that each interval in this matrix fully contains the corresponding interval in x.

Parameters

x	The matrix to compare with.

Returns

true if every interval in this matrix is a superset of the corresponding one in x.

{
  return _is_superset(x);
}

is_superset() [2/2]

template<typename OtherDerived>

bool is_superset ( const MatrixBase< OtherDerived > & x ) const

inline

Checks whether this matrix is a superset of another Eigen-compatible matrix.

Parameters

x	The matrix to compare to.

Returns

true if this matrix fully contains all intervals of x.

{
  return _is_superset(x);
}

is_strict_superset() [1/2]

bool is_strict_superset ( const Matrix< codac2::Interval, RowsAtCompileTime, ColsAtCompileTime > & x ) const

inline

Checks whether this matrix is a strict superset of another matrix.

A strict superset means that each interval contains the corresponding one in x, and at least one interval strictly contains its counterpart.

Parameters

x	The matrix to compare against.

Returns

true if this matrix strictly contains the other matrix.

{
  return _is_strict_superset(x);
}

is_strict_superset() [2/2]

template<typename OtherDerived>

bool is_strict_superset ( const MatrixBase< OtherDerived > & x ) const

inline

Checks whether this matrix is a strict superset of an Eigen-compatible matrix.

Parameters

x	The matrix to compare with.

Returns

true if this matrix strictly contains the other matrix.

{
  return _is_strict_superset(x);
}

is_bisectable()

bool is_bisectable ( ) const

inline

Checks whether at least one interval in the matrix is bisectable.

Note

Examples of non bisectable intervals are [0,next_float(0)] or [DBL_MAX,+oo).

Returns

true if at least one element in the matrix satisfies that condition

{
  for(Index i = 0 ; i < this->rows() ; i++)
    for(Index j = 0 ; j < this->cols() ; j++)
      if((*this)(i,j).is_bisectable())
        return true;
  return false;
}

has_integer_bounds()

bool has_integer_bounds ( ) const

inline

Checks whether all intervals in the matrix have integer lower and upper bounds.

Returns

true if every interval in the matrix has integer lower and upper bounds; false otherwise.

{
  for(Index i = 0 ; i < this->rows() ; i++)
    for(Index j = 0 ; j < this->cols() ; j++)
      if(!(*this)(i,j).has_integer_bounds())
        return false;
  return true;
}