A node class that for the vertices of model. Connected with eachother using Edge. More...

#include <node.h>

Collaboration diagram for Markov::Node< storageType >:

Public Member Functions
	Node ()
	Default constructor. Creates an empty Node. More...

	Node (storageType _value)
	Constructor. Creates a Node with no edges and with given NodeValue. More...

Edge< storageType > *	Link (Node< storageType > *)
	Link this node with another, with this node as its source. More...

Edge< storageType > *	Link (Edge< storageType > *)
	Link this node with another, with this node as its source. More...

Node< storageType > *	RandomNext (Markov::Random::RandomEngine *randomEngine)
	Chose a random node from the list of edges, with regards to its EdgeWeight, and TraverseNode to that. More...

bool	UpdateEdges (Edge< storageType > *)
	Insert a new edge to the this.edges. More...

Edge< storageType > *	FindEdge (storageType repr)
	Find an edge with its character representation. More...

Edge< storageType > *	FindEdge (Node< storageType > *target)
	Find an edge with its pointer. Avoid unless neccessary because comptutational cost of find by character is cheaper (because of std::map) More...

unsigned char	NodeValue ()
	Return character representation of this node. More...

void	UpdateTotalVerticeWeight (long int offset)
	Change total weights with offset. More...

std::map< storageType, Edge< storageType > * > *	Edges ()
	return edges More...

long int	TotalEdgeWeights ()
	return total edge weights More...

Public Attributes
std::vector< Edge< storageType > * >	edgesV

Private Attributes
storageType	_value
	Character representation of this node. 0 for starter, 0xff for terminator. More...

long int	total_edge_weights
	Total weights of the vertices, required by RandomNext. More...

std::map< storageType, Edge< storageType > * >	edges
	A map of all edges connected to this node, where this node is at the LeftNode. Map is indexed by unsigned char, which is the character representation of the node. More...

Detailed Description

template<typename storageType>
class Markov::Node< storageType >

A node class that for the vertices of model. Connected with eachother using Edge.

This class will later be templated to accept other data types than char*.

Definition at line 24 of file node.h.

Constructor & Destructor Documentation

◆ Node() [1/2]

template<typename storageType >

Markov::Node< storageType >::Node

Default constructor. Creates an empty Node.

Definition at line 209 of file node.h.

                               {
     this->_value = 0;
     this->total_edge_weights = 0L;
 };

◆ Node() [2/2]

template<typename storageType >

Markov::Node< storageType >::Node ( storageType _value )

Constructor. Creates a Node with no edges and with given NodeValue.

Parameters

_value - Nodes character representation.

Example Use: Construct nodes

Markov::Node<unsigned char>* LeftNode = new Markov::Node<unsigned char>('l');

Markov::Node<unsigned char>* RightNode = new Markov::Node<unsigned char>('r');

Markov::Node

A node class that for the vertices of model. Connected with eachother using Edge.

Definition: node.h:24

Definition at line 203 of file node.h.

                                                 {
     this->_value = _value;
     this->total_edge_weights = 0L;
 };

Member Function Documentation

◆ Edges()

template<typename storageType >

std::map< storageType, Markov::Edge< storageType > * > * Markov::Node< storageType >::Edges

inline

return edges

Definition at line 272 of file node.h.

                                                                                      {
     return &(this->edges);
 }

Referenced by Markov::API::MarkovPasswords::Buff().

Here is the caller graph for this function:

◆ FindEdge() [1/2]

template<typename storageType >

Edge<storageType>* Markov::Node< storageType >::FindEdge ( Node< storageType > * target )

Find an edge with its pointer. Avoid unless neccessary because comptutational cost of find by character is cheaper (because of std::map)

Parameters

target - target node.

Returns: Edge that is connected between this node, and the target node.

◆ FindEdge() [2/2]

template<typename storageType >

Markov::Edge< storageType > * Markov::Node< storageType >::FindEdge ( storageType repr )

Find an edge with its character representation.

Parameters

repr	- character NodeValue of the target node.

Returns: Edge that is connected between this node, and the target node.

Example Use: Construct and update edges

