# net::node

存储了网络中一个格点内的信息 More...

#include <node.hpp>

# Public Types

	Name
using half_edge< NodeVal, EdgeVal, NodeKey, EdgeKey, Trait >	EdgeType
using NodeKey	NodeKeyType
using NodeVal	NodeValType
using EdgeKey	EdgeKeyType
using EdgeVal	EdgeValType
using Trait	TraitType

# Public Functions

	Name
	node() =default
	node(const NodeKey & k)
	node(const NodeKey & k, const NodeVal & s)
	node(const node< NodeVal, EdgeVal, NodeKey, EdgeKey, Trait > & ) =default
node< NodeVal, EdgeVal, NodeKey, EdgeKey, Trait > &	operator=(const node< NodeVal, EdgeVal, NodeKey, EdgeKey, Trait > & ) =default
	node(node< NodeVal, EdgeVal, NodeKey, EdgeKey, Trait > && ) =default
node< NodeVal, EdgeVal, NodeKey, EdgeKey, Trait > &	operator=(node< NodeVal, EdgeVal, NodeKey, EdgeKey, Trait > && ) =default
half_edge< NodeVal, EdgeVal, NodeKey, EdgeKey, Trait >::EdgeItrType	add_half_edge(const EdgeKey & ind1, const EdgeVal & edgev) 添加一条半边
void	clean()
template <typename Condition > void	delete_half_edge(Condition && cond) 根据条件cond(edge_itr)是否为真，决定是否删除一条半边
template <typename Condition > void	break_edge(Condition && cond) 根据条件cond(edge_itr)是否为真，决定是否将一条边拆开，成为两条不相连的半边
template <typename Condition > void	delete_edge(Condition && cond) 根据条件cond(edge_itr)是否为真，决定是否删除一条半边，同时删除与其相连的半边
void	delete_nbedge() 根据条件cond(edge_itr)是否为真，决定是否删除半边所连接的另一条半边
void	reset_nbkey_of_nb(const NodeKey & newkey) 对格点的每一条边，更新邻居对应的边的nbkey为newkey。用于格点的改名。
template <typename absorb_type ,typename contract_type > void	absorb_nb(const NodeKey & nbkey, const NodeVal & nbval, const absorb_type & absorb_fun, const contract_type & contract_fun) 对格点的指定nbkey每一条边，记录这条边的(ind,nbind)，吸收边的val到格点的val，然后删掉这条边。
template <typename absorb_type ,typename Condition > void	harmless_absorb_nb(NodeVal & thisval, std::set< std::pair< EdgeKey, EdgeKey >, typename Trait::edge2key_less > & ind_pairs, const absorb_type & absorb_fun, Condition && cond) const 对格点的指定nbkey每一条边，如果符合条件，记录这条边的(ind,nbind)，吸收边的val到给定的的val，将ind-pair填入ind_pairs
void	transfer_edge(const typename network< NodeVal, EdgeVal, NodeKey, EdgeKey, Trait >::IterNode & newit) 对格点的每一条边，将它转移为格点newit的边
template <typename Condition > void	transfer_edge(const typename network< NodeVal, EdgeVal, NodeKey, EdgeKey, Trait >::IterNode & newit, Condition && cond) 对格点的每一条边，如果条件成立，将它和邻居的这条边转移为格点newit和邻居的边
template <typename Condition > void	transfer_edge(const typename network< NodeVal, EdgeVal, NodeKey, EdgeKey, Trait >::IterNode & newit, const typename network< NodeVal, EdgeVal, NodeKey, EdgeKey, Trait >::IterNode & newit2, Condition && cond) 对格点的每一条边，如果条件成立，将它和邻居的这条边转移为格点newit和邻居的边; 否则，将它和邻居的这条边转移为格点newit2和邻居的边
void	relink(std::map< NodeKey, node< NodeVal, EdgeVal, NodeKey, EdgeKey, Trait >, typename Trait::nodekey_less > & nodes) 更新所有半边的nbitr和nbegitr指针
bool	consistency(const std::map< NodeKey, node< NodeVal, EdgeVal, NodeKey, EdgeKey, Trait >, typename Trait::nodekey_less > & nodes, const NodeKey & t, std::ostream & diagnosis) const 检查格点的一致性
void	fope(std::function< NodeVal(const NodeVal &)> f1, std::function< EdgeVal(const EdgeVal &)> f2) 利用函数更新格点和边上的信息
template <typename NodeType2 > NodeType2	fmap(const NodeKey & this_key, std::function< typename NodeType2::NodeValType(const NodeVal &)> f1, std::function< typename NodeType2::EdgeValType(const EdgeVal &)> f2) const 从旧的格点得到新的格点，其格点和边上的信息由旧的格点通过映射得到
template <typename NodeType2 > NodeType2	fmap(const NodeKey & new_key, std::function< typename NodeType2::NodeValType(const NodeVal &)> f1, std::function< typename NodeType2::EdgeValType(const EdgeVal &)> f2, std::function< typename NodeType2::NodeKeyType(const NodeKey &)> f3, std::function< typename NodeType2::EdgeKeyType(const EdgeKey &)> f4) const 从旧的格点得到新的格点，其格点和边的名字，以及格点和边上的信息，由旧的格点通过映射得到
template <typename NodeVal2 ,typename EdgeVal2 ,typename Trait2 > node< NodeVal2, EdgeVal2, NodeKey, EdgeKey, Trait2 >	gfmap(const NodeKey & this_key, std::function< NodeVal2(const node< NodeVal, EdgeVal, NodeKey, EdgeKey, Trait > &)> f1, std::function< EdgeVal2(const node< NodeVal, EdgeVal, NodeKey, EdgeKey, Trait > &, const EdgeKey &)> f2) const 从旧的格点得到新的格点，其格点和边上的信息由旧的格点通过映射得到
void	gfope(std::function< NodeVal(const node< NodeVal, EdgeVal, NodeKey, EdgeKey, Trait > &)> f1, std::function< EdgeVal(const node< NodeVal, EdgeVal, NodeKey, EdgeKey, Trait > &, const EdgeKey &)> f2) 利用函数更新格点和边上的信息

