/Users/mourrain/Devel/mmx/numerix/include/numerix/ball_complex.hpp

Go to the documentation of this file.

/******************************************************************************
* MODULE     : ball_complex.hpp
* DESCRIPTION: Complex balls
* COPYRIGHT  : (C) 2006  Joris van der Hoeven
*******************************************************************************
* This software falls under the GNU general public license and comes WITHOUT
* ANY WARRANTY WHATSOEVER. See the file $TEXMACS_PATH/LICENSE for more details.
* If you don't have this file, write to the Free Software Foundation, Inc.,
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
******************************************************************************/

#ifndef __MMX_BALL_COMPLEX_HPP
#define __MMX_BALL_COMPLEX_HPP
#include <numerix/ball_complex_rounded.hpp>
namespace mmx {

/******************************************************************************
* Constructors
******************************************************************************/

template<typename Real, typename Complex, typename R> ball<Complex,R>
complex_gaussian (const ball<Real,R>& re) {
  typedef Ball_variant(R) V;
  typedef implementation<ball_complex_construct,ball_complex<V> > Impl;
  ball<Complex,R> z; Impl::gauss (z, re, promote (0, re)); return z;
}

template<typename Real, typename Complex, typename R> ball<Complex,R>
complex_gaussian (const ball<Real,R>& re, const ball<Real,R>& im) {
  typedef Ball_variant(R) V;
  typedef implementation<ball_complex_construct,ball_complex<V> > Impl;
  ball<Complex,R> z; Impl::gauss (z, re, im); return z;
}

/******************************************************************************
* General complex balls
******************************************************************************/

#define TMPL template<typename C,typename R,typename V>
#define Complex_ball ball<C,R,V>
#define Real Real_type(C)
#define Real_ball ball<Real,R,V>

UNARY_RETURN_TYPE(TMPL,Re_op,Complex_ball,Real_ball );

/******************************************************************************
* Extra arithmetic operations
******************************************************************************/

TMPL inline Real_ball Re (const Complex_ball& z) {
  return Real_ball (Re (center (z)), radius (z)); }
TMPL inline Real_ball Im (const Complex_ball& z) {
  return Real_ball (Im (center (z)), radius (z)); }
TMPL inline Real_ball arg (const Complex_ball& z) {
  return atan2 (Im (z), Re (z)); }
TMPL inline Complex_ball conj (const Complex_ball& z) {
  return Complex_ball (conj (center (z)), radius (z)); }
TMPL inline Complex_ball times_i (const Complex_ball& z) {
  return Complex_ball (times_i (center (z)), radius (z)); }
TMPL inline Complex_ball over_i (const Complex_ball& z) {
  return Complex_ball (over_i (center (z)), radius (z)); }

#undef TMPL
#undef Complex_ball
#undef Real
#undef Real_ball

/******************************************************************************
* Complex balls with center type of the form complex<Real>
******************************************************************************/

#define TMPL template<typename C,typename R,typename V>
#define Ball ball<C,R,V>
#define Complex_ball ball<complex<C>,R,V>

BINARY_RETURN_TYPE(TMPL,gaussian_op,Ball,Ball,Complex_ball);

/******************************************************************************
* Extra constructors
******************************************************************************/

TMPL Complex_ball
gaussian (const Ball& re, const Ball& im= 0) {
  typedef implementation<ball_complex_construct,ball_complex<V> > Impl;
  Complex_ball z; Impl::gauss (z, re, im); return z;
}

TMPL Complex_ball
polar (const Ball& r, const Ball& t) {
  typedef implementation<ball_complex_construct,ball_complex<V> > Impl;
  Complex_ball z; Impl::polar (z, r, t); return z;
}

/******************************************************************************
* Customized output routine
******************************************************************************/

TMPL syntactic
flatten (const Complex_ball& z) {
  if (is_nan (z)) return Nan (syntactic);
  if (is_fuzz (z)) return Fuzz (syntactic);
  if (is_infinite (z)) return Infinity (syntactic);
  if (is_exact_zero (z)) return 0;
  if (Re (z) != 0 && Im (z) == 0)
    return flatten (Re (z));
  if (Re (z) == 0 && Im (z) != 0)
    return flatten (Im (z)) * Imaginary (syntactic);
  return flatten (Re (z)) + flatten (Im (z)) * Imaginary (syntactic);
}

TMPL syntactic
flatten (const Complex_ball& z, nat dd) {
  if (is_nan (z)) return Nan (syntactic);
  if (is_fuzz (z)) return Fuzz (syntactic);
  if (is_infinite (z)) return Infinity (syntactic);
  if (is_exact_zero (z)) return 0;
  if (Re (z) != 0 && Im (z) == 0)
    return flatten (Re (z), dd);
  if (Re (z) == 0 && Im (z) != 0)
    return flatten (Im (z), dd) * Imaginary (syntactic);
  return flatten (Re (z), dd) + flatten (Im (z), dd) * Imaginary (syntactic);
}

/******************************************************************************
* Extra convenience arithmetic operations
******************************************************************************/

TMPL inline Complex_ball operator + (const Complex_ball& z1, const Ball& z2) {
  return z1 + Complex_ball (z2); }
TMPL inline Complex_ball operator + (const Ball& z1, const Complex_ball& z2) {
  return Complex_ball (z1) + z2; }
TMPL inline Complex_ball operator - (const Complex_ball& z1, const Ball& z2) {
  return z1 - Complex_ball (z2); }
TMPL inline Complex_ball operator - (const Ball& z1, const Complex_ball& z2) {
  return Complex_ball (z1) - z2; }
TMPL inline Complex_ball operator * (const Complex_ball& z1, const Ball& z2) {
  return z1 * Complex_ball (z2); }
TMPL inline Complex_ball operator * (const Ball& z1, const Complex_ball& z2) {
  return Complex_ball (z1) * z2; }
TMPL inline Complex_ball operator / (const Complex_ball& z1, const Ball& z2) {
  return z1 / Complex_ball (z2); }
TMPL inline Complex_ball operator / (const Ball& z1, const Complex_ball& z2) {
  return Complex_ball (z1) / z2; }

#undef TMPL
#undef Ball
#undef Complex_ball
} // namespace mmx
#endif // __MMX_BALL_COMPLEX_HPP