songsenand
/
cgal
mirror of https://github.com/CGAL/cgal
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

get the package out of way for the exacus polynomial

This commit is contained in:
Andreas Fabri 2006-07-13 12:50:51 +00:00
parent 00d1b18bb7
commit 0d6516c9de
9 changed files with 2822 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
NefPolynomial/changes.txt Normal file
View File

@ -0,0 +1,24 @@
2 September 2004 Menelaos Karavelas
- Polynomial : added the new number type traits tags Has_exact_division,
Has_exact_sqrt, Has_exact_ring_operations
20 June 2004 Sylvain Pion
- Replace "CGAL_NTS gcd" by "CGAL::gcd", since we know the type is int
(allows to define CGAL_NTS as empty)
18 Feb 2004 Sylvain Pion
- Added missing this-> required by g++ 3.4.
0.4 (6 Feb 2004)
-Added lines
typedef CGAL::Tag_false Has_sqrt;
typedef CGAL::Tag_true Has_division;
0.3 (18 Jan 2004)
- Remove CGAL_CFG_MATCHING_BUG_2.
0.2 (18 Jan 2004)
- Renamed CGAL_TEMPLATE_NULL to "template <>".
0.1 26 Nov. 2003 [rursu]
- Created the package Polynomial moving files from Nef_2 package

0
NefPolynomial/description.txt Normal file
View File

1
NefPolynomial/dont_submit Normal file
View File

@ -0,0 +1 @@

2008
NefPolynomial/include/CGAL/Nef_2/Polynomial.h Normal file
View File

File diff suppressed because it is too large Load Diff

1
NefPolynomial/maintainer Normal file
View File

@ -0,0 +1 @@
Andreas Fabri<Andreas.Fabri@geometryfactory.com>

193
NefPolynomial/src/CGAL/Polynomial.cpp Normal file
View File

