modulus_integer_naive Struct Reference

#include <modular_integer.hpp>

Inheritance diagram for modulus_integer_naive:

List of all members.

Static Public Member Functions

static void encode_mod (C &dest, const C &s, const M &m)
static void decode_mod (C &dest, const C &s, const M &m)
static void div_mod (C &dest, const C &s, const M &m)
static void div_mod (C &dest, const C &s1, const C &s2, const M &m)
static bool is_invertible_mod (const C &s, const M &m)
static void inv_mod (C &a, const M &m)
static void inv_mod (C &dest, const C &s, const M &m)
static void mul_mod (C &dest, const C &s, const M &m)
static void mul_mod (C &dest, const C &s, const M &m, C &carry)
static void mul_mod (C &dest, const C &s1, const C &s2, const M &m)
static void mul_mod (C &dest, const C &s1, const C &s2, const M &m, C &carry)
static void neg_mod (C &dest, const M &m)
static void neg_mod (C &dest, const M &m, C &carry)
static void neg_mod (C &dest, const C &s, const M &m)
static void neg_mod (C &dest, const C &s, const M &m, C &carry)
static void add_mod (C &dest, const C &s, const M &m)
static void add_mod (C &dest, const C &s, const M &m, C &carry)
static void add_mod (C &dest, const C &s1, const C &s2, const M &m)
static void add_mod (C &dest, const C &s1, const C &s2, const M &m, C &carry)
static void sub_mod_core (C &dest, const C &s, const C &p)
static void sub_mod_core (C &dest, const C &s, const C &p, C &carry)
static void sub_mod (C &dest, const C &s, const M &m)
static void sub_mod (C &dest, const C &s, const M &m, C &carry)
static void sub_mod (C &dest, const C &s1, const C &s2, const M &m)
static void sub_mod (C &dest, const C &s1, const C &s2, const M &m, C &carry)
static void reduce_mod (C &dest, const M &m)
static void reduce_mod (C &dest, const M &m, C &carry)
static void reduce_mod (C &dest, const C &s, const M &m)
static void reduce_mod (C &dest, const C &s, const M &m, C &carry)
template<typename C > static bool normalize (C &p)

Detailed Description

Definition at line 157 of file modular_integer.hpp.

Member Function Documentation

static void add_mod	(	C &	dest,
		const C &	s1,
		const C &	s2,
		const M &	m,
		C &	carry
	)			`[inline, static, inherited]`

Definition at line 78 of file modular_integer.hpp.

References modulus_add_integer_naive< V >::add_mod().

00078                                                                     {
00079     dest = s1;
00080     add_mod (dest, s2, m, carry); }

static void add_mod	(	C &	dest,
		const C &	s1,
		const C &	s2,
		const M &	m
	)			`[inline, static, inherited]`

Definition at line 73 of file modular_integer.hpp.

References modulus_add_integer_naive< V >::add_mod().

00073                                                           {
00074     dest = s1;
00075     add_mod (dest, s2, m); }

static void add_mod	(	C &	dest,
		const C &	s,
		const M &	m,
		C &	carry
	)			`[inline, static, inherited]`

Definition at line 67 of file modular_integer.hpp.

References VERIFY.

00067                                                       {
00068     VERIFY (carry == 0 || carry == 1, "unexpected large carry");
00069     dest += s + carry;
00070     if (dest >= m.p) { dest -= m.p; carry= 1; } else carry= 0; }

static void add_mod	(	C &	dest,
		const C &	s,
		const M &	m
	)			`[inline, static, inherited]`

Definition at line 62 of file modular_integer.hpp.

00062                                             {
00063     dest += s;
00064     if (dest >= m.p) dest -= m.p; }

static void decode_mod	(	C &	dest,
		const C &	s,
		const M &	m
	)			`[inline, static, inherited]`

Definition at line 152 of file modular_integer.hpp.

00152                                                {
00153     (void) m;
00154     dest = s; }

static void div_mod	(	C &	dest,
		const C &	s1,
		const C &	s2,
		const M &	m
	)			`[inline, static, inherited]`

Definition at line 179 of file modulus_naive.hpp.

References mmx::C.

