include/dai/var.h

   1 /*  Copyright (C) 2006-2008  Joris Mooij  [joris dot mooij at tuebingen dot mpg dot de]
   2     Radboud University Nijmegen, The Netherlands /
   3     Max Planck Institute for Biological Cybernetics, Germany
   4
   5     Copyright (C) 2002  Martijn Leisink  [martijn@mbfys.kun.nl]
   6     Radboud University Nijmegen, The Netherlands
   7
   8     This file is part of libDAI.
   9
  10     libDAI is free software; you can redistribute it and/or modify
  11     it under the terms of the GNU General Public License as published by
  12     the Free Software Foundation; either version 2 of the License, or
  13     (at your option) any later version.
  14
  15     libDAI is distributed in the hope that it will be useful,
  16     but WITHOUT ANY WARRANTY; without even the implied warranty of
  17     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18     GNU General Public License for more details.
  19
  20     You should have received a copy of the GNU General Public License
  21     along with libDAI; if not, write to the Free Software
  22     Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  23 */
  24
  25
  26 /// \file
  27 /// \brief Defines class Var
  28
  29
  30 #ifndef __defined_libdai_var_h
  31 #define __defined_libdai_var_h
  32
  33
  34 #include <iostream>
  35 #include <cassert>
  36
  37
  38 namespace dai {
  39
  40
  41 /// Represents a discrete random variable.
  42 /** A Var stores the \a label of the variable (an integer-valued unique ID)
  43  *  and the number of possible values (\a states) of that variable. Two
  44  *  Var objects with the same label are assumed to be identical (i.e., it
  45  *  is assumed that their states are also the same).
  46  *
  47  *  In this manual, we use the following notational conventions. The discrete
  48  *  random variable with label \f$l\f$ is denoted as \f$x_l\f$, and the number
  49  *  of possible values of this variable as \f$S_l\f$; this is represented in
  50  *  code by the object Var(\f$l\f$,\f$S_l\f$). The set of possible values of
  51  *  variable \f$x_l\f$ is denoted \f$X_l := \{0,1,\dots,S_l-1\}\f$.
  52  */
  53 class Var {
  54     private:
  55         /// Label of the variable (its unique ID)
  56         long    _label;
  57
  58         /// Number of possible values
  59         size_t  _states;
  60
  61     public:
  62         /// Default constructor
  63         Var() : _label(-1), _states(0) {}
  64         /// Constructor
  65         Var( long label, size_t states ) : _label(label), _states(states) {}
  66
  67         /// Returns the label
  68         long label() const { return _label; }
  69         /// Returns reference to label
  70         long & label() { return _label; }
  71
  72         /// Returns the number of states
  73         size_t states () const { return _states; }
  74         /// Returns reference to number of states
  75         size_t& states () { return _states; }
  76
  77         /// Smaller-than operator (compares only labels)
  78         bool operator < ( const Var& n ) const { return( _label <  n._label ); }
  79         /// Larger-than operator (compares only labels)
  80         bool operator > ( const Var& n ) const { return( _label >  n._label ); }
  81         /// Smaller-than-or-equal-to operator (only compares labels)
  82         bool operator <= ( const Var& n ) const {
  83 #ifdef DAI_DEBUG
  84             if( _label == n._label )
  85                 assert( _states == n._states );
  86 #endif
  87             return( _label <= n._label );
  88         }
  89         /// Larger-than-or-equal-to operator (only compares labels)
  90         bool operator >= ( const Var& n ) const {
  91 #ifdef DAI_DEBUG
  92             if( _label == n._label )
  93                 assert( _states == n._states );
  94 #endif
  95             return( _label >= n._label );
  96         }
  97         /// Not-equal-to operator (only compares labels)
  98         bool operator != ( const Var& n ) const {
  99 #ifdef DAI_DEBUG
 100             if( _label == n._label )
 101                 assert( _states == n._states );
 102 #endif
 103             return( _label != n._label );
 104         }
 105         /// Equal-to operator (only compares labels)
 106         bool operator == ( const Var& n ) const {
 107 #ifdef DAI_DEBUG
 108             if( _label == n._label )
 109                 assert( _states == n._states );
 110 #endif
 111             return( _label == n._label );
 112         }
 113
 114         /// Writes a Var to an output stream
 115         friend std::ostream& operator << ( std::ostream& os, const Var& n ) {
 116             return( os << "x" << n.label() );
 117         }
 118 };
 119
 120
 121 } // end of namespace dai
 122
 123
 124 #endif