@ -0,0 +1,193 @@
// Copyright (c) 2000 Utrecht University (The Netherlands),
// ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany),
// INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg
// (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria),
// and Tel-Aviv University (Israel). All rights reserved.
//
// This file is part of CGAL (www.cgal.org); you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation; version 2.1 of the License.
// See the file LICENSE.LGPL distributed with CGAL.
//
// Licensees holding a valid commercial license may use this file in
// accordance with the commercial license agreement provided with the software.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
//
// $URL$
// $Id$
//
//
// Author(s) : Michael Seel
// Andreas Fabri
#include <CGAL/Nef_2/Polynomial.h>
namespace CGAL{
void Polynomial<int>::euclidean_div(
const Polynomial<int>& f, const Polynomial<int>& g,
Polynomial<int>& q, Polynomial<int>& r)
{
r = f; r.copy_on_write();
int rd=r.degree(), gd=g.degree(), qd;
if ( rd < gd ) { q = Polynomial<int>(int(0)); }
else { qd = rd-gd+1; q = Polynomial<int>(std::size_t(qd)); }
while ( rd >= gd && !(r.is_zero())) {
int S = r[rd] / g[gd];
qd = rd-gd;
q.coeff(qd) += S;
r.minus_offsetmult(g,S,qd);
rd = r.degree();
}
CGAL_postcondition( f==q*g+r );
}
void Polynomial<int>::pseudo_div(
const Polynomial<int>& f, const Polynomial<int>& g,
Polynomial<int>& q, Polynomial<int>& r, int& D)
{
CGAL_NEF_TRACEN("pseudo_div "<<f<<" , "<< g);
int fd=f.degree(), gd=g.degree();
if ( fd<gd )
{ q = Polynomial<int>(0); r = f; D = 1;
CGAL_postcondition(Polynomial<int>(D)*f==q*g+r); return;
}
// now we know fd >= gd and f>=g
int qd=fd-gd, delta=qd+1, rd=fd;
{ q = Polynomial<int>( std::size_t(delta) ); }; // workaround for SUNPRO
int G = g[gd]; // highest order coeff of g
D = G; while (--delta) D*=G; // D = G^delta
Polynomial<int> res = Polynomial<int>(D)*f;
CGAL_NEF_TRACEN(" pseudo_div start "<<res<<" "<<qd<<" "<<q.degree());
while (qd >= 0) {
int F = res[rd]; // highest order coeff of res
int t = F/G; // ensured to be integer by multiplication of D
q.coeff(qd) = t; // store q coeff
res.minus_offsetmult(g,t,qd);
if (res.is_zero()) break;
rd = res.degree();
qd = rd - gd;
}
r = res;
CGAL_postcondition(Polynomial<int>(D)*f==q*g+r);
CGAL_NEF_TRACEN(" returning "<<q<<", "<<r<<", "<< D);
}
Polynomial<int> Polynomial<int>::gcd(
const Polynomial<int>& p1, const Polynomial<int>& p2)
{ CGAL_NEF_TRACEN("gcd("<<p1<<" , "<<p2<<")");
if ( p1.is_zero() )
if ( p2.is_zero() ) return Polynomial<int>(int(1));
else return p2.abs();
if ( p2.is_zero() )
return p1.abs();
Polynomial<int> f1 = p1.abs();
Polynomial<int> f2 = p2.abs();
int f1c = f1.content(), f2c = f2.content();
f1 /= f1c; f2 /= f2c;
int F = CGAL::gcd(f1c,f2c);
Polynomial<int> q,r; int M=1,D;
bool first = true;
while ( ! f2.is_zero() ) {
Polynomial<int>::pseudo_div(f1,f2,q,r,D);
if (!first) M*=D;
CGAL_NEF_TRACEV(f1);CGAL_NEF_TRACEV(f2);CGAL_NEF_TRACEV(q);CGAL_NEF_TRACEV(r);CGAL_NEF_TRACEV(M);
r /= r.content();
f1=f2; f2=r;
first=false;
}
CGAL_NEF_TRACEV(f1.content());
return Polynomial<int>(F)*f1.abs();
}
void Polynomial<double>::euclidean_div(
const Polynomial<double>& f, const Polynomial<double>& g,
Polynomial<double>& q, Polynomial<double>& r)
{
r = f; r.copy_on_write();
int rd=r.degree(), gd=g.degree(), qd;
if ( rd < gd ) { q = Polynomial<double>(double(0)); }
else { qd = rd-gd+1; q = Polynomial<double>(std::size_t(qd)); }
while ( rd >= gd && !(r.is_zero())) {
double S = r[rd] / g[gd];
qd = rd-gd;
q.coeff(qd) += S;
r.minus_offsetmult(g,S,qd);
rd = r.degree();
}
CGAL_postcondition( f==q*g+r );
}
void Polynomial<double>::pseudo_div(
const Polynomial<double>& f, const Polynomial<double>& g,
Polynomial<double>& q, Polynomial<double>& r, double& D)
{
CGAL_NEF_TRACEN("pseudo_div "<<f<<" , "<< g);
int fd=f.degree(), gd=g.degree();
if ( fd<gd )
{ q = Polynomial<double>(0); r = f; D = 1;
CGAL_postcondition(Polynomial<double>(D)*f==q*g+r); return;
}
// now we know fd >= gd and f>=g
int qd=fd-gd, delta=qd+1, rd=fd;
q = Polynomial<double>( std::size_t(delta) );
double G = g[gd]; // highest order coeff of g
D = G; while (--delta) D*=G; // D = G^delta
Polynomial<double> res = Polynomial<double>(D)*f;
CGAL_NEF_TRACEN(" pseudo_div start "<<res<<" "<<qd<<" "<<q.degree());
while (qd >= 0) {
double F = res[rd]; // highest order coeff of res
double t = F/G; // ensured to be integer by multiplication of D
q.coeff(qd) = t; // store q coeff
res.minus_offsetmult(g,t,qd);
if (res.is_zero()) break;
rd = res.degree();
qd = rd - gd;
}
r = res;
CGAL_postcondition(Polynomial<double>(D)*f==q*g+r);
CGAL_NEF_TRACEN(" returning "<<q<<", "<<r<<", "<< D);
}
Polynomial<double> Polynomial<double>::gcd(
const Polynomial<double>& p1, const Polynomial<double>& p2)
{ CGAL_NEF_TRACEN("gcd("<<p1<<" , "<<p2<<")");
if ( p1.is_zero() )
if ( p2.is_zero() ) return Polynomial<double>(double(1));
else return p2.abs();
if ( p2.is_zero() )
return p1.abs();
Polynomial<double> f1 = p1.abs();
Polynomial<double> f2 = p2.abs();
double f1c = f1.content(), f2c = f2.content();
f1 /= f1c; f2 /= f2c;
Polynomial<double> q,r; double M=1,D;
bool first = true;
while ( ! f2.is_zero() ) {
Polynomial<double>::pseudo_div(f1,f2,q,r,D);
if (!first) M*=D;
CGAL_NEF_TRACEV(f1);CGAL_NEF_TRACEV(f2);CGAL_NEF_TRACEV(q);CGAL_NEF_TRACEV(r);CGAL_NEF_TRACEV(M);
r /= r.content();
f1=f2; f2=r;
first=false;
}
CGAL_NEF_TRACEV(f1.content());
return Polynomial<double>(1)*f1.abs();
}
}//end namespace CGAL

