# HG changeset patch
# User Alpar Juttner <alpar@cs.elte.hu>
# Date 1231948529 0
# Node ID 81627fa1b0070a8175724f70868125203730fec9
# Parent  04c0631fd33241997b26542eec78715709d11003
Own support for isnan()
diff --git a/lemon/lp_base.h b/lemon/lp_base.h
        
              
              
                
                  | a | b |  | 
              
            
                  
                          | 597 | 597 | const Value &upperBound() const { return _ub; } | 
                          | 598 | 598 | ///Is the constraint lower bounded? | 
                          | 599 | 599 | bool lowerBounded() const { | 
            
                      
                        | 600 |  | return _lb != -INF && ! std::isnan(_lb); | 
                      
                        |  | 600 | return _lb != -INF && !isnan(_lb); | 
            
                  
                          | 601 | 601 | } | 
                          | 602 | 602 | ///Is the constraint upper bounded? | 
                          | 603 | 603 | bool upperBounded() const { | 
            
                      
                        | 604 |  | return _ub != INF && ! std::isnan(_ub); | 
                      
                        |  | 604 | return _ub != INF && !isnan(_ub); | 
            
                  
                          | 605 | 605 | } | 
                          | 606 | 606 |  | 
                          | 607 | 607 | }; | 
            
              
                
                  | … | … |  | 
              
            
                  
                          | 1666 | 1666 | inline LpBase::Constr operator<=(const LpBase::Value &n, | 
                          | 1667 | 1667 | const LpBase::Constr &c) { | 
                          | 1668 | 1668 | LpBase::Constr tmp(c); | 
            
                      
                        | 1669 |  | LEMON_ASSERT( std::isnan(tmp.lowerBound()), "Wrong LP constraint"); | 
                      
                        |  | 1669 | LEMON_ASSERT(isnan(tmp.lowerBound()), "Wrong LP constraint"); | 
            
                  
                          | 1670 | 1670 | tmp.lowerBound()=n; | 
                          | 1671 | 1671 | return tmp; | 
                          | 1672 | 1672 | } | 
            
              
                
                  | … | … |  | 
              
            
                  
                          | 1678 | 1678 | const LpBase::Value &n) | 
                          | 1679 | 1679 | { | 
                          | 1680 | 1680 | LpBase::Constr tmp(c); | 
            
                      
                        | 1681 |  | LEMON_ASSERT( std::isnan(tmp.upperBound()), "Wrong LP constraint"); | 
                      
                        |  | 1681 | LEMON_ASSERT(isnan(tmp.upperBound()), "Wrong LP constraint"); | 
            
                  
                          | 1682 | 1682 | tmp.upperBound()=n; | 
                          | 1683 | 1683 | return tmp; | 
                          | 1684 | 1684 | } | 
            
              
                
                  | … | … |  | 
              
            
                  
                          | 1690 | 1690 | inline LpBase::Constr operator>=(const LpBase::Value &n, | 
                          | 1691 | 1691 | const LpBase::Constr &c) { | 
                          | 1692 | 1692 | LpBase::Constr tmp(c); | 
            
                      
                        | 1693 |  | LEMON_ASSERT( std::isnan(tmp.upperBound()), "Wrong LP constraint"); | 
                      
                        |  | 1693 | LEMON_ASSERT(isnan(tmp.upperBound()), "Wrong LP constraint"); | 
            
                  
                          | 1694 | 1694 | tmp.upperBound()=n; | 
                          | 1695 | 1695 | return tmp; | 
                          | 1696 | 1696 | } | 
            
              
                
                  | … | … |  | 
              
            
                  
                          | 1702 | 1702 | const LpBase::Value &n) | 
                          | 1703 | 1703 | { | 
                          | 1704 | 1704 | LpBase::Constr tmp(c); | 
            
                      
                        | 1705 |  | LEMON_ASSERT( std::isnan(tmp.lowerBound()), "Wrong LP constraint"); | 
                      
                        |  | 1705 | LEMON_ASSERT(isnan(tmp.lowerBound()), "Wrong LP constraint"); | 
            
                  
                          | 1706 | 1706 | tmp.lowerBound()=n; | 
                          | 1707 | 1707 | return tmp; | 
                          | 1708 | 1708 | } | 
            
        
      
      
        
        diff --git a/lemon/math.h b/lemon/math.h
        
              
              
                
                  | a | b |  | 
              
            
                  
                          | 55 | 55 | /// 1/sqrt(2) | 
                          | 56 | 56 | const long double SQRT1_2 = 0.7071067811865475244008443621048490L; | 
                          | 57 | 57 |  | 
            
                  
                          |  | 58 | ///Check whether the parameter is NaN or not | 
                          |  | 59 |  | 
                          |  | 60 | ///This function checks whether the parameter is NaN or not. | 
                          |  | 61 | ///Is should be equivalent with std::isnan(), but it is not | 
                          |  | 62 | ///provided by all compilers. | 
                          |  | 63 | inline bool isnan(double v) | 
                          |  | 64 | { | 
                          |  | 65 | return v!=v; | 
                          |  | 66 | } | 
            
                  
                          | 58 | 67 |  | 
                          | 59 | 68 | /// @} | 
                          | 60 | 69 |  |