# Public Attributes

	Name
NodeKey	key 格点的名字
NodeVal	val 格点上附着的信息
std::map< EdgeKey, half_edge< NodeVal, EdgeVal, NodeKey, EdgeKey, Trait >, typename Trait::edgekey_less >	edges 格点所包含的半边, 存储了半边之间如何连接的信息

# Friends

	Name
std::ostream &	output_node_text(std::ostream & , const node< NodeVal1, EdgeVal1, NodeKey1, EdgeKey1, Trait1 > & ) 格点的字符串输出
std::istream &	input_node_text(std::istream & , node< NodeVal1, EdgeVal1, NodeKey1, EdgeKey1, Trait1 > & ) 格点的字符串输入
std::ostream &	output_node_bin(std::ostream & , const node< NodeVal1, EdgeVal1, NodeKey1, EdgeKey1, Trait1 > & ) 格点的二进制输出
std::istream &	input_node_bin(std::istream & , node< NodeVal1, EdgeVal1, NodeKey1, EdgeKey1, Trait1 > & ) 格点的二进制输入

# Detailed Description

template <typename NodeVal ,
typename EdgeVal ,
typename NodeKey ,
typename EdgeKey ,
typename Trait >
class net::node;

存储了网络中一个格点内的信息

Template Parameters:

NodeVal 每个格点中附着的信息类型
EdgeVal 每个边上附着的信息类型
NodeKey 格点名字的类型
EdgeKey 边的名字的类型
Trait 以上类型的特征，包括输入输出和比较

See:

每个格点中有一个中心元素val, 和一些半边每个边拥有一个名字和一个half edge对象

# Public Types Documentation

# using EdgeType

using net::node< NodeVal, EdgeVal, NodeKey, EdgeKey, Trait >::EdgeType =  half_edge<NodeVal, EdgeVal, NodeKey, EdgeKey, Trait>;

# using NodeKeyType

using net::node< NodeVal, EdgeVal, NodeKey, EdgeKey, Trait >::NodeKeyType =  NodeKey;

# using NodeValType

using net::node< NodeVal, EdgeVal, NodeKey, EdgeKey, Trait >::NodeValType =  NodeVal;

# using EdgeKeyType