477
NefPolynomial/test/Polynomial/Polynomial-test.C Normal file
View File

@ -0,0 +1,477 @@
#include <CGAL/basic.h>
#include <CGAL/Nef_2/Polynomial.h>
#include <CGAL/test_macros.h>
#ifdef CGAL_USE_LEDA
#include <CGAL/leda_integer.h>
typedef leda_integer Integer;
#else
#ifdef CGAL_USE_GMP
#include <CGAL/Gmpz.h>
typedef CGAL::Gmpz Integer;
#else
typedef int Integer;
#endif
#endif
using namespace CGAL;
#define PRT(t1,t2) std::cout<<"testing instances "<<#t1<<" "<<#t2<<std::endl
int main()
{
//CGAL_NEF_SETDTHREAD(3); CGAL::set_pretty_mode ( std::cerr );
CGAL_TEST_START;
{ PRT(Integer,Integer);
typedef Integer NT; typedef Polynomial<Integer> RP;
RP::NT seq[4] = { 0, 1, 2, 0 };
RP p1, p2(NT(1)), p3(NT(1),NT(1)), p4(5,2), p5(-2,5), p6(4,1),
p7(3,0), p8(std::make_pair(&seq[0], &seq[4]));
RP p10(-1,0,1), p11(-1,1), p12(1,1);
NT r1(2), r2(-2);
CGAL_TEST(p1.degree()==-1);
CGAL_TEST(p2.degree()==0);
CGAL_TEST(p4.degree()==1);
CGAL_TEST(p7.degree()==0);
CGAL_TEST(p8.degree()==2);
CGAL_TEST((-(-p4)) == p4);
CGAL_TEST((-(-p7)) == p7);
CGAL_TEST((p4+p5) == RP(3,7));
CGAL_TEST((p4-p5) == RP(7,-3));
RP::NT prod[3] = { -10, 21, 10 };
CGAL_TEST((p4*p5) == RP(std::make_pair(&prod[0],&prod[3])));
CGAL_TEST((p2*p3) == p3);
r1+p3;
p3+r1;
CGAL_TEST((r1+p3) == RP(3,1));
CGAL_TEST((r1-p3) == RP(1,-1));
CGAL_TEST((r1*p3) == RP(2,2));
CGAL_TEST((p3+r1) == RP(3,1));
CGAL_TEST((p3-r1) == RP(-1,1));
CGAL_TEST((p3*r1) == RP(2,2));
CGAL_TEST(p2 != p3);
CGAL_TEST(p2 < p3);
CGAL_TEST(p2 <= p3);
CGAL_TEST(p5 > p4);
CGAL_TEST(p5 >= p4);
CGAL_TEST(r1 != p2);
CGAL_TEST(r2 < p2);
CGAL_TEST(r2 <= p2);
CGAL_TEST(r1 > p2);
CGAL_TEST(r1 >= p2);
CGAL_TEST(p2 != r1);
CGAL_TEST(p2 > r2);
CGAL_TEST(p2 >= r2);
CGAL_TEST(p2 < r1);
CGAL_TEST(p2 <= r1);
CGAL_TEST(CGAL_NTS sign(p5)==+1);
CGAL_TEST(CGAL_NTS sign(-p5)==-1);
CGAL_TEST(CGAL_NTS sign(p2)==+1);
CGAL_TEST(CGAL_NTS sign(-p2)==-1);
p3 += p2;
p3 -= p2;
p3 *= p5;
p3 += r1;
p3 -= r1;
p3 *= r2;
RP::NT D;
RP q1(17),q2(5),q3,q4;
RP::pseudo_div(q1,q2,q3,q4,D);
CGAL_TEST(D*q1==q2*q3+q4);
RP::pseudo_div(-q1,q2,q3,q4,D);
CGAL_TEST(D*-q1==q2*q3+q4);
RP::pseudo_div(q1,-q2,q3,q4,D);
CGAL_TEST(D*q1==-q2*q3+q4);
RP::pseudo_div(-q1,-q2,q3,q4,D);
CGAL_TEST(D*-q1==-q2*q3+q4);
RP qq1(5),qq2(17),qq3,qq4;
RP::pseudo_div(qq1,qq2,qq3,qq4,D);
CGAL_TEST(D*qq1==qq2*qq3+qq4);
RP::pseudo_div(-qq1,qq2,qq3,qq4,D);
CGAL_TEST(D*-qq1==qq2*qq3+qq4);
RP::pseudo_div(qq1,-qq2,qq3,qq4,D);
CGAL_TEST(D*qq1==-qq2*qq3+qq4);
RP::pseudo_div(-qq1,-qq2,qq3,qq4,D);
CGAL_TEST(D*-qq1==-qq2*qq3+qq4);
CGAL_TEST(p10/p11 == p12);
q3 = RP::gcd(q1,q2);
CGAL_TEST(q3 == 1);
//CGAL_IO_TEST(p4,p1,CGAL::IO::BINARY);
CGAL_IO_TEST(p4,p1,CGAL::IO::ASCII);
CGAL_IO_TEST(p4,p1,CGAL::IO::PRETTY);
CGAL::to_double(p6);
CGAL::is_finite(p6);
CGAL::is_valid(p6);
}
{ PRT(int,Integer);
typedef int NT; typedef Polynomial<Integer> RP;
RP::NT seq[4] = { 0, 1, 2, 0 };
RP p1, p2(NT(1)), p3(NT(1),NT(1)), p4(5,2), p5(-2,5), p6(4,1),
p7(3,0), p8(std::make_pair(&seq[0],&seq[4]));
RP p10(-1,0,1), p11(-1,1), p12(1,1);
NT r1(2), r2(-2);
CGAL_TEST(p1.degree()==-1);
CGAL_TEST(p2.degree()==0);
CGAL_TEST(p4.degree()==1);
CGAL_TEST(p7.degree()==0);
CGAL_TEST(p8.degree()==2);
CGAL_TEST((-(-p4)) == p4);
CGAL_TEST((-(-p7)) == p7);
CGAL_TEST((p4+p5) == RP(3,7));
CGAL_TEST((p4-p5) == RP(7,-3));
RP::NT prod[3] = { -10, 21, 10 };
CGAL_TEST((p4*p5) == RP(std::make_pair(&prod[0],&prod[3])));
CGAL_TEST((p2*p3) == p3);
r1+p3;
p3+r1;
CGAL_TEST((r1+p3) == RP(3,1));
CGAL_TEST((r1-p3) == RP(1,-1));
CGAL_TEST((r1*p3) == RP(2,2));
CGAL_TEST((p3+r1) == RP(3,1));
CGAL_TEST((p3-r1) == RP(-1,1));
CGAL_TEST((p3*r1) == RP(2,2));
CGAL_TEST(p2 != p3);
CGAL_TEST(p2 < p3);
CGAL_TEST(p2 <= p3);
CGAL_TEST(p5 > p4);
CGAL_TEST(p5 >= p4);
CGAL_TEST(r1 != p2);
CGAL_TEST(r2 < p2);
CGAL_TEST(r2 <= p2);
CGAL_TEST(r1 > p2);
CGAL_TEST(r1 >= p2);
CGAL_TEST(p2 != r1);
CGAL_TEST(p2 > r2);
CGAL_TEST(p2 >= r2);
CGAL_TEST(p2 < r1);
CGAL_TEST(p2 <= r1);
CGAL_TEST(CGAL_NTS sign(p5)==+1);
CGAL_TEST(CGAL_NTS sign(-p5)==-1);
CGAL_TEST(CGAL_NTS sign(p2)==+1);
CGAL_TEST(CGAL_NTS sign(-p2)==-1);
p3 += p2;
p3 -= p2;
p3 *= p5;
p3 += r1;
p3 -= r1;
p3 *= r2;
RP::NT D;
RP q1(17),q2(5),q3,q4;
RP::pseudo_div(q1,q2,q3,q4,D);
CGAL_TEST(D*q1==q2*q3+q4);
RP::pseudo_div(-q1,q2,q3,q4,D);
CGAL_TEST(D*-q1==q2*q3+q4);
RP::pseudo_div(q1,-q2,q3,q4,D);
CGAL_TEST(D*q1==-q2*q3+q4);
RP::pseudo_div(-q1,-q2,q3,q4,D);
CGAL_TEST(D*-q1==-q2*q3+q4);
RP qq1(5),qq2(17),qq3,qq4;
RP::pseudo_div(qq1,qq2,qq3,qq4,D);
CGAL_TEST(D*qq1==qq2*qq3+qq4);
RP::pseudo_div(-qq1,qq2,qq3,qq4,D);
CGAL_TEST(D*-qq1==qq2*qq3+qq4);
RP::pseudo_div(qq1,-qq2,qq3,qq4,D);
CGAL_TEST(D*qq1==-qq2*qq3+qq4);
RP::pseudo_div(-qq1,-qq2,qq3,qq4,D);
CGAL_TEST(D*-qq1==-qq2*qq3+qq4);
CGAL_TEST(p10/p11 == p12);
q3 = RP::gcd(q1,q2);
CGAL_TEST(q3 == 1);
//CGAL_IO_TEST(p4,p1,CGAL::IO::BINARY);
CGAL_IO_TEST(p4,p1,CGAL::IO::ASCII);
CGAL_IO_TEST(p4,p1,CGAL::IO::PRETTY);
CGAL::to_double(p6);
CGAL::is_finite(p6);
CGAL::is_valid(p6);
}
{ PRT(double,Integer);
typedef double NT; typedef Polynomial<Integer> RP;
RP::NT seq[4] = { 0, 1, 2, 0 };
RP p1, p2(NT(1)), p3(NT(1),NT(1)), p4(5,2), p5(-2,5), p6(4,1),
p7(3,0), p8(std::make_pair(&seq[0],&seq[4]));
RP p10(-1,0,1), p11(-1,1), p12(1,1);
NT r1(2), r2(-2);
CGAL_TEST(p1.degree()==-1);
CGAL_TEST(p2.degree()==0);
CGAL_TEST(p4.degree()==1);
CGAL_TEST(p7.degree()==0);
CGAL_TEST(p8.degree()==2);
CGAL_TEST((-(-p4)) == p4);
CGAL_TEST((-(-p7)) == p7);
CGAL_TEST((p4+p5) == RP(3,7));
CGAL_TEST((p4-p5) == RP(7,-3));
RP::NT prod[3] = { -10, 21, 10 };
CGAL_TEST((p4*p5) == RP(std::make_pair(&prod[0],&prod[3])));
CGAL_TEST((p2*p3) == p3);
r1+p3;
p3+r1;
CGAL_TEST((r1+p3) == RP(3,1));
CGAL_TEST((r1-p3) == RP(1,-1));
CGAL_TEST((r1*p3) == RP(2,2));
CGAL_TEST((p3+r1) == RP(3,1));
CGAL_TEST((p3-r1) == RP(-1,1));
CGAL_TEST((p3*r1) == RP(2,2));
CGAL_TEST(p2 != p3);
CGAL_TEST(p2 < p3);
CGAL_TEST(p2 <= p3);
CGAL_TEST(p5 > p4);
CGAL_TEST(p5 >= p4);
CGAL_TEST(r1 != p2);
CGAL_TEST(r2 < p2);
CGAL_TEST(r2 <= p2);
CGAL_TEST(r1 > p2);
CGAL_TEST(r1 >= p2);
CGAL_TEST(p2 != r1);
CGAL_TEST(p2 > r2);
CGAL_TEST(p2 >= r2);
CGAL_TEST(p2 < r1);
CGAL_TEST(p2 <= r1);
CGAL_TEST(CGAL_NTS sign(p5)==+1);
CGAL_TEST(CGAL_NTS sign(-p5)==-1);
CGAL_TEST(CGAL_NTS sign(p2)==+1);
CGAL_TEST(CGAL_NTS sign(-p2)==-1);
p3 += p2;
p3 -= p2;
p3 *= p5;
p3 += r1;
p3 -= r1;
p3 *= r2;
RP::NT D;
RP q1(17),q2(5),q3,q4;
RP::pseudo_div(q1,q2,q3,q4,D);
CGAL_TEST(D*q1==q2*q3+q4);
RP::pseudo_div(-q1,q2,q3,q4,D);
CGAL_TEST(D*-q1==q2*q3+q4);
RP::pseudo_div(q1,-q2,q3,q4,D);
CGAL_TEST(D*q1==-q2*q3+q4);
RP::pseudo_div(-q1,-q2,q3,q4,D);
CGAL_TEST(D*-q1==-q2*q3+q4);
RP qq1(5),qq2(17),qq3,qq4;
RP::pseudo_div(qq1,qq2,qq3,qq4,D);
CGAL_TEST(D*qq1==qq2*qq3+qq4);
RP::pseudo_div(-qq1,qq2,qq3,qq4,D);
CGAL_TEST(D*-qq1==qq2*qq3+qq4);
RP::pseudo_div(qq1,-qq2,qq3,qq4,D);
CGAL_TEST(D*qq1==-qq2*qq3+qq4);
RP::pseudo_div(-qq1,-qq2,qq3,qq4,D);
CGAL_TEST(D*-qq1==-qq2*qq3+qq4);
CGAL_TEST(p10/p11 == p12);
q3 = RP::gcd(q1,q2);
CGAL_TEST(q3 == 1);
//CGAL_IO_TEST(p4,p1,CGAL::IO::BINARY);
CGAL_IO_TEST(p4,p1,CGAL::IO::ASCII);
CGAL_IO_TEST(p4,p1,CGAL::IO::PRETTY);
CGAL::to_double(p6);
CGAL::is_finite(p6);
CGAL::is_valid(p6);
}
{ PRT(int,int);
typedef int NT; typedef Polynomial<int> RP;
RP::NT seq[4] = { 0, 1, 2, 0 };
RP p1, p2(NT(1)), p3(NT(1),NT(1)), p4(5,2), p5(-2,5), p6(4,1),
p7(3,0), p8(std::make_pair(&seq[0],&seq[4]));
RP p10(-1,0,1), p11(-1,1), p12(1,1);
NT r1(2), r2(-2);
CGAL_TEST(p1.degree()==-1);
CGAL_TEST(p2.degree()==0);
CGAL_TEST(p4.degree()==1);
CGAL_TEST(p7.degree()==0);
CGAL_TEST(p8.degree()==2);
CGAL_TEST((-(-p4)) == p4);
CGAL_TEST((-(-p7)) == p7);
CGAL_TEST((p4+p5) == RP(3,7));
CGAL_TEST((p4-p5) == RP(7,-3));
RP::NT prod[3] = { -10, 21, 10 };
CGAL_TEST((p4*p5) == RP(std::make_pair(&prod[0],&prod[3])));
CGAL_TEST((p2*p3) == p3);
r1+p3;
p3+r1;
CGAL_TEST((r1+p3) == RP(3,1));
CGAL_TEST((r1-p3) == RP(1,-1));
CGAL_TEST((r1*p3) == RP(2,2));
CGAL_TEST((p3+r1) == RP(3,1));
CGAL_TEST((p3-r1) == RP(-1,1));
CGAL_TEST((p3*r1) == RP(2,2));
CGAL_TEST(p2 != p3);
CGAL_TEST(p2 < p3);
CGAL_TEST(p2 <= p3);
CGAL_TEST(p5 > p4);
CGAL_TEST(p5 >= p4);
CGAL_TEST(r1 != p2);
CGAL_TEST(r2 < p2);
CGAL_TEST(r2 <= p2);
CGAL_TEST(r1 > p2);
CGAL_TEST(r1 >= p2);
CGAL_TEST(p2 != r1);
CGAL_TEST(p2 > r2);
CGAL_TEST(p2 >= r2);
CGAL_TEST(p2 < r1);
CGAL_TEST(p2 <= r1);
CGAL_TEST(CGAL_NTS sign(p5)==+1);
CGAL_TEST(CGAL_NTS sign(-p5)==-1);
CGAL_TEST(CGAL_NTS sign(p2)==+1);
CGAL_TEST(CGAL_NTS sign(-p2)==-1);
p3 += p2;
p3 -= p2;
p3 *= p5;
p3 += r1;
p3 -= r1;
p3 *= r2;
RP::NT D;
RP q1(17),q2(5),q3,q4;
RP::pseudo_div(q1,q2,q3,q4,D);
CGAL_TEST(D*q1==q2*q3+q4);
RP::pseudo_div(-q1,q2,q3,q4,D);
CGAL_TEST(D*-q1==q2*q3+q4);
RP::pseudo_div(q1,-q2,q3,q4,D);
CGAL_TEST(D*q1==-q2*q3+q4);
RP::pseudo_div(-q1,-q2,q3,q4,D);
CGAL_TEST(D*-q1==-q2*q3+q4);
RP qq1(5),qq2(17),qq3,qq4;
RP::pseudo_div(qq1,qq2,qq3,qq4,D);
CGAL_TEST(D*qq1==qq2*qq3+qq4);
RP::pseudo_div(-qq1,qq2,qq3,qq4,D);
CGAL_TEST(D*-qq1==qq2*qq3+qq4);
RP::pseudo_div(qq1,-qq2,qq3,qq4,D);
CGAL_TEST(D*qq1==-qq2*qq3+qq4);
RP::pseudo_div(-qq1,-qq2,qq3,qq4,D);
CGAL_TEST(D*-qq1==-qq2*qq3+qq4);
CGAL_TEST(p10/p11 == p12);
q3 = RP::gcd(q1,q2);
CGAL_TEST(q3 == 1);
//CGAL_IO_TEST(p4,p1,CGAL::IO::BINARY);
CGAL_IO_TEST(p4,p1,CGAL::IO::ASCII);
CGAL_IO_TEST(p4,p1,CGAL::IO::PRETTY);
CGAL::to_double(p6);
CGAL::is_finite(p6);
CGAL::is_valid(p6);
}
{ PRT(double,int);
typedef double NT; typedef Polynomial<int> RP;
RP::NT seq[4] = { 0, 1, 2, 0 };
RP p1, p2(NT(1)), p3(NT(1),NT(1)), p4(5,2), p5(-2,5), p6(4,1),
p7(3,0), p8(std::make_pair(&seq[0],&seq[4]));
RP p10(-1,0,1), p11(-1,1), p12(1,1);
NT r1(2), r2(-2);
CGAL_TEST(p1.degree()==-1);
CGAL_TEST(p2.degree()==0);
CGAL_TEST(p4.degree()==1);
CGAL_TEST(p7.degree()==0);
CGAL_TEST(p8.degree()==2);
CGAL_TEST((-(-p4)) == p4);
CGAL_TEST((-(-p7)) == p7);
CGAL_TEST((p4+p5) == RP(3,7));
CGAL_TEST((p4-p5) == RP(7,-3));
RP::NT prod[3] = { -10, 21, 10 };
CGAL_TEST((p4*p5) == RP(std::make_pair(&prod[0],&prod[3])));
CGAL_TEST((p2*p3) == p3);
r1+p3;
p3+r1;
CGAL_TEST((r1+p3) == RP(3,1));
CGAL_TEST((r1-p3) == RP(1,-1));
CGAL_TEST((r1*p3) == RP(2,2));
CGAL_TEST((p3+r1) == RP(3,1));
CGAL_TEST((p3-r1) == RP(-1,1));
CGAL_TEST((p3*r1) == RP(2,2));
CGAL_TEST(p2 != p3);
CGAL_TEST(p2 < p3);
CGAL_TEST(p2 <= p3);
CGAL_TEST(p5 > p4);
CGAL_TEST(p5 >= p4);
CGAL_TEST(r1 != p2);
CGAL_TEST(r2 < p2);
CGAL_TEST(r2 <= p2);
CGAL_TEST(r1 > p2);
CGAL_TEST(r1 >= p2);
CGAL_TEST(p2 != r1);
CGAL_TEST(p2 > r2);
CGAL_TEST(p2 >= r2);
CGAL_TEST(p2 < r1);
CGAL_TEST(p2 <= r1);
CGAL_TEST(CGAL_NTS sign(p5)==+1);
CGAL_TEST(CGAL_NTS sign(-p5)==-1);
CGAL_TEST(CGAL_NTS sign(p2)==+1);
CGAL_TEST(CGAL_NTS sign(-p2)==-1);
p3 += p2;
p3 -= p2;
p3 *= p5;
p3 += r1;
p3 -= r1;
p3 *= r2;
RP::NT D;
RP q1(17),q2(5),q3,q4;
RP::pseudo_div(q1,q2,q3,q4,D);
CGAL_TEST(D*q1==q2*q3+q4);
RP::pseudo_div(-q1,q2,q3,q4,D);
CGAL_TEST(D*-q1==q2*q3+q4);
RP::pseudo_div(q1,-q2,q3,q4,D);
CGAL_TEST(D*q1==-q2*q3+q4);
RP::pseudo_div(-q1,-q2,q3,q4,D);
CGAL_TEST(D*-q1==-q2*q3+q4);
RP qq1(5),qq2(17),qq3,qq4;
RP::pseudo_div(qq1,qq2,qq3,qq4,D);
CGAL_TEST(D*qq1==qq2*qq3+qq4);
RP::pseudo_div(-qq1,qq2,qq3,qq4,D);
CGAL_TEST(D*-qq1==qq2*qq3+qq4);
RP::pseudo_div(qq1,-qq2,qq3,qq4,D);
CGAL_TEST(D*qq1==-qq2*qq3+qq4);
RP::pseudo_div(-qq1,-qq2,qq3,qq4,D);
CGAL_TEST(D*-qq1==-qq2*qq3+qq4);
CGAL_TEST(p10/p11 == p12);
q3 = RP::gcd(q1,q2);
CGAL_TEST(q3 == 1);
//CGAL_IO_TEST(p4,p1,CGAL::IO::BINARY);
CGAL_IO_TEST(p4,p1,CGAL::IO::ASCII);
CGAL_IO_TEST(p4,p1,CGAL::IO::PRETTY);
CGAL::to_double(p6);
CGAL::is_finite(p6);
CGAL::is_valid(p6);
}
CGAL_TEST_END;
}

