src/work/marci/lp/expression.h
changeset 1119 d3504fc075dc
parent 1097 c91e765266d7
child 1144 1cfabf245433
equal deleted inserted replaced
0:190b39152f69 1:47530e488a25
    17   template <typename _Col, typename _Value>
    17   template <typename _Col, typename _Value>
    18   class Expr;
    18   class Expr;
    19 
    19 
    20   template <typename _Col, typename _Value>
    20   template <typename _Col, typename _Value>
    21   class Expr {
    21   class Expr {
    22   protected:
    22 //  protected:
       
    23   public:
    23     typedef 
    24     typedef 
    24     typename std::map<_Col, _Value> Data; 
    25     typename std::map<_Col, _Value> Data; 
    25     Data data;
    26     Data data;
    26   public:
    27   public:
       
    28     void simplify() {
       
    29       for (typename Data::iterator i=data.begin(); 
       
    30 	   i!=data.end(); ++i) {
       
    31 	if ((*i).second==0) data.erase(i);
       
    32       }
       
    33     }
    27     Expr() { }
    34     Expr() { }
    28     Expr(_Col _col) { 
    35     Expr(_Col _col) { 
    29       data.insert(std::make_pair(_col, 1));
    36       data.insert(std::make_pair(_col, 1));
    30     }
    37     }
    31     Expr& operator*=(_Value _value) {
    38     Expr& operator*=(_Value _value) {
    32       for (typename Data::iterator i=data.begin(); 
    39       for (typename Data::iterator i=data.begin(); 
    33 	   i!=data.end(); ++i) {
    40 	   i!=data.end(); ++i) {
    34 	(*i).second *= _value;
    41 	(*i).second *= _value;
    35       }
    42       }
       
    43       simplify();
    36       return *this;
    44       return *this;
    37     }
    45     }
    38     Expr& operator+=(const Expr<_Col, _Value>& expr) {
    46     Expr& operator+=(const Expr<_Col, _Value>& expr) {
    39       for (typename Data::const_iterator j=expr.data.begin(); 
    47       for (typename Data::const_iterator j=expr.data.begin(); 
    40 	   j!=expr.data.end(); ++j) {
    48 	   j!=expr.data.end(); ++j) {
    43 	  data.insert(std::make_pair((*j).first, (*j).second));
    51 	  data.insert(std::make_pair((*j).first, (*j).second));
    44 	} else {
    52 	} else {
    45 	  (*i).second+=(*j).second;
    53 	  (*i).second+=(*j).second;
    46 	}
    54 	}
    47       }
    55       }
       
    56       simplify();
       
    57       return *this;
       
    58     }
       
    59     Expr& operator-=(const Expr<_Col, _Value>& expr) {
       
    60       for (typename Data::const_iterator j=expr.data.begin(); 
       
    61 	   j!=expr.data.end(); ++j) {
       
    62 	typename Data::iterator i=data.find((*j).first);
       
    63 	if (i==data.end()) {
       
    64 	  data.insert(std::make_pair((*j).first, -(*j).second));
       
    65 	} else {
       
    66 	  (*i).second+=-(*j).second;
       
    67 	}
       
    68       }
       
    69       simplify();
    48       return *this;
    70       return *this;
    49     }
    71     }
    50     template <typename _C, typename _V> 
    72     template <typename _C, typename _V> 
    51     friend std::ostream& operator<<(std::ostream& os, 
    73     friend std::ostream& operator<<(std::ostream& os, 
    52 				    const Expr<_C, _V>& expr);
    74 				    const Expr<_C, _V>& expr);
    54 
    76 
    55   template <typename _Col, typename _Value>
    77   template <typename _Col, typename _Value>
    56   Expr<_Col, _Value> operator*(_Value _value, _Col _col) {
    78   Expr<_Col, _Value> operator*(_Value _value, _Col _col) {
    57     Expr<_Col, _Value> tmp(_col);
    79     Expr<_Col, _Value> tmp(_col);
    58     tmp*=_value;
    80     tmp*=_value;
       
    81     tmp.simplify();
    59     return tmp;
    82     return tmp;
    60   }
    83   }
    61 
    84 
    62   template <typename _Col, typename _Value>
    85   template <typename _Col, typename _Value>
    63   Expr<_Col, _Value> operator*(_Value _value, 
    86   Expr<_Col, _Value> operator*(_Value _value, 
    64 			       const Expr<_Col, _Value>& expr) {
    87 			       const Expr<_Col, _Value>& expr) {
    65     Expr<_Col, _Value> tmp(expr);
    88     Expr<_Col, _Value> tmp(expr);
    66     tmp*=_value;
    89     tmp*=_value;
       
    90     tmp.simplify();
    67     return tmp;
    91     return tmp;
    68   }
    92   }
    69 
    93 
    70   template <typename _Col, typename _Value>
    94   template <typename _Col, typename _Value>
    71   Expr<_Col, _Value> operator+(const Expr<_Col, _Value>& expr1, 
    95   Expr<_Col, _Value> operator+(const Expr<_Col, _Value>& expr1, 
    72 			       const Expr<_Col, _Value>& expr2) {
    96 			       const Expr<_Col, _Value>& expr2) {
    73     Expr<_Col, _Value> tmp(expr1);
    97     Expr<_Col, _Value> tmp(expr1);
    74     tmp+=expr2;
    98     tmp+=expr2;
       
    99     tmp.simplify();
       
   100     return tmp;
       
   101   }
       
   102 
       
   103   template <typename _Col, typename _Value>
       
   104   Expr<_Col, _Value> operator-(const Expr<_Col, _Value>& expr1, 
       
   105 			       const Expr<_Col, _Value>& expr2) {
       
   106     Expr<_Col, _Value> tmp(expr1);
       
   107     tmp-=expr2;
       
   108     tmp.simplify();
    75     return tmp;
   109     return tmp;
    76   }
   110   }
    77 
   111 
    78   template <typename _Col, typename _Value>
   112   template <typename _Col, typename _Value>
    79   std::ostream& operator<<(std::ostream& os, 
   113   std::ostream& operator<<(std::ostream& os,