using net::node< NodeVal, EdgeVal, NodeKey, EdgeKey, Trait >::EdgeKeyType =  EdgeKey;

# using EdgeValType

using net::node< NodeVal, EdgeVal, NodeKey, EdgeKey, Trait >::EdgeValType =  EdgeVal;

# using TraitType

using net::node< NodeVal, EdgeVal, NodeKey, EdgeKey, Trait >::TraitType =  Trait;

# Public Functions Documentation

# function node

node() =default

# function node

inline node(
    const NodeKey & k
)

# function node

inline node(
    const NodeKey & k,
    const NodeVal & s
)

# function node

node(
    const node< NodeVal, EdgeVal, NodeKey, EdgeKey, Trait > & 
) =default

# function operator=

node< NodeVal, EdgeVal, NodeKey, EdgeKey, Trait > & operator=(
    const node< NodeVal, EdgeVal, NodeKey, EdgeKey, Trait > & 
) =default

# function node

node(
    node< NodeVal, EdgeVal, NodeKey, EdgeKey, Trait > && 
) =default

# function operator=

node< NodeVal, EdgeVal, NodeKey, EdgeKey, Trait > & operator=(
    node< NodeVal, EdgeVal, NodeKey, EdgeKey, Trait > && 
) =default

# function add_half_edge

half_edge< NodeVal, EdgeVal, NodeKey, EdgeKey, Trait >::EdgeItrType add_half_edge(
    const EdgeKey & ind1,
    const EdgeVal & edgev
)

添加一条半边

# function clean

void clean()

# function delete_half_edge

template <typename Condition >
void delete_half_edge(
    Condition && cond
)

根据条件cond(edge_itr)是否为真，决定是否删除一条半边

如果要删除的半边连接着另一条半边，那么保留另一条半边，使之悬空

# function break_edge

template <typename Condition >
void break_edge(
    Condition && cond
)

根据条件cond(edge_itr)是否为真，决定是否将一条边拆开，成为两条不相连的半边

# function delete_edge

template <typename Condition >
void delete_edge(
    Condition && cond
)

根据条件cond(edge_itr)是否为真，决定是否删除一条半边，同时删除与其相连的半边

# function delete_nbedge

void delete_nbedge()

根据条件cond(edge_itr)是否为真，决定是否删除半边所连接的另一条半边

# function reset_nbkey_of_nb

void reset_nbkey_of_nb(
    const NodeKey & newkey
)

对格点的每一条边，更新邻居对应的边的nbkey为newkey。用于格点的改名。

# function absorb_nb

template <typename absorb_type ,
typename contract_type >
void absorb_nb(
    const NodeKey & nbkey,
    const NodeVal & nbval,
    const absorb_type & absorb_fun,
    const contract_type & contract_fun
)

对格点的指定nbkey每一条边，记录这条边的(ind,nbind)，吸收边的val到格点的val，然后删掉这条边。

A(this) <-—> B(nb) <-—> C => A <-— B <-—> C

# function harmless_absorb_nb

template <typename absorb_type ,
typename Condition >
void harmless_absorb_nb(
    NodeVal & thisval,
    std::set< std::pair< EdgeKey, EdgeKey >, typename Trait::edge2key_less > & ind_pairs,
    const absorb_type & absorb_fun,
    Condition && cond
) const

对格点的指定nbkey每一条边，如果符合条件，记录这条边的(ind,nbind)，吸收边的val到给定的的val，将ind-pair填入ind_pairs

# function transfer_edge

void transfer_edge(
    const typename network< NodeVal, EdgeVal, NodeKey, EdgeKey, Trait >::IterNode & newit
)

对格点的每一条边，将它转移为格点newit的边

# function transfer_edge

template <typename Condition >
void transfer_edge(
    const typename network< NodeVal, EdgeVal, NodeKey, EdgeKey, Trait >::IterNode & newit,
    Condition && cond
)

对格点的每一条边，如果条件成立，将它和邻居的这条边转移为格点newit和邻居的边

# function transfer_edge

template <typename Condition >
void transfer_edge(
    const typename network< NodeVal, EdgeVal, NodeKey, EdgeKey, Trait >::IterNode & newit,
    const typename network< NodeVal, EdgeVal, NodeKey, EdgeKey, Trait >::IterNode & newit2,
    Condition && cond
)