61
NefPolynomial/test/Polynomial/include/CGAL/test_macros.h Normal file
View File

@ -0,0 +1,61 @@
#ifndef CGAL_TEST_MACROS_H
#define CGAL_TEST_MACROS_H
#include <CGAL/basic.h>
#include <CGAL/IO/io.h>
#include <iostream>
#include <sstream>
#include <vector>
#define CGAL_TEST_START int cgal_test_res=0
#define CGAL_TEST(b) if (!(b)) { ++cgal_test_res; \
std::cerr<<"ERROR: ("<<__LINE__ <<") test "<<#b<<" failed."<<std::endl; } \
else
#define CGAL_IO_TEST(datao,datai,iomode) { \
std::stringstream S; \
CGAL::set_mode(S,iomode); \
S << datao; \
if ( iomode != CGAL::IO::BINARY) \
S << '\n'; \
S << datao; \
S >> datai; \
if (datao != datai) { \
++cgal_test_res; \
std::cerr << "ERROR in 1.IO " << #iomode << " of " << #datao << " "\
<< #datai << " : " << S.str() << " failed." <<std::endl; \
} \
S >> datai; \
if (datao != datai) { \
++cgal_test_res; \
std::cerr << "ERROR in 2.IO " << #iomode << " of " << #datao << " "\
<< #datai << " : " << S.str() << " failed." <<std::endl; \
} \
}
#define CGAL_TEST_END return cgal_test_res
#undef CGAL_NEF_TRACE
#undef CGAL_NEF_TRACEN
#undef CGAL_NEF_TRACEV
#define CGAL_NEF_TRACE(t) std::cerr << t
#define CGAL_NEF_TRACEN(t) std::cerr << t << std::endl
#define CGAL_NEF_TRACEV(t) std::cerr << #t << " = " << (t) << std::endl
template <class T>
std::vector<T> make_vector(const T& t1, const T& t2)
{ std::vector<T> V(2); V[0]=t1; V[1]=t2; return V; }
template <class T>
std::vector<T> make_vector(const T& t1, const T& t2, const T& t3)
{ std::vector<T> V(3); V[0]=t1; V[1]=t2; V[2]=t3; return V; }
template <class T>
std::vector<T> make_vector(const T& t1, const T& t2,
const T& t3, const T& t4)
{ std::vector<T> V(4); V[0]=t1; V[1]=t2; V[2]=t3; V[3]=t4; return V; }
#endif //CGAL_TEST_MACROS_H

