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

Go to the documentation of this file.

/******************************************************************************
* MODULE     : twin.hpp
* DESCRIPTION: Twin numbers
* COPYRIGHT  : (C) 2007  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_TWIN_HPP
#define __MMX_TWIN_HPP
#include <basix/operators.hpp>
namespace mmx {
struct std_twin {};
#define TMPL_DEF template<typename C, typename D=generic, typename V=std_twin>
#define TMPL template<typename C, typename D, typename V>
#define Twin twin<C,D,V>
TMPL class twin;
TMPL inline C car (const Twin& x);
TMPL inline D cdr (const Twin& x);
TMPL inline C& car (Twin& x);
TMPL inline D& cdr (Twin& x);

/******************************************************************************
* The twin type
******************************************************************************/

TMPL_DEF
class twin {
MMX_ALLOCATORS;
private:
  C x1;
  D x2;
public:
  inline twin (): x1 (0), x2 (0) {}
  template<typename T> inline twin (const T& x):
    //x1 (x), x2 (x) {}
    x1 (as<C> (x)), x2 (as<D> (x)) {}
  template<typename T, typename U> inline twin (const T& y1, const U& y2):
    // x1 (y1), x2 (y2) {}
    x1 (as<C> (y1)), x2 (as<D> (y2)) {}
  inline twin (const int& x):
    x1 (x), x2 (x) {}
  template<typename T> inline twin (const T& y1, const int& y2):
    x1 (as<C> (y1)), x2 (y2) {}
  template<typename W> inline twin (const twin<C,V,W>& x):
    x1 (car (x)), x2 (cdr (x)) {}
  friend C car LESSGTR (const Twin& x);
  friend D cdr LESSGTR (const Twin& x);
  friend C& car LESSGTR (Twin& x);
  friend D& cdr LESSGTR (Twin& x);
};
DEFINE_BINARY_FORMAT_2 (twin)

template<typename C1, typename D1, typename V1,
         typename C2, typename D2, typename V2>
struct as_helper<twin<C1,D1,V1>,twin<C2,D2,V2> > {
  static inline twin<C1,D1,V1> cv (const twin<C2,D2,V2>& x) {
    return twin<C1,D1,V1> (as<C1> (car (x)), as<D1> (cdr (x))); }
};

TMPL generic
construct (const Twin& x) {
  return construct (as<generic> (x));
}

TMPL struct rounding_helper<Twin >: public rounding_helper<C> {};
TMPL struct projective_helper<Twin >: public projective_helper<C> {};

/******************************************************************************
* Basic routines
******************************************************************************/

TMPL inline C car (const Twin& x) { return x.x1; }
TMPL inline D cdr (const Twin& x) { return x.x2; }
TMPL inline C& car (Twin& x) { return x.x1; }
TMPL inline D& cdr (Twin& x) { return x.x2; }
TMPL inline format<C> CF1 (const Twin& z) { return get_format (car (z)); }
TMPL inline format<D> CF2 (const Twin& z) { return get_format (cdr (z)); }

TMPL inline Twin copy (const Twin& x) {
  return Twin (copy (car (x)), copy (cdr (x))); }
TMPL inline Twin duplicate (const Twin& x) {
  return Twin (duplicate (car (x)), duplicate (cdr (x))); }
TMPL inline bool is_exact_zero (const Twin& x) {
  return is_exact_zero (car (x)); }

template<typename Op, typename C, typename D, typename V> nat
unary_hash (const Twin& x) {
  return Op::op (car (x));
}

TMPL inline syntactic
flatten (const Twin& x) {
  return flatten (cdr (x));
}

template<typename CS, typename CD, typename DS, typename DD> twin<CD,DD>
map (const function_1<CD,Argument(CS) >& funC,
     const function_1<DD,Argument(DS) >& funD,
     const twin<CS,DS>& z,
     const format<CD>& fmC,
     const format<DD>& fmD) {
  return twin<CD,DD> (funC (car (z)), funD (cdr (z)));
}

