Исследование вершинной и рёберной связностей графов мобильных сетей при различных стратегиях перемещения узлов (стр. 4 )

  rib_rel_status = find_rib_relations(head_graph);

  if (rib_rel_status < 0)

  { rib_coherence. push_back(0); }

  else

  { rib_coherence. push_back(rib_rel_status); }

  node_rel_status = find_node_relations(head_graph);

  if (node_rel_status < 0)

  { node_coherence. push_back(0); }

  else

  { node_coherence. push_back(node_rel_status); }

  }

  else{

  coherence_probability[coh_prob_id] = coherence_probability[coh_prob_id]

  + check_relations(head_graph);

  number_of_ribs[nor_id] = number_of_ribs[nor_id] + head_graph->number_of_arcs;

  number_of_nodes[non_id] = number_of_nodes[non_id] + head_graph->number_of_nodes;

  rib_rel_status = find_rib_relations(head_graph);

  if (rib_rel_status > 0)

  rib_coherence[rib_coh_id] = rib_coherence[rib_coh_id] + rib_rel_status;

  node_rel_status = find_node_relations(head_graph);

  if (node_rel_status > 0)

  node_coherence[rib_coh_id] = node_coherence[rib_coh_id] + node_rel_status;

  }

  coh_prob_id ++;

  nor_id ++;

  non_id ++;

  rib_coh_id ++;

  node_coh_id ++;

  t = t + delta_t;

  }

  delete_graph(head_graph);

  }

  for (int i = 0; i < coherence_probability. size(); i++){

  cout << "Coherence probability for t = " << i << " is: " << coherence_probability[i]/cycle_id << endl;

  }

  for (int i = 0; i < number_of_ribs. size(); i++){

  cout << "Average number of ribs for t = " << i << " is: " << number_of_ribs[i]/cycle_id << endl;

  }

  for (int i = 0; i < number_of_nodes. size(); i++){

  cout << "Number of nodes for t = " << i << " is: " << number_of_nodes[i]/cycle_id << endl;

  }

  for (int i = 0; i < rib_coherence. size(); i++){

  cout << "Average rib rel status for t = " << i << " is: " << rib_coherence[i]/cycle_id << endl;

  }

  for (int i = 0; i < node_coherence. size(); i++){

  cout << "Average node rel status for t = " << i << " is: " << node_coherence[i]/cycle_id << endl;

  }

  cout << " * Graph analysis finished..." << endl;

  cout << "Goodbay!" << endl;

  return 0;

}

//Описание структур, представленных в программе

#ifndef STRUCTS_DESCRIPTION_H

#define        STRUCTS_DESCRIPTION_H

#define NAMELENGTH 128

typedef struct _graph graph;

typedef struct _node node;

typedef struct _input input;

typedef struct _output output;

typedef struct _aux_elem_arc aux_elem_arc;

typedef struct _arc arc;

typedef struct _aux_elem_input aux_elem_input;

typedef struct _aux_elem_output aux_elem_output;

typedef struct _array_of_characteristics array_of_characteristics;

typedef struct _list_of_characteristics list_of_characteristics;

double changer_x, changer_y;

double delta = 0.2;

//Вспомогательный элемент дуги

struct _aux_elem_arc {

  struct _aux_elem_arc *next;

  arc *arc_pointer;

};

//Вспомогательный элемент входа

struct _aux_elem_input {

  struct _aux_elem_input *next;

  input *input_pointer;

};

//Вспомогательный элемент выхода

struct _aux_elem_output {

  struct _aux_elem_output *next;

  output *output_pointer;

};

//Дескриптор дуги

struct _arc {

  int mark;

  struct _arc *prev;

  struct _arc *next;

  int uid;

  char name[NAMELENGTH];

  //char long_name[9];

  //char type[9];

  int arn;

  int number_of_outputs;

  aux_elem_output *aux_elem_output_pointer;

  int number_of_inputs;

  aux_elem_input *aux_elem_input_pointer;

};

//Дескриптор выхода

struct _output {

  int mark;

  struct _output *prev;

  struct _output *next;

  int uid; //int

  char name[NAMELENGTH];

  //char long_name[9];

  //char type[9];

  int number_of_incidence_arcs;

  aux_elem_arc *aux_elem_pointer;

  int link_with_process;

  node *node_pointer;

};

//Дескриптор входа

struct _input {

  int mark;

  struct _input *prev;

  struct _input *next;

  int uid;

  char name[NAMELENGTH];

  //char long_name[9];

  //char type[9];

  int number_of_incidence_arcs;

  aux_elem_arc *aux_elem_pointer;

  int link_with_process;

  node *node_pointer;

};

//Дескриптор вершины

struct _node {

  int mark;

  struct _node *prev;

  struct _node *next;

  struct _node *prevv;

  struct _node *nextt;

