913 lines
22 KiB
C++
913 lines
22 KiB
C++
//This file is part of Bertini 2.
|
|
//
|
|
//homogenization_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.
|
|
//
|
|
//homogenization_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 homogenization_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
|
|
|
|
// homogenization_test.cpp
|
|
|
|
|
|
|
|
#include <boost/test/unit_test.hpp>
|
|
|
|
|
|
|
|
#include "bertini2/system/system.hpp"
|
|
|
|
#include "externs.hpp"
|
|
|
|
|
|
BOOST_AUTO_TEST_SUITE(homogenization)
|
|
|
|
using Variable = bertini::node::Variable;
|
|
using Float = bertini::node::Float;
|
|
using mpfr_float = bertini::mpfr_float;
|
|
using Var = std::shared_ptr<bertini::node::Variable>;
|
|
|
|
using Flt = std::shared_ptr<bertini::node::Float>;
|
|
using VariableGroup = bertini::VariableGroup;
|
|
using dbl = bertini::dbl;
|
|
using mpfr = bertini::mpfr_complex;
|
|
|
|
|
|
|
|
|
|
|
|
BOOST_AUTO_TEST_CASE(no_homogenization_needed_x)
|
|
{
|
|
Var x = Variable::Make("x");
|
|
Var h = Variable::Make("h");
|
|
|
|
auto f1 = x;
|
|
|
|
BOOST_CHECK(f1->IsHomogeneous());
|
|
|
|
VariableGroup vars;
|
|
vars.push_back(x);
|
|
|
|
f1->Homogenize(vars,h);
|
|
BOOST_CHECK_EQUAL(f1->Degree(h), 0);
|
|
BOOST_CHECK(f1->IsHomogeneous());
|
|
BOOST_CHECK( f1->IsHomogeneous(x));
|
|
BOOST_CHECK( f1->IsHomogeneous(h));
|
|
|
|
vars.push_back(h);
|
|
BOOST_CHECK(f1->IsHomogeneous(vars));
|
|
|
|
|
|
BOOST_CHECK(f1->IsPolynomial());
|
|
}
|
|
|
|
|
|
|
|
|
|
BOOST_AUTO_TEST_CASE(homogenization_needed_x_minus_1)
|
|
{
|
|
Var x = Variable::Make("x");
|
|
Var t = Variable::Make("t");
|
|
Var h = Variable::Make("h");
|
|
|
|
auto f1 = x-1;
|
|
|
|
BOOST_CHECK(!f1->IsHomogeneous());
|
|
|
|
VariableGroup vars;
|
|
vars.push_back(x);
|
|
|
|
f1->Homogenize(vars,h);
|
|
BOOST_CHECK_EQUAL(f1->Degree(h), 1);
|
|
|
|
BOOST_CHECK(f1->IsHomogeneous());
|
|
BOOST_CHECK(!f1->IsHomogeneous(x));
|
|
BOOST_CHECK(!f1->IsHomogeneous(h));
|
|
|
|
|
|
vars.push_back(h);
|
|
BOOST_CHECK(f1->IsHomogeneous(vars));
|
|
|
|
BOOST_CHECK(f1->IsPolynomial());
|
|
}
|
|
|
|
|
|
|
|
BOOST_AUTO_TEST_CASE(homogenization_needed_1_minus_t_x_plus_t_1_minus_x)
|
|
{
|
|
std::shared_ptr<bertini::node::Variable> x = Variable::Make("x");
|
|
std::shared_ptr<bertini::node::Variable> t = Variable::Make("t");
|
|
auto f1 = (1-t)*x + t*(1-x);
|
|
|
|
BOOST_CHECK(!f1->IsHomogeneous());
|
|
|
|
Var h = Variable::Make("h");
|
|
VariableGroup vars;
|
|
vars.push_back(x);
|
|
|
|
f1->Homogenize(vars,h);
|
|
BOOST_CHECK_EQUAL(f1->Degree(h), 1);
|
|
BOOST_CHECK(!f1->IsHomogeneous());
|
|
|
|
BOOST_CHECK(!f1->IsHomogeneous(x));
|
|
BOOST_CHECK(!f1->IsHomogeneous(h));
|
|
BOOST_CHECK(!f1->IsHomogeneous(t));
|
|
|
|
vars.push_back(h);
|
|
BOOST_CHECK(f1->IsHomogeneous(vars));
|
|
|
|
BOOST_CHECK(f1->IsPolynomial());
|
|
}
|
|
|
|
|
|
|
|
BOOST_AUTO_TEST_CASE(homogenization_needed_x_minus_t)
|
|
{
|
|
Var x = Variable::Make("x");
|
|
Var t = Variable::Make("t");
|
|
Var h = Variable::Make("h");
|
|
|
|
auto f1 = x-t;
|
|
|
|
BOOST_CHECK(f1->IsHomogeneous());
|
|
|
|
VariableGroup vars;
|
|
vars.push_back(x);
|
|
|
|
f1->Homogenize(vars,h);
|
|
BOOST_CHECK_EQUAL(f1->Degree(h), 1);
|
|
BOOST_CHECK(!f1->IsHomogeneous());
|
|
|
|
BOOST_CHECK(!f1->IsHomogeneous(x));
|
|
BOOST_CHECK(!f1->IsHomogeneous(h));
|
|
BOOST_CHECK(!f1->IsHomogeneous(t));
|
|
|
|
vars.push_back(h);
|
|
BOOST_CHECK(f1->IsHomogeneous(vars));
|
|
|
|
BOOST_CHECK(f1->IsPolynomial());
|
|
}
|
|
|
|
|
|
|
|
BOOST_AUTO_TEST_CASE(no_homogenization_needed_x_minus_y_t)
|
|
{
|
|
Var x = Variable::Make("x");
|
|
Var y = Variable::Make("y");
|
|
Var t = Variable::Make("t");
|
|
Var h = Variable::Make("h");
|
|
|
|
auto f1 = x-y*t;
|
|
|
|
BOOST_CHECK(!f1->IsHomogeneous());
|
|
|
|
VariableGroup vars;
|
|
vars.push_back(x);
|
|
vars.push_back(y);
|
|
|
|
f1->Homogenize(vars,h);
|
|
BOOST_CHECK_EQUAL(f1->Degree(h), 0);
|
|
BOOST_CHECK(!f1->IsHomogeneous());
|
|
|
|
BOOST_CHECK(!f1->IsHomogeneous(x));
|
|
BOOST_CHECK( f1->IsHomogeneous(h));
|
|
BOOST_CHECK(!f1->IsHomogeneous(t));
|
|
|
|
vars.push_back(h);
|
|
BOOST_CHECK(f1->IsHomogeneous(vars));
|
|
|
|
BOOST_CHECK(f1->IsPolynomial());
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
BOOST_AUTO_TEST_CASE(homogenization_needed_sphere)
|
|
{
|
|
Var x = Variable::Make("x");
|
|
Var y = Variable::Make("y");
|
|
Var z = Variable::Make("z");
|
|
Var h = Variable::Make("h");
|
|
|
|
auto f1 = pow(x,2) + pow(y,2) + pow(z,2)-1;
|
|
|
|
BOOST_CHECK(!f1->IsHomogeneous());
|
|
|
|
VariableGroup vars;
|
|
vars.push_back(x);
|
|
vars.push_back(y);
|
|
vars.push_back(z);
|
|
|
|
f1->Homogenize(vars,h);
|
|
BOOST_CHECK_EQUAL(f1->Degree(h), 2);
|
|
BOOST_CHECK(f1->IsHomogeneous());
|
|
|
|
BOOST_CHECK(!f1->IsHomogeneous(x));
|
|
BOOST_CHECK(!f1->IsHomogeneous(y));
|
|
BOOST_CHECK(!f1->IsHomogeneous(z));
|
|
BOOST_CHECK(!f1->IsHomogeneous(h));
|
|
|
|
|
|
vars.push_back(h);
|
|
BOOST_CHECK(f1->IsHomogeneous(vars));
|
|
|
|
BOOST_CHECK(f1->IsPolynomial());
|
|
}
|
|
|
|
|
|
|
|
|
|
BOOST_AUTO_TEST_CASE(homogenization_needed_quadric)
|
|
{
|
|
Var x = Variable::Make("x");
|
|
Var y = Variable::Make("y");
|
|
Var z = Variable::Make("z");
|
|
Var h = Variable::Make("h");
|
|
|
|
auto f1 = x*y+x*z+y*z-1;
|
|
BOOST_CHECK(!f1->IsHomogeneous());
|
|
|
|
VariableGroup vars;
|
|
vars.push_back(x);
|
|
vars.push_back(y);
|
|
vars.push_back(z);
|
|
|
|
f1->Homogenize(vars,h);
|
|
BOOST_CHECK_EQUAL(f1->Degree(h), 2);
|
|
BOOST_CHECK(f1->IsHomogeneous());
|
|
|
|
BOOST_CHECK(!f1->IsHomogeneous(x));
|
|
BOOST_CHECK(!f1->IsHomogeneous(y));
|
|
BOOST_CHECK(!f1->IsHomogeneous(z));
|
|
BOOST_CHECK(!f1->IsHomogeneous(h));
|
|
|
|
vars.push_back(h);
|
|
BOOST_CHECK(f1->IsHomogeneous(vars));
|
|
|
|
|
|
BOOST_CHECK(f1->IsPolynomial());
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
BOOST_AUTO_TEST_CASE(homogenization_needed_quadratic)
|
|
{
|
|
Var x = Variable::Make("x");
|
|
Var h = Variable::Make("h");
|
|
|
|
|
|
auto f1 = pow(x,2) + x + 1;
|
|
|
|
BOOST_CHECK(!f1->IsHomogeneous());
|
|
|
|
VariableGroup vars;
|
|
vars.push_back(x);
|
|
|
|
f1->Homogenize(vars,h);
|
|
BOOST_CHECK_EQUAL(f1->Degree(h), 2);
|
|
BOOST_CHECK(f1->IsHomogeneous());
|
|
|
|
BOOST_CHECK(!f1->IsHomogeneous(x));
|
|
BOOST_CHECK(!f1->IsHomogeneous(h));
|
|
|
|
vars.push_back(h);
|
|
BOOST_CHECK(f1->IsHomogeneous(vars));
|
|
|
|
BOOST_CHECK(f1->IsPolynomial());
|
|
}
|
|
|
|
|
|
|
|
BOOST_AUTO_TEST_CASE(homogenization_needed_quadratic_no_constant)
|
|
{
|
|
Var x = Variable::Make("x");
|
|
Var h = Variable::Make("h");
|
|
|
|
|
|
auto f1 = pow(x,2) + x;
|
|
|
|
BOOST_CHECK(!f1->IsHomogeneous());
|
|
|
|
VariableGroup vars;
|
|
vars.push_back(x);
|
|
|
|
f1->Homogenize(vars,h);
|
|
BOOST_CHECK_EQUAL(f1->Degree(h), 1);
|
|
BOOST_CHECK(f1->IsHomogeneous());
|
|
|
|
BOOST_CHECK(!f1->IsHomogeneous(x));
|
|
BOOST_CHECK(!f1->IsHomogeneous(h));
|
|
|
|
vars.push_back(h);
|
|
BOOST_CHECK(f1->IsHomogeneous(vars));
|
|
|
|
BOOST_CHECK(f1->IsPolynomial());
|
|
}
|
|
|
|
|
|
|
|
BOOST_AUTO_TEST_CASE(homogenization_needed_quadratic_no_constant_wrt_y)
|
|
{
|
|
Var x = Variable::Make("x");
|
|
Var y = Variable::Make("y");
|
|
Var h = Variable::Make("h");
|
|
|
|
|
|
auto f1 = pow(x,2) + x;
|
|
|
|
BOOST_CHECK(!f1->IsHomogeneous());
|
|
|
|
VariableGroup vars;
|
|
vars.push_back(y);
|
|
|
|
f1->Homogenize(vars,h);
|
|
BOOST_CHECK_EQUAL(f1->Degree(h), 0);
|
|
BOOST_CHECK(!f1->IsHomogeneous());
|
|
|
|
BOOST_CHECK(!f1->IsHomogeneous(x));
|
|
BOOST_CHECK( f1->IsHomogeneous(h));
|
|
BOOST_CHECK( f1->IsHomogeneous(y));
|
|
|
|
vars.push_back(h);
|
|
BOOST_CHECK(f1->IsHomogeneous(vars));
|
|
|
|
BOOST_CHECK(f1->IsPolynomial());
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
BOOST_AUTO_TEST_CASE(nothomogeneous_sin_x)
|
|
{
|
|
Var x = Variable::Make("x");
|
|
|
|
auto f1 = sin(x);
|
|
|
|
BOOST_CHECK(!f1->IsHomogeneous());
|
|
|
|
BOOST_CHECK(!f1->IsPolynomial());
|
|
}
|
|
|
|
|
|
|
|
BOOST_AUTO_TEST_CASE(nothomogeneous_cos_x)
|
|
{
|
|
Var x = Variable::Make("x");
|
|
|
|
auto f1 = cos(x);
|
|
|
|
BOOST_CHECK(!f1->IsHomogeneous());
|
|
|
|
BOOST_CHECK(!f1->IsPolynomial());
|
|
}
|
|
|
|
BOOST_AUTO_TEST_CASE(nothomogeneous_tan_x)
|
|
{
|
|
Var x = Variable::Make("x");
|
|
|
|
auto f1 = tan(x);
|
|
|
|
BOOST_CHECK(!f1->IsHomogeneous());
|
|
|
|
BOOST_CHECK(!f1->IsPolynomial());
|
|
}
|
|
|
|
|
|
|
|
BOOST_AUTO_TEST_CASE(nothomogeneous_exp_x)
|
|
{
|
|
Var x = Variable::Make("x");
|
|
|
|
auto f1 = exp(x);
|
|
|
|
BOOST_CHECK(!f1->IsHomogeneous());
|
|
|
|
BOOST_CHECK(!f1->IsPolynomial());
|
|
}
|
|
|
|
|
|
BOOST_AUTO_TEST_CASE(nothomogeneous_sqrt_x)
|
|
{
|
|
Var x = Variable::Make("x");
|
|
|
|
auto f1 = sqrt(x);
|
|
|
|
BOOST_CHECK(!f1->IsHomogeneous());
|
|
|
|
BOOST_CHECK(!f1->IsPolynomial());
|
|
}
|
|
|
|
|
|
|
|
BOOST_AUTO_TEST_CASE(is_homogeneous_sin_0)
|
|
{
|
|
Flt n = Float::Make("1");
|
|
|
|
auto f1 = sin(n);
|
|
|
|
BOOST_CHECK(f1->IsHomogeneous());
|
|
|
|
BOOST_CHECK(f1->IsPolynomial());
|
|
}
|
|
|
|
BOOST_AUTO_TEST_CASE(is_homogeneous_cos_1)
|
|
{
|
|
Flt n = Float::Make("1");
|
|
|
|
auto f1 = cos(n);
|
|
|
|
BOOST_CHECK(f1->IsHomogeneous());
|
|
|
|
BOOST_CHECK(f1->IsPolynomial());
|
|
}
|
|
|
|
BOOST_AUTO_TEST_CASE(is_homogeneous_sin_1_plus_1)
|
|
{
|
|
Flt n = Float::Make("1");
|
|
|
|
auto f1 = sin(n + n);
|
|
|
|
BOOST_CHECK(f1->IsHomogeneous());
|
|
|
|
BOOST_CHECK(f1->IsPolynomial());
|
|
}
|
|
|
|
|
|
|
|
|
|
BOOST_AUTO_TEST_CASE(is_homogeneous_summands_homogeneous)
|
|
{
|
|
Var x = Variable::Make("x");
|
|
Var y = Variable::Make("y");
|
|
|
|
auto a = pow(x,3) / 2;
|
|
auto b = pow(x,2) * mpfr_float("4.12331") * pow(x,1);
|
|
|
|
auto f1 = a+b;
|
|
BOOST_CHECK(f1->IsHomogeneous());
|
|
|
|
BOOST_CHECK(f1->IsHomogeneous(x));
|
|
BOOST_CHECK(f1->IsHomogeneous(y));
|
|
|
|
|
|
BOOST_CHECK(f1->IsPolynomial());
|
|
|
|
}
|
|
|
|
BOOST_AUTO_TEST_CASE(not_homogeneous_summands_inhomogeneous)
|
|
{
|
|
Var x = Variable::Make("x");
|
|
Var y = Variable::Make("y");
|
|
|
|
auto a = pow(x,3) / 2;
|
|
auto b = pow(x,2) * mpfr_float("4.12331");
|
|
|
|
auto f1 = a+b;
|
|
BOOST_CHECK(!f1->IsHomogeneous());
|
|
|
|
BOOST_CHECK(!f1->IsHomogeneous(x));
|
|
BOOST_CHECK( f1->IsHomogeneous(y));
|
|
|
|
BOOST_CHECK(f1->IsPolynomial());
|
|
}
|
|
|
|
|
|
|
|
BOOST_AUTO_TEST_CASE(linprod_ishom)
|
|
{
|
|
using bertini::VariableGroup;
|
|
using namespace bertini::node;
|
|
|
|
auto x = Variable::Make("x");
|
|
auto y = Variable::Make("y");
|
|
auto z = Variable::Make("z");
|
|
auto w = Variable::Make("w");
|
|
|
|
|
|
|
|
VariableGroup v1{x,w};
|
|
VariableGroup v2{y};
|
|
VariableGroup v3{z};
|
|
VariableGroup hom{x,w,z};
|
|
|
|
std::shared_ptr<Node> linprod_node = (2 + 3*x + 2*w) * (4 - 2*x - 6*w)*(4+8*y);
|
|
std::shared_ptr<Node> linprod = LinearProduct::Make(v1,2)*LinearProduct::Make(v2,1);
|
|
|
|
BOOST_CHECK_EQUAL(linprod->IsHomogeneous(v1), linprod_node->IsHomogeneous(v1));
|
|
BOOST_CHECK_EQUAL(linprod->IsHomogeneous(v2), linprod_node->IsHomogeneous(v2));
|
|
BOOST_CHECK_EQUAL(linprod->IsHomogeneous(x), linprod_node->IsHomogeneous(x));
|
|
BOOST_CHECK_EQUAL(linprod->IsHomogeneous(y), linprod_node->IsHomogeneous(y));
|
|
|
|
linprod_node->Homogenize(v1, z);
|
|
linprod->Homogenize(v1,z);
|
|
VariableGroup badgp{x,y};
|
|
|
|
|
|
BOOST_CHECK_EQUAL(linprod->IsHomogeneous(v1), linprod_node->IsHomogeneous(v1));
|
|
BOOST_CHECK_EQUAL(linprod->IsHomogeneous(v2), linprod_node->IsHomogeneous(v2));
|
|
BOOST_CHECK_EQUAL(linprod->IsHomogeneous(x), linprod_node->IsHomogeneous(x));
|
|
BOOST_CHECK_EQUAL(linprod->IsHomogeneous(y), linprod_node->IsHomogeneous(y));
|
|
BOOST_CHECK_EQUAL(linprod->IsHomogeneous(badgp), linprod_node->IsHomogeneous(badgp));
|
|
|
|
linprod = LinearProduct::Make(v1,2)*LinearProduct::Make(v2,1);
|
|
BOOST_CHECK_THROW(linprod->Homogenize(badgp,y), std::exception);
|
|
|
|
linprod_node = (2 + 3*x + 2*w) * (4 - 2*x - 6*w)*(4+8*y);
|
|
linprod = LinearProduct::Make(v1,2)*LinearProduct::Make(v2,1);
|
|
|
|
BOOST_CHECK_THROW(linprod->Homogenize(badgp,y), std::exception);
|
|
|
|
linprod = LinearProduct::Make(v1,2)*LinearProduct::Make(v2,1);
|
|
|
|
linprod_node->Homogenize(hom, z);
|
|
linprod->Homogenize(hom,z);
|
|
|
|
BOOST_CHECK_EQUAL(linprod->IsHomogeneous(v1), linprod_node->IsHomogeneous(v1));
|
|
BOOST_CHECK_EQUAL(linprod->IsHomogeneous(v2), linprod_node->IsHomogeneous(v2));
|
|
BOOST_CHECK_EQUAL(linprod->IsHomogeneous(x), linprod_node->IsHomogeneous(x));
|
|
BOOST_CHECK_EQUAL(linprod->IsHomogeneous(y), linprod_node->IsHomogeneous(y));
|
|
BOOST_CHECK_EQUAL(linprod->IsHomogeneous(badgp), linprod_node->IsHomogeneous(badgp));
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
BOOST_AUTO_TEST_CASE(linprod_hom_eval)
|
|
{
|
|
using bertini::VariableGroup;
|
|
using namespace bertini::node;
|
|
|
|
auto x = Variable::Make("x");
|
|
auto y = Variable::Make("y");
|
|
auto h0 = Variable::Make("HOM0");
|
|
auto h1 = Variable::Make("HOM1");
|
|
auto z = Variable::Make("z");
|
|
|
|
|
|
|
|
VariableGroup v0{x,z};
|
|
VariableGroup v1{y};
|
|
Mat<dbl> coeff_dbl(2,3);
|
|
Mat<mpfr> coeff_mpfr(2,3);
|
|
|
|
for(int ii = 0; ii < 2; ++ii)
|
|
{
|
|
for(int jj = 0; jj < 3; ++jj)
|
|
{
|
|
coeff_dbl(ii,jj) = dbl(ii+1, jj+1);
|
|
coeff_mpfr(ii,jj) = mpfr(ii+1, jj+1);
|
|
}
|
|
}
|
|
|
|
std::shared_ptr<bertini::node::Node>linprod1 = bertini::node::LinearProduct::Make(v0, coeff_mpfr);
|
|
|
|
coeff_dbl = Mat<dbl>(1,2);
|
|
coeff_mpfr = Mat<mpfr>(1,2);
|
|
|
|
for(int ii = 0; ii < 1; ++ii)
|
|
{
|
|
for(int jj = 0; jj < 2; ++jj)
|
|
{
|
|
coeff_dbl(ii,jj) = dbl(ii+3, jj+3);
|
|
coeff_mpfr(ii,jj) = mpfr(ii+3, jj+3);
|
|
}
|
|
}
|
|
|
|
std::shared_ptr<bertini::node::Node> linprod2 = bertini::node::LinearProduct::Make(v1, coeff_mpfr);
|
|
|
|
std::shared_ptr<bertini::node::Node> linprod_node = (mpfr(1,1)*x + mpfr(1,2)*z + mpfr(1,3)) * (mpfr(2,1)*x + mpfr(2,2)*z+ mpfr(2,3))* (mpfr(3,3)*y + mpfr(3,4));
|
|
std::shared_ptr<bertini::node::Node> linprod = linprod1*linprod2;
|
|
|
|
dbl xval_d = dbl(.5,1);
|
|
dbl yval_d = dbl(.6,1);
|
|
dbl zval_d = dbl(.7,1);
|
|
dbl h0val_d = dbl(.34, -2.1);
|
|
dbl h1val_d = dbl(-1.2, .0043);
|
|
mpfr xval_mp = mpfr(".5", "1");
|
|
mpfr yval_mp = mpfr(".6", "1");
|
|
mpfr zval_mp = mpfr(".7", "1");
|
|
mpfr h0val_mp = mpfr(".34", "-2.1");
|
|
mpfr h1val_mp = mpfr("-1.2", ".0043");
|
|
|
|
v0[0]->set_current_value(xval_d);
|
|
v0[1]->set_current_value(zval_d);
|
|
v1[0]->set_current_value(yval_d);
|
|
v0[0]->set_current_value(xval_mp);
|
|
v0[1]->set_current_value(zval_mp);
|
|
v1[0]->set_current_value(yval_mp);
|
|
|
|
h0->set_current_value(h0val_d);
|
|
h1->set_current_value(h1val_d);
|
|
h0->set_current_value(h0val_mp);
|
|
h1->set_current_value(h1val_mp);
|
|
|
|
|
|
linprod_node->Homogenize(v0,h0);
|
|
linprod->Homogenize(v0,h0);
|
|
|
|
dbl eval_d = linprod->Eval<dbl>();
|
|
dbl exact_d = linprod_node->Eval<dbl>();
|
|
mpfr eval_mp = linprod->Eval<mpfr>();
|
|
mpfr exact_mp = linprod_node->Eval<mpfr>();
|
|
|
|
BOOST_CHECK(fabs(eval_d.real()/exact_d.real() - 1) < threshold_clearance_d);
|
|
BOOST_CHECK(fabs(eval_d.imag()/exact_d.imag() - 1) < threshold_clearance_d);
|
|
BOOST_CHECK(fabs(eval_mp.real()/exact_mp.real() - 1) < threshold_clearance_mp);
|
|
BOOST_CHECK(fabs(eval_mp.imag()/exact_mp.imag() - 1) < threshold_clearance_mp);
|
|
|
|
linprod_node->Homogenize(v1,h1);
|
|
linprod->Homogenize(v1,h1);
|
|
|
|
eval_d = linprod->Eval<dbl>();
|
|
exact_d = linprod_node->Eval<dbl>();
|
|
eval_mp = linprod->Eval<mpfr>();
|
|
exact_mp = linprod_node->Eval<mpfr>();
|
|
|
|
BOOST_CHECK(fabs(eval_d.real()/exact_d.real() - 1) < threshold_clearance_d);
|
|
BOOST_CHECK(fabs(eval_d.imag()/exact_d.imag() - 1) < threshold_clearance_d);
|
|
BOOST_CHECK(fabs(eval_mp.real()/exact_mp.real() - 1) < threshold_clearance_mp);
|
|
BOOST_CHECK(fabs(eval_mp.imag()/exact_mp.imag() - 1) < threshold_clearance_mp);
|
|
|
|
|
|
}
|
|
|
|
BOOST_AUTO_TEST_CASE(linprod_hom_eval_homvars)
|
|
{
|
|
using bertini::VariableGroup;
|
|
using namespace bertini::node;
|
|
|
|
auto x = Variable::Make("x");
|
|
auto y = Variable::Make("y");
|
|
auto h0 = Variable::Make("HOM0");
|
|
auto h1 = Variable::Make("HOM1");
|
|
auto z = Variable::Make("z");
|
|
|
|
|
|
|
|
VariableGroup v0{x,z};
|
|
VariableGroup v1{y};
|
|
Mat<dbl> coeff_dbl(2,3);
|
|
Mat<mpfr> coeff_mpfr(2,3);
|
|
|
|
for(int ii = 0; ii < 2; ++ii)
|
|
{
|
|
for(int jj = 0; jj < 3; ++jj)
|
|
{
|
|
coeff_dbl(ii,jj) = dbl(ii+1, jj+1);
|
|
coeff_mpfr(ii,jj) = mpfr(ii+1, jj+1);
|
|
}
|
|
}
|
|
|
|
std::shared_ptr<bertini::node::Node>linprod1 = bertini::node::LinearProduct::Make(v0, coeff_mpfr, true);
|
|
|
|
coeff_dbl = Mat<dbl>(1,2);
|
|
coeff_mpfr = Mat<mpfr>(1,2);
|
|
|
|
for(int ii = 0; ii < 1; ++ii)
|
|
{
|
|
for(int jj = 0; jj < 2; ++jj)
|
|
{
|
|
coeff_dbl(ii,jj) = dbl(ii+3, jj+3);
|
|
coeff_mpfr(ii,jj) = mpfr(ii+3, jj+3);
|
|
}
|
|
}
|
|
|
|
std::shared_ptr<bertini::node::Node> linprod2 = bertini::node::LinearProduct::Make(v1, coeff_mpfr, true);
|
|
|
|
std::shared_ptr<bertini::node::Node> linprod_node = (mpfr(1,1)*x + mpfr(1,2)*z) * (mpfr(2,1)*x + mpfr(2,2)*z)* (mpfr(3,3)*y);
|
|
std::shared_ptr<bertini::node::Node> linprod = linprod1*linprod2;
|
|
|
|
dbl xval_d = dbl(.5,1);
|
|
dbl yval_d = dbl(.6,1);
|
|
dbl zval_d = dbl(.7,1);
|
|
dbl h0val_d = dbl(.34, -2.1);
|
|
dbl h1val_d = dbl(-1.2, .0043);
|
|
mpfr xval_mp = mpfr(".5", "1");
|
|
mpfr yval_mp = mpfr(".6", "1");
|
|
mpfr zval_mp = mpfr(".7", "1");
|
|
mpfr h0val_mp = mpfr(".34", "-2.1");
|
|
mpfr h1val_mp = mpfr("-1.2", ".0043");
|
|
|
|
v0[0]->set_current_value(xval_d);
|
|
v0[1]->set_current_value(zval_d);
|
|
v1[0]->set_current_value(yval_d);
|
|
v0[0]->set_current_value(xval_mp);
|
|
v0[1]->set_current_value(zval_mp);
|
|
v1[0]->set_current_value(yval_mp);
|
|
|
|
h0->set_current_value(h0val_d);
|
|
h1->set_current_value(h1val_d);
|
|
h0->set_current_value(h0val_mp);
|
|
h1->set_current_value(h1val_mp);
|
|
|
|
|
|
linprod_node->Homogenize(v0,h0);
|
|
linprod->Homogenize(v0,h0);
|
|
|
|
dbl eval_d = linprod->Eval<dbl>();
|
|
dbl exact_d = linprod_node->Eval<dbl>();
|
|
mpfr eval_mp = linprod->Eval<mpfr>();
|
|
mpfr exact_mp = linprod_node->Eval<mpfr>();
|
|
|
|
BOOST_CHECK(fabs(eval_d.real()/exact_d.real() - 1) < threshold_clearance_d);
|
|
BOOST_CHECK(fabs(eval_d.imag()/exact_d.imag() - 1) < threshold_clearance_d);
|
|
BOOST_CHECK(fabs(eval_mp.real()/exact_mp.real() - 1) < threshold_clearance_mp);
|
|
BOOST_CHECK(fabs(eval_mp.imag()/exact_mp.imag() - 1) < threshold_clearance_mp);
|
|
|
|
linprod_node->Homogenize(v1,h1);
|
|
linprod->Homogenize(v1,h1);
|
|
|
|
eval_d = linprod->Eval<dbl>();
|
|
exact_d = linprod_node->Eval<dbl>();
|
|
eval_mp = linprod->Eval<mpfr>();
|
|
exact_mp = linprod_node->Eval<mpfr>();
|
|
|
|
BOOST_CHECK(fabs(eval_d.real()/exact_d.real() - 1) < threshold_clearance_d);
|
|
BOOST_CHECK(fabs(eval_d.imag()/exact_d.imag() - 1) < threshold_clearance_d);
|
|
BOOST_CHECK(fabs(eval_mp.real()/exact_mp.real() - 1) < threshold_clearance_mp);
|
|
BOOST_CHECK(fabs(eval_mp.imag()/exact_mp.imag() - 1) < threshold_clearance_mp);
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
BOOST_AUTO_TEST_CASE(linprod_hom_diff_eval)
|
|
{
|
|
using bertini::VariableGroup;
|
|
using namespace bertini::node;
|
|
|
|
auto x = Variable::Make("x");
|
|
auto y = Variable::Make("y");
|
|
auto h0 = Variable::Make("HOM0");
|
|
auto h1 = Variable::Make("HOM1");
|
|
auto z = Variable::Make("z");
|
|
auto w = Variable::Make("w");
|
|
|
|
|
|
|
|
VariableGroup v0{x,z,y};
|
|
VariableGroup v1{w};
|
|
int num_factors = 3;
|
|
int num_variables = v0.size();
|
|
Mat<dbl> coeff_dbl(num_factors,num_variables+1);
|
|
Mat<mpfr> coeff_mpfr(num_factors,num_variables+1);
|
|
|
|
for(int ii = 0; ii < num_factors; ++ii)
|
|
{
|
|
for(int jj = 0; jj < num_variables+1; ++jj)
|
|
{
|
|
coeff_dbl(ii,jj) = dbl(ii+1, jj+1);
|
|
coeff_mpfr(ii,jj) = mpfr(ii+1, jj+1);
|
|
}
|
|
}
|
|
|
|
std::shared_ptr<bertini::node::Node> linprod1 = bertini::node::LinearProduct::Make(v0, coeff_mpfr);
|
|
|
|
num_factors = 1;
|
|
num_variables = v1.size();
|
|
coeff_dbl = Mat<dbl>(num_factors,num_variables+1);
|
|
coeff_mpfr = Mat<mpfr>(num_factors,num_variables+1);
|
|
|
|
for(int ii = 0; ii < num_factors; ++ii)
|
|
{
|
|
for(int jj = 0; jj < num_variables+1; ++jj)
|
|
{
|
|
coeff_dbl(ii,jj) = dbl(ii+3, jj+3);
|
|
coeff_mpfr(ii,jj) = mpfr(ii+3, jj+3);
|
|
}
|
|
}
|
|
|
|
|
|
std::shared_ptr<bertini::node::Node> linprod2 = bertini::node::LinearProduct::Make(v1, coeff_mpfr);
|
|
|
|
std::shared_ptr<bertini::node::Node> linprod1_node = (mpfr(1,1)*x + mpfr(1,2)*z + mpfr(1,3)*y+ mpfr(1,4)) * (mpfr(2,1)*x + mpfr(2,2)*z + mpfr(2,3)*y+ mpfr(2,4))*(mpfr(3,1)*x + mpfr(3,2)*z + mpfr(3,3)*y+ mpfr(3,4));
|
|
std::shared_ptr<bertini::node::Node> linprod2_node = (mpfr(3,3)*w + mpfr(3,4));
|
|
|
|
std::shared_ptr<bertini::node::Node> linprod_node = linprod1_node*linprod2_node;
|
|
std::shared_ptr<bertini::node::Node> linprod = linprod1*linprod2;
|
|
|
|
|
|
dbl xval_d = dbl(.5,1);
|
|
dbl yval_d = dbl(.6,1);
|
|
dbl zval_d = dbl(.7,1);
|
|
dbl wval_d = dbl(2.1, -.03);
|
|
dbl h0val_d = dbl(.34, -2.1);
|
|
dbl h1val_d = dbl(-1.2, .0043);
|
|
mpfr xval_mp = mpfr(".5", "1");
|
|
mpfr yval_mp = mpfr(".6", "1");
|
|
mpfr zval_mp = mpfr(".7", "1");
|
|
mpfr wval_mp = mpfr("2.1", "-.03");
|
|
mpfr h0val_mp = mpfr(".34", "-2.1");
|
|
mpfr h1val_mp = mpfr("-1.2", ".0043");
|
|
|
|
v0[0]->set_current_value(xval_d);
|
|
v0[1]->set_current_value(zval_d);
|
|
v0[2]->set_current_value(yval_d);
|
|
v0[0]->set_current_value(xval_mp);
|
|
v0[1]->set_current_value(zval_mp);
|
|
v0[2]->set_current_value(yval_mp);
|
|
|
|
v1[0]->set_current_value(wval_d);
|
|
v1[0]->set_current_value(wval_mp);
|
|
|
|
h0->set_current_value(h0val_d);
|
|
h1->set_current_value(h1val_d);
|
|
h0->set_current_value(h0val_mp);
|
|
h1->set_current_value(h1val_mp);
|
|
|
|
linprod_node->Homogenize(v0,h0);
|
|
linprod->Homogenize(v0,h0);
|
|
|
|
linprod_node->Homogenize(v1,h1);
|
|
linprod->Homogenize(v1,h1);
|
|
|
|
|
|
auto J_node = bertini::node::Jacobian::Make(linprod_node->Differentiate());
|
|
auto J = bertini::node::Jacobian::Make(linprod->Differentiate());
|
|
|
|
|
|
dbl evalx_d = J->EvalJ<dbl>(x);
|
|
dbl exactx_d = J_node->EvalJ<dbl>(x);
|
|
mpfr evalx_mp = J->EvalJ<mpfr>(x);
|
|
mpfr exactx_mp = J_node->EvalJ<mpfr>(x);
|
|
|
|
|
|
|
|
BOOST_CHECK(fabs(evalx_d.real()/exactx_d.real() - 1) < threshold_clearance_d);
|
|
BOOST_CHECK(fabs(evalx_d.imag()/exactx_d.imag() - 1) < threshold_clearance_d);
|
|
BOOST_CHECK(fabs(evalx_mp.real()/exactx_mp.real() - 1) < threshold_clearance_mp);
|
|
BOOST_CHECK(fabs(evalx_mp.imag()/exactx_mp.imag() - 1) < threshold_clearance_mp);
|
|
|
|
|
|
evalx_d = J->EvalJ<dbl>(z);
|
|
exactx_d = J_node->EvalJ<dbl>(z);
|
|
evalx_mp = J->EvalJ<mpfr>(z);
|
|
exactx_mp = J_node->EvalJ<mpfr>(z);
|
|
|
|
|
|
|
|
BOOST_CHECK(fabs(evalx_d.real()/exactx_d.real() - 1) < threshold_clearance_d);
|
|
BOOST_CHECK(fabs(evalx_d.imag()/exactx_d.imag() - 1) < threshold_clearance_d);
|
|
BOOST_CHECK(fabs(evalx_mp.real()/exactx_mp.real() - 1) < threshold_clearance_mp);
|
|
BOOST_CHECK(fabs(evalx_mp.imag()/exactx_mp.imag() - 1) < threshold_clearance_mp);
|
|
|
|
|
|
evalx_d = J->EvalJ<dbl>(y);
|
|
exactx_d = J_node->EvalJ<dbl>(y);
|
|
evalx_mp = J->EvalJ<mpfr>(y);
|
|
exactx_mp = J_node->EvalJ<mpfr>(y);
|
|
|
|
|
|
BOOST_CHECK(fabs(evalx_d.real()/exactx_d.real() - 1) < threshold_clearance_d);
|
|
BOOST_CHECK(fabs(evalx_d.imag()/exactx_d.imag() - 1) < relaxed_threshold_clearance_d);
|
|
BOOST_CHECK(fabs(evalx_mp.real()/exactx_mp.real() - 1) < threshold_clearance_mp);
|
|
BOOST_CHECK(fabs(evalx_mp.imag()/exactx_mp.imag() - 1) < threshold_clearance_mp);
|
|
|
|
|
|
evalx_d = J->EvalJ<dbl>(w);
|
|
exactx_d = J_node->EvalJ<dbl>(w);
|
|
evalx_mp = J->EvalJ<mpfr>(w);
|
|
exactx_mp = J_node->EvalJ<mpfr>(w);
|
|
|
|
|
|
|
|
BOOST_CHECK(fabs(evalx_d.real()/exactx_d.real() - 1) < threshold_clearance_d);
|
|
BOOST_CHECK(fabs(evalx_d.imag()/exactx_d.imag() - 1) < threshold_clearance_d);
|
|
BOOST_CHECK(fabs(evalx_mp.real()/exactx_mp.real() - 1) < threshold_clearance_mp);
|
|
BOOST_CHECK(fabs(evalx_mp.imag()/exactx_mp.imag() - 1) < threshold_clearance_mp);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
BOOST_AUTO_TEST_SUITE_END()
|
|
|
|
|
|
|
|
|
|
|