TMPL
struct binary_helper<Twin >: public void_binary_helper<Twin > {
  static inline string short_type_name () {
    return "Tw" * Short_type_name (C) * Short_type_name (D); }
  static inline generic full_type_name () {
    return gen ("Twin", Full_type_name (C), Full_type_name (D)); }
  static inline generic disassemble (const Twin& z) {
    return gen_vec (as<generic> (car (z)), as<generic> (cdr (z))); }
  static inline Twin assemble (const generic& v) {
    return Twin (as<C> (vector_access (v, 0)),
                 as<D> (vector_access (v, 1))); }
  static inline void write (const port& out, const Twin& z) {
    binary_write<C> (out, car (z));
    binary_write<D> (out, cdr (z)); }
  static inline Twin read (const port& in) {
    C c= binary_read<C> (in);
    D d= binary_read<D> (in);
    return Twin (c, d); }
};

/******************************************************************************
* Equality and ordering relations
******************************************************************************/

TMPL bool operator == (const Twin& x, const Twin& y) {
  return car (x) == car (y); }
TMPL bool operator != (const Twin& x, const Twin& y) {
  return car (x) != car (y); }
TMPL bool operator < (const Twin& x, const Twin& y) {
  return car (x) < car (y); }
TMPL bool operator <= (const Twin& x, const Twin& y) {
  return car (x) <= car (y); }
TMPL bool operator > (const Twin& x, const Twin& y) {
  return car (x) > car (y); }
TMPL bool operator >= (const Twin& x, const Twin& y) {
  return car (x) >= car (y); }

EQUAL_INT_SUGAR(TMPL,Twin);
COMPARE_INT_SUGAR(TMPL,Twin);

TMPL nat hash (const Twin& x) { return hash (car (x)); }
TMPL nat exact_hash (const Twin& x) { return exact_hash (cdr (x)); }
TMPL nat hard_hash (const Twin& x) { return hard_hash (cdr (x)); }

TMPL bool exact_eq (const Twin& x, const Twin& y) {
  return exact_eq (cdr (x), cdr (y)); }
TMPL bool exact_neq (const Twin& x, const Twin& y) {
  return exact_neq (cdr (x), cdr (y)); }
TMPL bool hard_eq (const Twin& x, const Twin& y) {
  return hard_eq (cdr (x), cdr (y)); }
TMPL bool hard_neq (const Twin& x, const Twin& y) {
  return hard_neq (cdr (x), cdr (y)); }

/******************************************************************************
* Constants
******************************************************************************/

TMPL inline void set_nan (Twin& z) {
  set_nan (car (z)); set_nan (cdr (z)); }
TMPL inline void set_infinity (Twin& z) {
  set_infinity (car (z)); set_infinity (cdr (z)); }
TMPL inline void set_fuzz (Twin& z) {
  set_fuzz (car (z)); set_fuzz (cdr (z)); }
TMPL inline void set_smallest (Twin& z) {
  set_smallest (car (z)); set_smallest (cdr (z)); }
TMPL inline void set_largest (Twin& z) {
  set_largest (car (z)); set_largest (cdr (z)); }
TMPL inline void set_accuracy (Twin& z) {
  set_accuracy (car (z)); set_accuracy (cdr (z)); }
TMPL inline void set_log2 (Twin& z) {
  set_log2 (car (z)); set_log2 (cdr (z)); }
TMPL inline void set_pi (Twin& z) {
  set_pi (car (z)); set_pi (cdr (z)); }
TMPL inline void set_euler (Twin& z) {
  set_euler (car (z)); set_euler (cdr (z)); }
TMPL inline void set_imaginary (Twin& z) {
  set_zero (car (z)); set_imaginary (cdr (z)); }
TMPL inline Twin times_infinity (const Twin& x) {
  return x * infinity_cst<Twin > (); }

/******************************************************************************
* Basic arithmetic
******************************************************************************/

TMPL inline Twin
operator + (const Twin& x1, const Twin& x2) {
  return Twin (car (x1) + car (x2), cdr (x1) + cdr (x2));
}

TMPL inline Twin
operator - (const Twin& x) {
  return Twin (-car (x), -cdr (x));
}

TMPL inline Twin
operator - (const Twin& x1, const Twin& x2) {
  return Twin (car (x1) - car (x2), cdr (x1) - cdr (x2));
}

TMPL inline Twin
operator * (const Twin& x1, const Twin& x2) {
  return Twin (car (x1) * car (x2), cdr (x1) * cdr (x2));
}

TMPL inline Twin
operator / (const Twin& x1, const Twin& x2) {
  return Twin (car (x1) / car (x2), cdr (x1) / cdr (x2));
}

