244 lines
4.6 KiB
C++
244 lines
4.6 KiB
C++
//This file is part of Bertini 2.
|
|
//
|
|
//patch_test.cpp is free software: you can redistribute it and/or modify
|
|
//it under the terms of the GNU General Public License as published by
|
|
//the Free Software Foundation, either version 3 of the License, or
|
|
//(at your option) any later version.
|
|
//
|
|
//patch_test.cpp is distributed in the hope that it will be useful,
|
|
//but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
//GNU General Public License for more details.
|
|
//
|
|
//You should have received a copy of the GNU General Public License
|
|
//along with patch_test.cpp. If not, see <http://www.gnu.org/licenses/>.
|
|
//
|
|
// Copyright(C) 2015 - 2021 by Bertini2 Development Team
|
|
//
|
|
// See <http://www.gnu.org/licenses/> for a copy of the license,
|
|
// as well as COPYING. Bertini2 is provided with permitted
|
|
// additional terms in the b2/licenses/ directory.
|
|
|
|
// individual authors of this file include:
|
|
// silviana amethyst, university of wisconsin eau claire
|
|
|
|
// patch_test.cpp
|
|
//
|
|
// Created by Collins, James B. on 4/30/15.
|
|
// Copyright (c) 2015 West Texas A&M University. All rights reserved.
|
|
|
|
|
|
/**
|
|
\file patch_test.cpp Unit testing for the bertini::Patch class.
|
|
*/
|
|
|
|
|
|
#include <boost/test/unit_test.hpp>
|
|
#include "bertini2/system/patch.hpp"
|
|
|
|
|
|
|
|
|
|
#include "externs.hpp"
|
|
|
|
|
|
|
|
|
|
BOOST_AUTO_TEST_SUITE(patch_class)
|
|
|
|
|
|
using bertini::DefaultPrecision;
|
|
|
|
template<typename NumType> using Vec = bertini::Vec<NumType>;
|
|
template<typename NumType> using Mat = bertini::Mat<NumType>;
|
|
using Patch = bertini::Patch;
|
|
|
|
using dbl = bertini::dbl;
|
|
using mpfr = bertini::mpfr_complex;
|
|
|
|
using mpfr_float = bertini::mpfr_float;
|
|
|
|
|
|
BOOST_AUTO_TEST_CASE(patch_create)
|
|
{
|
|
Patch p;
|
|
}
|
|
|
|
|
|
BOOST_AUTO_TEST_CASE(patch_create_one_variable_group)
|
|
{
|
|
std::vector<unsigned> s{2};
|
|
|
|
Patch p(s);
|
|
}
|
|
|
|
|
|
BOOST_AUTO_TEST_CASE(patch_create_two_variable_groups)
|
|
{
|
|
std::vector<unsigned> s{2,3};
|
|
|
|
Patch p(s);
|
|
}
|
|
|
|
|
|
BOOST_AUTO_TEST_CASE(patch_eval_two_variable_groups_prec16)
|
|
{
|
|
std::vector<unsigned> s{2,3};
|
|
|
|
Patch p(s);
|
|
|
|
Vec<dbl> v(5);
|
|
v << dbl(1), dbl(1), dbl(1), dbl(1), dbl(1);
|
|
|
|
p.Precision(16);
|
|
|
|
auto f = p.Eval(v);
|
|
|
|
BOOST_CHECK_EQUAL(f.size(),2);
|
|
}
|
|
|
|
|
|
BOOST_AUTO_TEST_CASE(patch_jacobian_two_variable_groups_prec16)
|
|
{
|
|
std::vector<unsigned> s{2,3};
|
|
|
|
Patch p(s);
|
|
|
|
Vec<dbl> v(5);
|
|
v << dbl(1), dbl(1), dbl(1), dbl(1), dbl(1);
|
|
|
|
p.Precision(16);
|
|
|
|
auto J = p.Jacobian(v);
|
|
BOOST_CHECK_EQUAL(J.rows(),2);
|
|
BOOST_CHECK_EQUAL(J.cols(),5);
|
|
|
|
BOOST_CHECK_EQUAL(J(0,2),dbl(0));
|
|
BOOST_CHECK_EQUAL(J(0,3),dbl(0));
|
|
BOOST_CHECK_EQUAL(J(0,4),dbl(0));
|
|
|
|
BOOST_CHECK_EQUAL(J(1,0),dbl(0));
|
|
BOOST_CHECK_EQUAL(J(1,1),dbl(0));
|
|
}
|
|
|
|
|
|
|
|
BOOST_AUTO_TEST_CASE(patch_eval_two_variable_groups_prec30)
|
|
{
|
|
DefaultPrecision(30);
|
|
std::vector<unsigned> s{2,3};
|
|
|
|
Patch p(s);
|
|
|
|
Vec<mpfr> v(5);
|
|
v << mpfr(1), mpfr(1), mpfr(1), mpfr(1), mpfr(1);
|
|
|
|
p.Precision(30);
|
|
auto f = p.Eval(v);
|
|
}
|
|
|
|
|
|
BOOST_AUTO_TEST_CASE(patch_jacobian_two_variable_groups_prec30)
|
|
{
|
|
DefaultPrecision(30);
|
|
|
|
std::vector<unsigned> s{2,3};
|
|
|
|
Patch p(s);
|
|
|
|
Vec<mpfr> v(5);
|
|
v << mpfr(1), mpfr(1), mpfr(1), mpfr(1), mpfr(1);
|
|
|
|
p.Precision(30);
|
|
|
|
auto J = p.Jacobian(v);
|
|
|
|
BOOST_CHECK_EQUAL(J.rows(),2);
|
|
BOOST_CHECK_EQUAL(J.cols(),5);
|
|
|
|
BOOST_CHECK_EQUAL(J(0,2),mpfr(0));
|
|
BOOST_CHECK_EQUAL(J(0,3),mpfr(0));
|
|
BOOST_CHECK_EQUAL(J(0,4),mpfr(0));
|
|
|
|
BOOST_CHECK_EQUAL(J(1,0),mpfr(0));
|
|
BOOST_CHECK_EQUAL(J(1,1),mpfr(0));
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
BOOST_AUTO_TEST_CASE(patch_rescale_and_evaluate_prec16)
|
|
{
|
|
DefaultPrecision(CLASS_TEST_MPFR_DEFAULT_DIGITS);
|
|
|
|
std::vector<unsigned> s{2,3};
|
|
|
|
Patch p(s);
|
|
p.Precision(16);
|
|
|
|
Vec<dbl> v(5);
|
|
v << dbl(1), dbl(1), dbl(1), dbl(1), dbl(1);
|
|
|
|
auto v_rescaled = p.RescalePoint(v);
|
|
|
|
auto f = p.Eval(v_rescaled);
|
|
|
|
BOOST_CHECK_EQUAL(f.size(),2);
|
|
for (int ii = 0; ii < 2; ++ii)
|
|
BOOST_CHECK(abs(f(ii)) < threshold_clearance_d);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
BOOST_AUTO_TEST_CASE(patch_rescale_and_evaluate_prec_default_mpfr)
|
|
{
|
|
DefaultPrecision(CLASS_TEST_MPFR_DEFAULT_DIGITS);
|
|
|
|
std::vector<unsigned> s{2,3};
|
|
|
|
Patch p(s);
|
|
|
|
Vec<mpfr> v(5);
|
|
v << mpfr(1), mpfr(1), mpfr(1), mpfr(1), mpfr(1);
|
|
|
|
auto v_rescaled = p.RescalePoint(v);
|
|
|
|
auto f = p.Eval(v_rescaled);
|
|
|
|
BOOST_CHECK_EQUAL(f.size(),2);
|
|
for (int ii = 0; ii < 2; ++ii)
|
|
BOOST_CHECK(abs(f(ii)) < threshold_clearance_mp);
|
|
|
|
}
|
|
|
|
|
|
BOOST_AUTO_TEST_CASE(patch_equality_checks)
|
|
{
|
|
DefaultPrecision(CLASS_TEST_MPFR_DEFAULT_DIGITS);
|
|
|
|
std::vector<unsigned> s1{2,3};
|
|
std::vector<unsigned> s2{3,4};
|
|
|
|
Patch p(s1), q(s1), r(s2);
|
|
|
|
BOOST_CHECK_EQUAL(p,p);
|
|
BOOST_CHECK_EQUAL(q,q);
|
|
BOOST_CHECK_EQUAL(r,r);
|
|
|
|
BOOST_CHECK(p!=q);
|
|
BOOST_CHECK(p!=r);
|
|
BOOST_CHECK(q!=r);
|
|
|
|
BOOST_CHECK(q!=p);
|
|
BOOST_CHECK(r!=p);
|
|
BOOST_CHECK(r!=q);
|
|
}
|
|
|
|
|
|
|
|
BOOST_AUTO_TEST_SUITE_END() // end the patch_class test suite
|
|
|