Markov::Node<unsigned char>* src = new Markov::Node<unsigned char>('a');
Markov::Node<unsigned char>* target1 = new Markov::Node<unsigned char>('b');
Markov::Node<unsigned char>* target2 = new Markov::Node<unsigned char>('c');
Markov::Edge<unsigned char>* res = NULL;
src->Link(target1);
src->Link(target2);         
res = src->FindEdge('b');

Definition at line 260 of file node.h.

                                                                            {
     auto e = this->edges.find(repr);
     if (e == this->edges.end()) return NULL;
     return e->second;
 };

◆ Link() [1/2]

template<typename storageType >

Markov::Edge< storageType > * Markov::Node< storageType >::Link ( Markov::Edge< storageType > * v )

Link this node with another, with this node as its source.

DOES NOT create a new Edge.

Parameters

Edge	- Edge that will accept this node as its LeftNode.

Returns: the same edge as parameter target.

Example Use: Construct and link nodes

Markov::Node<unsigned char>* LeftNode = new Markov::Node<unsigned char>('l');
Markov::Node<unsigned char>* RightNode = new Markov::Node<unsigned char>('r');
Markov::Edge<unsigned char>* e = LeftNode->Link(RightNode);
LeftNode->Link(e);

Definition at line 227 of file node.h.

                                                                                  {
     v->SetLeftEdge(this);
     this->UpdateEdges(v);
     return v;
 }

◆ Link() [2/2]

template<typename storageType >

Markov::Edge< storageType > * Markov::Node< storageType >::Link ( Markov::Node< storageType > * n )

Link this node with another, with this node as its source.

Creates a new Edge.

Parameters

target - Target node which will be the RightNode() of new edge.

Returns: A new node with LeftNode as this, and RightNode as parameter target.

Example Use: Construct nodes

Markov::Node<unsigned char>* LeftNode = new Markov::Node<unsigned char>('l');
Markov::Node<unsigned char>* RightNode = new Markov::Node<unsigned char>('r');
Markov::Edge<unsigned char>* e = LeftNode->Link(RightNode);

Definition at line 220 of file node.h.

                                                                                  {
     Markov::Edge<storageType>* v = new Markov::Edge<storageType>(this, n);
     this->UpdateEdges(v);
     return v;
 }

◆ NodeValue()

template<typename storageType >

unsigned char Markov::Node< storageType >::NodeValue

inline

Return character representation of this node.

Returns: character representation at _value.

Definition at line 215 of file node.h.

                                                         {
     return _value;
 }

References Markov::Node< storageType >::_value.

Referenced by Markov::API::ModelMatrix::ConstructMatrix().

Here is the caller graph for this function:

◆ RandomNext()

template<typename storageType >

Markov::Node< storageType > * Markov::Node< storageType >::RandomNext ( Markov::Random::RandomEngine * randomEngine )

Chose a random node from the list of edges, with regards to its EdgeWeight, and TraverseNode to that.

This operation is done by generating a random number in range of 0-this.total_edge_weights, and then iterating over the list of edges. At each step, EdgeWeight of the edge is subtracted from the random number, and once it is 0, next node is selected.

Returns: Node that was chosen at EdgeWeight biased random.

Example Use: Use randomNext to do a random walk on the model

char* buffer[64];
Markov::Model<char> model;
model.Import("model.mdl");
   Markov::Node<char>* n = model.starterNode;
int len = 0;
Markov::Node<char>* temp_node;
while (true) {
   temp_node = n->RandomNext(randomEngine);
   if (len >= maxSetting) {
       break;
   }
   else if ((temp_node == NULL) && (len < minSetting)) {
       continue;
   }
 
   else if (temp_node == NULL){
       break;
   }
       
   n = temp_node;
 
   buffer[len++] = n->NodeValue();
}

