nil::crypto3::math::polynomial< FieldValueType, Allocator > Class Template Reference

#include <polynomial.hpp>

+ Collaboration diagram for nil::crypto3::math::polynomial< FieldValueType, Allocator >:

Public Types

typedef container_type::allocator_type allocator_type
 
typedef container_type::const_iterator const_iterator
 
typedef container_type::const_pointer const_pointer
 
typedef container_type::const_reference const_reference
 
typedef container_type::const_reverse_iterator const_reverse_iterator
 
typedef container_type::difference_type difference_type
 
typedef container_type::iterator iterator
 
typedef container_type::pointer pointer
 
typedef container_type::reference reference
 
typedef container_type::reverse_iterator reverse_iterator
 
typedef container_type::size_type size_type
 
typedef container_type::value_type value_type
 

Public Member Functions

template<typename InputIterator >
std::iterator_traits< InputIterator >::reference assign (InputIterator first, InputIterator last)
 
void assign (size_type n, const_reference u)
 
void assign (std::initializer_list< value_type > il)
 
reference at (size_type _n)
 
const_reference at (size_type _n) const
 
reference back () BOOST_NOEXCEPT
 
const_reference back () const BOOST_NOEXCEPT
 
iterator begin () BOOST_NOEXCEPT
 
const_iterator begin () const BOOST_NOEXCEPT
 
size_type capacity () const BOOST_NOEXCEPT
 
const_iterator cbegin () const BOOST_NOEXCEPT
 
const_iterator cend () const BOOST_NOEXCEPT
 
void clear () BOOST_NOEXCEPT
 
void condense ()
 
const_reverse_iterator crbegin () const BOOST_NOEXCEPT
 
const_reverse_iterator crend () const BOOST_NOEXCEPT
 
value_typedata () BOOST_NOEXCEPT
 
const value_typedata () const BOOST_NOEXCEPT
 
size_type degree () const BOOST_NOEXCEPT
 
template<class... Args>
iterator emplace (const_iterator _position, Args &&... _args)
 
template<class... Args>
reference emplace_back (Args &&... _args)
 
bool empty () const BOOST_NOEXCEPT
 
iterator end () BOOST_NOEXCEPT
 
const_iterator end () const BOOST_NOEXCEPT
 
iterator erase (const_iterator _first, const_iterator _last)
 
iterator erase (const_iterator _position)
 
FieldValueType evaluate (const FieldValueType &value) const
 
template<typename Range >
FieldValueType evaluate (const Range &values) const
 
reference front () BOOST_NOEXCEPT
 
const_reference front () const BOOST_NOEXCEPT
 
allocator_type get_allocator () const BOOST_NOEXCEPT
 
iterator insert (const_iterator _position, const_reference _x)
 
template<class InputIterator >
iterator insert (const_iterator _position, InputIterator _first, InputIterator _last)
 
iterator insert (const_iterator _position, size_type _n, const_reference _x)
 
iterator insert (const_iterator _position, std::initializer_list< value_type > _il)
 
iterator insert (const_iterator _position, value_type &&_x)
 
bool is_zero () const
 
size_type max_size () const BOOST_NOEXCEPT
 
bool operator!= (const polynomial &rhs) const
 
polynomial operator% (const polynomial &other) const
 
polynomial operator* (const polynomial &other) const
 
polynomial operator+ (const polynomial &other) const
 
polynomial operator- () const
 
polynomial operator- (const polynomial &other) const
 
polynomial operator/ (const polynomial &other) const
 
polynomialoperator= (const container_type &x)
 
polynomialoperator= (const polynomial &x)
 
polynomialoperator= (container_type &&x)
 
polynomialoperator= (polynomial &&x)
 
polynomialoperator= (std::initializer_list< value_type > il)
 
bool operator== (const polynomial &rhs) const
 
reference operator[] (size_type _n) BOOST_NOEXCEPT
 
const_reference operator[] (size_type _n) const BOOST_NOEXCEPT
 
 polynomial ()
 
 polynomial (const container_type &c)
 
 polynomial (const FieldValueType &value, std::size_t power=0)
 
 polynomial (const polynomial &x)
 
 polynomial (const polynomial &x, const allocator_type &a)
 
 polynomial (container_type &&c)
 
template<typename InputIterator >
 polynomial (InputIterator first, InputIterator last)
 
