algebraic.hpp File Reference

#include "config.hpp"
#include <iostream>
#include <sstream>
#include "_utility.hpp"
#include "factory.hpp"
#include "intalg.hpp"
#include "polyalg.hpp"
#include "sturm.hpp"
#include "algebrslt.hpp"
#include "sparse_polynom.hpp"
#include "rational.hpp"
#include "interval.hpp"
#include "std_import.hpp"

Go to the source code of this file.

Namespaces
namespace	Arageli
Classes
struct	Arageli::algebraic_config_default< TP, TS, Poly, Seg >
class	Arageli::algebraic< TP, TS, Poly, Seg, Config >
	Algebraic number class. More...
struct	Arageli::factory< algebraic< TP, TS, Poly, Seg, Cfg > >
Defines
#define	ARAGELI_ALGEBRAIC_BINARY_OP(OP, OPASS)
#define	ARAGELI_ALGEBRAIC_LOGIC_OP(OP)
Functions
template<typename TP1, typename TS1, typename Poly1, typename Seg1, typename Cfg1, typename TP2, typename TS2, typename Poly2, typename Seg2, typename Cfg2>
algebraic< TP1, TS1, Poly1, Seg1, Cfg1 >	Arageli::operator+ (algebraic< TP1, TS1, Poly1, Seg1, Cfg1 > a, const algebraic< TP2, TS2, Poly2, Seg2, Cfg2 > &b)
template<typename TP1, typename TS1, typename Poly1, typename Seg1, typename Cfg1, typename TP2, typename TS2, typename Poly2, typename Seg2, typename Cfg2>
algebraic< TP1, TS1, Poly1, Seg1, Cfg1 >	Arageli::operator- (algebraic< TP1, TS1, Poly1, Seg1, Cfg1 > a, const algebraic< TP2, TS2, Poly2, Seg2, Cfg2 > &b)
template<typename TP1, typename TS1, typename Poly1, typename Seg1, typename Cfg1, typename TP2, typename TS2, typename Poly2, typename Seg2, typename Cfg2>
algebraic< TP1, TS1, Poly1, Seg1, Cfg1 >	Arageli::operator * (algebraic< TP1, TS1, Poly1, Seg1, Cfg1 > a, const algebraic< TP2, TS2, Poly2, Seg2, Cfg2 > &b)
template<typename TP1, typename TS1, typename Poly1, typename Seg1, typename Cfg1, typename TP2, typename TS2, typename Poly2, typename Seg2, typename Cfg2>
algebraic< TP1, TS1, Poly1, Seg1, Cfg1 >	Arageli::operator/ (algebraic< TP1, TS1, Poly1, Seg1, Cfg1 > a, const algebraic< TP2, TS2, Poly2, Seg2, Cfg2 > &b)
template<typename TP1, typename TS1, typename Poly1, typename Seg1, typename Cfg1, typename TP2, typename TS2, typename Poly2, typename Seg2, typename Cfg2>
algebraic< TP1, TS1, Poly1, Seg1, Cfg1 >	Arageli::operator% (algebraic< TP1, TS1, Poly1, Seg1, Cfg1 > a, const algebraic< TP2, TS2, Poly2, Seg2, Cfg2 > &b)
template<typename TP1, typename TS1, typename Poly1, typename Seg1, typename Cfg1, typename TP2, typename TS2, typename Poly2, typename Seg2, typename Cfg2>
bool	Arageli::operator== (const algebraic< TP1, TS1, Poly1, Seg1, Cfg1 > &a, const algebraic< TP2, TS2, Poly2, Seg2, Cfg2 > &b)
template<typename TP1, typename TS1, typename Poly1, typename Seg1, typename Cfg1, typename TS2>
bool	Arageli::operator== (const algebraic< TP1, TS1, Poly1, Seg1, Cfg1 > &a, const TS2 &b)
template<typename TS1, typename TP2, typename TS2, typename Poly2, typename Seg2, typename Cfg2>
bool	Arageli::operator== (const TS1 &a, const algebraic< TP2, TS2, Poly2, Seg2, Cfg2 > &b)
template<typename TP1, typename TS1, typename Poly1, typename Seg1, typename Cfg1, typename TP2, typename TS2, typename Poly2, typename Seg2, typename Cfg2>
bool	Arageli::operator!= (const algebraic< TP1, TS1, Poly1, Seg1, Cfg1 > &a, const algebraic< TP2, TS2, Poly2, Seg2, Cfg2 > &b)
template<typename TP1, typename TS1, typename Poly1, typename Seg1, typename Cfg1, typename TS2>
bool	Arageli::operator!= (const algebraic< TP1, TS1, Poly1, Seg1, Cfg1 > &a, const TS2 &b)
template<typename TS1, typename TP2, typename TS2, typename Poly2, typename Seg2, typename Cfg2>
bool	Arageli::operator!= (const TS1 &a, const algebraic< TP2, TS2, Poly2, Seg2, Cfg2 > &b)
template<typename TP1, typename TS1, typename Poly1, typename Seg1, typename Cfg1, typename TP2, typename TS2, typename Poly2, typename Seg2, typename Cfg2>
bool	Arageli::operator< (const algebraic< TP1, TS1, Poly1, Seg1, Cfg1 > &a, const algebraic< TP2, TS2, Poly2, Seg2, Cfg2 > &b)
template<typename TP1, typename TS1, typename Poly1, typename Seg1, typename Cfg1, typename TS2>
bool	Arageli::operator< (const algebraic< TP1, TS1, Poly1, Seg1, Cfg1 > &a, const TS2 &b)
template<typename TS1, typename TP2, typename TS2, typename Poly2, typename Seg2, typename Cfg2>
bool	Arageli::operator< (const TS1 &a, const algebraic< TP2, TS2, Poly2, Seg2, Cfg2 > &b)
template<typename TP1, typename TS1, typename Poly1, typename Seg1, typename Cfg1, typename TP2, typename TS2, typename Poly2, typename Seg2, typename Cfg2>
bool	Arageli::operator<= (const algebraic< TP1, TS1, Poly1, Seg1, Cfg1 > &a, const algebraic< TP2, TS2, Poly2, Seg2, Cfg2 > &b)
template<typename TP1, typename TS1, typename Poly1, typename Seg1, typename Cfg1, typename TS2>
bool	Arageli::operator<= (const algebraic< TP1, TS1, Poly1, Seg1, Cfg1 > &a, const TS2 &b)
template<typename TS1, typename TP2, typename TS2, typename Poly2, typename Seg2, typename Cfg2>
bool	Arageli::operator<= (const TS1 &a, const algebraic< TP2, TS2, Poly2, Seg2, Cfg2 > &b)
template<typename TP1, typename TS1, typename Poly1, typename Seg1, typename Cfg1, typename TP2, typename TS2, typename Poly2, typename Seg2, typename Cfg2>
bool	Arageli::operator> (const algebraic< TP1, TS1, Poly1, Seg1, Cfg1 > &a, const algebraic< TP2, TS2, Poly2, Seg2, Cfg2 > &b)
template<typename TP1, typename TS1, typename Poly1, typename Seg1, typename Cfg1, typename TS2>
bool	Arageli::operator> (const algebraic< TP1, TS1, Poly1, Seg1, Cfg1 > &a, const TS2 &b)
template<typename TS1, typename TP2, typename TS2, typename Poly2, typename Seg2, typename Cfg2>
bool	Arageli::operator> (const TS1 &a, const algebraic< TP2, TS2, Poly2, Seg2, Cfg2 > &b)
template<typename TP1, typename TS1, typename Poly1, typename Seg1, typename Cfg1, typename TP2, typename TS2, typename Poly2, typename Seg2, typename Cfg2>
bool	Arageli::operator>= (const algebraic< TP1, TS1, Poly1, Seg1, Cfg1 > &a, const algebraic< TP2, TS2, Poly2, Seg2, Cfg2 > &b)
template<typename TP1, typename TS1, typename Poly1, typename Seg1, typename Cfg1, typename TS2>
bool	Arageli::operator>= (const algebraic< TP1, TS1, Poly1, Seg1, Cfg1 > &a, const TS2 &b)
template<typename TS1, typename TP2, typename TS2, typename Poly2, typename Seg2, typename Cfg2>
bool	Arageli::operator>= (const TS1 &a, const algebraic< TP2, TS2, Poly2, Seg2, Cfg2 > &b)
template<typename TP1, typename TS1, typename Poly1, typename Seg1, typename Cfg1, typename TP2, typename TS2, typename Poly2, typename Seg2, typename Cfg2>
int	Arageli::cmp (const algebraic< TP1, TS1, Poly1, Seg1, Cfg1 > &a, const algebraic< TP2, TS2, Poly2, Seg2, Cfg2 > &b)
template<typename TP1, typename TS1, typename Poly1, typename Seg1, typename Cfg1, typename TP2>
int	Arageli::cmp (const algebraic< TP1, TS1, Poly1, Seg1, Cfg1 > &a, const TP2 &b)
template<typename TP1, typename TP2, typename TS2, typename Poly2, typename Seg2, typename Cfg2>
int	Arageli::cmp (const TP1 &a, const algebraic< TP2, TS2, Poly2, Seg2, Cfg2 > &b)
template<typename Out, typename TP1, typename TS1, typename Poly1, typename Seg1, typename Cfg1>
Out &	Arageli::operator<< (Out &out, const algebraic< TP1, TS1, Poly1, Seg1, Cfg1 > &x)

---

Detailed Description

This file contains declaration of class template `algebraic' for representation any algebraic number over rational field.

WARNING. It's implementation in "old style" because it doesn't use mixing computations. Be careful: in the neares future we plan to replace it to modern one with full support of the mixing computation mechanism.

Definition in file algebraic.hpp.

---

Define Documentation

#define ARAGELI_ALGEBRAIC_BINARY_OP	(	OP,
		OPASS		)

Value:

template                                                                        \
    <                                                                               \
        typename TP1, typename TS1, typename Poly1, typename Seg1, typename Cfg1,   \
        typename TP2, typename TS2, typename Poly2, typename Seg2, typename Cfg2    \
    >                                                                               \
    inline algebraic<TP1, TS1, Poly1, Seg1, Cfg1> operator OP                       \
    (                                                                               \
        algebraic<TP1, TS1, Poly1, Seg1, Cfg1> a,                                   \
        const algebraic<TP2, TS2, Poly2, Seg2, Cfg2>& b                             \
    )                                                                               \
    { return a OPASS b; }

Definition at line 307 of file algebraic.hpp.

#define ARAGELI_ALGEBRAIC_LOGIC_OP

(

OP

)

Definition at line 327 of file algebraic.hpp.

---