268 lines
7.2 KiB
C++
268 lines
7.2 KiB
C++
//This file is part of Bertini 2.
|
|
//
|
|
//python/node_export.hpp 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.
|
|
//
|
|
//python/node_export.hpp 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 python/node_export.hpp. If not, see <http://www.gnu.org/licenses/>.
|
|
//
|
|
// Copyright(C) 2016-2018 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:
|
|
//
|
|
// James Collins
|
|
// West Texas A&M University
|
|
// Spring 2016
|
|
//
|
|
// silviana amethyst
|
|
// UWEC
|
|
// Spring 2018
|
|
//
|
|
// python/node_export.hpp: Header file for exposing Node class to python.
|
|
|
|
#pragma once
|
|
#ifndef BERTINI_PYTHON_NODE_EXPORT_HPP
|
|
#define BERTINI_PYTHON_NODE_EXPORT_HPP
|
|
|
|
#include <bertini2/function_tree.hpp>
|
|
#include <bertini2/function_tree/node.hpp>
|
|
|
|
|
|
#include "python_common.hpp"
|
|
|
|
namespace bertini{
|
|
namespace python{
|
|
|
|
|
|
using namespace bertini::node;
|
|
|
|
using Nodeptr = std::shared_ptr<Node>;
|
|
|
|
void ExportNode();
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
template<typename NodeBaseT>
|
|
class NodeVisitor: public def_visitor<NodeVisitor<NodeBaseT> >
|
|
{
|
|
friend class def_visitor_access;
|
|
|
|
public:
|
|
template<class PyClass>
|
|
void visit(PyClass& cl) const;
|
|
|
|
private:
|
|
static unsigned GetPrecision(NodeBaseT const& self) {return self.precision();}
|
|
static void SetPrecision(NodeBaseT & self, unsigned p){self.precision(p);}
|
|
|
|
static Nodeptr Diff0(NodeBaseT& self) { return self.Differentiate();}
|
|
Nodeptr (NodeBaseT::*Diff1)(std::shared_ptr<Variable> const&) const= &NodeBaseT::Differentiate;
|
|
|
|
static int Deg0(NodeBaseT& self) { return self.Degree();}
|
|
int (NodeBaseT::*Deg1)(std::shared_ptr<Variable> const&) const= &NodeBaseT::Degree;
|
|
int (NodeBaseT::*Deg2)(VariableGroup const&) const = &NodeBaseT::Degree;
|
|
|
|
static bool IsHom0(NodeBaseT& self) { return self.IsHomogeneous();}
|
|
bool (NodeBaseT::*IsHom1)(std::shared_ptr<Variable> const&) const= &NodeBaseT::IsHomogeneous;
|
|
bool (NodeBaseT::*IsHom2)(VariableGroup const& vars) const= &NodeBaseT::IsHomogeneous;
|
|
|
|
static bool IsPoly0(NodeBaseT& self) { return self.IsPolynomial();}
|
|
bool (NodeBaseT::*IsPoly1)(std::shared_ptr<Variable> const&) const= &NodeBaseT::IsPolynomial;
|
|
bool (NodeBaseT::*IsPoly2)(VariableGroup const& vars) const= &NodeBaseT::IsPolynomial;
|
|
|
|
// Can't create member function pointer to Eval with zero arguments because implementation
|
|
// uses default arguments
|
|
template <typename T>
|
|
static T Eval0(NodeBaseT& self) { return self.template Eval<T>();}
|
|
|
|
// Use templating to return member function pointer to Eval<T>
|
|
template <typename T>
|
|
using Eval1_ptr = T (NodeBaseT::*)(std::shared_ptr<Variable> const&) const;
|
|
|
|
template <typename T>
|
|
static Eval1_ptr<T> return_Eval1_ptr()
|
|
{
|
|
return &NodeBaseT::template Eval<T>;
|
|
};
|
|
|
|
|
|
|
|
// Addition operators
|
|
Nodeptr(*addNodeNode)(Nodeptr, const Nodeptr&) = &(operator+);
|
|
Nodeptr(*addNodeMpfr)(Nodeptr, const mpfr_complex&) = &(operator+);
|
|
|
|
static Nodeptr raddNodeMpfr(Nodeptr y, const mpfr_complex & x)
|
|
{
|
|
return x+y;
|
|
}
|
|
|
|
|
|
Nodeptr(*addNodeRat)(Nodeptr, const bertini::mpq_rational&) = &(operator+);
|
|
static Nodeptr raddNodeRat(Nodeptr y, const bertini::mpq_rational& x)
|
|
{ return x+y; }
|
|
|
|
|
|
static Nodeptr raddNodeInt(Nodeptr y, const int & x)
|
|
{
|
|
return x+y;
|
|
}
|
|
|
|
Nodeptr(*addNodeInt)(Nodeptr, int) = &(operator+);
|
|
static Nodeptr iaddNodeNode(Nodeptr lhs, const Nodeptr & rhs)
|
|
{
|
|
return lhs += rhs;
|
|
}
|
|
// static Nodeptr iaddNodeDouble(Nodeptr lhs, double rhs)
|
|
// {
|
|
// return lhs += rhs;
|
|
// }
|
|
static SumOperator iaddSumNode(SumOperator lhs, const Nodeptr & rhs)
|
|
{
|
|
return lhs += rhs;
|
|
}
|
|
|
|
// Subtraction operators
|
|
Nodeptr(*subNodeNode)(Nodeptr, const Nodeptr&) = &(operator-);
|
|
Nodeptr(*subNodeMpfr)(Nodeptr, mpfr_complex) = &(operator-);
|
|
Nodeptr(*subNodeInt)(Nodeptr, int) = &(operator-);
|
|
static Nodeptr isubNodeNode(Nodeptr lhs, const Nodeptr & rhs)
|
|
{
|
|
return lhs -= rhs;
|
|
}
|
|
|
|
static SumOperator isubSumNode(SumOperator lhs, const Nodeptr & rhs)
|
|
{
|
|
return lhs -= rhs;
|
|
}
|
|
|
|
|
|
static Nodeptr rsubNodeMpfr(Nodeptr y, const mpfr_complex & x)
|
|
{
|
|
return x-y;
|
|
}
|
|
|
|
Nodeptr(*subNodeRat)(Nodeptr, const bertini::mpq_rational&) = &(operator-);
|
|
static Nodeptr rsubNodeRat(Nodeptr y, const bertini::mpq_rational& x)
|
|
{ return x-y; }
|
|
|
|
static Nodeptr rsubNodeInt(Nodeptr y, const int & x)
|
|
{
|
|
return x-y;
|
|
}
|
|
|
|
// Negate operator
|
|
Nodeptr(*negNode)(const Nodeptr &) = &(operator-);
|
|
|
|
|
|
|
|
|
|
// Multiplication operators
|
|
Nodeptr(*multNodeNode)(Nodeptr, const Nodeptr&) = &(operator*);
|
|
Nodeptr(*multNodeMpfr)(Nodeptr, mpfr_complex) = &(operator*);
|
|
Nodeptr(*multNodeRat)(Nodeptr, const mpq_rational&) = &(operator*);
|
|
Nodeptr(*multNodeInt)(Nodeptr, int) = &(operator*);
|
|
static Nodeptr imultNodeNode(Nodeptr lhs, const Nodeptr & rhs)
|
|
{
|
|
return lhs *= rhs;
|
|
}
|
|
|
|
Nodeptr(*imultMultNode)(std::shared_ptr<node::MultOperator> &, const Nodeptr &) = &(operator*=);
|
|
|
|
|
|
static Nodeptr rmultNodeMpfr(Nodeptr y, const mpfr_complex & x)
|
|
{
|
|
return x*y;
|
|
}
|
|
|
|
static Nodeptr rmultNodeRat(Nodeptr y, const mpq_rational & x)
|
|
{
|
|
return x*y;
|
|
}
|
|
|
|
static Nodeptr rmultNodeInt(Nodeptr y, const int & x)
|
|
{
|
|
return x*y;
|
|
}
|
|
|
|
|
|
|
|
|
|
// Division operators
|
|
Nodeptr(*divNodeNode)(Nodeptr, const Nodeptr&) = &(operator/);
|
|
Nodeptr(*divNodeRat)(Nodeptr, const mpq_rational&) = &(operator/);
|
|
Nodeptr(*divNodeMpfr)(Nodeptr, mpfr_complex) = &(operator/);
|
|
Nodeptr(*divNodeInt)(Nodeptr, int) = &(operator/);
|
|
static Nodeptr idivNodeNode(Nodeptr lhs, const Nodeptr & rhs)
|
|
{
|
|
return lhs /= rhs;
|
|
}
|
|
|
|
Nodeptr(*idivMultNode)(std::shared_ptr<node::MultOperator> &, const Nodeptr &) = &(operator/=);
|
|
|
|
|
|
static Nodeptr rdivNodeMpfr(Nodeptr y, const mpfr_complex & x)
|
|
{
|
|
return x/y;
|
|
}
|
|
|
|
static Nodeptr rdivNodeRat(Nodeptr y, const mpq_rational & x)
|
|
{
|
|
return x/y;
|
|
}
|
|
|
|
static Nodeptr rdivNodeInt(Nodeptr y, const int & x)
|
|
{
|
|
return x/y;
|
|
}
|
|
|
|
|
|
|
|
// Power operators
|
|
Nodeptr(*powNodeNode)(const Nodeptr &, const Nodeptr&) = &pow;
|
|
Nodeptr(*powNodeMpfr)(const Nodeptr&, mpfr_complex) = &pow;
|
|
Nodeptr(*powNodeRat)(const Nodeptr&, const mpq_rational&) = &pow;
|
|
Nodeptr(*powNodeInt)( Nodeptr const&, int) = &pow;
|
|
|
|
// Transcendental operators
|
|
Nodeptr(*expNodeNode)(const Nodeptr &) = &exp;
|
|
Nodeptr(*logNodeNode)(const Nodeptr &) = &log;
|
|
Nodeptr(*sinNodeNode)(const Nodeptr &) = &sin;
|
|
Nodeptr(*asinNodeNode)(const Nodeptr &) = &asin;
|
|
Nodeptr(*cosNodeNode)(const Nodeptr &) = &cos;
|
|
Nodeptr(*acosNodeNode)(const Nodeptr &) = &acos;
|
|
Nodeptr(*tanNodeNode)(const Nodeptr &) = &tan;
|
|
Nodeptr(*atanNodeNode)(const Nodeptr &) = &atan;
|
|
|
|
|
|
};
|
|
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#endif
|