ser_carry_polynomial_regular_root_op Struct Reference

#include <series_carry_naive.hpp>

Static Public Member Functions

static generic name ()
template<typename M > static M op (const polynomial< Lift_type(M)> &P)
template<typename M > static M op (const polynomial< M > &P, const M &init)
template<typename M , typename V , typename L > static series< M, V > op (const polynomial< L > &P)
template<typename M , typename V , typename L > static series< M, V > op (const polynomial< L > &P, const M &init)
static syntactic op (const syntactic &P)
template<typename R , typename L > static void set_op (R &x, const polynomial< L > &P)
template<typename M , typename V , typename L > static series< M, V > op_init (const polynomial< L > &P, const M &i)
static nat nr_init ()
template<typename M , typename V , typename L > static series< M, V > def (const series< M, V > &me, const polynomial< L > &P)

Detailed Description

Definition at line 791 of file series_carry_naive.hpp.

Member Function Documentation

static series<M,V> def	(	const series< M, V > &	me,
		const polynomial< L > &	P
	)			`[inline, static]`

Definition at line 831 of file series_carry_naive.hpp.

References mmx::eval(), mmx::lshiftz(), mmx::N(), R, mmx::rem(), mmx::rshiftz(), Series, and mmx::square().

00831                                                  {
00832     L y0 (* me[0]);
00833     polynomial<L> Q;
00834     polynomial<L> sqr (vec<L> (square (y0), - 2 * y0, 1)); // (X-y_O)²
00835     polynomial<L> R= rem (P, sqr, Q);
00836     Series Py0= integer_to_series_carry<M, V> (R[0]);
00837     Series dPy0= integer_to_series_carry<M, V> (R[1]);
00838     nat n = N(Q);
00839     vector<Series> vs (Series(), n);
00840     for (nat i= 0; i<n; i++)
00841       vs[i] = integer_to_series_carry<M, V> (Q[i]);
00842     polynomial<Series> sQ (vs);
00843     return ((Py0 - me[0] * dPy0 + lshiftz (square (rshiftz (me))
00844                                            * eval (sQ, me), 2)) / (-dPy0));
00845   }

static generic name ( ) [inline, static]

Definition at line 793 of file series_carry_naive.hpp.

00793 { return "polynomial_regular_root"; }

static nat nr_init ( ) [inline, static]

Definition at line 828 of file series_carry_naive.hpp.

00828 { return 1; }

static syntactic op ( const syntactic & P ) [inline, static]

Definition at line 817 of file series_carry_naive.hpp.

00817                           {
00818     return apply ("polynomial_regular_root", P); }

static series<M,V> op	(	const polynomial< L > &	P,
		const M &	init
	)			`[inline, static]`

Definition at line 813 of file series_carry_naive.hpp.

00813                                              {
00814     return polynomial_regular_root<M,V,L> (P,init); }

static series<M,V> op ( const polynomial< L > & P ) [inline, static]

Definition at line 809 of file series_carry_naive.hpp.

00809                               {
00810     return polynomial_regular_root<M,V,L> (P); }

static M op	(	const polynomial< M > &	P,
		const M &	init
	)			`[inline, static]`

Definition at line 805 of file series_carry_naive.hpp.

00805                                              {
00806     return init; }

static M op ( const polynomial< Lift_type(M)> & P ) [inline, static]

Definition at line 796 of file series_carry_naive.hpp.

References M, mmx::N(), mmx::polynomial_modular_root(), and mmx::rem().

00796                                           {
00797     typedef Lift_type (M) L;
00798     L p (* M::get_modulus());
00799     vector<M> cP (M(0), N(P));
00800     for (nat i= 0; i < N(P); i++)
00801       cP[i]= M (rem (P[i], p));
00802     return polynomial_modular_root (polynomial<M> (cP)); }

static series<M,V> op_init	(	const polynomial< L > &	P,
		const M &	i
	)			`[inline, static]`

Definition at line 825 of file series_carry_naive.hpp.

00825                                                {
00826     return polynomial_regular_root_init<M,V,L> (P, i); }

static void set_op	(	R &	x,
		const polynomial< L > &	P
	)			`[inline, static]`

Definition at line 821 of file series_carry_naive.hpp.

References mmx::polynomial_regular_root().

00821                                         {
00822     x= polynomial_regular_root (P); }

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

include/algebramix/series_carry_naive.hpp