//

 //  Copyright (c) 2000-2002

 //  Joerg Walter, Mathias Koch

 //

 //  Permission to use, copy, modify, distribute and sell this software

 //  and its documentation for any purpose is hereby granted without fee,

 //  provided that the above copyright notice appear in all copies and

 //  that both that copyright notice and this permission notice appear

 //  in supporting documentation.  The authors make no representations

 //  about the suitability of this software for any purpose.

 //  It is provided "as is" without express or implied warranty.

 //

 //  The authors gratefully acknowledge the support of

 //  GeNeSys mbH & Co. KG in producing this work.

 //

 #ifndef _BOOST_UBLAS_EXCEPTION_

 #define _BOOST_UBLAS_EXCEPTION_

 #if ! defined (BOOST_NO_EXCEPTIONS) && ! defined (BOOST_UBLAS_NO_EXCEPTIONS)

 #include <stdexcept>

 #else

 #include <cstdlib>

 #endif

 #ifndef BOOST_UBLAS_NO_STD_CERR

 #include <iostream>

 #endif

 #include <boost/numeric/ublas/detail/config.hpp>

 namespace boost { namespace numeric { namespace ublas {

     struct divide_by_zero

 #if ! defined (BOOST_NO_EXCEPTIONS) && ! defined (BOOST_UBLAS_NO_EXCEPTIONS)

         // Inherit from standard exceptions as requested during review.

         : public std::runtime_error {

         explicit divide_by_zero (const char *s = "divide by zero") :

             std::runtime_error (s) {}

         void raise () {

             throw *this;

         }

 #else

     {

         divide_by_zero ()

             {}

         explicit divide_by_zero (const char *)

             {}

         void raise () {

             std::abort ();

         }

 #endif

     };

     struct internal_logic

 #if ! defined (BOOST_NO_EXCEPTIONS) && ! defined (BOOST_UBLAS_NO_EXCEPTIONS)

         // Inherit from standard exceptions as requested during review.

         : public std::logic_error {

         explicit internal_logic (const char *s = "internal logic") :

             std::logic_error (s) {}

         void raise () {

             throw *this;

         }

 #else

     {

         internal_logic ()

             {}

         explicit internal_logic (const char *)

             {}

         void raise () {

             std::abort ();

         }

 #endif

     };

     struct external_logic

 #if ! defined (BOOST_NO_EXCEPTIONS) && ! defined (BOOST_UBLAS_NO_EXCEPTIONS)

         // Inherit from standard exceptions as requested during review.

         : public std::logic_error {

         explicit external_logic (const char *s = "external logic") :

             std::logic_error (s) {}

         // virtual const char *what () const throw () {

         //     return "exception: external logic";

         // }

         void raise () {

             throw *this;

         }

 #else

     {

         external_logic ()

             {}

         explicit external_logic (const char *)

             {}

         void raise () {

             std::abort ();

         }

 #endif

     };

     struct bad_argument

 #if ! defined (BOOST_NO_EXCEPTIONS) && ! defined (BOOST_UBLAS_NO_EXCEPTIONS)

         // Inherit from standard exceptions as requested during review.

         : public std::invalid_argument {

         explicit bad_argument (const char *s = "bad argument") :

             std::invalid_argument (s) {}

         void raise () {

             throw *this;

         }

 #else

     {

         bad_argument ()

             {}

         explicit bad_argument (const char *)

             {}

         void raise () {

             std::abort ();

         }

 #endif

     };

     struct bad_size

 #if ! defined (BOOST_NO_EXCEPTIONS) && ! defined (BOOST_UBLAS_NO_EXCEPTIONS)

         // Inherit from standard exceptions as requested during review.

         : public std::domain_error {

         explicit bad_size (const char *s = "bad size") :

             std::domain_error (s) {}

         void raise () {

             throw *this;

         }

 #else

     {

         bad_size ()

             {}

         explicit bad_size (const char *)

             {}

         void raise () {

             std::abort ();

         }

 #endif

     };

     struct bad_index

 #if ! defined (BOOST_NO_EXCEPTIONS) && ! defined (BOOST_UBLAS_NO_EXCEPTIONS)

         // Inherit from standard exceptions as requested during review.

         : public std::out_of_range {

         explicit bad_index (const char *s = "bad index") :

             std::out_of_range (s) {}

         void raise () {

             throw *this;

         }

 #else

     {

         bad_index ()

             {}

         explicit bad_index (const char *)

             {}

         void raise () {

             std::abort ();

         }

 #endif

     };

     struct singular

 #if ! defined (BOOST_NO_EXCEPTIONS) && ! defined (BOOST_UBLAS_NO_EXCEPTIONS)

         // Inherit from standard exceptions as requested during review.

         : public std::runtime_error {

         explicit singular (const char *s = "singular") :

             std::runtime_error (s) {}

         void raise () {

             throw *this;

         }

 #else

     {

         singular ()

             {}

         explicit singular (const char *)

             {}

         void raise () {

             throw *this;

             std::abort ();

         }

 #endif

     };

     struct non_real

 #if ! defined (BOOST_NO_EXCEPTIONS) && ! defined (BOOST_UBLAS_NO_EXCEPTIONS)

         // Inherit from standard exceptions as requested during review.

         : public std::domain_error {

         explicit non_real (const char *s = "exception: non real") :

             std::domain_error (s) {}

         void raise () {

             throw *this;

         }

 #else

      {

         non_real ()

             {}

         explicit non_real (const char *)

             {}

         void raise () {

             std::abort ();

         }

 #endif

     };

 #if BOOST_UBLAS_CHECK_ENABLE

 // Macros are equivilent to 

 //    template<class E>

 //    BOOST_UBLAS_INLINE

 //    void check (bool expression, const E &e) {

 //        if (! expression)

 //            e.raise ();

 //    }

 //    template<class E>

 //    BOOST_UBLAS_INLINE

 //    void check_ex (bool expression, const char *file, int line, const E &e) {

 //        if (! expression)

 //            e.raise ();

 //    }

 #ifndef BOOST_UBLAS_NO_STD_CERR

 #define BOOST_UBLAS_CHECK_FALSE(e) \

     std::cerr << "Check failed in file " << __FILE__ << " at line " << __LINE__ << ":" << std::endl; \

     e.raise ();

 #define BOOST_UBLAS_CHECK(expression, e) \

     if (! (expression)) { \

         std::cerr << "Check failed in file " << __FILE__ << " at line " << __LINE__ << ":" << std::endl; \

         std::cerr << #expression << std::endl; \

         e.raise (); \

     }

 #define BOOST_UBLAS_CHECK_EX(expression, file, line, e) \

     if (! (expression)) { \

         std::cerr << "Check failed in file " << (file) << " at line " << (line) << ":" << std::endl; \

         std::cerr << #expression << std::endl; \

         e.raise (); \

     }

 #else

 #define BOOST_UBLAS_CHECK_FALSE(e) \

     e.raise ();

 #define BOOST_UBLAS_CHECK(expression, e) \

     if (! (expression)) { \

         e.raise (); \

     }

 #define BOOST_UBLAS_CHECK_EX(expression, file, line, e) \

     if (! (expression)) { \

         e.raise (); \

     }

 #endif

 #else

 // Macros are equivilent to 

 //    template<class E>

 //    BOOST_UBLAS_INLINE

 //    void check (bool expression, const E &e) {}

 //    template<class E>

 //    BOOST_UBLAS_INLINE

 //    void check_ex (bool expression, const char *file, int line, const E &e) {}

 #define BOOST_UBLAS_CHECK_FALSE(e)

 #define BOOST_UBLAS_CHECK(expression, e)

 #define BOOST_UBLAS_CHECK_EX(expression, file, line, e)

 #endif

 #ifndef BOOST_UBLAS_USE_FAST_SAME

 // Macro is equivilent to 

 //    template<class T>

 //    BOOST_UBLAS_INLINE

 //    const T &same_impl (const T &size1, const T &size2) {

 //        BOOST_UBLAS_CHECK (size1 == size2, bad_argument ());

 //        return (std::min) (size1, size2);

 //    }

 // #define BOOST_UBLAS_SAME(size1, size2) same_impl ((size1), (size2))

     template<class T>

     BOOST_UBLAS_INLINE

     // Kresimir Fresl and Dan Muller reported problems with COMO.

     // We better change the signature instead of libcomo ;-)

     // const T &same_impl_ex (const T &size1, const T &size2, const char *file, int line) {

     T same_impl_ex (const T &size1, const T &size2, const char *file, int line) {

         BOOST_UBLAS_CHECK_EX (size1 == size2, file, line, bad_argument ());

         return (std::min) (size1, size2);

     }

 #define BOOST_UBLAS_SAME(size1, size2) same_impl_ex ((size1), (size2), __FILE__, __LINE__)

 #else

 // Macros are equivilent to 

 //    template<class T>

 //    BOOST_UBLAS_INLINE

 //    const T &same_impl (const T &size1, const T &size2) {

 //        return size1;

 //    }

 // #define BOOST_UBLAS_SAME(size1, size2) same_impl ((size1), (size2))

 #define BOOST_UBLAS_SAME(size1, size2) (size1)

 #endif

 }}}

 #endif