  int uid;

  char name[NAMELENGTH];

  graph *graph_pointer;

  int number_of_inputs;

  input *input_pointer;

  int number_of_outputs;

  output *output_pointer;

  int link_with_process;

  /*double x;

  double y;

  */

  float x_cur;

  float y_cur;

  float speed; // Длина вектора скорости

  float speed_x; // Его координаты

  float speed_y;

  float radius;

  float rads; // Радианная мера угла

  float grad; // Градусная мера угла

};

//Дескриптор графа

struct _graph {

  int mark;

  struct _graph *prev;

  struct _graph *next;

  int uid;

  char name[NAMELENGTH];

  //char long_name[NAMELENGTH];

  //char type[NAMELENGTH];

  int arn;

  float live_radius; // Для генерации графа.

  int number_of_nodes;

  node *node_pointer;

  int number_of_arcs;

  arc *arc_pointer;

};

#endif        /* STRUCTS_DESCRIPTION_H */

//walk_through

#ifndef WALK_THROUGH_H

#define        WALK_THROUGH_H

#include "structs_description. h"

void walk(graph *g) {

  graph *head_graph, *current_graph;

  node *head_node, *current_node;

  arc *head_arc, *current_arc;

  input *head_input, *current_input;

  output *head_output, *current_output;

  aux_elem_arc *head_aux_elem_arc_out, *head_aux_elem_arc_inp, *current_aux_elem_arc_out, *current_aux_elem_arc_inp;

  head_graph = g;

  head_node = head_graph->node_pointer;

  head_arc = head_graph->arc_pointer;

  if (head_node){

  head_input = head_node->input_pointer;

  head_output = head_node->output_pointer;

  }

  else{

  head_input = NULL;

  head_output = NULL;

  }

  if (head_output == NULL)

  head_aux_elem_arc_out = NULL;

  else

  head_aux_elem_arc_out = head_output->aux_elem_pointer;

  if (head_input == NULL)

  head_aux_elem_arc_inp = NULL;

  else

  head_aux_elem_arc_inp = head_input->aux_elem_pointer;

  current_graph = head_graph;

  current_node = head_node;

  current_arc = head_arc;

  current_input = head_input;

  current_output = head_output;

  current_aux_elem_arc_out = head_aux_elem_arc_out;

  current_aux_elem_arc_inp = head_aux_elem_arc_inp;

  cout << " ======= Walking on graph ======= " << endl;

  while (current_graph!= NULL) {

  printf("Общее число узлов графа: %d.\n", current_graph->number_of_nodes);

  printf("Общее число дуг графа: %d.\n", current_graph->number_of_arcs);

  while (current_node!= NULL) {

  printf(" * Координаты узла %s x = %f; y = %f.\n",

  current_node->name, current_node->x_cur, current_node->y_cur);

  printf("  ** Характеристики %s speed = %f; speed_x = %f; speed_y = %f.\n",

  current_node->name, current_node->speed, current_node->speed_x, current_node->speed_y);

  current_output = current_node->output_pointer;

  current_input = current_node->input_pointer;

  if (current_input!= NULL)

  current_aux_elem_arc_inp = current_input->aux_elem_pointer;

  if (current_output!= NULL)

  current_aux_elem_arc_out = current_output->aux_elem_pointer;

  //printf(" * Число входов узла %s: %d.\n", current_node->name, current_node->number_of_inputs);

  while (current_input!= NULL) {

  if (current_node->number_of_inputs!= 0) {

  if (current_graph->number_of_arcs!= 0) {

  printf(" ** Во вход %s входит дуга(и): ", current_input->name);

  while (current_aux_elem_arc_inp!= NULL) {

  printf("%s ", current_aux_elem_arc_inp->arc_pointer->name);

  current_aux_elem_arc_inp = current_aux_elem_arc_inp->next;

  }

  printf("\n");

  }

  }

  current_input = current_input->next;

  if (current_input!= NULL)

  current_aux_elem_arc_inp = current_input->aux_elem_pointer;

  }

  //printf("Число выходов узла %s: %d.\n", current_node->name, current_node->number_of_outputs);

  while (current_output!= NULL) {

  if (current_node->number_of_outputs!= 0) {

  if (current_graph->number_of_arcs!= 0) {

  printf(" ** Из выхода %s выходит дуга(и): ", current_output->name);

  while (current_aux_elem_arc_out!= NULL) {

  printf("%s ", current_aux_elem_arc_out->arc_pointer->name);

  current_aux_elem_arc_out = current_aux_elem_arc_out->next;

  }

  printf("\n");

  }

  }

  current_output = current_output->next;

  if (current_output!= NULL)

  current_aux_elem_arc_out = current_output->aux_elem_pointer;

  }

  current_node = current_node->next;

  }

  printf(" * Вывод информации о дугах \n");