00179                                                           {
00180     C t;
00181     V::inv_mod (t, s2, m);
00182     V::mul_mod (dest, s1, t, m); }

static void div_mod	(	C &	dest,
		const C &	s,
		const M &	m
	)			`[inline, static, inherited]`

Definition at line 173 of file modulus_naive.hpp.

References mmx::C.

00173                                             {
00174     C t = s;
00175     V::inv_mod (t, m);
00176     V::mul_mod (dest, t, m); }

static void encode_mod	(	C &	dest,
		const C &	s,
		const M &	m
	)			`[inline, static, inherited]`

Definition at line 141 of file modular_integer.hpp.

00141                                                {
00142     if (s < 0 && m.p != 0) {
00143       dest = - s;
00144       V::reduce_mod (dest, m);
00145       dest = m.p - dest;
00146     }
00147     else
00148       dest = s;
00149       V::reduce_mod (dest, m);
00150   }

static void inv_mod	(	C &	dest,
		const C &	s,
		const M &	m
	)			`[inline, static, inherited]`

Definition at line 133 of file modular_integer.hpp.

References modulus_inv_integer_naive< V >::inv_mod().

00133                                             {
00134     dest = s;
00135     inv_mod (dest, m); }

static void inv_mod	(	C &	a,
		const M &	m
	)			`[inline, static, inherited]`

Definition at line 121 of file modular_integer.hpp.

References ERROR.

00121                              {
00122     if (m.p == 0) {
00123       if (a == 1 || a == -1)
00124         return;
00125       else
00126         ERROR ("inv_mod: argument is not invertible");  
00127     }
00128     a = invert_modulo (a, m.p);
00129     if (a == 0 && m.p != 1)
00130       ERROR ("inv_mod: argument is not invertible"); }

static bool is_invertible_mod	(	const C &	s,
		const M &	m
	)			`[inline, static, inherited]`

Definition at line 117 of file modular_integer.hpp.

References mmx::abs(), and mmx::gcd().

00117                                              {
00118     return abs (gcd (s, m.p)) == 1; }

static void mul_mod	(	C &	dest,
		const C &	s1,
		const C &	s2,
		const M &	m,
		C &	carry
	)			`[inline, static, inherited]`

Definition at line 144 of file modulus_naive.hpp.

00144                                                                     {
00145     V::reduce_mod (dest, s1 * s2 + carry, m, carry); }

static void mul_mod	(	C &	dest,
		const C &	s1,
		const C &	s2,
		const M &	m
	)			`[inline, static, inherited]`

Definition at line 140 of file modulus_naive.hpp.

00140                                                           {
00141     V::reduce_mod (dest, s1 * s2, m); }

static void mul_mod	(	C &	dest,
		const C &	s,
		const M &	m,
		C &	carry
	)			`[inline, static, inherited]`

Definition at line 134 of file modulus_naive.hpp.

00134                                                       {
00135     dest *= s;
00136     dest += carry;
00137     V::reduce_mod (dest, m, carry); }

static void mul_mod	(	C &	dest,
		const C &	s,
		const M &	m
	)			`[inline, static, inherited]`

Definition at line 129 of file modulus_naive.hpp.

00129                                             {
00130     dest *= s;
00131     V::reduce_mod (dest, m); }

static void neg_mod	(	C &	dest,
		const C &	s,
		const M &	m,
		C &	carry
	)			`[inline, static, inherited]`

Definition at line 56 of file modular_integer.hpp.

References VERIFY.

00056                                                       {
00057     VERIFY (carry == 0 || carry == 1, "unexpected large carry");
00058     if (s != 0 || carry != 0) { dest= m.p - s - carry; carry= 1; }
00059     else dest= 0; }

static void neg_mod	(	C &	dest,
		const C &	s,
		const M &	m
	)			`[inline, static, inherited]`

Definition at line 51 of file modular_integer.hpp.

00051                                             {
00052     if (s != 0) dest = m.p - s; else dest = s;
00053  }

static void neg_mod	(	C &	dest,
		const M &	m,
		C &	carry
	)			`[inline, static, inherited]`

Definition at line 46 of file modular_integer.hpp.

References VERIFY.

