include/algebramix/kronecker_modular_int.hpp

Go to the documentation of this file.

/******************************************************************************
* MODULE     : kronecker_modular_int.hpp
* DESCRIPTION: Kronecker tranforms for modular integers
* COPYRIGHT  : (C) 2009  Joris van der Hoeven and 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_KRONECKER_MODULAR_INT_HPP
#define __MMX_KRONECKER_MODULAR_INT_HPP
#include <basix/vector.hpp>
#include <numerix/modular_int.hpp>
#include <algebramix/kronecker_int.hpp>

namespace mmx {

/******************************************************************************
* Low level Kronecker multiplication for modular ints
******************************************************************************/

#define DECLARE_HELPER(I)                                               \
  void decode_kronecker_mod (I* dest, nat n, xnat bits,                 \
                             const integer& src, const I& p);           \
  void mul_kronecker_mod (I* dest, const I* src1, nat n1,               \
                          const I* src2, nat n2, const I& p);           \
  void square_kronecker_mod (I* dest, const I* src1, nat n1, const I& p);
DECLARE_HELPER(signed char)
DECLARE_HELPER(unsigned char)
DECLARE_HELPER(short int)
DECLARE_HELPER(unsigned short int)
DECLARE_HELPER(int)
DECLARE_HELPER(unsigned int)
DECLARE_HELPER(long int)
DECLARE_HELPER(unsigned long int)
DECLARE_HELPER(long long int)
DECLARE_HELPER(unsigned long long int)
#undef DECLARE_HELPER

/******************************************************************************
* Standard routines
******************************************************************************/

#define TMPL template<typename I, typename MoV, typename MaV>
#define C modular<modulus<I,MoV>,MaV>

TMPL inline void
mul_kronecker (C* dest, const C* s1, nat n1, const C* s2, nat n2) {
  mul_kronecker_mod ((I*) (void*) dest,
                     (const I*) (const void*) s1, n1,
                     (const I*) (const void*) s2, n2, 
                     * C::get_modulus());
}

TMPL inline void
square_kronecker (C* dest, const C* s, nat n) {
  square_kronecker_mod ((I*) (void*) dest,
                        (const I*) (const void*) s, n, 
                        * C::get_modulus()); 
}

#undef C
#undef TMPL

#define TMPL template<typename I, typename MoV>
#define C modular<modulus<I,MoV>,modular_local>

TMPL inline void
mul_kronecker (C* dest, const C* s1, const C* s2, nat n1, nat n2) {
  nat l1= default_aligned_size<I> (n1), l2= default_aligned_size<I> (n2);
  nat spc= l1 + l2 + default_aligned_size<I> (n1 + n2 - 1);
  I* t1= mmx_new<I> (spc); I* t2= t1 + l1, * r= t1 + l1 + l2;
  for (nat i= 0; i < n1; i++) t1[i]= * s1[i];
  for (nat i= 0; i < n2; i++) t2[i]= * s2[i];
  I p= * get_modulus (s1[0]);
  mul_kronecker_mod (r, t1, n1, t2, n2, p);
  for (nat i= 0; i < n1 + n2 - 1; i++) dest[i]= C (* r[i], p, true);
  mmx_delete<I> (t1, spc);
}

TMPL inline void
square_kronecker (C* dest, const C* s, nat n) {
  nat ls= default_aligned_size<I> (n);
  nat spc= ls + default_aligned_size<I> (2 * n - 1);
  I* t= mmx_new<I> (spc), * r= t + ls;
  for (nat i= 0; i < n; i++) t[i]= * s[i];
  I p= * get_modulus (s[0]);
  square_kronecker_mod (r, t, n, p);
  for (nat i= 0; i < 2 * n - 1; i++) dest[i]= C (* r[i], p, true);
  mmx_delete<I> (t, spc);
}

#undef C
#undef TMPL
} // namespace mmx
#endif // __MMX_KRONECKER_MODULAR_INT_HPP

---