57
NefPolynomial/test/Polynomial/makefile Normal file
View File

@ -0,0 +1,57 @@
# Created by the script cgal_create_makefile
# This is the makefile for compiling a CGAL application.
#---------------------------------------------------------------------#
# include platform specific settings
#---------------------------------------------------------------------#
# Choose the right include file from the <cgalroot>/make directory.
# CGAL_MAKEFILE = ENTER_YOUR_INCLUDE_MAKEFILE_HERE
include $(CGAL_MAKEFILE)
#---------------------------------------------------------------------#
# compiler flags
#---------------------------------------------------------------------#
CXXFLAGS = \
$(TESTSUITE_CXXFLAGS) \
$(EXTRA_FLAGS) \
-Iinclude \
$(CGAL_CXXFLAGS) \
$(LONG_NAME_PROBLEM_CXXFLAGS) \
$(DEBUG_OPT)
#---------------------------------------------------------------------#
# linker flags
#---------------------------------------------------------------------#
LIBPATH = \
$(TESTSUITE_LIBPATH) \
$(CGAL_LIBPATH)
LDFLAGS = \
$(TESTSUITE_LDFLAGS) \
$(LONG_NAME_PROBLEM_LDFLAGS) \
$(CGAL_LDFLAGS)
#---------------------------------------------------------------------#
# target entries
#---------------------------------------------------------------------#
all: \
Polynomial-test
Polynomial-test$(EXE_EXT): Polynomial-test$(OBJ_EXT)
$(CGAL_CXX) $(LIBPATH) $(EXE_OPT)Polynomial-test Polynomial-test$(OBJ_EXT) $(LDFLAGS)
clean: \
Polynomial-test.clean
#---------------------------------------------------------------------#
# suffix rules
#---------------------------------------------------------------------#
.C$(OBJ_EXT):
$(CGAL_CXX) $(CXXFLAGS) $(OBJ_OPT) $<