00046                                           {
00047     VERIFY (carry == 0 || carry == 1, "unexpected large carry");
00048     if (dest != 0 || carry != 0) { dest= m.p - dest - carry; carry= 1; } }

static void neg_mod	(	C &	dest,
		const M &	m
	)			`[inline, static, inherited]`

Definition at line 42 of file modular_integer.hpp.

00042                                 {
00043     if (dest != 0) dest = m.p - dest; }

static bool normalize ( C & p ) [inline, static, inherited]

Definition at line 32 of file modular_integer.hpp.

00032                    {
00033     if (p < 0) p = -p;
00034     return true;
00035   }

static void reduce_mod	(	C &	dest,
		const C &	s,
		const M &	m,
		C &	carry
	)			`[inline, static, inherited]`

Definition at line 51 of file modulus_naive.hpp.

00051                                                          {
00052     if (m.p != 0) {
00053       carry= quo (s, m.p);
00054       dest = rem (s, m.p);
00055     }
00056     else {
00057       carry= 0;
00058       dest= s;
00059     } }

static void reduce_mod	(	C &	dest,
		const C &	s,
		const M &	m
	)			`[inline, static, inherited]`

Definition at line 47 of file modulus_naive.hpp.

00047                                                {
00048     if (m.p != 0) dest = rem (s, m.p); else dest = s; }

static void reduce_mod	(	C &	dest,
		const M &	m,
		C &	carry
	)			`[inline, static, inherited]`

Definition at line 38 of file modulus_naive.hpp.

00038                                              {
00039     if (m.p != 0) {
00040       carry= quo (dest, m.p);
00041       dest = rem (dest, m.p);
00042     }
00043     else
00044       carry= 0; }

static void reduce_mod	(	C &	dest,
		const M &	m
	)			`[inline, static, inherited]`

Definition at line 34 of file modulus_naive.hpp.

00034                                    {
00035     if (m.p != 0) dest = rem (dest, m.p); }

static void sub_mod	(	C &	dest,
		const C &	s1,
		const C &	s2,
		const M &	m,
		C &	carry
	)			`[inline, static, inherited]`

Definition at line 108 of file modular_integer.hpp.

References modulus_add_integer_naive< V >::sub_mod().

00108                                                                     {
00109     dest = s1;
00110     sub_mod (dest, s2, m, carry); }

static void sub_mod	(	C &	dest,
		const C &	s1,
		const C &	s2,
		const M &	m
	)			`[inline, static, inherited]`

Definition at line 103 of file modular_integer.hpp.

References modulus_add_integer_naive< V >::sub_mod().

00103                                                           {
00104     dest = s1;
00105     sub_mod (dest, s2, m); }

static void sub_mod	(	C &	dest,
		const C &	s,
		const M &	m,
		C &	carry
	)			`[inline, static, inherited]`

Definition at line 99 of file modular_integer.hpp.

References modulus_add_integer_naive< V >::sub_mod_core().

00099                                                       {
00100     sub_mod_core (dest, s, m.p, carry); }

static void sub_mod	(	C &	dest,
		const C &	s,
		const M &	m
	)			`[inline, static, inherited]`

Definition at line 95 of file modular_integer.hpp.

References modulus_add_integer_naive< V >::sub_mod_core().

00095                                             {
00096     sub_mod_core (dest, s, m.p); }

static void sub_mod_core	(	C &	dest,
		const C &	s,
		const C &	p,
		C &	carry
	)			`[inline, static, inherited]`

Definition at line 88 of file modular_integer.hpp.

References mmx::C, and VERIFY.

00088                                                            {
00089     VERIFY (carry == 0 || carry == 1, "unexpected large carry");
00090     C t = s + carry;
00091     if (t == p || dest < t) { dest += p; carry= 1; } else carry= 0;
00092     dest -= t; }

static void sub_mod_core	(	C &	dest,
		const C &	s,
		const C &	p
	)			`[inline, static, inherited]`

Definition at line 83 of file modular_integer.hpp.

00083                                                  {
00084     if (dest < s) dest += p;
00085     dest -= s; }

The documentation for this struct was generated from the following file:

include/numerix/modular_integer.hpp