/Users/mourrain/Devel/mmx/basix/include/basix/pair.hpp

Go to the documentation of this file.

/******************************************************************************
* MODULE     : pair.hpp
* DESCRIPTION: Pairs
* COPYRIGHT  : (C) 2004  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_PAIR_HPP
#define __MMX_PAIR_HPP
#include <basix/syntactic.hpp>
#include <basix/operators.hpp>


namespace mmx {
#define TMPL template<typename C1, typename C2>
#define Pair pair<C1,C2>

TMPL
class pair {
MMX_ALLOCATORS;
public:
  C1 x1;
  C2 x2;
  inline pair () {}
  inline pair (const format<C1>& fm1, const format<C2>& fm2):
    x1 (get_sample (fm1)), x2 (get_sample (fm2)) {}
  inline pair (const C1& x1b, const C2& x2b): x1 (x1b), x2 (x2b) {}
};
DEFINE_BINARY_FORMAT_2 (pair)

TMPL inline C1 first (const Pair& p) { return p.x1; }
TMPL inline C2 second (const Pair& p) { return p.x2; }
TMPL inline format<C1> CF1 (const Pair& p) { return get_format (p.x1); }
TMPL inline format<C2> CF2 (const Pair& p) { return get_format (p.x2); }

template<typename Op, typename C1, typename C2> nat
unary_hash (const Pair& p) {
  nat h= Op::op (p.x1);
  return (h<<1) ^ (h<<3) ^ (h<<9) ^ (h>>29) ^ Op::op (p.x2);
}

template<typename Op, typename C1, typename C2> bool
binary_test (const Pair& p1, const Pair& p2) {
  return Op::op (p1.x1, p2.x1) && Op::op (p1.x2, p2.x2);
}

TRUE_IDENTITY_OP_SUGAR(TMPL,Pair)
EXACT_IDENTITY_OP_SUGAR(TMPL,Pair)
HARD_IDENTITY_OP_SUGAR(TMPL,Pair)

TMPL inline Pair
operator * (const Pair& p1, const Pair& p2) {
  return Pair (p1.x1 * p2.x1, p1.x2 * p2.x2);
}

TMPL inline syntactic
flatten (const Pair& p) {
  return apply (GEN_SQTUPLE, flatten (p.x1), flatten (p.x2));
}

TMPL
struct binary_helper<Pair >: public void_binary_helper<Pair > {
  static inline string short_type_name () {
    return "Pa" * Short_type_name (C1) * Short_type_name (C2); }
  static inline generic full_type_name () {
    return gen ("Pair", Full_type_name (C1), Full_type_name (C2)); }
  static inline nat size (const Pair& v) {
    (void) v; return 2; }
  static inline generic access (const Pair& v, nat i) {
    if (i == 0) return as<generic> (v.x1);
    else if (i == 1) return as<generic> (v.x2);
    else ERROR ("index out of range"); }
  static inline generic disassemble (const Pair& v) {
    return gen_vec (as<generic> (v.x1), as<generic> (v.x2)); }
  static inline Pair assemble (const generic& v) {
    return Pair (as<C1> (vector_access (v, 0)),
                 as<C2> (vector_access (v, 1))); }
  static inline void write (const port& out, const Pair& p) {
    binary_write<C1> (out, p.x1);
    binary_write<C2> (out, p.x2); }
  static inline Pair read (const port& in) {
    C1 x1= binary_read<C1> (in);
    C2 x2= binary_read<C2> (in);
    return Pair (x1, x2); }
};

#undef TMPL
#undef Pair
} // namespace mmx
#endif // __MMX_PAIR_HPP