blend_block.hpp File Reference

A System evaluation block that linearly combines whole Systems with t-coefficients. More...

#include <vector>
#include <memory>
#include <cassert>
#include <boost/serialization/vector.hpp>
#include <boost/serialization/shared_ptr.hpp>
#include <boost/serialization/split_member.hpp>
#include "bertini2/num_traits.hpp"
#include "bertini2/eigen_extensions.hpp"
#include "bertini2/function_tree.hpp"
#include "bertini2/function_tree/reintern.hpp"
#include "bertini2/system/blocks/describe.hpp"

Include dependency graph for blend_block.hpp:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
class	bertini::blocks::BlendBlock< SystemT >
	A block forming the blend (coupling homotopy) H = sum_i c_i(t) * operand_i of several systems. More...

Namespaces
namespace	bertini
namespace	bertini::blocks

Detailed Description

A System evaluation block that linearly combines whole Systems with t-coefficients.

This is how a coupled / start-target homotopy is represented inside the block-composed System: a blend

H(x,t) = sum_i  c_i(t) * f_i(x)

of operand Systems f_i (e.g. an SLP polynomial target and a products-of-linears MHom start) weighted by coefficient functions c_i(t) that are ordinary function-tree nodes in the path variable t – so (1-t), gamma*t, and later t^lifting all work, and the time-derivative is exact via Node::Differentiate(t):

dH/dt = sum_i c_i'(t) * f_i(x)

(the operand Systems are autonomous in t, so df_i/dt = 0). The Jacobian is sum_i c_i(t) * (df_i/dx).

Only the operands' NATURAL functions are blended; the homotopy System that owns this block carries the (shared) patch, appended once after the block – so patches are not double-counted or scaled.

Templated on the system type so that System can remain a forward declaration in the Block variant (a System contains a Block which contains a BlendBlock<System> which holds shared_ptr<const System> – the template parameter makes System a dependent name, so its member functions are only required complete at instantiation, breaking the cycle). Operands are held by shared_ptr, never by value, for the same reason.

Note

Evaluating a coefficient node sets the shared path-variable node's value (mutable node state); per-thread tracking must Clone the homotopy, as it already must for Systems. The operand Systems are shared_ptr<const System>; deep-cloning them per thread is a follow-up (block-operand Clone semantics).