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

Go to the documentation of this file.

/******************************************************************************
* MODULE     : modulus.hpp
* DESCRIPTION: modulus for modular arithmetic
* COPYRIGHT  : (C) 2008  Gregoire Lecerf
*******************************************************************************
* 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__MODULUS__HPP
#define __MMX__MODULUS__HPP
#include <numerix/modulus_naive.hpp>
#include <basix/wrap.hpp>

namespace mmx {

#define Modulus_variant(C) modulus_variant_helper<C>::MV
#define TMPL_DEF \
  template<typename C, typename V=typename Modulus_variant(C) >
#define TMPL template<typename C, typename V>
#define Modulus modulus<C,V>

/******************************************************************************
* General modulus
******************************************************************************/

TMPL_DEF
class modulus {
MMX_ALLOCATORS
public:
  C p;
  typedef C base;
  typedef V variant;
  typedef modulus <C, V> self_type;

  inline C operator * () const { return p; }

  inline modulus () : p (C(0)) {
    ASSERT (V::normalize (p), "modulus: bad value"); }

  inline modulus (const self_type& x) : p (x.p) {}

  template<typename X>
  inline modulus (const X& x) : p (C(x)) {
    ASSERT (V::normalize (p), "modulus: bad value"); }

  template<typename X, X _p>
  inline modulus (const fixed_value<X, _p>& x) {
    p = _p < 0 ? -_p : _p; }

  inline Modulus& operator = (const Modulus& m) {
    p = m.p;
    return *this; }

  inline bool operator == (const Modulus& a) const {
    return p == a.p; }

  inline bool operator != (const Modulus& a) const {
    return p != a.p; }
};

WRAP_WRAPPED_IMPL(TMPL inline,Modulus)

template<typename T, typename F, typename TV, typename FV>
struct as_helper<modulus<T,TV>,modulus<F,FV> > {
  static inline modulus<T,TV>
  cv (const modulus<F,FV>& m) { return modulus<T,TV> (*m); }
};

/******************************************************************************
* Extrary operations
******************************************************************************/

TMPL inline void
reduce_mod (C& dest, const Modulus& m) {
  V::reduce_mod (dest, m); }

TMPL inline void
reduce_mod (C& dest, const Modulus& m, C& carry) {
  V::reduce_mod (dest, m, carry); }

TMPL inline void
reduce_mod (C& dest, const C& s, const Modulus& m) {
  V::reduce_mod (dest, s, m); }

TMPL inline void
reduce_mod (C& dest, const C& s, const Modulus& m, C& carry) {
  V::reduce_mod (dest, s, m, carry); }

TMPL inline void
encode_mod (C& dest, const C& s, const Modulus& m) {
  V::encode_mod (dest, s, m); }

TMPL inline void
decode_mod (C& dest, const C& s, const Modulus& m) {
  V::decode_mod (dest, s, m); }

TMPL inline void
neg_mod (C& dest, const Modulus& m) {
  V::neg_mod (dest, m); }

TMPL inline void
neg_mod (C& dest, const Modulus& m, C& carry) {
  V::neg_mod (dest, m, carry); }

TMPL inline void
neg_mod (C& dest, const C& s, const Modulus& m) {
  V::neg_mod (dest, s, m); }

TMPL inline void
neg_mod (C& dest, const C& s, const Modulus& m, C& carry) {
  V::neg_mod (dest, s, m, carry); }

TMPL inline void
add_mod (C& dest, const C& s, const Modulus& m) {
  V::add_mod (dest, s, m); }

TMPL inline void
add_mod (C& dest, const C& s, const Modulus& m, C& carry) {
  V::add_mod (dest, s, m, carry); }

TMPL inline void
add_mod (C& dest, const C& s1, const C& s2, const Modulus& m) {
  V::add_mod (dest, s1, s2, m); }

TMPL inline void
add_mod (C& dest, const C& s1, const C& s2, const Modulus& m, C& carry) {
  V::add_mod (dest, s1, s2, m, carry); }

TMPL inline void
sub_mod (C& dest, const C& s, const Modulus& m) {
  V::sub_mod (dest, s, m); }

TMPL inline void
sub_mod (C& dest, const C& s, const Modulus& m, C& carry) {
  V::sub_mod (dest, s, m, carry); }

TMPL inline void
sub_mod (C& dest, const C& s1, const C& s2, const Modulus& m) {
  V::sub_mod (dest, s1, s2, m); }

TMPL inline void
sub_mod (C& dest, const C& s1, const C& s2, const Modulus& m, C& carry) {
  V::sub_mod (dest, s1, s2, m, carry); }

TMPL inline void
mul_mod (C& dest, const C& s, const Modulus& m) {
  V::mul_mod (dest, s, m); }

TMPL inline void
mul_mod (C& dest, const C& s, const Modulus& m, C& carry) {
  V::mul_mod (dest, s, m, carry); }

TMPL inline void
mul_mod (C& dest, const C& s1, const C& s2, const Modulus& m) {
  V::mul_mod (dest, s1, s2, m); }

TMPL inline void
mul_mod (C& dest, const C& s1, const C& s2, const Modulus& m, C& carry) {
  V::mul_mod (dest, s1, s2, m, carry); }

TMPL inline void
inv_mod (C& dest, const Modulus& m) {
  V::inv_mod (dest, m); }

TMPL inline void
inv_mod (C& dest, const C& s, const Modulus& m) {
  V::inv_mod (dest, s, m); }

TMPL inline void
div_mod (C& dest, const C& s, const Modulus& m) {
  V::div_mod (dest, s, m); }

TMPL inline void
div_mod (C& dest, const C& s1, const C& s2, const Modulus& m) {
  V::div_mod (dest, s1, s2, m); }

/******************************************************************************
* Output routine
******************************************************************************/

template<typename V> inline syntactic
flatten (const modulus<char,V>& c) {
  return as_syntactic ((int) (*c)); }

template<typename V> inline syntactic
flatten (const modulus<unsigned char,V>& c) {
  return as_syntactic ((int) (*c)); }

WRAP_PRINT_IMPL(TMPL inline,Modulus)

#undef TMPL_DEF
#undef TMPL
#undef Modulus
} // namespace mmx
#endif //__MMX__MODULUS__HPP