ARITH_INT_SUGAR(TMPL,Twin)

/******************************************************************************
* Elementary functions
******************************************************************************/

TMPL Twin sqrt (const Twin& x) {
  return Twin (sqrt (car (x)), sqrt (cdr (x))); }
TMPL Twin exp (const Twin& x) {
  return Twin (exp (car (x)), exp (cdr (x))); }
TMPL Twin log (const Twin& x) {
  return Twin (log (car (x)), log (cdr (x))); }
TMPL inline Twin pow (const Twin& x1, const Twin& x2) {
  return Twin (pow (car (x1), car (x2)), pow (cdr (x1), cdr (x2))); }
TMPL inline Twin pow (const Twin& x1, const int& x2) {
  return pow (x1, Twin (x2)); }
TMPL Twin cos (const Twin& x) {
  return Twin (cos (car (x)), cos (cdr (x))); }
TMPL Twin sin (const Twin& x) {
  return Twin (sin (car (x)), sin (cdr (x))); }
TMPL Twin tan (const Twin& x) {
  return Twin (tan (car (x)), tan (cdr (x))); }
TMPL Twin acos (const Twin& x) {
  return Twin (acos (car (x)), acos (cdr (x))); }
TMPL Twin asin (const Twin& x) {
  return Twin (asin (car (x)), asin (cdr (x))); }
TMPL Twin atan (const Twin& x) {
  return Twin (atan (car (x)), atan (cdr (x))); }
TMPL Twin cosh (const Twin& x) {
  return Twin (cosh (car (x)), cosh (cdr (x))); }
TMPL Twin sinh (const Twin& x) {
  return Twin (sinh (car (x)), sinh (cdr (x))); }
TMPL Twin tanh (const Twin& x) {
  return Twin (tanh (car (x)), tanh (cdr (x))); }
TMPL Twin acosh (const Twin& x) {
  return Twin (acosh (car (x)), acosh (cdr (x))); }
TMPL Twin asinh (const Twin& x) {
  return Twin (asinh (car (x)), asinh (cdr (x))); }
TMPL Twin atanh (const Twin& x) {
  return Twin (atanh (car (x)), atanh (cdr (x))); }
TMPL Twin atan2 (const Twin& x, const Twin& y) {
  return Twin (atan2 (car (x), car (y)), atan2 (cdr (x), cdr (y))); }
TMPL Twin hypot (const Twin& x, const Twin& y) {
  return Twin (hypot (car (x), car (y)), hypot (cdr (x), cdr (y))); }

/******************************************************************************
* Floating point related functions
******************************************************************************/

TMPL inline bool is_finite (const Twin& x) {
  return is_finite (car (x)); }
TMPL inline bool is_infinite (const Twin& x) {
  return is_infinite (car (x)); }
TMPL inline bool is_fuzz (const Twin& x) {
  return is_fuzz (car (x)); }
TMPL inline bool is_nan (const Twin& x) {
  return is_nan (car (x)); }
TMPL inline bool is_reliable (const Twin& x) {
  return is_reliable (car (x)); }

TMPL inline Twin change_precision (const Twin& x, xnat p) {
  return Twin (change_precision (car (x), p), cdr (x)); }
TMPL inline xnat precision (const Twin& x) {
  return precision (car (x)); }

TMPL inline xint exponent (const Twin& x) {
  return exponent (car (x)); }
TMPL inline double magnitude (const Twin& x) {
  return magnitude (car (x)); }
TMPL inline Twin operator << (const Twin& x, const xint& shift) {
  return Twin (incexp2 (car (x), shift), incexp2 (cdr (x), shift)); }
TMPL inline Twin operator >> (const Twin& x, const xint& shift) {
  return Twin (decexp2 (car (x), shift), decexp2 (cdr (x), shift)); }

TMPL inline Twin sharpen (const Twin& z) {
  return Twin (sharpen (car (z)), sharpen (cdr (z))); }
template<typename C, typename D, typename V,
         typename C2, typename D2, typename V2> inline Twin
blur (const Twin& z, const twin<C2,D2,V2>& r) {
  return Twin (blur (car (z), car (r)), blur (cdr (z), cdr (r))); }

#undef TMPL_DEF
#undef TMPL
#undef Twin
} // namespace mmx
#endif // __MMX_TWIN_HPP