Definition at line 234 of file node.h.

                                                                                                    {
  
     //get a random NodeValue in range of total_vertice_weight
     long int selection = randomEngine->random() % this->total_edge_weights;//distribution()(generator());// distribution(generator);
     //make absolute, no negative modulus values wanted
     //selection = (selection >= 0) ? selection : (selection + this->total_edge_weights);
     for(int i=0;i<this->edgesV.size();i++){
         selection -= this->edgesV[i]->EdgeWeight();
         if (selection < 0) return this->edgesV[i]->TraverseNode();
     }
  
     //if this assertion is reached, it means there is an implementation error above
     std::cout << "This should never be reached (node failed to walk to next)\n"; //cant assert from child thread
     assert(true && "This should never be reached (node failed to walk to next)");
     return NULL;
 }

References Markov::Random::RandomEngine::random().

Here is the call graph for this function:

◆ TotalEdgeWeights()

template<typename storageType >

long int Markov::Node< storageType >::TotalEdgeWeights

inline

return total edge weights

Definition at line 277 of file node.h.

                                                           {
     return this->total_edge_weights;
 }

Referenced by Markov::API::ModelMatrix::ConstructMatrix().

Here is the caller graph for this function:

◆ UpdateEdges()

template<typename storageType >

bool Markov::Node< storageType >::UpdateEdges ( Markov::Edge< storageType > * v )

Insert a new edge to the this.edges.

Parameters

edge	- New edge that will be inserted.

Returns: true if insertion was successful, false if it fails.

Example Use: Construct and update edges

Markov::Node<unsigned char>* src = new Markov::Node<unsigned char>('a');
Markov::Node<unsigned char>* target1 = new Markov::Node<unsigned char>('b');
Markov::Node<unsigned char>* target2 = new Markov::Node<unsigned char>('c');
Markov::Edge<unsigned char>* e1 = new Markov::Edge<unsigned char>(src, target1);
Markov::Edge<unsigned char>* e2 = new Markov::Edge<unsigned char>(src, target2);
e1->AdjustEdge(25);
src->UpdateEdges(e1);
e2->AdjustEdge(30);
src->UpdateEdges(e2);

Definition at line 252 of file node.h.

                                                                     {
     this->edges.insert({ v->RightNode()->NodeValue(), v });
     this->edgesV.push_back(v);
     //this->total_edge_weights += v->EdgeWeight();
     return v->TraverseNode();
 }

◆ UpdateTotalVerticeWeight()

template<typename storageType >

void Markov::Node< storageType >::UpdateTotalVerticeWeight ( long int offset )

Change total weights with offset.

Parameters

offset to adjust the vertice weight with

Definition at line 267 of file node.h.

                                                                       {
     this->total_edge_weights += offset;
 }

Member Data Documentation

◆ _value

template<typename storageType >

storageType Markov::Node< storageType >::_value

private

Character representation of this node. 0 for starter, 0xff for terminator.

Definition at line 179 of file node.h.

Referenced by Markov::Node< storageType >::NodeValue().

◆ edges

template<typename storageType >

std::map<storageType, Edge<storageType>*> Markov::Node< storageType >::edges

private

A map of all edges connected to this node, where this node is at the LeftNode. Map is indexed by unsigned char, which is the character representation of the node.

Definition at line 190 of file node.h.

◆ edgesV

template<typename storageType >

std::vector<Edge<storageType>*> Markov::Node< storageType >::edgesV

Definition at line 173 of file node.h.

◆ total_edge_weights

template<typename storageType >

long int Markov::Node< storageType >::total_edge_weights

private

Total weights of the vertices, required by RandomNext.

Definition at line 184 of file node.h.

The documentation for this class was generated from the following files:

Markopy/MarkovModel/src/model.h
Markopy/MarkovModel/src/node.h

Public Member Functions

Public Attributes

Private Attributes

Detailed Description

template<typename storageType> class Markov::Node< storageType >

Constructor & Destructor Documentation

◆ Node() [1/2]

◆ Node() [2/2]

Member Function Documentation

◆ Edges()

◆ FindEdge() [1/2]

◆ FindEdge() [2/2]

◆ Link() [1/2]

◆ Link() [2/2]

◆ NodeValue()

◆ RandomNext()

◆ TotalEdgeWeights()

◆ UpdateEdges()

◆ UpdateTotalVerticeWeight()

Member Data Documentation

◆ _value

◆ edges

◆ edgesV

◆ total_edge_weights

template<typename storageType>
class Markov::Node< storageType >