template<typename InputIterator >
 polynomial (InputIterator first, InputIterator last, const allocator_type &a)
 
 polynomial (polynomial &&x) BOOST_NOEXCEPT(std
 
 polynomial (polynomial &&x, const allocator_type &a)
 
 polynomial (size_type n)
 
 polynomial (size_type n, const allocator_type &a)
 
 polynomial (size_type n, const value_type &x)
 
 polynomial (size_type n, const value_type &x, const allocator_type &a)
 
 polynomial (std::initializer_list< value_type > il)
 
 polynomial (std::initializer_list< value_type > il, const allocator_type &a)
 
void pop_back ()
 
void push_back (const_reference _x)
 
void push_back (value_type &&_x)
 
reverse_iterator rbegin () BOOST_NOEXCEPT
 
const_reverse_iterator rbegin () const BOOST_NOEXCEPT
 
reverse_iterator rend () BOOST_NOEXCEPT
 
const_reverse_iterator rend () const BOOST_NOEXCEPT
 
void reserve (size_type _n)
 
void resize (size_type _sz)
 
void resize (size_type _sz, const_reference _x)
 
void reverse (std::size_t n)
 
void shrink_to_fit () BOOST_NOEXCEPT
 
size_type size () const BOOST_NOEXCEPT
 
void swap (polynomial &other)
 
 ~polynomial ()=default
 

Member Typedef Documentation

◆ allocator_type

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
typedef container_type::allocator_type nil::crypto3::math::polynomial< FieldValueType, Allocator >::allocator_type

◆ const_iterator

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
typedef container_type::const_iterator nil::crypto3::math::polynomial< FieldValueType, Allocator >::const_iterator

◆ const_pointer

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
typedef container_type::const_pointer nil::crypto3::math::polynomial< FieldValueType, Allocator >::const_pointer

◆ const_reference

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
typedef container_type::const_reference nil::crypto3::math::polynomial< FieldValueType, Allocator >::const_reference

◆ const_reverse_iterator

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
typedef container_type::const_reverse_iterator nil::crypto3::math::polynomial< FieldValueType, Allocator >::const_reverse_iterator

◆ difference_type

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
typedef container_type::difference_type nil::crypto3::math::polynomial< FieldValueType, Allocator >::difference_type

◆ iterator

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
typedef container_type::iterator nil::crypto3::math::polynomial< FieldValueType, Allocator >::iterator

◆ pointer

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
typedef container_type::pointer nil::crypto3::math::polynomial< FieldValueType, Allocator >::pointer

◆ reference

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
typedef container_type::reference nil::crypto3::math::polynomial< FieldValueType, Allocator >::reference

◆ reverse_iterator

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
typedef container_type::reverse_iterator nil::crypto3::math::polynomial< FieldValueType, Allocator >::reverse_iterator

◆ size_type

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
typedef container_type::size_type nil::crypto3::math::polynomial< FieldValueType, Allocator >::size_type

◆ value_type

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
typedef container_type::value_type nil::crypto3::math::polynomial< FieldValueType, Allocator >::value_type

Constructor & Destructor Documentation

◆ polynomial() [1/16]

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
nil::crypto3::math::polynomial< FieldValueType, Allocator >::polynomial ( )
inline

◆ polynomial() [2/16]

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
nil::crypto3::math::polynomial< FieldValueType, Allocator >::polynomial ( size_type  n)
inlineexplicit

◆ polynomial() [3/16]

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
nil::crypto3::math::polynomial< FieldValueType, Allocator >::polynomial ( size_type  n,
const allocator_type a 
)
inlineexplicit

◆ polynomial() [4/16]

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
nil::crypto3::math::polynomial< FieldValueType, Allocator >::polynomial ( size_type  n,
const value_type x 
)
inline

◆ polynomial() [5/16]

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
nil::crypto3::math::polynomial< FieldValueType, Allocator >::polynomial ( size_type  n,
const value_type x,
const allocator_type a 
)
inline

◆ polynomial() [6/16]

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
template<typename InputIterator >
nil::crypto3::math::polynomial< FieldValueType, Allocator >::polynomial ( InputIterator  first,
InputIterator  last 
)
inline

◆ polynomial() [7/16]

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
template<typename InputIterator >
nil::crypto3::math::polynomial< FieldValueType, Allocator >::polynomial ( InputIterator  first,
InputIterator  last,
const allocator_type a 
)
inline

◆ ~polynomial()

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
nil::crypto3::math::polynomial< FieldValueType, Allocator >::~polynomial ( )
default

◆ polynomial() [8/16]

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
nil::crypto3::math::polynomial< FieldValueType, Allocator >::polynomial ( const polynomial< FieldValueType, Allocator > &  x)
inline

◆ polynomial() [9/16]

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
nil::crypto3::math::polynomial< FieldValueType, Allocator >::polynomial ( const polynomial< FieldValueType, Allocator > &  x,
const allocator_type a 
)
inline

◆ polynomial() [10/16]

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
nil::crypto3::math::polynomial< FieldValueType, Allocator >::polynomial ( std::initializer_list< value_type il)
inline

◆ polynomial() [11/16]

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
nil::crypto3::math::polynomial< FieldValueType, Allocator >::polynomial ( std::initializer_list< value_type il,
const allocator_type a 
)
inline

◆ polynomial() [12/16]

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
nil::crypto3::math::polynomial< FieldValueType, Allocator >::polynomial ( polynomial< FieldValueType, Allocator > &&  x)
inline

◆ polynomial() [13/16]

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
nil::crypto3::math::polynomial< FieldValueType, Allocator >::polynomial ( polynomial< FieldValueType, Allocator > &&  x,
const allocator_type a 
)
inline

◆ polynomial() [14/16]

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
nil::crypto3::math::polynomial< FieldValueType, Allocator >::polynomial ( const FieldValueType &  value,
std::size_t  power = 0 
)
inline

◆ polynomial() [15/16]

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
nil::crypto3::math::polynomial< FieldValueType, Allocator >::polynomial ( const container_type &  c)
inline

◆ polynomial() [16/16]

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
nil::crypto3::math::polynomial< FieldValueType, Allocator >::polynomial ( container_type &&  c)
inline

Member Function Documentation

◆ assign() [1/3]

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
template<typename InputIterator >
std::iterator_traits<InputIterator>::reference nil::crypto3::math::polynomial< FieldValueType, Allocator >::assign ( InputIterator  first,
InputIterator  last 
)
inline

◆ assign() [2/3]

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
void nil::crypto3::math::polynomial< FieldValueType, Allocator >::assign ( size_type  n,
const_reference  u 
)
inline

◆ assign() [3/3]

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
void nil::crypto3::math::polynomial< FieldValueType, Allocator >::assign ( std::initializer_list< value_type il)
inline

◆ at() [1/2]

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
reference nil::crypto3::math::polynomial< FieldValueType, Allocator >::at ( size_type  _n)
inline

◆ at() [2/2]

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
const_reference nil::crypto3::math::polynomial< FieldValueType, Allocator >::at ( size_type  _n) const
inline

◆ back() [1/2]

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
reference nil::crypto3::math::polynomial< FieldValueType, Allocator >::back ( )
inline

◆ back() [2/2]

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
const_reference nil::crypto3::math::polynomial< FieldValueType, Allocator >::back ( ) const
inline

◆ begin() [1/2]

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
iterator nil::crypto3::math::polynomial< FieldValueType, Allocator >::begin ( )
inline

◆ begin() [2/2]

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
const_iterator nil::crypto3::math::polynomial< FieldValueType, Allocator >::begin ( ) const
inline

◆ capacity()

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
size_type nil::crypto3::math::polynomial< FieldValueType, Allocator >::capacity ( ) const
inline

◆ cbegin()

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
const_iterator nil::crypto3::math::polynomial< FieldValueType, Allocator >::cbegin ( ) const
inline

◆ cend()

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
const_iterator nil::crypto3::math::polynomial< FieldValueType, Allocator >::cend ( ) const
inline

◆ clear()

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
void nil::crypto3::math::polynomial< FieldValueType, Allocator >::clear ( )
inline

◆ condense()

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
void nil::crypto3::math::polynomial< FieldValueType, Allocator >::condense ( )
inline

Removes extraneous zero entries from in vector representation of polynomial. Example - Degree-4 Polynomial: [0, 1, 2, 3, 4, 0, 0, 0, 0] -> [0, 1, 2, 3, 4] Note: Simplest condensed form is a zero polynomial of vector form: [0]

◆ crbegin()

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
const_reverse_iterator nil::crypto3::math::polynomial< FieldValueType, Allocator >::crbegin ( ) const
inline

◆ crend()

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
const_reverse_iterator nil::crypto3::math::polynomial< FieldValueType, Allocator >::crend ( ) const
inline

◆ data() [1/2]

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
value_type* nil::crypto3::math::polynomial< FieldValueType, Allocator >::data ( )
inline

◆ data() [2/2]

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
const value_type* nil::crypto3::math::polynomial< FieldValueType, Allocator >::data ( ) const
inline

◆ degree()

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
size_type nil::crypto3::math::polynomial< FieldValueType, Allocator >::degree ( ) const
inline

◆ emplace()

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
template<class... Args>
iterator nil::crypto3::math::polynomial< FieldValueType, Allocator >::emplace ( const_iterator  _position,
Args &&...  _args 
)
inline

◆ emplace_back()

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
template<class... Args>
reference nil::crypto3::math::polynomial< FieldValueType, Allocator >::emplace_back ( Args &&...  _args)
inline

◆ empty()

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
bool nil::crypto3::math::polynomial< FieldValueType, Allocator >::empty ( ) const
inline

◆ end() [1/2]

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
iterator nil::crypto3::math::polynomial< FieldValueType, Allocator >::end ( )
inline

◆ end() [2/2]

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
const_iterator nil::crypto3::math::polynomial< FieldValueType, Allocator >::end ( ) const
inline

◆ erase() [1/2]

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
iterator nil::crypto3::math::polynomial< FieldValueType, Allocator >::erase ( const_iterator  _first,
const_iterator  _last 
)
inline

◆ erase() [2/2]

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
iterator nil::crypto3::math::polynomial< FieldValueType, Allocator >::erase ( const_iterator  _position)
inline

◆ evaluate() [1/2]

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
FieldValueType nil::crypto3::math::polynomial< FieldValueType, Allocator >::evaluate ( const FieldValueType &  value) const
inline

◆ evaluate() [2/2]

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
template<typename Range >
FieldValueType nil::crypto3::math::polynomial< FieldValueType, Allocator >::evaluate ( const Range &  values) const
inline

◆ front() [1/2]

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
reference nil::crypto3::math::polynomial< FieldValueType, Allocator >::front ( )
inline

◆ front() [2/2]

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
const_reference nil::crypto3::math::polynomial< FieldValueType, Allocator >::front ( ) const
inline

◆ get_allocator()

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
allocator_type nil::crypto3::math::polynomial< FieldValueType, Allocator >::get_allocator ( ) const
inline

◆ insert() [1/5]

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
iterator nil::crypto3::math::polynomial< FieldValueType, Allocator >::insert ( const_iterator  _position,
const_reference  _x 
)
inline

◆ insert() [2/5]

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
template<class InputIterator >
iterator nil::crypto3::math::polynomial< FieldValueType, Allocator >::insert ( const_iterator  _position,
InputIterator  _first,
InputIterator  _last 
)
inline

◆ insert() [3/5]

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
iterator nil::crypto3::math::polynomial< FieldValueType, Allocator >::insert ( const_iterator  _position,
size_type  _n,
const_reference  _x 
)
inline

◆ insert() [4/5]

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
iterator nil::crypto3::math::polynomial< FieldValueType, Allocator >::insert ( const_iterator  _position,
std::initializer_list< value_type _il 
)
inline

◆ insert() [5/5]

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
iterator nil::crypto3::math::polynomial< FieldValueType, Allocator >::insert ( const_iterator  _position,
value_type &&  _x 
)
inline

◆ is_zero()

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
bool nil::crypto3::math::polynomial< FieldValueType, Allocator >::is_zero ( ) const
inline

Returns true if polynomial is a zero polynomial.

◆ max_size()

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
size_type nil::crypto3::math::polynomial< FieldValueType, Allocator >::max_size ( ) const
inline

◆ operator!=()

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
bool nil::crypto3::math::polynomial< FieldValueType, Allocator >::operator!= ( const polynomial< FieldValueType, Allocator > &  rhs) const
inline

◆ operator%()

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
polynomial nil::crypto3::math::polynomial< FieldValueType, Allocator >::operator% ( const polynomial< FieldValueType, Allocator > &  other) const
inline

Perform the standard Euclidean Division algorithm. Input: Polynomial A, Polynomial B, where A / B Output: Polynomial R, such that A = (Q * B) + R.

◆ operator*()

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
polynomial nil::crypto3::math::polynomial< FieldValueType, Allocator >::operator* ( const polynomial< FieldValueType, Allocator > &  other) const
inline

Perform the multiplication of two polynomials, polynomial A * polynomial B, and stores result in polynomial C.

◆ operator+()

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
polynomial nil::crypto3::math::polynomial< FieldValueType, Allocator >::operator+ ( const polynomial< FieldValueType, Allocator > &  other) const
inline

Computes the standard polynomial addition, polynomial A + polynomial B, and stores result in polynomial C.

◆ operator-() [1/2]

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
polynomial nil::crypto3::math::polynomial< FieldValueType, Allocator >::operator- ( ) const
inline

◆ operator-() [2/2]

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
polynomial nil::crypto3::math::polynomial< FieldValueType, Allocator >::operator- ( const polynomial< FieldValueType, Allocator > &  other) const
inline

Computes the standard polynomial subtraction, polynomial A - polynomial B, and stores result in polynomial C.

◆ operator/()

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
polynomial nil::crypto3::math::polynomial< FieldValueType, Allocator >::operator/ ( const polynomial< FieldValueType, Allocator > &  other) const
inline

Perform the standard Euclidean Division algorithm. Input: Polynomial A, Polynomial B, where A / B Output: Polynomial Q, such that A = (Q * B) + R.

◆ operator=() [1/5]

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
polynomial& nil::crypto3::math::polynomial< FieldValueType, Allocator >::operator= ( const container_type &  x)
inline

◆ operator=() [2/5]

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
polynomial& nil::crypto3::math::polynomial< FieldValueType, Allocator >::operator= ( const polynomial< FieldValueType, Allocator > &  x)
inline

◆ operator=() [3/5]

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
polynomial& nil::crypto3::math::polynomial< FieldValueType, Allocator >::operator= ( container_type &&  x)
inline

◆ operator=() [4/5]

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
polynomial& nil::crypto3::math::polynomial< FieldValueType, Allocator >::operator= ( polynomial< FieldValueType, Allocator > &&  x)
inline

◆ operator=() [5/5]

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
polynomial& nil::crypto3::math::polynomial< FieldValueType, Allocator >::operator= ( std::initializer_list< value_type il)
inline

◆ operator==()

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
bool nil::crypto3::math::polynomial< FieldValueType, Allocator >::operator== ( const polynomial< FieldValueType, Allocator > &  rhs) const
inline

◆ operator[]() [1/2]

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
reference nil::crypto3::math::polynomial< FieldValueType, Allocator >::operator[] ( size_type  _n)
inline

◆ operator[]() [2/2]

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
const_reference nil::crypto3::math::polynomial< FieldValueType, Allocator >::operator[] ( size_type  _n) const
inline

◆ pop_back()

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
void nil::crypto3::math::polynomial< FieldValueType, Allocator >::pop_back ( )
inline

◆ push_back() [1/2]

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
void nil::crypto3::math::polynomial< FieldValueType, Allocator >::push_back ( const_reference  _x)
inline

◆ push_back() [2/2]

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
void nil::crypto3::math::polynomial< FieldValueType, Allocator >::push_back ( value_type &&  _x)
inline

◆ rbegin() [1/2]

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
reverse_iterator nil::crypto3::math::polynomial< FieldValueType, Allocator >::rbegin ( )
inline

◆ rbegin() [2/2]

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
const_reverse_iterator nil::crypto3::math::polynomial< FieldValueType, Allocator >::rbegin ( ) const
inline

◆ rend() [1/2]

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
reverse_iterator nil::crypto3::math::polynomial< FieldValueType, Allocator >::rend ( )
inline

◆ rend() [2/2]

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
const_reverse_iterator nil::crypto3::math::polynomial< FieldValueType, Allocator >::rend ( ) const
inline

◆ reserve()

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
void nil::crypto3::math::polynomial< FieldValueType, Allocator >::reserve ( size_type  _n)
inline

◆ resize() [1/2]

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
void nil::crypto3::math::polynomial< FieldValueType, Allocator >::resize ( size_type  _sz)
inline

◆ resize() [2/2]

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
void nil::crypto3::math::polynomial< FieldValueType, Allocator >::resize ( size_type  _sz,
const_reference  _x 
)
inline

◆ reverse()

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
void nil::crypto3::math::polynomial< FieldValueType, Allocator >::reverse ( std::size_t  n)
inline

Compute the reverse polynomial up to vector size n (degree n-1). Below we make use of the reversal endomorphism definition from [Bostan, Lecerf, & Schost, 2003. Tellegen's Principle in Practice, on page 38].

◆ shrink_to_fit()

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
void nil::crypto3::math::polynomial< FieldValueType, Allocator >::shrink_to_fit ( )
inline

◆ size()

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
size_type nil::crypto3::math::polynomial< FieldValueType, Allocator >::size ( ) const
inline

◆ swap()

template<typename FieldValueType , typename Allocator = std::allocator<FieldValueType>>
void nil::crypto3::math::polynomial< FieldValueType, Allocator >::swap ( polynomial< FieldValueType, Allocator > &  other)
inline

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