block.hpp

Go to the documentation of this file.

//This file is part of Bertini 2.
//
//block.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.
//
//block.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 block.hpp.  If not, see <http://www.gnu.org/licenses/>.
//
// Copyright(C) 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.

 
#pragma once
 
#include <type_traits>
#include <variant>
 
#include "bertini2/num_traits.hpp"
#include "bertini2/eigen_extensions.hpp"
 
#include "bertini2/system/blocks/polynomial_block.hpp"
#include "bertini2/system/blocks/products_of_linears_block.hpp"
#include "bertini2/system/blocks/linear_forms_block.hpp"
#include "bertini2/system/blocks/blend_block.hpp"
#include "bertini2/system/blocks/randomization_block.hpp"
 
namespace bertini {
namespace blocks {

template <typename, typename = void>
struct is_block : std::false_type {};
 
template <typename B>
struct is_block<B, std::void_t<
    decltype(std::declval<const B&>().NumFunctions()),
    decltype(std::declval<const B&>().DependsOnPathVariable()),
    decltype(std::declval<const B&>().Precision()),
    decltype(std::declval<const B&>().Precision(0u)),                 // the precision setter
    decltype(std::declval<const B&>().Degrees()),
    decltype(std::declval<const B&>().Degrees(std::declval<VariableGroup const&>())),
    decltype(std::declval<const B&>().IsHomogeneous(std::declval<VariableGroup const&>())),
    decltype(std::declval<const B&>().IsPolynomial(std::declval<VariableGroup const&>())),
    // Homogenize mutates (e.g. LinearFormsBlock folds its constant column onto the hom var), so
    // it is detected on a non-const B&.
    decltype(std::declval<B&>().Homogenize(
        std::declval<VariableGroup const&>(), std::declval<std::shared_ptr<node::Variable> const&>())),
    decltype(std::declval<const B&>().template EvalInPlace<complex_dbl>(
        std::declval<Eigen::Ref<Vec<complex_dbl>>>(), std::declval<Vec<complex_dbl> const&>(), std::declval<complex_dbl const&>())),
    decltype(std::declval<const B&>().template JacobianInPlace<complex_dbl>(
        std::declval<Eigen::Ref<Mat<complex_dbl>>>(), std::declval<Vec<complex_dbl> const&>(), std::declval<complex_dbl const&>())),
    decltype(std::declval<const B&>().template TimeDerivInPlace<complex_dbl>(
        std::declval<Eigen::Ref<Vec<complex_dbl>>>(), std::declval<Vec<complex_dbl> const&>(), std::declval<complex_dbl const&>()))
>> : std::true_type {};

template <typename B>
inline constexpr bool is_block_v = is_block<B>::value;
 
// As blocks are added, extend this static_assert list (and, later, the Block variant).
static_assert(is_block_v<PolynomialBlock>,
              "PolynomialBlock must satisfy the evaluation-block contract");
static_assert(is_block_v<ProductsOfLinearsBlock>,
              "ProductsOfLinearsBlock must satisfy the evaluation-block contract");
static_assert(is_block_v<LinearFormsBlock>,
              "LinearFormsBlock must satisfy the evaluation-block contract");
 
} // namespace blocks
 
// Forward declaration: BlendBlock and RandomizationBlock hold their operands by
// shared_ptr<System>, and a System contains Blocks -- the template parameter keeps System a
// dependent name so the recursive type closes without System being complete here.  (For the
// same reason these two block types are absent from the is_block_v static_assert list above:
// detecting the contract instantiates their templated eval entry points, which need System
// complete; that check happens structurally at the std::visit site instead.)
class System;

using Block = std::variant<blocks::PolynomialBlock, blocks::ProductsOfLinearsBlock, blocks::LinearFormsBlock, blocks::BlendBlock<System>, blocks::RandomizationBlock<System>>;
 
} // namespace bertini