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

Go to the documentation of this file.

/******************************************************************************
* MODULE     : triple.hpp
* DESCRIPTION: Triples
* 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_TRIPLE_HPP
#define __MMX_TRIPLE_HPP
#include <basix/syntactic.hpp>
#include <basix/operators.hpp>


namespace mmx {
#define TMPL template<typename C1, typename C2, typename C3>
#define Triple triple<C1,C2,C3>

TMPL
class triple {
MMX_ALLOCATORS;
public:
  C1 x1;
  C2 x2;
  C3 x3;
  inline triple () {}
  inline triple (const format<C1>& fm1, const format<C2>& fm2,
                 const format<C3>& fm3):
    x1 (get_sample (fm1)), x2 (get_sample (fm2)), x3 (get_sample (fm3)) {}
  inline triple (const C1& x1b, const C2& x2b, const C3& x3b):
    x1 (x1b), x2 (x2b), x3 (x3b) {}
};
DEFINE_TERNARY_FORMAT_3 (triple)

TMPL inline C1 first (const Triple& t) { return t.x1; }
TMPL inline C2 second (const Triple& t) { return t.x2; }
TMPL inline C3 third (const Triple& t) { return t.x3; }
TMPL inline format<C1> CF1 (const Triple& t) { return get_format (t.x1); }
TMPL inline format<C2> CF2 (const Triple& t) { return get_format (t.x2); }
TMPL inline format<C3> CF3 (const Triple& t) { return get_format (t.x3); }

template<typename Op, typename C1, typename C2, typename C3> nat
unary_hash (const Triple& t) {
  nat h1= Op::op (t.x1), h2= Op::op (t.x2);
  return h1 ^ h2 ^ (h1<<3) ^ (h2<<5) ^ Op::op (t.x3);
}

template<typename Op, typename C1, typename C2, typename C3> bool
binary_test (const Triple& t1, const Triple& t2) {
  return Op::op (t1.x1,t2.x1) && Op::op(t1.x2, t2.x2) && Op::op(t1.x3, t2.x3);
}

TRUE_IDENTITY_OP_SUGAR(TMPL,Triple)
EXACT_IDENTITY_OP_SUGAR(TMPL,Triple)
HARD_IDENTITY_OP_SUGAR(TMPL,Triple)

TMPL inline syntactic
flatten (const Triple& t) {
  return apply (GEN_SQTUPLE, flatten (t.x1), flatten (t.x2), flatten (t.x3));
}

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

#undef TMPL
#undef Triple
} // namespace mmx
#endif // __MMX_TRIPLE_HPP