对格点的每一条边，如果条件成立，将它和邻居的这条边转移为格点newit和邻居的边; 否则，将它和邻居的这条边转移为格点newit2和邻居的边

# function relink

void relink(
    std::map< NodeKey, node< NodeVal, EdgeVal, NodeKey, EdgeKey, Trait >, typename Trait::nodekey_less > & nodes
)

更新所有半边的nbitr和nbegitr指针

# function consistency

bool consistency(
    const std::map< NodeKey, node< NodeVal, EdgeVal, NodeKey, EdgeKey, Trait >, typename Trait::nodekey_less > & nodes,
    const NodeKey & t,
    std::ostream & diagnosis
) const

检查格点的一致性

# function fope

void fope(
    std::function< NodeVal(const NodeVal &)> f1,
    std::function< EdgeVal(const EdgeVal &)> f2
)

利用函数更新格点和边上的信息

# function fmap

template <typename NodeType2 >
NodeType2 fmap(
    const NodeKey & this_key,
    std::function< typename NodeType2::NodeValType(const NodeVal &)> f1,
    std::function< typename NodeType2::EdgeValType(const EdgeVal &)> f2
) const

从旧的格点得到新的格点，其格点和边上的信息由旧的格点通过映射得到

# function fmap

template <typename NodeType2 >
NodeType2 fmap(
    const NodeKey & new_key,
    std::function< typename NodeType2::NodeValType(const NodeVal &)> f1,
    std::function< typename NodeType2::EdgeValType(const EdgeVal &)> f2,
    std::function< typename NodeType2::NodeKeyType(const NodeKey &)> f3,
    std::function< typename NodeType2::EdgeKeyType(const EdgeKey &)> f4
) const

从旧的格点得到新的格点，其格点和边的名字，以及格点和边上的信息，由旧的格点通过映射得到

# function gfmap

template <typename NodeVal2 ,
typename EdgeVal2 ,
typename Trait2 >
node< NodeVal2, EdgeVal2, NodeKey, EdgeKey, Trait2 > gfmap(
    const NodeKey & this_key,
    std::function< NodeVal2(const node< NodeVal, EdgeVal, NodeKey, EdgeKey, Trait > &)> f1,
    std::function< EdgeVal2(const node< NodeVal, EdgeVal, NodeKey, EdgeKey, Trait > &, const EdgeKey &)> f2
) const

从旧的格点得到新的格点，其格点和边上的信息由旧的格点通过映射得到

# function gfope

void gfope(
    std::function< NodeVal(const node< NodeVal, EdgeVal, NodeKey, EdgeKey, Trait > &)> f1,
    std::function< EdgeVal(const node< NodeVal, EdgeVal, NodeKey, EdgeKey, Trait > &, const EdgeKey &)> f2
)

利用函数更新格点和边上的信息

# Public Attributes Documentation

# variable key

NodeKey key;

格点的名字

# variable val

NodeVal val;

格点上附着的信息

# variable edges

std::map< EdgeKey, half_edge< NodeVal, EdgeVal, NodeKey, EdgeKey, Trait >, typename Trait::edgekey_less > edges;

格点所包含的半边, 存储了半边之间如何连接的信息

See: half_edge

# Friends

# friend output_node_text

friend std::ostream & output_node_text(
    std::ostream & ,
    const node< NodeVal1, EdgeVal1, NodeKey1, EdgeKey1, Trait1 > & 
);

格点的字符串输出

# friend input_node_text

friend std::istream & input_node_text(
    std::istream & ,
    node< NodeVal1, EdgeVal1, NodeKey1, EdgeKey1, Trait1 > & 
);

格点的字符串输入

# friend output_node_bin

friend std::ostream & output_node_bin(
    std::ostream & ,
    const node< NodeVal1, EdgeVal1, NodeKey1, EdgeKey1, Trait1 > & 
);

格点的二进制输出

# friend input_node_bin

friend std::istream & input_node_bin(
    std::istream & ,
    node< NodeVal1, EdgeVal1, NodeKey1, EdgeKey1, Trait1 > & 
);

格点的二进制输入

Updated on 15 June 2022 at 16:04:19 CST