/*
**  ha_imath.hpp: additional headerfile for the C-XSC library
**                mathematical standard functions (elementary functions)
**                of high accuracy for interval arguments 
**
**  Copyright  (C) 2002 Dr. W. Hofschuster
**                      Wiss. Rechnen/Softwaretechnologie
**                      Universitaet Wuppertal, Germany   
**
**  This library is free software; you can redistribute it and/or
**  modify it under the terms of the GNU Library General Public
**  License as published by the Free Software Foundation; either
**  version 2 of the License, or (at your option) any later version.
**
**  This library is distributed in the hope that it will be useful,
**  but WITHOUT ANY WARRANTY; without even the implied warranty of
**  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
**  Library General Public License for more details.
**
**  You should have received a copy of the GNU Library General Public
**  License along with this library; if not, write to the Free
**  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

#include "rts_real.hpp"
#include "interval.hpp"

extern "C" {
#ifndef rfcth_included
#define rfcth_included
#include "r_fcth.h"
#endif
}

namespace ha_cxsc {
inline a_intv _a_intv(const cxsc::interval &x)
{	return *((const a_intv *)(&x));
}
inline cxsc::interval _interval(const a_intv &x)
{	return *((const cxsc::interval *)(&x));
}

inline cxsc::interval sqrt   (const cxsc::interval &a) { return _interval(i_sqrt(_a_intv(a))); }

inline cxsc::interval sin    (const cxsc::interval &a) { return _interval(i_sin(_a_intv(a))); }
inline cxsc::interval cos    (const cxsc::interval &a) { return _interval(i_cos(_a_intv(a))); }
inline cxsc::interval tan    (const cxsc::interval &a) { return _interval(i_tan(_a_intv(a))); }
inline cxsc::interval cot    (const cxsc::interval &a) { return _interval(i_cot(_a_intv(a))); }

inline cxsc::interval exp    (const cxsc::interval &a) { return _interval(i_exp(_a_intv(a))); }
inline cxsc::interval log    (const cxsc::interval &a) { return _interval(i_log(_a_intv(a))); }

inline cxsc::interval sinh   (const cxsc::interval &a) { return _interval(i_sinh(_a_intv(a))); }
inline cxsc::interval cosh   (const cxsc::interval &a) { return _interval(i_cosh(_a_intv(a))); }
inline cxsc::interval tanh   (const cxsc::interval &a) { return _interval(i_tanh(_a_intv(a))); }
inline cxsc::interval coth   (const cxsc::interval &a) { return _interval(i_coth(_a_intv(a))); }

inline cxsc::interval asin   (const cxsc::interval &a) { return _interval(i_asin(_a_intv(a))); }
inline cxsc::interval acos   (const cxsc::interval &a) { return _interval(i_acos(_a_intv(a))); }
inline cxsc::interval atan   (const cxsc::interval &a) { return _interval(i_atan(_a_intv(a))); }
inline cxsc::interval acot   (const cxsc::interval &a) { return _interval(i_acot(_a_intv(a))); }

inline cxsc::interval asinh  (const cxsc::interval &a) { return _interval(i_asnh(_a_intv(a))); }
inline cxsc::interval acosh  (const cxsc::interval &a) { return _interval(i_acsh(_a_intv(a))); }
inline cxsc::interval acoth  (const cxsc::interval &a) { return _interval(i_acth(_a_intv(a))); }
inline cxsc::interval atanh  (const cxsc::interval &a) { return _interval(i_tanh(_a_intv(a))); }

inline cxsc::interval pow    (const cxsc::interval &a, const cxsc::interval &b) 
       {  cxsc::interval res = _interval(i_pow(_a_intv(a),_a_intv(b))); 
          if (cxsc::Inf(res) <= cxsc::Sup(res))
	     return res;
	  else
	     return cxsc::interval(cxsc::Sup(res),cxsc::Inf(res));
       }
inline cxsc::interval power  (const cxsc::interval &a, const int &n) 
       { return ha_cxsc::pow(a,cxsc::interval(n)); }

//---------------------------------------------------------------
// Additional elementary functions
//---------------------------------------------------------------

inline cxsc::interval exp10  (const cxsc::interval &a) { return _interval(i_ep10(_a_intv(a))); }
inline cxsc::interval exp2   (const cxsc::interval &a) { return _interval(i_exp2(_a_intv(a))); }
inline cxsc::interval log10  (const cxsc::interval &a) { return _interval(i_lg10(_a_intv(a))); }
inline cxsc::interval log2   (const cxsc::interval &a) { return _interval(i_log2(_a_intv(a))); }
inline cxsc::interval loga   (const cxsc::interval &a, const cxsc::real &x) 
       { return _interval(i_loga(_a_intv(a),_a_real(x))); }
}