partition stringclasses 3 values | func_name stringlengths 1 134 | docstring stringlengths 1 46.9k | path stringlengths 4 223 | original_string stringlengths 75 104k | code stringlengths 75 104k | docstring_tokens listlengths 1 1.97k | repo stringlengths 7 55 | language stringclasses 1 value | url stringlengths 87 315 | code_tokens listlengths 19 28.4k | sha stringlengths 40 40 |
|---|---|---|---|---|---|---|---|---|---|---|---|
valid | read_graph | !
@brief Read graph from file in GRPR format.
@param[in] filename (string): Path to file with graph in GRPR format.
@return (graph) Graph that is read from file. | pyclustering/utils/graph.py | def read_graph(filename):
"""!
@brief Read graph from file in GRPR format.
@param[in] filename (string): Path to file with graph in GRPR format.
@return (graph) Graph that is read from file.
"""
file = open(filename, 'r');
comments = "";
space_descr = [];
data = [];
data_type = None;
map_data_repr = dict(); # Used as a temporary buffer only when input graph is represented by edges.
for line in file:
if (line[0] == 'c' or line[0] == 'p'):
comments += line[1:];
elif (line[0] == 'r'):
node_coordinates = [float(val) for val in line[1:].split()];
if (len(node_coordinates) != 2):
raise NameError('Invalid format of space description for node (only 2-dimension space is supported)');
space_descr.append( [float(val) for val in line[1:].split()] );
elif (line[0] == 'm'):
if ( (data_type is not None) and (data_type != 'm') ):
raise NameError('Invalid format of graph representation (only one type should be used)');
data_type = 'm';
data.append( [float(val) for val in line[1:].split()] );
elif (line[0] == 'v'):
if ( (data_type is not None) and (data_type != 'v') ):
raise NameError('Invalid format of graph representation (only one type should be used)');
data_type = 'v';
data.append( [float(val) for val in line[1:].split()] );
elif (line[0] == 'e'):
if ( (data_type is not None) and (data_type != 'e') ):
raise NameError('Invalid format of graph representation (only one type should be used)');
data_type = 'e';
vertices = [int(val) for val in line[1:].split()];
if (vertices[0] not in map_data_repr):
map_data_repr[ vertices[0] ] = [ vertices[1] ];
else:
map_data_repr[ vertices[0] ].append(vertices[1])
if (vertices[1] not in map_data_repr):
map_data_repr[ vertices[1] ] = [ vertices[0] ];
else:
map_data_repr[ vertices[1] ].append(vertices[0]);
elif (len(line.strip()) == 0): continue;
else:
print(line);
raise NameError('Invalid format of file with graph description');
# In case of edge representation result should be copied.
if (data_type == 'e'):
for index in range(len(map_data_repr)):
data.append([0] * len(map_data_repr));
for index_neighbour in map_data_repr[index + 1]:
data[index][index_neighbour - 1] = 1;
file.close();
# Set graph description
graph_descr = None;
if (data_type == 'm'): graph_descr = type_graph_descr.GRAPH_MATRIX_DESCR;
elif (data_type == 'v'): graph_descr = type_graph_descr.GRAPH_VECTOR_DESCR;
elif (data_type == 'e'): graph_descr = type_graph_descr.GRAPH_MATRIX_DESCR;
else:
raise NameError('Invalid format of file with graph description');
if (space_descr != []):
if (len(data) != len(space_descr)):
raise NameError("Invalid format of file with graph - number of nodes is different in space representation and graph description");
return graph(data, graph_descr, space_descr, comments); | def read_graph(filename):
"""!
@brief Read graph from file in GRPR format.
@param[in] filename (string): Path to file with graph in GRPR format.
@return (graph) Graph that is read from file.
"""
file = open(filename, 'r');
comments = "";
space_descr = [];
data = [];
data_type = None;
map_data_repr = dict(); # Used as a temporary buffer only when input graph is represented by edges.
for line in file:
if (line[0] == 'c' or line[0] == 'p'):
comments += line[1:];
elif (line[0] == 'r'):
node_coordinates = [float(val) for val in line[1:].split()];
if (len(node_coordinates) != 2):
raise NameError('Invalid format of space description for node (only 2-dimension space is supported)');
space_descr.append( [float(val) for val in line[1:].split()] );
elif (line[0] == 'm'):
if ( (data_type is not None) and (data_type != 'm') ):
raise NameError('Invalid format of graph representation (only one type should be used)');
data_type = 'm';
data.append( [float(val) for val in line[1:].split()] );
elif (line[0] == 'v'):
if ( (data_type is not None) and (data_type != 'v') ):
raise NameError('Invalid format of graph representation (only one type should be used)');
data_type = 'v';
data.append( [float(val) for val in line[1:].split()] );
elif (line[0] == 'e'):
if ( (data_type is not None) and (data_type != 'e') ):
raise NameError('Invalid format of graph representation (only one type should be used)');
data_type = 'e';
vertices = [int(val) for val in line[1:].split()];
if (vertices[0] not in map_data_repr):
map_data_repr[ vertices[0] ] = [ vertices[1] ];
else:
map_data_repr[ vertices[0] ].append(vertices[1])
if (vertices[1] not in map_data_repr):
map_data_repr[ vertices[1] ] = [ vertices[0] ];
else:
map_data_repr[ vertices[1] ].append(vertices[0]);
elif (len(line.strip()) == 0): continue;
else:
print(line);
raise NameError('Invalid format of file with graph description');
# In case of edge representation result should be copied.
if (data_type == 'e'):
for index in range(len(map_data_repr)):
data.append([0] * len(map_data_repr));
for index_neighbour in map_data_repr[index + 1]:
data[index][index_neighbour - 1] = 1;
file.close();
# Set graph description
graph_descr = None;
if (data_type == 'm'): graph_descr = type_graph_descr.GRAPH_MATRIX_DESCR;
elif (data_type == 'v'): graph_descr = type_graph_descr.GRAPH_VECTOR_DESCR;
elif (data_type == 'e'): graph_descr = type_graph_descr.GRAPH_MATRIX_DESCR;
else:
raise NameError('Invalid format of file with graph description');
if (space_descr != []):
if (len(data) != len(space_descr)):
raise NameError("Invalid format of file with graph - number of nodes is different in space representation and graph description");
return graph(data, graph_descr, space_descr, comments); | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/utils/graph.py#L138-L228 | [
"def",
"read_graph",
"(",
"filename",
")",
":",
"file",
"=",
"open",
"(",
"filename",
",",
"'r'",
")",
"comments",
"=",
"\"\"",
"space_descr",
"=",
"[",
"]",
"data",
"=",
"[",
"]",
"data_type",
"=",
"None",
"map_data_repr",
"=",
"dict",
"(",
")",
"# Used as a temporary buffer only when input graph is represented by edges.\r",
"for",
"line",
"in",
"file",
":",
"if",
"(",
"line",
"[",
"0",
"]",
"==",
"'c'",
"or",
"line",
"[",
"0",
"]",
"==",
"'p'",
")",
":",
"comments",
"+=",
"line",
"[",
"1",
":",
"]",
"elif",
"(",
"line",
"[",
"0",
"]",
"==",
"'r'",
")",
":",
"node_coordinates",
"=",
"[",
"float",
"(",
"val",
")",
"for",
"val",
"in",
"line",
"[",
"1",
":",
"]",
".",
"split",
"(",
")",
"]",
"if",
"(",
"len",
"(",
"node_coordinates",
")",
"!=",
"2",
")",
":",
"raise",
"NameError",
"(",
"'Invalid format of space description for node (only 2-dimension space is supported)'",
")",
"space_descr",
".",
"append",
"(",
"[",
"float",
"(",
"val",
")",
"for",
"val",
"in",
"line",
"[",
"1",
":",
"]",
".",
"split",
"(",
")",
"]",
")",
"elif",
"(",
"line",
"[",
"0",
"]",
"==",
"'m'",
")",
":",
"if",
"(",
"(",
"data_type",
"is",
"not",
"None",
")",
"and",
"(",
"data_type",
"!=",
"'m'",
")",
")",
":",
"raise",
"NameError",
"(",
"'Invalid format of graph representation (only one type should be used)'",
")",
"data_type",
"=",
"'m'",
"data",
".",
"append",
"(",
"[",
"float",
"(",
"val",
")",
"for",
"val",
"in",
"line",
"[",
"1",
":",
"]",
".",
"split",
"(",
")",
"]",
")",
"elif",
"(",
"line",
"[",
"0",
"]",
"==",
"'v'",
")",
":",
"if",
"(",
"(",
"data_type",
"is",
"not",
"None",
")",
"and",
"(",
"data_type",
"!=",
"'v'",
")",
")",
":",
"raise",
"NameError",
"(",
"'Invalid format of graph representation (only one type should be used)'",
")",
"data_type",
"=",
"'v'",
"data",
".",
"append",
"(",
"[",
"float",
"(",
"val",
")",
"for",
"val",
"in",
"line",
"[",
"1",
":",
"]",
".",
"split",
"(",
")",
"]",
")",
"elif",
"(",
"line",
"[",
"0",
"]",
"==",
"'e'",
")",
":",
"if",
"(",
"(",
"data_type",
"is",
"not",
"None",
")",
"and",
"(",
"data_type",
"!=",
"'e'",
")",
")",
":",
"raise",
"NameError",
"(",
"'Invalid format of graph representation (only one type should be used)'",
")",
"data_type",
"=",
"'e'",
"vertices",
"=",
"[",
"int",
"(",
"val",
")",
"for",
"val",
"in",
"line",
"[",
"1",
":",
"]",
".",
"split",
"(",
")",
"]",
"if",
"(",
"vertices",
"[",
"0",
"]",
"not",
"in",
"map_data_repr",
")",
":",
"map_data_repr",
"[",
"vertices",
"[",
"0",
"]",
"]",
"=",
"[",
"vertices",
"[",
"1",
"]",
"]",
"else",
":",
"map_data_repr",
"[",
"vertices",
"[",
"0",
"]",
"]",
".",
"append",
"(",
"vertices",
"[",
"1",
"]",
")",
"if",
"(",
"vertices",
"[",
"1",
"]",
"not",
"in",
"map_data_repr",
")",
":",
"map_data_repr",
"[",
"vertices",
"[",
"1",
"]",
"]",
"=",
"[",
"vertices",
"[",
"0",
"]",
"]",
"else",
":",
"map_data_repr",
"[",
"vertices",
"[",
"1",
"]",
"]",
".",
"append",
"(",
"vertices",
"[",
"0",
"]",
")",
"elif",
"(",
"len",
"(",
"line",
".",
"strip",
"(",
")",
")",
"==",
"0",
")",
":",
"continue",
"else",
":",
"print",
"(",
"line",
")",
"raise",
"NameError",
"(",
"'Invalid format of file with graph description'",
")",
"# In case of edge representation result should be copied.\r",
"if",
"(",
"data_type",
"==",
"'e'",
")",
":",
"for",
"index",
"in",
"range",
"(",
"len",
"(",
"map_data_repr",
")",
")",
":",
"data",
".",
"append",
"(",
"[",
"0",
"]",
"*",
"len",
"(",
"map_data_repr",
")",
")",
"for",
"index_neighbour",
"in",
"map_data_repr",
"[",
"index",
"+",
"1",
"]",
":",
"data",
"[",
"index",
"]",
"[",
"index_neighbour",
"-",
"1",
"]",
"=",
"1",
"file",
".",
"close",
"(",
")",
"# Set graph description\r",
"graph_descr",
"=",
"None",
"if",
"(",
"data_type",
"==",
"'m'",
")",
":",
"graph_descr",
"=",
"type_graph_descr",
".",
"GRAPH_MATRIX_DESCR",
"elif",
"(",
"data_type",
"==",
"'v'",
")",
":",
"graph_descr",
"=",
"type_graph_descr",
".",
"GRAPH_VECTOR_DESCR",
"elif",
"(",
"data_type",
"==",
"'e'",
")",
":",
"graph_descr",
"=",
"type_graph_descr",
".",
"GRAPH_MATRIX_DESCR",
"else",
":",
"raise",
"NameError",
"(",
"'Invalid format of file with graph description'",
")",
"if",
"(",
"space_descr",
"!=",
"[",
"]",
")",
":",
"if",
"(",
"len",
"(",
"data",
")",
"!=",
"len",
"(",
"space_descr",
")",
")",
":",
"raise",
"NameError",
"(",
"\"Invalid format of file with graph - number of nodes is different in space representation and graph description\"",
")",
"return",
"graph",
"(",
"data",
",",
"graph_descr",
",",
"space_descr",
",",
"comments",
")"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | draw_graph | !
@brief Draw graph.
@param[in] graph_instance (graph): Graph that should be drawn.
@param[in] map_coloring (list): List of color indexes for each vertex. Size of this list should be equal to size of graph (number of vertices).
If it's not specified (None) than graph without coloring will be dwarn.
@warning Graph can be represented if there is space representation for it. | pyclustering/utils/graph.py | def draw_graph(graph_instance, map_coloring = None):
"""!
@brief Draw graph.
@param[in] graph_instance (graph): Graph that should be drawn.
@param[in] map_coloring (list): List of color indexes for each vertex. Size of this list should be equal to size of graph (number of vertices).
If it's not specified (None) than graph without coloring will be dwarn.
@warning Graph can be represented if there is space representation for it.
"""
if (graph_instance.space_description is None):
raise NameError("The graph haven't got representation in space");
if (map_coloring is not None):
if (len(graph_instance) != len(map_coloring)):
raise NameError("Size of graph should be equal to size coloring map");
fig = plt.figure();
axes = fig.add_subplot(111);
available_colors = ['#00a2e8', '#22b14c', '#ed1c24',
'#fff200', '#000000', '#a349a4',
'#ffaec9', '#7f7f7f', '#b97a57',
'#c8bfe7', '#880015', '#ff7f27',
'#3f48cc', '#c3c3c3', '#ffc90e',
'#efe4b0', '#b5e61d', '#99d9ea',
'#7092b4', '#ffffff'];
if (map_coloring is not None):
if (len(map_coloring) > len(available_colors)):
raise NameError('Impossible to represent colored graph due to number of specified colors.');
x_maximum = -float('inf');
x_minimum = float('inf');
y_maximum = -float('inf');
y_minimum = float('inf');
for i in range(0, len(graph_instance.space_description), 1):
if (graph_instance.type_graph_descr == type_graph_descr.GRAPH_MATRIX_DESCR):
for j in range(i, len(graph_instance.space_description), 1): # draw connection between two points only one time
if (graph_instance.data[i][j] == 1):
axes.plot([graph_instance.space_description[i][0], graph_instance.space_description[j][0]], [graph_instance.space_description[i][1], graph_instance.space_description[j][1]], 'k-', linewidth = 1.5);
elif (graph_instance.type_graph_descr == type_graph_descr.GRAPH_VECTOR_DESCR):
for j in graph_instance.data[i]:
if (i > j): # draw connection between two points only one time
axes.plot([graph_instance.space_description[i][0], graph_instance.space_description[j][0]], [graph_instance.space_description[i][1], graph_instance.space_description[j][1]], 'k-', linewidth = 1.5);
color_node = 'b';
if (map_coloring is not None):
color_node = colors.hex2color(available_colors[map_coloring[i]]);
axes.plot(graph_instance.space_description[i][0], graph_instance.space_description[i][1], color = color_node, marker = 'o', markersize = 20);
if (x_maximum < graph_instance.space_description[i][0]): x_maximum = graph_instance.space_description[i][0];
if (x_minimum > graph_instance.space_description[i][0]): x_minimum = graph_instance.space_description[i][0];
if (y_maximum < graph_instance.space_description[i][1]): y_maximum = graph_instance.space_description[i][1];
if (y_minimum > graph_instance.space_description[i][1]): y_minimum = graph_instance.space_description[i][1];
plt.xlim(x_minimum - 0.5, x_maximum + 0.5);
plt.ylim(y_minimum - 0.5, y_maximum + 0.5);
plt.show(); | def draw_graph(graph_instance, map_coloring = None):
"""!
@brief Draw graph.
@param[in] graph_instance (graph): Graph that should be drawn.
@param[in] map_coloring (list): List of color indexes for each vertex. Size of this list should be equal to size of graph (number of vertices).
If it's not specified (None) than graph without coloring will be dwarn.
@warning Graph can be represented if there is space representation for it.
"""
if (graph_instance.space_description is None):
raise NameError("The graph haven't got representation in space");
if (map_coloring is not None):
if (len(graph_instance) != len(map_coloring)):
raise NameError("Size of graph should be equal to size coloring map");
fig = plt.figure();
axes = fig.add_subplot(111);
available_colors = ['#00a2e8', '#22b14c', '#ed1c24',
'#fff200', '#000000', '#a349a4',
'#ffaec9', '#7f7f7f', '#b97a57',
'#c8bfe7', '#880015', '#ff7f27',
'#3f48cc', '#c3c3c3', '#ffc90e',
'#efe4b0', '#b5e61d', '#99d9ea',
'#7092b4', '#ffffff'];
if (map_coloring is not None):
if (len(map_coloring) > len(available_colors)):
raise NameError('Impossible to represent colored graph due to number of specified colors.');
x_maximum = -float('inf');
x_minimum = float('inf');
y_maximum = -float('inf');
y_minimum = float('inf');
for i in range(0, len(graph_instance.space_description), 1):
if (graph_instance.type_graph_descr == type_graph_descr.GRAPH_MATRIX_DESCR):
for j in range(i, len(graph_instance.space_description), 1): # draw connection between two points only one time
if (graph_instance.data[i][j] == 1):
axes.plot([graph_instance.space_description[i][0], graph_instance.space_description[j][0]], [graph_instance.space_description[i][1], graph_instance.space_description[j][1]], 'k-', linewidth = 1.5);
elif (graph_instance.type_graph_descr == type_graph_descr.GRAPH_VECTOR_DESCR):
for j in graph_instance.data[i]:
if (i > j): # draw connection between two points only one time
axes.plot([graph_instance.space_description[i][0], graph_instance.space_description[j][0]], [graph_instance.space_description[i][1], graph_instance.space_description[j][1]], 'k-', linewidth = 1.5);
color_node = 'b';
if (map_coloring is not None):
color_node = colors.hex2color(available_colors[map_coloring[i]]);
axes.plot(graph_instance.space_description[i][0], graph_instance.space_description[i][1], color = color_node, marker = 'o', markersize = 20);
if (x_maximum < graph_instance.space_description[i][0]): x_maximum = graph_instance.space_description[i][0];
if (x_minimum > graph_instance.space_description[i][0]): x_minimum = graph_instance.space_description[i][0];
if (y_maximum < graph_instance.space_description[i][1]): y_maximum = graph_instance.space_description[i][1];
if (y_minimum > graph_instance.space_description[i][1]): y_minimum = graph_instance.space_description[i][1];
plt.xlim(x_minimum - 0.5, x_maximum + 0.5);
plt.ylim(y_minimum - 0.5, y_maximum + 0.5);
plt.show(); | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/utils/graph.py#L232-L297 | [
"def",
"draw_graph",
"(",
"graph_instance",
",",
"map_coloring",
"=",
"None",
")",
":",
"if",
"(",
"graph_instance",
".",
"space_description",
"is",
"None",
")",
":",
"raise",
"NameError",
"(",
"\"The graph haven't got representation in space\"",
")",
"if",
"(",
"map_coloring",
"is",
"not",
"None",
")",
":",
"if",
"(",
"len",
"(",
"graph_instance",
")",
"!=",
"len",
"(",
"map_coloring",
")",
")",
":",
"raise",
"NameError",
"(",
"\"Size of graph should be equal to size coloring map\"",
")",
"fig",
"=",
"plt",
".",
"figure",
"(",
")",
"axes",
"=",
"fig",
".",
"add_subplot",
"(",
"111",
")",
"available_colors",
"=",
"[",
"'#00a2e8'",
",",
"'#22b14c'",
",",
"'#ed1c24'",
",",
"'#fff200'",
",",
"'#000000'",
",",
"'#a349a4'",
",",
"'#ffaec9'",
",",
"'#7f7f7f'",
",",
"'#b97a57'",
",",
"'#c8bfe7'",
",",
"'#880015'",
",",
"'#ff7f27'",
",",
"'#3f48cc'",
",",
"'#c3c3c3'",
",",
"'#ffc90e'",
",",
"'#efe4b0'",
",",
"'#b5e61d'",
",",
"'#99d9ea'",
",",
"'#7092b4'",
",",
"'#ffffff'",
"]",
"if",
"(",
"map_coloring",
"is",
"not",
"None",
")",
":",
"if",
"(",
"len",
"(",
"map_coloring",
")",
">",
"len",
"(",
"available_colors",
")",
")",
":",
"raise",
"NameError",
"(",
"'Impossible to represent colored graph due to number of specified colors.'",
")",
"x_maximum",
"=",
"-",
"float",
"(",
"'inf'",
")",
"x_minimum",
"=",
"float",
"(",
"'inf'",
")",
"y_maximum",
"=",
"-",
"float",
"(",
"'inf'",
")",
"y_minimum",
"=",
"float",
"(",
"'inf'",
")",
"for",
"i",
"in",
"range",
"(",
"0",
",",
"len",
"(",
"graph_instance",
".",
"space_description",
")",
",",
"1",
")",
":",
"if",
"(",
"graph_instance",
".",
"type_graph_descr",
"==",
"type_graph_descr",
".",
"GRAPH_MATRIX_DESCR",
")",
":",
"for",
"j",
"in",
"range",
"(",
"i",
",",
"len",
"(",
"graph_instance",
".",
"space_description",
")",
",",
"1",
")",
":",
"# draw connection between two points only one time\r",
"if",
"(",
"graph_instance",
".",
"data",
"[",
"i",
"]",
"[",
"j",
"]",
"==",
"1",
")",
":",
"axes",
".",
"plot",
"(",
"[",
"graph_instance",
".",
"space_description",
"[",
"i",
"]",
"[",
"0",
"]",
",",
"graph_instance",
".",
"space_description",
"[",
"j",
"]",
"[",
"0",
"]",
"]",
",",
"[",
"graph_instance",
".",
"space_description",
"[",
"i",
"]",
"[",
"1",
"]",
",",
"graph_instance",
".",
"space_description",
"[",
"j",
"]",
"[",
"1",
"]",
"]",
",",
"'k-'",
",",
"linewidth",
"=",
"1.5",
")",
"elif",
"(",
"graph_instance",
".",
"type_graph_descr",
"==",
"type_graph_descr",
".",
"GRAPH_VECTOR_DESCR",
")",
":",
"for",
"j",
"in",
"graph_instance",
".",
"data",
"[",
"i",
"]",
":",
"if",
"(",
"i",
">",
"j",
")",
":",
"# draw connection between two points only one time\r",
"axes",
".",
"plot",
"(",
"[",
"graph_instance",
".",
"space_description",
"[",
"i",
"]",
"[",
"0",
"]",
",",
"graph_instance",
".",
"space_description",
"[",
"j",
"]",
"[",
"0",
"]",
"]",
",",
"[",
"graph_instance",
".",
"space_description",
"[",
"i",
"]",
"[",
"1",
"]",
",",
"graph_instance",
".",
"space_description",
"[",
"j",
"]",
"[",
"1",
"]",
"]",
",",
"'k-'",
",",
"linewidth",
"=",
"1.5",
")",
"color_node",
"=",
"'b'",
"if",
"(",
"map_coloring",
"is",
"not",
"None",
")",
":",
"color_node",
"=",
"colors",
".",
"hex2color",
"(",
"available_colors",
"[",
"map_coloring",
"[",
"i",
"]",
"]",
")",
"axes",
".",
"plot",
"(",
"graph_instance",
".",
"space_description",
"[",
"i",
"]",
"[",
"0",
"]",
",",
"graph_instance",
".",
"space_description",
"[",
"i",
"]",
"[",
"1",
"]",
",",
"color",
"=",
"color_node",
",",
"marker",
"=",
"'o'",
",",
"markersize",
"=",
"20",
")",
"if",
"(",
"x_maximum",
"<",
"graph_instance",
".",
"space_description",
"[",
"i",
"]",
"[",
"0",
"]",
")",
":",
"x_maximum",
"=",
"graph_instance",
".",
"space_description",
"[",
"i",
"]",
"[",
"0",
"]",
"if",
"(",
"x_minimum",
">",
"graph_instance",
".",
"space_description",
"[",
"i",
"]",
"[",
"0",
"]",
")",
":",
"x_minimum",
"=",
"graph_instance",
".",
"space_description",
"[",
"i",
"]",
"[",
"0",
"]",
"if",
"(",
"y_maximum",
"<",
"graph_instance",
".",
"space_description",
"[",
"i",
"]",
"[",
"1",
"]",
")",
":",
"y_maximum",
"=",
"graph_instance",
".",
"space_description",
"[",
"i",
"]",
"[",
"1",
"]",
"if",
"(",
"y_minimum",
">",
"graph_instance",
".",
"space_description",
"[",
"i",
"]",
"[",
"1",
"]",
")",
":",
"y_minimum",
"=",
"graph_instance",
".",
"space_description",
"[",
"i",
"]",
"[",
"1",
"]",
"plt",
".",
"xlim",
"(",
"x_minimum",
"-",
"0.5",
",",
"x_maximum",
"+",
"0.5",
")",
"plt",
".",
"ylim",
"(",
"y_minimum",
"-",
"0.5",
",",
"y_maximum",
"+",
"0.5",
")",
"plt",
".",
"show",
"(",
")"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | fcm.process | !
@brief Performs cluster analysis in line with Fuzzy C-Means algorithm.
@see get_clusters()
@see get_centers()
@see get_membership() | pyclustering/cluster/fcm.py | def process(self):
"""!
@brief Performs cluster analysis in line with Fuzzy C-Means algorithm.
@see get_clusters()
@see get_centers()
@see get_membership()
"""
if self.__ccore is True:
self.__process_by_ccore()
else:
self.__process_by_python()
return self | def process(self):
"""!
@brief Performs cluster analysis in line with Fuzzy C-Means algorithm.
@see get_clusters()
@see get_centers()
@see get_membership()
"""
if self.__ccore is True:
self.__process_by_ccore()
else:
self.__process_by_python()
return self | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/cluster/fcm.py#L141-L155 | [
"def",
"process",
"(",
"self",
")",
":",
"if",
"self",
".",
"__ccore",
"is",
"True",
":",
"self",
".",
"__process_by_ccore",
"(",
")",
"else",
":",
"self",
".",
"__process_by_python",
"(",
")",
"return",
"self"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | fcm.__process_by_ccore | !
@brief Performs cluster analysis using C/C++ implementation. | pyclustering/cluster/fcm.py | def __process_by_ccore(self):
"""!
@brief Performs cluster analysis using C/C++ implementation.
"""
result = wrapper.fcm_algorithm(self.__data, self.__centers, self.__m, self.__tolerance, self.__itermax)
self.__clusters = result[wrapper.fcm_package_indexer.INDEX_CLUSTERS]
self.__centers = result[wrapper.fcm_package_indexer.INDEX_CENTERS]
self.__membership = result[wrapper.fcm_package_indexer.INDEX_MEMBERSHIP] | def __process_by_ccore(self):
"""!
@brief Performs cluster analysis using C/C++ implementation.
"""
result = wrapper.fcm_algorithm(self.__data, self.__centers, self.__m, self.__tolerance, self.__itermax)
self.__clusters = result[wrapper.fcm_package_indexer.INDEX_CLUSTERS]
self.__centers = result[wrapper.fcm_package_indexer.INDEX_CENTERS]
self.__membership = result[wrapper.fcm_package_indexer.INDEX_MEMBERSHIP] | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/cluster/fcm.py#L204-L213 | [
"def",
"__process_by_ccore",
"(",
"self",
")",
":",
"result",
"=",
"wrapper",
".",
"fcm_algorithm",
"(",
"self",
".",
"__data",
",",
"self",
".",
"__centers",
",",
"self",
".",
"__m",
",",
"self",
".",
"__tolerance",
",",
"self",
".",
"__itermax",
")",
"self",
".",
"__clusters",
"=",
"result",
"[",
"wrapper",
".",
"fcm_package_indexer",
".",
"INDEX_CLUSTERS",
"]",
"self",
".",
"__centers",
"=",
"result",
"[",
"wrapper",
".",
"fcm_package_indexer",
".",
"INDEX_CENTERS",
"]",
"self",
".",
"__membership",
"=",
"result",
"[",
"wrapper",
".",
"fcm_package_indexer",
".",
"INDEX_MEMBERSHIP",
"]"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | fcm.__process_by_python | !
@brief Performs cluster analysis using Python implementation. | pyclustering/cluster/fcm.py | def __process_by_python(self):
"""!
@brief Performs cluster analysis using Python implementation.
"""
self.__data = numpy.array(self.__data)
self.__centers = numpy.array(self.__centers)
self.__membership = numpy.zeros((len(self.__data), len(self.__centers)))
change = float('inf')
iteration = 0
while change > self.__tolerance and iteration < self.__itermax:
self.__update_membership()
centers = self.__calculate_centers()
change = self.__calculate_changes(centers)
self.__centers = centers
iteration += 1
self.__extract_clusters() | def __process_by_python(self):
"""!
@brief Performs cluster analysis using Python implementation.
"""
self.__data = numpy.array(self.__data)
self.__centers = numpy.array(self.__centers)
self.__membership = numpy.zeros((len(self.__data), len(self.__centers)))
change = float('inf')
iteration = 0
while change > self.__tolerance and iteration < self.__itermax:
self.__update_membership()
centers = self.__calculate_centers()
change = self.__calculate_changes(centers)
self.__centers = centers
iteration += 1
self.__extract_clusters() | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/cluster/fcm.py#L216-L237 | [
"def",
"__process_by_python",
"(",
"self",
")",
":",
"self",
".",
"__data",
"=",
"numpy",
".",
"array",
"(",
"self",
".",
"__data",
")",
"self",
".",
"__centers",
"=",
"numpy",
".",
"array",
"(",
"self",
".",
"__centers",
")",
"self",
".",
"__membership",
"=",
"numpy",
".",
"zeros",
"(",
"(",
"len",
"(",
"self",
".",
"__data",
")",
",",
"len",
"(",
"self",
".",
"__centers",
")",
")",
")",
"change",
"=",
"float",
"(",
"'inf'",
")",
"iteration",
"=",
"0",
"while",
"change",
">",
"self",
".",
"__tolerance",
"and",
"iteration",
"<",
"self",
".",
"__itermax",
":",
"self",
".",
"__update_membership",
"(",
")",
"centers",
"=",
"self",
".",
"__calculate_centers",
"(",
")",
"change",
"=",
"self",
".",
"__calculate_changes",
"(",
"centers",
")",
"self",
".",
"__centers",
"=",
"centers",
"iteration",
"+=",
"1",
"self",
".",
"__extract_clusters",
"(",
")"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | fcm.__calculate_centers | !
@brief Calculate center using membership of each cluster.
@return (list) Updated clusters as list of clusters. Each cluster contains indexes of objects from data.
@return (numpy.array) Updated centers. | pyclustering/cluster/fcm.py | def __calculate_centers(self):
"""!
@brief Calculate center using membership of each cluster.
@return (list) Updated clusters as list of clusters. Each cluster contains indexes of objects from data.
@return (numpy.array) Updated centers.
"""
dimension = self.__data.shape[1]
centers = numpy.zeros((len(self.__centers), dimension))
for i in range(len(self.__centers)):
# multiplication '@' requires python version 3.5
centers[i] = numpy.divide(self.__membership[:, i] @ self.__data, numpy.sum(self.__membership[:, i]))
return centers | def __calculate_centers(self):
"""!
@brief Calculate center using membership of each cluster.
@return (list) Updated clusters as list of clusters. Each cluster contains indexes of objects from data.
@return (numpy.array) Updated centers.
"""
dimension = self.__data.shape[1]
centers = numpy.zeros((len(self.__centers), dimension))
for i in range(len(self.__centers)):
# multiplication '@' requires python version 3.5
centers[i] = numpy.divide(self.__membership[:, i] @ self.__data, numpy.sum(self.__membership[:, i]))
return centers | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/cluster/fcm.py#L240-L256 | [
"def",
"__calculate_centers",
"(",
"self",
")",
":",
"dimension",
"=",
"self",
".",
"__data",
".",
"shape",
"[",
"1",
"]",
"centers",
"=",
"numpy",
".",
"zeros",
"(",
"(",
"len",
"(",
"self",
".",
"__centers",
")",
",",
"dimension",
")",
")",
"for",
"i",
"in",
"range",
"(",
"len",
"(",
"self",
".",
"__centers",
")",
")",
":",
"# multiplication '@' requires python version 3.5\r",
"centers",
"[",
"i",
"]",
"=",
"numpy",
".",
"divide",
"(",
"self",
".",
"__membership",
"[",
":",
",",
"i",
"]",
"@",
"self",
".",
"__data",
",",
"numpy",
".",
"sum",
"(",
"self",
".",
"__membership",
"[",
":",
",",
"i",
"]",
")",
")",
"return",
"centers"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | fcm.__update_membership | !
@brief Update membership for each point in line with current cluster centers. | pyclustering/cluster/fcm.py | def __update_membership(self):
"""!
@brief Update membership for each point in line with current cluster centers.
"""
data_difference = numpy.zeros((len(self.__centers), len(self.__data)))
for i in range(len(self.__centers)):
data_difference[i] = numpy.sum(numpy.square(self.__data - self.__centers[i]), axis=1)
for i in range(len(self.__data)):
for j in range(len(self.__centers)):
divider = sum([pow(data_difference[j][i] / data_difference[k][i], self.__degree) for k in range(len(self.__centers)) if data_difference[k][i] != 0.0])
if divider != 0.0:
self.__membership[i][j] = 1.0 / divider
else:
self.__membership[i][j] = 1.0 | def __update_membership(self):
"""!
@brief Update membership for each point in line with current cluster centers.
"""
data_difference = numpy.zeros((len(self.__centers), len(self.__data)))
for i in range(len(self.__centers)):
data_difference[i] = numpy.sum(numpy.square(self.__data - self.__centers[i]), axis=1)
for i in range(len(self.__data)):
for j in range(len(self.__centers)):
divider = sum([pow(data_difference[j][i] / data_difference[k][i], self.__degree) for k in range(len(self.__centers)) if data_difference[k][i] != 0.0])
if divider != 0.0:
self.__membership[i][j] = 1.0 / divider
else:
self.__membership[i][j] = 1.0 | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/cluster/fcm.py#L259-L276 | [
"def",
"__update_membership",
"(",
"self",
")",
":",
"data_difference",
"=",
"numpy",
".",
"zeros",
"(",
"(",
"len",
"(",
"self",
".",
"__centers",
")",
",",
"len",
"(",
"self",
".",
"__data",
")",
")",
")",
"for",
"i",
"in",
"range",
"(",
"len",
"(",
"self",
".",
"__centers",
")",
")",
":",
"data_difference",
"[",
"i",
"]",
"=",
"numpy",
".",
"sum",
"(",
"numpy",
".",
"square",
"(",
"self",
".",
"__data",
"-",
"self",
".",
"__centers",
"[",
"i",
"]",
")",
",",
"axis",
"=",
"1",
")",
"for",
"i",
"in",
"range",
"(",
"len",
"(",
"self",
".",
"__data",
")",
")",
":",
"for",
"j",
"in",
"range",
"(",
"len",
"(",
"self",
".",
"__centers",
")",
")",
":",
"divider",
"=",
"sum",
"(",
"[",
"pow",
"(",
"data_difference",
"[",
"j",
"]",
"[",
"i",
"]",
"/",
"data_difference",
"[",
"k",
"]",
"[",
"i",
"]",
",",
"self",
".",
"__degree",
")",
"for",
"k",
"in",
"range",
"(",
"len",
"(",
"self",
".",
"__centers",
")",
")",
"if",
"data_difference",
"[",
"k",
"]",
"[",
"i",
"]",
"!=",
"0.0",
"]",
")",
"if",
"divider",
"!=",
"0.0",
":",
"self",
".",
"__membership",
"[",
"i",
"]",
"[",
"j",
"]",
"=",
"1.0",
"/",
"divider",
"else",
":",
"self",
".",
"__membership",
"[",
"i",
"]",
"[",
"j",
"]",
"=",
"1.0"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | fcm.__calculate_changes | !
@brief Calculate changes between centers.
@return (float) Maximum change between centers. | pyclustering/cluster/fcm.py | def __calculate_changes(self, updated_centers):
"""!
@brief Calculate changes between centers.
@return (float) Maximum change between centers.
"""
changes = numpy.sum(numpy.square(self.__centers - updated_centers), axis=1).T
return numpy.max(changes) | def __calculate_changes(self, updated_centers):
"""!
@brief Calculate changes between centers.
@return (float) Maximum change between centers.
"""
changes = numpy.sum(numpy.square(self.__centers - updated_centers), axis=1).T
return numpy.max(changes) | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/cluster/fcm.py#L279-L287 | [
"def",
"__calculate_changes",
"(",
"self",
",",
"updated_centers",
")",
":",
"changes",
"=",
"numpy",
".",
"sum",
"(",
"numpy",
".",
"square",
"(",
"self",
".",
"__centers",
"-",
"updated_centers",
")",
",",
"axis",
"=",
"1",
")",
".",
"T",
"return",
"numpy",
".",
"max",
"(",
"changes",
")"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | ga_observer.collect_global_best | !
@brief Stores the best chromosome and its fitness function's value.
@param[in] best_chromosome (list): The best chromosome that were observed.
@param[in] best_fitness_function (float): Fitness function value of the best chromosome. | pyclustering/cluster/ga.py | def collect_global_best(self, best_chromosome, best_fitness_function):
"""!
@brief Stores the best chromosome and its fitness function's value.
@param[in] best_chromosome (list): The best chromosome that were observed.
@param[in] best_fitness_function (float): Fitness function value of the best chromosome.
"""
if not self._need_global_best:
return
self._global_best_result['chromosome'].append(best_chromosome)
self._global_best_result['fitness_function'].append(best_fitness_function) | def collect_global_best(self, best_chromosome, best_fitness_function):
"""!
@brief Stores the best chromosome and its fitness function's value.
@param[in] best_chromosome (list): The best chromosome that were observed.
@param[in] best_fitness_function (float): Fitness function value of the best chromosome.
"""
if not self._need_global_best:
return
self._global_best_result['chromosome'].append(best_chromosome)
self._global_best_result['fitness_function'].append(best_fitness_function) | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/cluster/ga.py#L87-L100 | [
"def",
"collect_global_best",
"(",
"self",
",",
"best_chromosome",
",",
"best_fitness_function",
")",
":",
"if",
"not",
"self",
".",
"_need_global_best",
":",
"return",
"self",
".",
"_global_best_result",
"[",
"'chromosome'",
"]",
".",
"append",
"(",
"best_chromosome",
")",
"self",
".",
"_global_best_result",
"[",
"'fitness_function'",
"]",
".",
"append",
"(",
"best_fitness_function",
")"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | ga_observer.collect_population_best | !
@brief Stores the best chromosome for current specific iteration and its fitness function's value.
@param[in] best_chromosome (list): The best chromosome on specific iteration.
@param[in] best_fitness_function (float): Fitness function value of the chromosome. | pyclustering/cluster/ga.py | def collect_population_best(self, best_chromosome, best_fitness_function):
"""!
@brief Stores the best chromosome for current specific iteration and its fitness function's value.
@param[in] best_chromosome (list): The best chromosome on specific iteration.
@param[in] best_fitness_function (float): Fitness function value of the chromosome.
"""
if not self._need_population_best:
return
self._best_population_result['chromosome'].append(best_chromosome)
self._best_population_result['fitness_function'].append(best_fitness_function) | def collect_population_best(self, best_chromosome, best_fitness_function):
"""!
@brief Stores the best chromosome for current specific iteration and its fitness function's value.
@param[in] best_chromosome (list): The best chromosome on specific iteration.
@param[in] best_fitness_function (float): Fitness function value of the chromosome.
"""
if not self._need_population_best:
return
self._best_population_result['chromosome'].append(best_chromosome)
self._best_population_result['fitness_function'].append(best_fitness_function) | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/cluster/ga.py#L103-L116 | [
"def",
"collect_population_best",
"(",
"self",
",",
"best_chromosome",
",",
"best_fitness_function",
")",
":",
"if",
"not",
"self",
".",
"_need_population_best",
":",
"return",
"self",
".",
"_best_population_result",
"[",
"'chromosome'",
"]",
".",
"append",
"(",
"best_chromosome",
")",
"self",
".",
"_best_population_result",
"[",
"'fitness_function'",
"]",
".",
"append",
"(",
"best_fitness_function",
")"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | ga_observer.collect_mean | !
@brief Stores average value of fitness function among chromosomes on specific iteration.
@param[in] fitness_functions (float): Average value of fitness functions among chromosomes. | pyclustering/cluster/ga.py | def collect_mean(self, fitness_functions):
"""!
@brief Stores average value of fitness function among chromosomes on specific iteration.
@param[in] fitness_functions (float): Average value of fitness functions among chromosomes.
"""
if not self._need_mean_ff:
return
self._mean_ff_result.append(np.mean(fitness_functions)) | def collect_mean(self, fitness_functions):
"""!
@brief Stores average value of fitness function among chromosomes on specific iteration.
@param[in] fitness_functions (float): Average value of fitness functions among chromosomes.
"""
if not self._need_mean_ff:
return
self._mean_ff_result.append(np.mean(fitness_functions)) | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/cluster/ga.py#L119-L130 | [
"def",
"collect_mean",
"(",
"self",
",",
"fitness_functions",
")",
":",
"if",
"not",
"self",
".",
"_need_mean_ff",
":",
"return",
"self",
".",
"_mean_ff_result",
".",
"append",
"(",
"np",
".",
"mean",
"(",
"fitness_functions",
")",
")"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | ga_visualizer.show_evolution | !
@brief Displays evolution of fitness function for the best chromosome, for the current best chromosome and
average value among all chromosomes.
@param[in] observer (ga_observer): Genetic algorithm observer that was used for collecting evolution in the algorithm and
where whole required information for visualization is stored.
@param[in] start_iteration (uint): Iteration from that evolution should be shown.
@param[in] stop_iteration (uint): Iteration after that evolution shouldn't be shown.
@param[in] ax (Axes): Canvas where evolution should be displayed.
@param[in] display (bool): If 'True' then visualization of the evolution will be shown by the function.
This argument should be 'False' if you want to add something else to the canvas and display it later.
@return (Axis) Canvas where evolution was shown. | pyclustering/cluster/ga.py | def show_evolution(observer, start_iteration = 0, stop_iteration=None, ax=None, display=True):
"""!
@brief Displays evolution of fitness function for the best chromosome, for the current best chromosome and
average value among all chromosomes.
@param[in] observer (ga_observer): Genetic algorithm observer that was used for collecting evolution in the algorithm and
where whole required information for visualization is stored.
@param[in] start_iteration (uint): Iteration from that evolution should be shown.
@param[in] stop_iteration (uint): Iteration after that evolution shouldn't be shown.
@param[in] ax (Axes): Canvas where evolution should be displayed.
@param[in] display (bool): If 'True' then visualization of the evolution will be shown by the function.
This argument should be 'False' if you want to add something else to the canvas and display it later.
@return (Axis) Canvas where evolution was shown.
"""
if (ax is None):
_, ax = plt.subplots(1)
ax.set_title("Evolution")
if stop_iteration is None:
stop_iteration = len(observer)
line_best, = ax.plot(observer.get_global_best()['fitness_function'][start_iteration:stop_iteration], 'r')
line_current, = ax.plot(observer.get_population_best()['fitness_function'][start_iteration:stop_iteration], 'k')
line_mean, = ax.plot(observer.get_mean_fitness_function()[start_iteration:stop_iteration], 'c')
if start_iteration < (stop_iteration - 1):
ax.set_xlim([start_iteration, (stop_iteration - 1)])
ax.set_xlabel("Iteration")
ax.set_ylabel("Fitness function")
ax.legend([line_best, line_current, line_mean], ["The best pop.", "Cur. best pop.", "Average"], prop={'size': 10})
ax.grid()
if display is True:
plt.show()
return ax | def show_evolution(observer, start_iteration = 0, stop_iteration=None, ax=None, display=True):
"""!
@brief Displays evolution of fitness function for the best chromosome, for the current best chromosome and
average value among all chromosomes.
@param[in] observer (ga_observer): Genetic algorithm observer that was used for collecting evolution in the algorithm and
where whole required information for visualization is stored.
@param[in] start_iteration (uint): Iteration from that evolution should be shown.
@param[in] stop_iteration (uint): Iteration after that evolution shouldn't be shown.
@param[in] ax (Axes): Canvas where evolution should be displayed.
@param[in] display (bool): If 'True' then visualization of the evolution will be shown by the function.
This argument should be 'False' if you want to add something else to the canvas and display it later.
@return (Axis) Canvas where evolution was shown.
"""
if (ax is None):
_, ax = plt.subplots(1)
ax.set_title("Evolution")
if stop_iteration is None:
stop_iteration = len(observer)
line_best, = ax.plot(observer.get_global_best()['fitness_function'][start_iteration:stop_iteration], 'r')
line_current, = ax.plot(observer.get_population_best()['fitness_function'][start_iteration:stop_iteration], 'k')
line_mean, = ax.plot(observer.get_mean_fitness_function()[start_iteration:stop_iteration], 'c')
if start_iteration < (stop_iteration - 1):
ax.set_xlim([start_iteration, (stop_iteration - 1)])
ax.set_xlabel("Iteration")
ax.set_ylabel("Fitness function")
ax.legend([line_best, line_current, line_mean], ["The best pop.", "Cur. best pop.", "Average"], prop={'size': 10})
ax.grid()
if display is True:
plt.show()
return ax | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/cluster/ga.py#L205-L244 | [
"def",
"show_evolution",
"(",
"observer",
",",
"start_iteration",
"=",
"0",
",",
"stop_iteration",
"=",
"None",
",",
"ax",
"=",
"None",
",",
"display",
"=",
"True",
")",
":",
"if",
"(",
"ax",
"is",
"None",
")",
":",
"_",
",",
"ax",
"=",
"plt",
".",
"subplots",
"(",
"1",
")",
"ax",
".",
"set_title",
"(",
"\"Evolution\"",
")",
"if",
"stop_iteration",
"is",
"None",
":",
"stop_iteration",
"=",
"len",
"(",
"observer",
")",
"line_best",
",",
"=",
"ax",
".",
"plot",
"(",
"observer",
".",
"get_global_best",
"(",
")",
"[",
"'fitness_function'",
"]",
"[",
"start_iteration",
":",
"stop_iteration",
"]",
",",
"'r'",
")",
"line_current",
",",
"=",
"ax",
".",
"plot",
"(",
"observer",
".",
"get_population_best",
"(",
")",
"[",
"'fitness_function'",
"]",
"[",
"start_iteration",
":",
"stop_iteration",
"]",
",",
"'k'",
")",
"line_mean",
",",
"=",
"ax",
".",
"plot",
"(",
"observer",
".",
"get_mean_fitness_function",
"(",
")",
"[",
"start_iteration",
":",
"stop_iteration",
"]",
",",
"'c'",
")",
"if",
"start_iteration",
"<",
"(",
"stop_iteration",
"-",
"1",
")",
":",
"ax",
".",
"set_xlim",
"(",
"[",
"start_iteration",
",",
"(",
"stop_iteration",
"-",
"1",
")",
"]",
")",
"ax",
".",
"set_xlabel",
"(",
"\"Iteration\"",
")",
"ax",
".",
"set_ylabel",
"(",
"\"Fitness function\"",
")",
"ax",
".",
"legend",
"(",
"[",
"line_best",
",",
"line_current",
",",
"line_mean",
"]",
",",
"[",
"\"The best pop.\"",
",",
"\"Cur. best pop.\"",
",",
"\"Average\"",
"]",
",",
"prop",
"=",
"{",
"'size'",
":",
"10",
"}",
")",
"ax",
".",
"grid",
"(",
")",
"if",
"display",
"is",
"True",
":",
"plt",
".",
"show",
"(",
")",
"return",
"ax"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | ga_visualizer.show_clusters | !
@brief Shows allocated clusters by the genetic algorithm.
@param[in] data (list): Input data that was used for clustering process by the algorithm.
@param[in] observer (ga_observer): Observer that was used for collection information about clustering process.
@param[in] marker (char): Type of marker that should be used for object (point) representation.
@param[in] markersize (uint): Size of the marker that is used for object (point) representation.
@note If you have clusters instead of observer then 'cluster_visualizer' can be used for visualization purposes.
@see cluster_visualizer | pyclustering/cluster/ga.py | def show_clusters(data, observer, marker='.', markersize=None):
"""!
@brief Shows allocated clusters by the genetic algorithm.
@param[in] data (list): Input data that was used for clustering process by the algorithm.
@param[in] observer (ga_observer): Observer that was used for collection information about clustering process.
@param[in] marker (char): Type of marker that should be used for object (point) representation.
@param[in] markersize (uint): Size of the marker that is used for object (point) representation.
@note If you have clusters instead of observer then 'cluster_visualizer' can be used for visualization purposes.
@see cluster_visualizer
"""
figure = plt.figure()
ax1 = figure.add_subplot(121)
clusters = ga_math.get_clusters_representation(observer.get_global_best()['chromosome'][-1])
visualizer = cluster_visualizer(1, 2)
visualizer.append_clusters(clusters, data, 0, marker, markersize)
visualizer.show(figure, display=False)
ga_visualizer.show_evolution(observer, 0, None, ax1, True) | def show_clusters(data, observer, marker='.', markersize=None):
"""!
@brief Shows allocated clusters by the genetic algorithm.
@param[in] data (list): Input data that was used for clustering process by the algorithm.
@param[in] observer (ga_observer): Observer that was used for collection information about clustering process.
@param[in] marker (char): Type of marker that should be used for object (point) representation.
@param[in] markersize (uint): Size of the marker that is used for object (point) representation.
@note If you have clusters instead of observer then 'cluster_visualizer' can be used for visualization purposes.
@see cluster_visualizer
"""
figure = plt.figure()
ax1 = figure.add_subplot(121)
clusters = ga_math.get_clusters_representation(observer.get_global_best()['chromosome'][-1])
visualizer = cluster_visualizer(1, 2)
visualizer.append_clusters(clusters, data, 0, marker, markersize)
visualizer.show(figure, display=False)
ga_visualizer.show_evolution(observer, 0, None, ax1, True) | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/cluster/ga.py#L248-L272 | [
"def",
"show_clusters",
"(",
"data",
",",
"observer",
",",
"marker",
"=",
"'.'",
",",
"markersize",
"=",
"None",
")",
":",
"figure",
"=",
"plt",
".",
"figure",
"(",
")",
"ax1",
"=",
"figure",
".",
"add_subplot",
"(",
"121",
")",
"clusters",
"=",
"ga_math",
".",
"get_clusters_representation",
"(",
"observer",
".",
"get_global_best",
"(",
")",
"[",
"'chromosome'",
"]",
"[",
"-",
"1",
"]",
")",
"visualizer",
"=",
"cluster_visualizer",
"(",
"1",
",",
"2",
")",
"visualizer",
".",
"append_clusters",
"(",
"clusters",
",",
"data",
",",
"0",
",",
"marker",
",",
"markersize",
")",
"visualizer",
".",
"show",
"(",
"figure",
",",
"display",
"=",
"False",
")",
"ga_visualizer",
".",
"show_evolution",
"(",
"observer",
",",
"0",
",",
"None",
",",
"ax1",
",",
"True",
")"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | ga_visualizer.animate_cluster_allocation | !
@brief Animate clustering process of genetic clustering algorithm.
@details This method can be also used for rendering movie of clustering process and 'ffmpeg' is required for that purpuse.
@param[in] data (list): Input data that was used for clustering process by the algorithm.
@param[in] observer (ga_observer): Observer that was used for collection information about clustering process.
Be sure that whole information was collected by the observer.
@param[in] animation_velocity (uint): Interval between frames in milliseconds (for run-time animation only).
@param[in] movie_fps (uint): Defines frames per second (for rendering movie only).
@param[in] save_movie (string): If it is specified then animation will be stored to file that is specified in this parameter. | pyclustering/cluster/ga.py | def animate_cluster_allocation(data, observer, animation_velocity=75, movie_fps=5, save_movie=None):
"""!
@brief Animate clustering process of genetic clustering algorithm.
@details This method can be also used for rendering movie of clustering process and 'ffmpeg' is required for that purpuse.
@param[in] data (list): Input data that was used for clustering process by the algorithm.
@param[in] observer (ga_observer): Observer that was used for collection information about clustering process.
Be sure that whole information was collected by the observer.
@param[in] animation_velocity (uint): Interval between frames in milliseconds (for run-time animation only).
@param[in] movie_fps (uint): Defines frames per second (for rendering movie only).
@param[in] save_movie (string): If it is specified then animation will be stored to file that is specified in this parameter.
"""
figure = plt.figure()
def init_frame():
return frame_generation(0)
def frame_generation(index_iteration):
figure.clf()
figure.suptitle("Clustering genetic algorithm (iteration: " + str(index_iteration) + ")", fontsize=18, fontweight='bold')
visualizer = cluster_visualizer(4, 2, ["The best pop. on step #" + str(index_iteration), "The best population"])
local_minimum_clusters = ga_math.get_clusters_representation(observer.get_population_best()['chromosome'][index_iteration])
visualizer.append_clusters(local_minimum_clusters, data, 0)
global_minimum_clusters = ga_math.get_clusters_representation(observer.get_global_best()['chromosome'][index_iteration])
visualizer.append_clusters(global_minimum_clusters, data, 1)
ax1 = plt.subplot2grid((2, 2), (1, 0), colspan=2)
ga_visualizer.show_evolution(observer, 0, index_iteration + 1, ax1, False)
visualizer.show(figure, shift=0, display=False)
figure.subplots_adjust(top=0.85)
return [figure.gca()]
iterations = len(observer)
cluster_animation = animation.FuncAnimation(figure, frame_generation, iterations, interval=animation_velocity, init_func=init_frame, repeat_delay=5000)
if save_movie is not None:
cluster_animation.save(save_movie, writer='ffmpeg', fps=movie_fps, bitrate=1500)
else:
plt.show() | def animate_cluster_allocation(data, observer, animation_velocity=75, movie_fps=5, save_movie=None):
"""!
@brief Animate clustering process of genetic clustering algorithm.
@details This method can be also used for rendering movie of clustering process and 'ffmpeg' is required for that purpuse.
@param[in] data (list): Input data that was used for clustering process by the algorithm.
@param[in] observer (ga_observer): Observer that was used for collection information about clustering process.
Be sure that whole information was collected by the observer.
@param[in] animation_velocity (uint): Interval between frames in milliseconds (for run-time animation only).
@param[in] movie_fps (uint): Defines frames per second (for rendering movie only).
@param[in] save_movie (string): If it is specified then animation will be stored to file that is specified in this parameter.
"""
figure = plt.figure()
def init_frame():
return frame_generation(0)
def frame_generation(index_iteration):
figure.clf()
figure.suptitle("Clustering genetic algorithm (iteration: " + str(index_iteration) + ")", fontsize=18, fontweight='bold')
visualizer = cluster_visualizer(4, 2, ["The best pop. on step #" + str(index_iteration), "The best population"])
local_minimum_clusters = ga_math.get_clusters_representation(observer.get_population_best()['chromosome'][index_iteration])
visualizer.append_clusters(local_minimum_clusters, data, 0)
global_minimum_clusters = ga_math.get_clusters_representation(observer.get_global_best()['chromosome'][index_iteration])
visualizer.append_clusters(global_minimum_clusters, data, 1)
ax1 = plt.subplot2grid((2, 2), (1, 0), colspan=2)
ga_visualizer.show_evolution(observer, 0, index_iteration + 1, ax1, False)
visualizer.show(figure, shift=0, display=False)
figure.subplots_adjust(top=0.85)
return [figure.gca()]
iterations = len(observer)
cluster_animation = animation.FuncAnimation(figure, frame_generation, iterations, interval=animation_velocity, init_func=init_frame, repeat_delay=5000)
if save_movie is not None:
cluster_animation.save(save_movie, writer='ffmpeg', fps=movie_fps, bitrate=1500)
else:
plt.show() | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/cluster/ga.py#L276-L322 | [
"def",
"animate_cluster_allocation",
"(",
"data",
",",
"observer",
",",
"animation_velocity",
"=",
"75",
",",
"movie_fps",
"=",
"5",
",",
"save_movie",
"=",
"None",
")",
":",
"figure",
"=",
"plt",
".",
"figure",
"(",
")",
"def",
"init_frame",
"(",
")",
":",
"return",
"frame_generation",
"(",
"0",
")",
"def",
"frame_generation",
"(",
"index_iteration",
")",
":",
"figure",
".",
"clf",
"(",
")",
"figure",
".",
"suptitle",
"(",
"\"Clustering genetic algorithm (iteration: \"",
"+",
"str",
"(",
"index_iteration",
")",
"+",
"\")\"",
",",
"fontsize",
"=",
"18",
",",
"fontweight",
"=",
"'bold'",
")",
"visualizer",
"=",
"cluster_visualizer",
"(",
"4",
",",
"2",
",",
"[",
"\"The best pop. on step #\"",
"+",
"str",
"(",
"index_iteration",
")",
",",
"\"The best population\"",
"]",
")",
"local_minimum_clusters",
"=",
"ga_math",
".",
"get_clusters_representation",
"(",
"observer",
".",
"get_population_best",
"(",
")",
"[",
"'chromosome'",
"]",
"[",
"index_iteration",
"]",
")",
"visualizer",
".",
"append_clusters",
"(",
"local_minimum_clusters",
",",
"data",
",",
"0",
")",
"global_minimum_clusters",
"=",
"ga_math",
".",
"get_clusters_representation",
"(",
"observer",
".",
"get_global_best",
"(",
")",
"[",
"'chromosome'",
"]",
"[",
"index_iteration",
"]",
")",
"visualizer",
".",
"append_clusters",
"(",
"global_minimum_clusters",
",",
"data",
",",
"1",
")",
"ax1",
"=",
"plt",
".",
"subplot2grid",
"(",
"(",
"2",
",",
"2",
")",
",",
"(",
"1",
",",
"0",
")",
",",
"colspan",
"=",
"2",
")",
"ga_visualizer",
".",
"show_evolution",
"(",
"observer",
",",
"0",
",",
"index_iteration",
"+",
"1",
",",
"ax1",
",",
"False",
")",
"visualizer",
".",
"show",
"(",
"figure",
",",
"shift",
"=",
"0",
",",
"display",
"=",
"False",
")",
"figure",
".",
"subplots_adjust",
"(",
"top",
"=",
"0.85",
")",
"return",
"[",
"figure",
".",
"gca",
"(",
")",
"]",
"iterations",
"=",
"len",
"(",
"observer",
")",
"cluster_animation",
"=",
"animation",
".",
"FuncAnimation",
"(",
"figure",
",",
"frame_generation",
",",
"iterations",
",",
"interval",
"=",
"animation_velocity",
",",
"init_func",
"=",
"init_frame",
",",
"repeat_delay",
"=",
"5000",
")",
"if",
"save_movie",
"is",
"not",
"None",
":",
"cluster_animation",
".",
"save",
"(",
"save_movie",
",",
"writer",
"=",
"'ffmpeg'",
",",
"fps",
"=",
"movie_fps",
",",
"bitrate",
"=",
"1500",
")",
"else",
":",
"plt",
".",
"show",
"(",
")"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | genetic_algorithm.process | !
@brief Perform clustering procedure in line with rule of genetic clustering algorithm.
@see get_clusters() | pyclustering/cluster/ga.py | def process(self):
"""!
@brief Perform clustering procedure in line with rule of genetic clustering algorithm.
@see get_clusters()
"""
# Initialize population
chromosomes = self._init_population(self._count_clusters, len(self._data), self._chromosome_count)
# Initialize the Best solution
best_chromosome, best_ff, first_fitness_functions \
= self._get_best_chromosome(chromosomes, self._data, self._count_clusters)
# Save best result into observer
if self._observer is not None:
self._observer.collect_global_best(best_chromosome, best_ff)
self._observer.collect_population_best(best_chromosome, best_ff)
self._observer.collect_mean(first_fitness_functions)
# Next population
for _ in range(self._population_count):
# Select
chromosomes = self._select(chromosomes, self._data, self._count_clusters, self._select_coeff)
# Crossover
self._crossover(chromosomes)
# Mutation
self._mutation(chromosomes, self._count_clusters, self._count_mutation_gens, self._coeff_mutation_count)
# Update the Best Solution
new_best_chromosome, new_best_ff, fitness_functions \
= self._get_best_chromosome(chromosomes, self._data, self._count_clusters)
# Get best chromosome
if new_best_ff < best_ff:
best_ff = new_best_ff
best_chromosome = new_best_chromosome
# Save best result into observer
if self._observer is not None:
self._observer.collect_global_best(best_chromosome, best_ff)
self._observer.collect_population_best(new_best_chromosome, new_best_ff)
self._observer.collect_mean(fitness_functions)
# Save result
self._result_clustering['best_chromosome'] = best_chromosome
self._result_clustering['best_fitness_function'] = best_ff
return best_chromosome, best_ff | def process(self):
"""!
@brief Perform clustering procedure in line with rule of genetic clustering algorithm.
@see get_clusters()
"""
# Initialize population
chromosomes = self._init_population(self._count_clusters, len(self._data), self._chromosome_count)
# Initialize the Best solution
best_chromosome, best_ff, first_fitness_functions \
= self._get_best_chromosome(chromosomes, self._data, self._count_clusters)
# Save best result into observer
if self._observer is not None:
self._observer.collect_global_best(best_chromosome, best_ff)
self._observer.collect_population_best(best_chromosome, best_ff)
self._observer.collect_mean(first_fitness_functions)
# Next population
for _ in range(self._population_count):
# Select
chromosomes = self._select(chromosomes, self._data, self._count_clusters, self._select_coeff)
# Crossover
self._crossover(chromosomes)
# Mutation
self._mutation(chromosomes, self._count_clusters, self._count_mutation_gens, self._coeff_mutation_count)
# Update the Best Solution
new_best_chromosome, new_best_ff, fitness_functions \
= self._get_best_chromosome(chromosomes, self._data, self._count_clusters)
# Get best chromosome
if new_best_ff < best_ff:
best_ff = new_best_ff
best_chromosome = new_best_chromosome
# Save best result into observer
if self._observer is not None:
self._observer.collect_global_best(best_chromosome, best_ff)
self._observer.collect_population_best(new_best_chromosome, new_best_ff)
self._observer.collect_mean(fitness_functions)
# Save result
self._result_clustering['best_chromosome'] = best_chromosome
self._result_clustering['best_fitness_function'] = best_ff
return best_chromosome, best_ff | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/cluster/ga.py#L430-L482 | [
"def",
"process",
"(",
"self",
")",
":",
"# Initialize population",
"chromosomes",
"=",
"self",
".",
"_init_population",
"(",
"self",
".",
"_count_clusters",
",",
"len",
"(",
"self",
".",
"_data",
")",
",",
"self",
".",
"_chromosome_count",
")",
"# Initialize the Best solution",
"best_chromosome",
",",
"best_ff",
",",
"first_fitness_functions",
"=",
"self",
".",
"_get_best_chromosome",
"(",
"chromosomes",
",",
"self",
".",
"_data",
",",
"self",
".",
"_count_clusters",
")",
"# Save best result into observer",
"if",
"self",
".",
"_observer",
"is",
"not",
"None",
":",
"self",
".",
"_observer",
".",
"collect_global_best",
"(",
"best_chromosome",
",",
"best_ff",
")",
"self",
".",
"_observer",
".",
"collect_population_best",
"(",
"best_chromosome",
",",
"best_ff",
")",
"self",
".",
"_observer",
".",
"collect_mean",
"(",
"first_fitness_functions",
")",
"# Next population",
"for",
"_",
"in",
"range",
"(",
"self",
".",
"_population_count",
")",
":",
"# Select",
"chromosomes",
"=",
"self",
".",
"_select",
"(",
"chromosomes",
",",
"self",
".",
"_data",
",",
"self",
".",
"_count_clusters",
",",
"self",
".",
"_select_coeff",
")",
"# Crossover",
"self",
".",
"_crossover",
"(",
"chromosomes",
")",
"# Mutation",
"self",
".",
"_mutation",
"(",
"chromosomes",
",",
"self",
".",
"_count_clusters",
",",
"self",
".",
"_count_mutation_gens",
",",
"self",
".",
"_coeff_mutation_count",
")",
"# Update the Best Solution",
"new_best_chromosome",
",",
"new_best_ff",
",",
"fitness_functions",
"=",
"self",
".",
"_get_best_chromosome",
"(",
"chromosomes",
",",
"self",
".",
"_data",
",",
"self",
".",
"_count_clusters",
")",
"# Get best chromosome",
"if",
"new_best_ff",
"<",
"best_ff",
":",
"best_ff",
"=",
"new_best_ff",
"best_chromosome",
"=",
"new_best_chromosome",
"# Save best result into observer",
"if",
"self",
".",
"_observer",
"is",
"not",
"None",
":",
"self",
".",
"_observer",
".",
"collect_global_best",
"(",
"best_chromosome",
",",
"best_ff",
")",
"self",
".",
"_observer",
".",
"collect_population_best",
"(",
"new_best_chromosome",
",",
"new_best_ff",
")",
"self",
".",
"_observer",
".",
"collect_mean",
"(",
"fitness_functions",
")",
"# Save result",
"self",
".",
"_result_clustering",
"[",
"'best_chromosome'",
"]",
"=",
"best_chromosome",
"self",
".",
"_result_clustering",
"[",
"'best_fitness_function'",
"]",
"=",
"best_ff",
"return",
"best_chromosome",
",",
"best_ff"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | genetic_algorithm._select | !
@brief Performs selection procedure where new chromosomes are calculated.
@param[in] chromosomes (numpy.array): Chromosomes | pyclustering/cluster/ga.py | def _select(chromosomes, data, count_clusters, select_coeff):
"""!
@brief Performs selection procedure where new chromosomes are calculated.
@param[in] chromosomes (numpy.array): Chromosomes
"""
# Calc centers
centres = ga_math.get_centres(chromosomes, data, count_clusters)
# Calc fitness functions
fitness = genetic_algorithm._calc_fitness_function(centres, data, chromosomes)
for _idx in range(len(fitness)):
fitness[_idx] = math.exp(1 + fitness[_idx] * select_coeff)
# Calc probability vector
probabilities = ga_math.calc_probability_vector(fitness)
# Select P chromosomes with probabilities
new_chromosomes = np.zeros(chromosomes.shape, dtype=np.int)
# Selecting
for _idx in range(len(chromosomes)):
new_chromosomes[_idx] = chromosomes[ga_math.get_uniform(probabilities)]
return new_chromosomes | def _select(chromosomes, data, count_clusters, select_coeff):
"""!
@brief Performs selection procedure where new chromosomes are calculated.
@param[in] chromosomes (numpy.array): Chromosomes
"""
# Calc centers
centres = ga_math.get_centres(chromosomes, data, count_clusters)
# Calc fitness functions
fitness = genetic_algorithm._calc_fitness_function(centres, data, chromosomes)
for _idx in range(len(fitness)):
fitness[_idx] = math.exp(1 + fitness[_idx] * select_coeff)
# Calc probability vector
probabilities = ga_math.calc_probability_vector(fitness)
# Select P chromosomes with probabilities
new_chromosomes = np.zeros(chromosomes.shape, dtype=np.int)
# Selecting
for _idx in range(len(chromosomes)):
new_chromosomes[_idx] = chromosomes[ga_math.get_uniform(probabilities)]
return new_chromosomes | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/cluster/ga.py#L507-L534 | [
"def",
"_select",
"(",
"chromosomes",
",",
"data",
",",
"count_clusters",
",",
"select_coeff",
")",
":",
"# Calc centers",
"centres",
"=",
"ga_math",
".",
"get_centres",
"(",
"chromosomes",
",",
"data",
",",
"count_clusters",
")",
"# Calc fitness functions",
"fitness",
"=",
"genetic_algorithm",
".",
"_calc_fitness_function",
"(",
"centres",
",",
"data",
",",
"chromosomes",
")",
"for",
"_idx",
"in",
"range",
"(",
"len",
"(",
"fitness",
")",
")",
":",
"fitness",
"[",
"_idx",
"]",
"=",
"math",
".",
"exp",
"(",
"1",
"+",
"fitness",
"[",
"_idx",
"]",
"*",
"select_coeff",
")",
"# Calc probability vector",
"probabilities",
"=",
"ga_math",
".",
"calc_probability_vector",
"(",
"fitness",
")",
"# Select P chromosomes with probabilities",
"new_chromosomes",
"=",
"np",
".",
"zeros",
"(",
"chromosomes",
".",
"shape",
",",
"dtype",
"=",
"np",
".",
"int",
")",
"# Selecting",
"for",
"_idx",
"in",
"range",
"(",
"len",
"(",
"chromosomes",
")",
")",
":",
"new_chromosomes",
"[",
"_idx",
"]",
"=",
"chromosomes",
"[",
"ga_math",
".",
"get_uniform",
"(",
"probabilities",
")",
"]",
"return",
"new_chromosomes"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | genetic_algorithm._crossover | !
@brief Crossover procedure. | pyclustering/cluster/ga.py | def _crossover(chromosomes):
"""!
@brief Crossover procedure.
"""
# Get pairs to Crossover
pairs_to_crossover = np.array(range(len(chromosomes)))
# Set random pairs
np.random.shuffle(pairs_to_crossover)
# Index offset ( pairs_to_crossover split into 2 parts : [V1, V2, .. | P1, P2, ...] crossover between V<->P)
offset_in_pair = int(len(pairs_to_crossover) / 2)
# For each pair
for _idx in range(offset_in_pair):
# Generate random mask for crossover
crossover_mask = genetic_algorithm._get_crossover_mask(len(chromosomes[_idx]))
# Crossover a pair
genetic_algorithm._crossover_a_pair(chromosomes[pairs_to_crossover[_idx]],
chromosomes[pairs_to_crossover[_idx + offset_in_pair]],
crossover_mask) | def _crossover(chromosomes):
"""!
@brief Crossover procedure.
"""
# Get pairs to Crossover
pairs_to_crossover = np.array(range(len(chromosomes)))
# Set random pairs
np.random.shuffle(pairs_to_crossover)
# Index offset ( pairs_to_crossover split into 2 parts : [V1, V2, .. | P1, P2, ...] crossover between V<->P)
offset_in_pair = int(len(pairs_to_crossover) / 2)
# For each pair
for _idx in range(offset_in_pair):
# Generate random mask for crossover
crossover_mask = genetic_algorithm._get_crossover_mask(len(chromosomes[_idx]))
# Crossover a pair
genetic_algorithm._crossover_a_pair(chromosomes[pairs_to_crossover[_idx]],
chromosomes[pairs_to_crossover[_idx + offset_in_pair]],
crossover_mask) | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/cluster/ga.py#L538-L562 | [
"def",
"_crossover",
"(",
"chromosomes",
")",
":",
"# Get pairs to Crossover",
"pairs_to_crossover",
"=",
"np",
".",
"array",
"(",
"range",
"(",
"len",
"(",
"chromosomes",
")",
")",
")",
"# Set random pairs",
"np",
".",
"random",
".",
"shuffle",
"(",
"pairs_to_crossover",
")",
"# Index offset ( pairs_to_crossover split into 2 parts : [V1, V2, .. | P1, P2, ...] crossover between V<->P)",
"offset_in_pair",
"=",
"int",
"(",
"len",
"(",
"pairs_to_crossover",
")",
"/",
"2",
")",
"# For each pair",
"for",
"_idx",
"in",
"range",
"(",
"offset_in_pair",
")",
":",
"# Generate random mask for crossover",
"crossover_mask",
"=",
"genetic_algorithm",
".",
"_get_crossover_mask",
"(",
"len",
"(",
"chromosomes",
"[",
"_idx",
"]",
")",
")",
"# Crossover a pair",
"genetic_algorithm",
".",
"_crossover_a_pair",
"(",
"chromosomes",
"[",
"pairs_to_crossover",
"[",
"_idx",
"]",
"]",
",",
"chromosomes",
"[",
"pairs_to_crossover",
"[",
"_idx",
"+",
"offset_in_pair",
"]",
"]",
",",
"crossover_mask",
")"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | genetic_algorithm._mutation | !
@brief Mutation procedure. | pyclustering/cluster/ga.py | def _mutation(chromosomes, count_clusters, count_gen_for_mutation, coeff_mutation_count):
"""!
@brief Mutation procedure.
"""
# Count gens in Chromosome
count_gens = len(chromosomes[0])
# Get random chromosomes for mutation
random_idx_chromosomes = np.array(range(len(chromosomes)))
np.random.shuffle(random_idx_chromosomes)
#
for _idx_chromosome in range(int(len(random_idx_chromosomes) * coeff_mutation_count)):
#
for _ in range(count_gen_for_mutation):
# Get random gen
gen_num = np.random.randint(count_gens)
# Set random cluster
chromosomes[random_idx_chromosomes[_idx_chromosome]][gen_num] = np.random.randint(count_clusters) | def _mutation(chromosomes, count_clusters, count_gen_for_mutation, coeff_mutation_count):
"""!
@brief Mutation procedure.
"""
# Count gens in Chromosome
count_gens = len(chromosomes[0])
# Get random chromosomes for mutation
random_idx_chromosomes = np.array(range(len(chromosomes)))
np.random.shuffle(random_idx_chromosomes)
#
for _idx_chromosome in range(int(len(random_idx_chromosomes) * coeff_mutation_count)):
#
for _ in range(count_gen_for_mutation):
# Get random gen
gen_num = np.random.randint(count_gens)
# Set random cluster
chromosomes[random_idx_chromosomes[_idx_chromosome]][gen_num] = np.random.randint(count_clusters) | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/cluster/ga.py#L566-L589 | [
"def",
"_mutation",
"(",
"chromosomes",
",",
"count_clusters",
",",
"count_gen_for_mutation",
",",
"coeff_mutation_count",
")",
":",
"# Count gens in Chromosome",
"count_gens",
"=",
"len",
"(",
"chromosomes",
"[",
"0",
"]",
")",
"# Get random chromosomes for mutation",
"random_idx_chromosomes",
"=",
"np",
".",
"array",
"(",
"range",
"(",
"len",
"(",
"chromosomes",
")",
")",
")",
"np",
".",
"random",
".",
"shuffle",
"(",
"random_idx_chromosomes",
")",
"#",
"for",
"_idx_chromosome",
"in",
"range",
"(",
"int",
"(",
"len",
"(",
"random_idx_chromosomes",
")",
"*",
"coeff_mutation_count",
")",
")",
":",
"#",
"for",
"_",
"in",
"range",
"(",
"count_gen_for_mutation",
")",
":",
"# Get random gen",
"gen_num",
"=",
"np",
".",
"random",
".",
"randint",
"(",
"count_gens",
")",
"# Set random cluster",
"chromosomes",
"[",
"random_idx_chromosomes",
"[",
"_idx_chromosome",
"]",
"]",
"[",
"gen_num",
"]",
"=",
"np",
".",
"random",
".",
"randint",
"(",
"count_clusters",
")"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | genetic_algorithm._crossover_a_pair | !
@brief Crossovers a pair of chromosomes.
@param[in] chromosome_1 (numpy.array): The first chromosome for crossover.
@param[in] chromosome_2 (numpy.array): The second chromosome for crossover.
@param[in] mask (numpy.array): Crossover mask that defines which genes should be swapped. | pyclustering/cluster/ga.py | def _crossover_a_pair(chromosome_1, chromosome_2, mask):
"""!
@brief Crossovers a pair of chromosomes.
@param[in] chromosome_1 (numpy.array): The first chromosome for crossover.
@param[in] chromosome_2 (numpy.array): The second chromosome for crossover.
@param[in] mask (numpy.array): Crossover mask that defines which genes should be swapped.
"""
for _idx in range(len(chromosome_1)):
if mask[_idx] == 1:
# Swap values
chromosome_1[_idx], chromosome_2[_idx] = chromosome_2[_idx], chromosome_1[_idx] | def _crossover_a_pair(chromosome_1, chromosome_2, mask):
"""!
@brief Crossovers a pair of chromosomes.
@param[in] chromosome_1 (numpy.array): The first chromosome for crossover.
@param[in] chromosome_2 (numpy.array): The second chromosome for crossover.
@param[in] mask (numpy.array): Crossover mask that defines which genes should be swapped.
"""
for _idx in range(len(chromosome_1)):
if mask[_idx] == 1:
# Swap values
chromosome_1[_idx], chromosome_2[_idx] = chromosome_2[_idx], chromosome_1[_idx] | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/cluster/ga.py#L593-L607 | [
"def",
"_crossover_a_pair",
"(",
"chromosome_1",
",",
"chromosome_2",
",",
"mask",
")",
":",
"for",
"_idx",
"in",
"range",
"(",
"len",
"(",
"chromosome_1",
")",
")",
":",
"if",
"mask",
"[",
"_idx",
"]",
"==",
"1",
":",
"# Swap values",
"chromosome_1",
"[",
"_idx",
"]",
",",
"chromosome_2",
"[",
"_idx",
"]",
"=",
"chromosome_2",
"[",
"_idx",
"]",
",",
"chromosome_1",
"[",
"_idx",
"]"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | genetic_algorithm._get_crossover_mask | !
@brief Crossover mask to crossover a pair of chromosomes.
@param[in] mask_length (uint): Length of the mask. | pyclustering/cluster/ga.py | def _get_crossover_mask(mask_length):
"""!
@brief Crossover mask to crossover a pair of chromosomes.
@param[in] mask_length (uint): Length of the mask.
"""
# Initialize mask
mask = np.zeros(mask_length)
# Set a half of array to 1
mask[:int(int(mask_length) / 2)] = 1
# Random shuffle
np.random.shuffle(mask)
return mask | def _get_crossover_mask(mask_length):
"""!
@brief Crossover mask to crossover a pair of chromosomes.
@param[in] mask_length (uint): Length of the mask.
"""
# Initialize mask
mask = np.zeros(mask_length)
# Set a half of array to 1
mask[:int(int(mask_length) / 2)] = 1
# Random shuffle
np.random.shuffle(mask)
return mask | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/cluster/ga.py#L611-L628 | [
"def",
"_get_crossover_mask",
"(",
"mask_length",
")",
":",
"# Initialize mask",
"mask",
"=",
"np",
".",
"zeros",
"(",
"mask_length",
")",
"# Set a half of array to 1",
"mask",
"[",
":",
"int",
"(",
"int",
"(",
"mask_length",
")",
"/",
"2",
")",
"]",
"=",
"1",
"# Random shuffle",
"np",
".",
"random",
".",
"shuffle",
"(",
"mask",
")",
"return",
"mask"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | genetic_algorithm._init_population | !
@brief Returns first population as a uniform random choice.
@param[in] count_clusters (uint): Amount of clusters that should be allocated.
@param[in] count_data (uint): Data size that is used for clustering process.
@param[in] chromosome_count (uint):Amount of chromosome that is used for clustering. | pyclustering/cluster/ga.py | def _init_population(count_clusters, count_data, chromosome_count):
"""!
@brief Returns first population as a uniform random choice.
@param[in] count_clusters (uint): Amount of clusters that should be allocated.
@param[in] count_data (uint): Data size that is used for clustering process.
@param[in] chromosome_count (uint):Amount of chromosome that is used for clustering.
"""
population = np.random.randint(count_clusters, size=(chromosome_count, count_data))
return population | def _init_population(count_clusters, count_data, chromosome_count):
"""!
@brief Returns first population as a uniform random choice.
@param[in] count_clusters (uint): Amount of clusters that should be allocated.
@param[in] count_data (uint): Data size that is used for clustering process.
@param[in] chromosome_count (uint):Amount of chromosome that is used for clustering.
"""
population = np.random.randint(count_clusters, size=(chromosome_count, count_data))
return population | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/cluster/ga.py#L632-L644 | [
"def",
"_init_population",
"(",
"count_clusters",
",",
"count_data",
",",
"chromosome_count",
")",
":",
"population",
"=",
"np",
".",
"random",
".",
"randint",
"(",
"count_clusters",
",",
"size",
"=",
"(",
"chromosome_count",
",",
"count_data",
")",
")",
"return",
"population"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | genetic_algorithm._get_best_chromosome | !
@brief Returns the current best chromosome.
@param[in] chromosomes (list): Chromosomes that are used for searching.
@param[in] data (list): Input data that is used for clustering process.
@param[in] count_clusters (uint): Amount of clusters that should be allocated.
@return (list, float, list) The best chromosome, its fitness function value and fitness function values for
all chromosomes. | pyclustering/cluster/ga.py | def _get_best_chromosome(chromosomes, data, count_clusters):
"""!
@brief Returns the current best chromosome.
@param[in] chromosomes (list): Chromosomes that are used for searching.
@param[in] data (list): Input data that is used for clustering process.
@param[in] count_clusters (uint): Amount of clusters that should be allocated.
@return (list, float, list) The best chromosome, its fitness function value and fitness function values for
all chromosomes.
"""
# Calc centers
centres = ga_math.get_centres(chromosomes, data, count_clusters)
# Calc Fitness functions
fitness_functions = genetic_algorithm._calc_fitness_function(centres, data, chromosomes)
# Index of the best chromosome
best_chromosome_idx = fitness_functions.argmin()
# Get chromosome with the best fitness function
return chromosomes[best_chromosome_idx], fitness_functions[best_chromosome_idx], fitness_functions | def _get_best_chromosome(chromosomes, data, count_clusters):
"""!
@brief Returns the current best chromosome.
@param[in] chromosomes (list): Chromosomes that are used for searching.
@param[in] data (list): Input data that is used for clustering process.
@param[in] count_clusters (uint): Amount of clusters that should be allocated.
@return (list, float, list) The best chromosome, its fitness function value and fitness function values for
all chromosomes.
"""
# Calc centers
centres = ga_math.get_centres(chromosomes, data, count_clusters)
# Calc Fitness functions
fitness_functions = genetic_algorithm._calc_fitness_function(centres, data, chromosomes)
# Index of the best chromosome
best_chromosome_idx = fitness_functions.argmin()
# Get chromosome with the best fitness function
return chromosomes[best_chromosome_idx], fitness_functions[best_chromosome_idx], fitness_functions | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/cluster/ga.py#L648-L671 | [
"def",
"_get_best_chromosome",
"(",
"chromosomes",
",",
"data",
",",
"count_clusters",
")",
":",
"# Calc centers",
"centres",
"=",
"ga_math",
".",
"get_centres",
"(",
"chromosomes",
",",
"data",
",",
"count_clusters",
")",
"# Calc Fitness functions",
"fitness_functions",
"=",
"genetic_algorithm",
".",
"_calc_fitness_function",
"(",
"centres",
",",
"data",
",",
"chromosomes",
")",
"# Index of the best chromosome",
"best_chromosome_idx",
"=",
"fitness_functions",
".",
"argmin",
"(",
")",
"# Get chromosome with the best fitness function",
"return",
"chromosomes",
"[",
"best_chromosome_idx",
"]",
",",
"fitness_functions",
"[",
"best_chromosome_idx",
"]",
",",
"fitness_functions"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | genetic_algorithm._calc_fitness_function | !
@brief Calculate fitness function values for chromosomes.
@param[in] centres (list): Cluster centers.
@param[in] data (list): Input data that is used for clustering process.
@param[in] chromosomes (list): Chromosomes whose fitness function's values are calculated.
@return (list) Fitness function value for each chromosome correspondingly. | pyclustering/cluster/ga.py | def _calc_fitness_function(centres, data, chromosomes):
"""!
@brief Calculate fitness function values for chromosomes.
@param[in] centres (list): Cluster centers.
@param[in] data (list): Input data that is used for clustering process.
@param[in] chromosomes (list): Chromosomes whose fitness function's values are calculated.
@return (list) Fitness function value for each chromosome correspondingly.
"""
# Get count of chromosomes and clusters
count_chromosome = len(chromosomes)
# Initialize fitness function values
fitness_function = np.zeros(count_chromosome)
# Calc fitness function for each chromosome
for _idx_chromosome in range(count_chromosome):
# Get centers for a selected chromosome
centres_data = np.zeros(data.shape)
# Fill data centres
for _idx in range(len(data)):
centres_data[_idx] = centres[_idx_chromosome][chromosomes[_idx_chromosome][_idx]]
# Get City Block distance for a chromosome
fitness_function[_idx_chromosome] += np.sum(abs(data - centres_data))
return fitness_function | def _calc_fitness_function(centres, data, chromosomes):
"""!
@brief Calculate fitness function values for chromosomes.
@param[in] centres (list): Cluster centers.
@param[in] data (list): Input data that is used for clustering process.
@param[in] chromosomes (list): Chromosomes whose fitness function's values are calculated.
@return (list) Fitness function value for each chromosome correspondingly.
"""
# Get count of chromosomes and clusters
count_chromosome = len(chromosomes)
# Initialize fitness function values
fitness_function = np.zeros(count_chromosome)
# Calc fitness function for each chromosome
for _idx_chromosome in range(count_chromosome):
# Get centers for a selected chromosome
centres_data = np.zeros(data.shape)
# Fill data centres
for _idx in range(len(data)):
centres_data[_idx] = centres[_idx_chromosome][chromosomes[_idx_chromosome][_idx]]
# Get City Block distance for a chromosome
fitness_function[_idx_chromosome] += np.sum(abs(data - centres_data))
return fitness_function | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/cluster/ga.py#L675-L706 | [
"def",
"_calc_fitness_function",
"(",
"centres",
",",
"data",
",",
"chromosomes",
")",
":",
"# Get count of chromosomes and clusters",
"count_chromosome",
"=",
"len",
"(",
"chromosomes",
")",
"# Initialize fitness function values",
"fitness_function",
"=",
"np",
".",
"zeros",
"(",
"count_chromosome",
")",
"# Calc fitness function for each chromosome",
"for",
"_idx_chromosome",
"in",
"range",
"(",
"count_chromosome",
")",
":",
"# Get centers for a selected chromosome",
"centres_data",
"=",
"np",
".",
"zeros",
"(",
"data",
".",
"shape",
")",
"# Fill data centres",
"for",
"_idx",
"in",
"range",
"(",
"len",
"(",
"data",
")",
")",
":",
"centres_data",
"[",
"_idx",
"]",
"=",
"centres",
"[",
"_idx_chromosome",
"]",
"[",
"chromosomes",
"[",
"_idx_chromosome",
"]",
"[",
"_idx",
"]",
"]",
"# Get City Block distance for a chromosome",
"fitness_function",
"[",
"_idx_chromosome",
"]",
"+=",
"np",
".",
"sum",
"(",
"abs",
"(",
"data",
"-",
"centres_data",
")",
")",
"return",
"fitness_function"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | cfentry.get_distance | !
@brief Calculates distance between two clusters in line with measurement type.
@details In case of usage CENTROID_EUCLIDIAN_DISTANCE square euclidian distance will be returned.
Square root should be taken from the result for obtaining real euclidian distance between
entries.
@param[in] entry (cfentry): Clustering feature to which distance should be obtained.
@param[in] type_measurement (measurement_type): Distance measurement algorithm between two clusters.
@return (double) Distance between two clusters. | pyclustering/container/cftree.py | def get_distance(self, entry, type_measurement):
"""!
@brief Calculates distance between two clusters in line with measurement type.
@details In case of usage CENTROID_EUCLIDIAN_DISTANCE square euclidian distance will be returned.
Square root should be taken from the result for obtaining real euclidian distance between
entries.
@param[in] entry (cfentry): Clustering feature to which distance should be obtained.
@param[in] type_measurement (measurement_type): Distance measurement algorithm between two clusters.
@return (double) Distance between two clusters.
"""
if (type_measurement is measurement_type.CENTROID_EUCLIDEAN_DISTANCE):
return euclidean_distance_square(entry.get_centroid(), self.get_centroid());
elif (type_measurement is measurement_type.CENTROID_MANHATTAN_DISTANCE):
return manhattan_distance(entry.get_centroid(), self.get_centroid());
elif (type_measurement is measurement_type.AVERAGE_INTER_CLUSTER_DISTANCE):
return self.__get_average_inter_cluster_distance(entry);
elif (type_measurement is measurement_type.AVERAGE_INTRA_CLUSTER_DISTANCE):
return self.__get_average_intra_cluster_distance(entry);
elif (type_measurement is measurement_type.VARIANCE_INCREASE_DISTANCE):
return self.__get_variance_increase_distance(entry);
else:
assert 0; | def get_distance(self, entry, type_measurement):
"""!
@brief Calculates distance between two clusters in line with measurement type.
@details In case of usage CENTROID_EUCLIDIAN_DISTANCE square euclidian distance will be returned.
Square root should be taken from the result for obtaining real euclidian distance between
entries.
@param[in] entry (cfentry): Clustering feature to which distance should be obtained.
@param[in] type_measurement (measurement_type): Distance measurement algorithm between two clusters.
@return (double) Distance between two clusters.
"""
if (type_measurement is measurement_type.CENTROID_EUCLIDEAN_DISTANCE):
return euclidean_distance_square(entry.get_centroid(), self.get_centroid());
elif (type_measurement is measurement_type.CENTROID_MANHATTAN_DISTANCE):
return manhattan_distance(entry.get_centroid(), self.get_centroid());
elif (type_measurement is measurement_type.AVERAGE_INTER_CLUSTER_DISTANCE):
return self.__get_average_inter_cluster_distance(entry);
elif (type_measurement is measurement_type.AVERAGE_INTRA_CLUSTER_DISTANCE):
return self.__get_average_intra_cluster_distance(entry);
elif (type_measurement is measurement_type.VARIANCE_INCREASE_DISTANCE):
return self.__get_variance_increase_distance(entry);
else:
assert 0; | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/container/cftree.py#L226-L257 | [
"def",
"get_distance",
"(",
"self",
",",
"entry",
",",
"type_measurement",
")",
":",
"if",
"(",
"type_measurement",
"is",
"measurement_type",
".",
"CENTROID_EUCLIDEAN_DISTANCE",
")",
":",
"return",
"euclidean_distance_square",
"(",
"entry",
".",
"get_centroid",
"(",
")",
",",
"self",
".",
"get_centroid",
"(",
")",
")",
"elif",
"(",
"type_measurement",
"is",
"measurement_type",
".",
"CENTROID_MANHATTAN_DISTANCE",
")",
":",
"return",
"manhattan_distance",
"(",
"entry",
".",
"get_centroid",
"(",
")",
",",
"self",
".",
"get_centroid",
"(",
")",
")",
"elif",
"(",
"type_measurement",
"is",
"measurement_type",
".",
"AVERAGE_INTER_CLUSTER_DISTANCE",
")",
":",
"return",
"self",
".",
"__get_average_inter_cluster_distance",
"(",
"entry",
")",
"elif",
"(",
"type_measurement",
"is",
"measurement_type",
".",
"AVERAGE_INTRA_CLUSTER_DISTANCE",
")",
":",
"return",
"self",
".",
"__get_average_intra_cluster_distance",
"(",
"entry",
")",
"elif",
"(",
"type_measurement",
"is",
"measurement_type",
".",
"VARIANCE_INCREASE_DISTANCE",
")",
":",
"return",
"self",
".",
"__get_variance_increase_distance",
"(",
"entry",
")",
"else",
":",
"assert",
"0"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | cfentry.get_centroid | !
@brief Calculates centroid of cluster that is represented by the entry.
@details It's calculated once when it's requested after the last changes.
@return (list) Centroid of cluster that is represented by the entry. | pyclustering/container/cftree.py | def get_centroid(self):
"""!
@brief Calculates centroid of cluster that is represented by the entry.
@details It's calculated once when it's requested after the last changes.
@return (list) Centroid of cluster that is represented by the entry.
"""
if (self.__centroid is not None):
return self.__centroid;
self.__centroid = [0] * len(self.linear_sum);
for index_dimension in range(0, len(self.linear_sum)):
self.__centroid[index_dimension] = self.linear_sum[index_dimension] / self.number_points;
return self.__centroid; | def get_centroid(self):
"""!
@brief Calculates centroid of cluster that is represented by the entry.
@details It's calculated once when it's requested after the last changes.
@return (list) Centroid of cluster that is represented by the entry.
"""
if (self.__centroid is not None):
return self.__centroid;
self.__centroid = [0] * len(self.linear_sum);
for index_dimension in range(0, len(self.linear_sum)):
self.__centroid[index_dimension] = self.linear_sum[index_dimension] / self.number_points;
return self.__centroid; | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/container/cftree.py#L260-L276 | [
"def",
"get_centroid",
"(",
"self",
")",
":",
"if",
"(",
"self",
".",
"__centroid",
"is",
"not",
"None",
")",
":",
"return",
"self",
".",
"__centroid",
"self",
".",
"__centroid",
"=",
"[",
"0",
"]",
"*",
"len",
"(",
"self",
".",
"linear_sum",
")",
"for",
"index_dimension",
"in",
"range",
"(",
"0",
",",
"len",
"(",
"self",
".",
"linear_sum",
")",
")",
":",
"self",
".",
"__centroid",
"[",
"index_dimension",
"]",
"=",
"self",
".",
"linear_sum",
"[",
"index_dimension",
"]",
"/",
"self",
".",
"number_points",
"return",
"self",
".",
"__centroid"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | cfentry.get_radius | !
@brief Calculates radius of cluster that is represented by the entry.
@details It's calculated once when it's requested after the last changes.
@return (double) Radius of cluster that is represented by the entry. | pyclustering/container/cftree.py | def get_radius(self):
"""!
@brief Calculates radius of cluster that is represented by the entry.
@details It's calculated once when it's requested after the last changes.
@return (double) Radius of cluster that is represented by the entry.
"""
if (self.__radius is not None):
return self.__radius;
centroid = self.get_centroid();
radius_part_1 = self.square_sum;
radius_part_2 = 0.0;
radius_part_3 = 0.0;
if (type(centroid) == list):
radius_part_2 = 2.0 * sum(list_math_multiplication(self.linear_sum, centroid));
radius_part_3 = self.number_points * sum(list_math_multiplication(centroid, centroid));
else:
radius_part_2 = 2.0 * self.linear_sum * centroid;
radius_part_3 = self.number_points * centroid * centroid;
self.__radius = ( (1.0 / self.number_points) * (radius_part_1 - radius_part_2 + radius_part_3) ) ** 0.5;
return self.__radius; | def get_radius(self):
"""!
@brief Calculates radius of cluster that is represented by the entry.
@details It's calculated once when it's requested after the last changes.
@return (double) Radius of cluster that is represented by the entry.
"""
if (self.__radius is not None):
return self.__radius;
centroid = self.get_centroid();
radius_part_1 = self.square_sum;
radius_part_2 = 0.0;
radius_part_3 = 0.0;
if (type(centroid) == list):
radius_part_2 = 2.0 * sum(list_math_multiplication(self.linear_sum, centroid));
radius_part_3 = self.number_points * sum(list_math_multiplication(centroid, centroid));
else:
radius_part_2 = 2.0 * self.linear_sum * centroid;
radius_part_3 = self.number_points * centroid * centroid;
self.__radius = ( (1.0 / self.number_points) * (radius_part_1 - radius_part_2 + radius_part_3) ) ** 0.5;
return self.__radius; | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/container/cftree.py#L279-L306 | [
"def",
"get_radius",
"(",
"self",
")",
":",
"if",
"(",
"self",
".",
"__radius",
"is",
"not",
"None",
")",
":",
"return",
"self",
".",
"__radius",
"centroid",
"=",
"self",
".",
"get_centroid",
"(",
")",
"radius_part_1",
"=",
"self",
".",
"square_sum",
"radius_part_2",
"=",
"0.0",
"radius_part_3",
"=",
"0.0",
"if",
"(",
"type",
"(",
"centroid",
")",
"==",
"list",
")",
":",
"radius_part_2",
"=",
"2.0",
"*",
"sum",
"(",
"list_math_multiplication",
"(",
"self",
".",
"linear_sum",
",",
"centroid",
")",
")",
"radius_part_3",
"=",
"self",
".",
"number_points",
"*",
"sum",
"(",
"list_math_multiplication",
"(",
"centroid",
",",
"centroid",
")",
")",
"else",
":",
"radius_part_2",
"=",
"2.0",
"*",
"self",
".",
"linear_sum",
"*",
"centroid",
"radius_part_3",
"=",
"self",
".",
"number_points",
"*",
"centroid",
"*",
"centroid",
"self",
".",
"__radius",
"=",
"(",
"(",
"1.0",
"/",
"self",
".",
"number_points",
")",
"*",
"(",
"radius_part_1",
"-",
"radius_part_2",
"+",
"radius_part_3",
")",
")",
"**",
"0.5",
"return",
"self",
".",
"__radius"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | cfentry.get_diameter | !
@brief Calculates diameter of cluster that is represented by the entry.
@details It's calculated once when it's requested after the last changes.
@return (double) Diameter of cluster that is represented by the entry. | pyclustering/container/cftree.py | def get_diameter(self):
"""!
@brief Calculates diameter of cluster that is represented by the entry.
@details It's calculated once when it's requested after the last changes.
@return (double) Diameter of cluster that is represented by the entry.
"""
if (self.__diameter is not None):
return self.__diameter;
diameter_part = 0.0;
if (type(self.linear_sum) == list):
diameter_part = self.square_sum * self.number_points - 2.0 * sum(list_math_multiplication(self.linear_sum, self.linear_sum)) + self.square_sum * self.number_points;
else:
diameter_part = self.square_sum * self.number_points - 2.0 * self.linear_sum * self.linear_sum + self.square_sum * self.number_points;
self.__diameter = ( diameter_part / (self.number_points * (self.number_points - 1)) ) ** 0.5;
return self.__diameter; | def get_diameter(self):
"""!
@brief Calculates diameter of cluster that is represented by the entry.
@details It's calculated once when it's requested after the last changes.
@return (double) Diameter of cluster that is represented by the entry.
"""
if (self.__diameter is not None):
return self.__diameter;
diameter_part = 0.0;
if (type(self.linear_sum) == list):
diameter_part = self.square_sum * self.number_points - 2.0 * sum(list_math_multiplication(self.linear_sum, self.linear_sum)) + self.square_sum * self.number_points;
else:
diameter_part = self.square_sum * self.number_points - 2.0 * self.linear_sum * self.linear_sum + self.square_sum * self.number_points;
self.__diameter = ( diameter_part / (self.number_points * (self.number_points - 1)) ) ** 0.5;
return self.__diameter; | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/container/cftree.py#L309-L328 | [
"def",
"get_diameter",
"(",
"self",
")",
":",
"if",
"(",
"self",
".",
"__diameter",
"is",
"not",
"None",
")",
":",
"return",
"self",
".",
"__diameter",
"diameter_part",
"=",
"0.0",
"if",
"(",
"type",
"(",
"self",
".",
"linear_sum",
")",
"==",
"list",
")",
":",
"diameter_part",
"=",
"self",
".",
"square_sum",
"*",
"self",
".",
"number_points",
"-",
"2.0",
"*",
"sum",
"(",
"list_math_multiplication",
"(",
"self",
".",
"linear_sum",
",",
"self",
".",
"linear_sum",
")",
")",
"+",
"self",
".",
"square_sum",
"*",
"self",
".",
"number_points",
"else",
":",
"diameter_part",
"=",
"self",
".",
"square_sum",
"*",
"self",
".",
"number_points",
"-",
"2.0",
"*",
"self",
".",
"linear_sum",
"*",
"self",
".",
"linear_sum",
"+",
"self",
".",
"square_sum",
"*",
"self",
".",
"number_points",
"self",
".",
"__diameter",
"=",
"(",
"diameter_part",
"/",
"(",
"self",
".",
"number_points",
"*",
"(",
"self",
".",
"number_points",
"-",
"1",
")",
")",
")",
"**",
"0.5",
"return",
"self",
".",
"__diameter"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | cfentry.__get_average_inter_cluster_distance | !
@brief Calculates average inter cluster distance between current and specified clusters.
@param[in] entry (cfentry): Clustering feature to which distance should be obtained.
@return (double) Average inter cluster distance. | pyclustering/container/cftree.py | def __get_average_inter_cluster_distance(self, entry):
"""!
@brief Calculates average inter cluster distance between current and specified clusters.
@param[in] entry (cfentry): Clustering feature to which distance should be obtained.
@return (double) Average inter cluster distance.
"""
linear_part_distance = sum(list_math_multiplication(self.linear_sum, entry.linear_sum));
return ( (entry.number_points * self.square_sum - 2.0 * linear_part_distance + self.number_points * entry.square_sum) / (self.number_points * entry.number_points) ) ** 0.5; | def __get_average_inter_cluster_distance(self, entry):
"""!
@brief Calculates average inter cluster distance between current and specified clusters.
@param[in] entry (cfentry): Clustering feature to which distance should be obtained.
@return (double) Average inter cluster distance.
"""
linear_part_distance = sum(list_math_multiplication(self.linear_sum, entry.linear_sum));
return ( (entry.number_points * self.square_sum - 2.0 * linear_part_distance + self.number_points * entry.square_sum) / (self.number_points * entry.number_points) ) ** 0.5; | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/container/cftree.py#L331-L343 | [
"def",
"__get_average_inter_cluster_distance",
"(",
"self",
",",
"entry",
")",
":",
"linear_part_distance",
"=",
"sum",
"(",
"list_math_multiplication",
"(",
"self",
".",
"linear_sum",
",",
"entry",
".",
"linear_sum",
")",
")",
"return",
"(",
"(",
"entry",
".",
"number_points",
"*",
"self",
".",
"square_sum",
"-",
"2.0",
"*",
"linear_part_distance",
"+",
"self",
".",
"number_points",
"*",
"entry",
".",
"square_sum",
")",
"/",
"(",
"self",
".",
"number_points",
"*",
"entry",
".",
"number_points",
")",
")",
"**",
"0.5"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | cfentry.__get_average_intra_cluster_distance | !
@brief Calculates average intra cluster distance between current and specified clusters.
@param[in] entry (cfentry): Clustering feature to which distance should be obtained.
@return (double) Average intra cluster distance. | pyclustering/container/cftree.py | def __get_average_intra_cluster_distance(self, entry):
"""!
@brief Calculates average intra cluster distance between current and specified clusters.
@param[in] entry (cfentry): Clustering feature to which distance should be obtained.
@return (double) Average intra cluster distance.
"""
linear_part_first = list_math_addition(self.linear_sum, entry.linear_sum);
linear_part_second = linear_part_first;
linear_part_distance = sum(list_math_multiplication(linear_part_first, linear_part_second));
general_part_distance = 2.0 * (self.number_points + entry.number_points) * (self.square_sum + entry.square_sum) - 2.0 * linear_part_distance;
return (general_part_distance / ( (self.number_points + entry.number_points) * (self.number_points + entry.number_points - 1.0) )) ** 0.5; | def __get_average_intra_cluster_distance(self, entry):
"""!
@brief Calculates average intra cluster distance between current and specified clusters.
@param[in] entry (cfentry): Clustering feature to which distance should be obtained.
@return (double) Average intra cluster distance.
"""
linear_part_first = list_math_addition(self.linear_sum, entry.linear_sum);
linear_part_second = linear_part_first;
linear_part_distance = sum(list_math_multiplication(linear_part_first, linear_part_second));
general_part_distance = 2.0 * (self.number_points + entry.number_points) * (self.square_sum + entry.square_sum) - 2.0 * linear_part_distance;
return (general_part_distance / ( (self.number_points + entry.number_points) * (self.number_points + entry.number_points - 1.0) )) ** 0.5; | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/container/cftree.py#L346-L363 | [
"def",
"__get_average_intra_cluster_distance",
"(",
"self",
",",
"entry",
")",
":",
"linear_part_first",
"=",
"list_math_addition",
"(",
"self",
".",
"linear_sum",
",",
"entry",
".",
"linear_sum",
")",
"linear_part_second",
"=",
"linear_part_first",
"linear_part_distance",
"=",
"sum",
"(",
"list_math_multiplication",
"(",
"linear_part_first",
",",
"linear_part_second",
")",
")",
"general_part_distance",
"=",
"2.0",
"*",
"(",
"self",
".",
"number_points",
"+",
"entry",
".",
"number_points",
")",
"*",
"(",
"self",
".",
"square_sum",
"+",
"entry",
".",
"square_sum",
")",
"-",
"2.0",
"*",
"linear_part_distance",
"return",
"(",
"general_part_distance",
"/",
"(",
"(",
"self",
".",
"number_points",
"+",
"entry",
".",
"number_points",
")",
"*",
"(",
"self",
".",
"number_points",
"+",
"entry",
".",
"number_points",
"-",
"1.0",
")",
")",
")",
"**",
"0.5"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | cfentry.__get_variance_increase_distance | !
@brief Calculates variance increase distance between current and specified clusters.
@param[in] entry (cfentry): Clustering feature to which distance should be obtained.
@return (double) Variance increase distance. | pyclustering/container/cftree.py | def __get_variance_increase_distance(self, entry):
"""!
@brief Calculates variance increase distance between current and specified clusters.
@param[in] entry (cfentry): Clustering feature to which distance should be obtained.
@return (double) Variance increase distance.
"""
linear_part_12 = list_math_addition(self.linear_sum, entry.linear_sum);
variance_part_first = (self.square_sum + entry.square_sum) - \
2.0 * sum(list_math_multiplication(linear_part_12, linear_part_12)) / (self.number_points + entry.number_points) + \
(self.number_points + entry.number_points) * sum(list_math_multiplication(linear_part_12, linear_part_12)) / (self.number_points + entry.number_points)**2.0;
linear_part_11 = sum(list_math_multiplication(self.linear_sum, self.linear_sum));
variance_part_second = -( self.square_sum - (2.0 * linear_part_11 / self.number_points) + (linear_part_11 / self.number_points) );
linear_part_22 = sum(list_math_multiplication(entry.linear_sum, entry.linear_sum));
variance_part_third = -( entry.square_sum - (2.0 / entry.number_points) * linear_part_22 + entry.number_points * (1.0 / entry.number_points ** 2.0) * linear_part_22 );
return (variance_part_first + variance_part_second + variance_part_third); | def __get_variance_increase_distance(self, entry):
"""!
@brief Calculates variance increase distance between current and specified clusters.
@param[in] entry (cfentry): Clustering feature to which distance should be obtained.
@return (double) Variance increase distance.
"""
linear_part_12 = list_math_addition(self.linear_sum, entry.linear_sum);
variance_part_first = (self.square_sum + entry.square_sum) - \
2.0 * sum(list_math_multiplication(linear_part_12, linear_part_12)) / (self.number_points + entry.number_points) + \
(self.number_points + entry.number_points) * sum(list_math_multiplication(linear_part_12, linear_part_12)) / (self.number_points + entry.number_points)**2.0;
linear_part_11 = sum(list_math_multiplication(self.linear_sum, self.linear_sum));
variance_part_second = -( self.square_sum - (2.0 * linear_part_11 / self.number_points) + (linear_part_11 / self.number_points) );
linear_part_22 = sum(list_math_multiplication(entry.linear_sum, entry.linear_sum));
variance_part_third = -( entry.square_sum - (2.0 / entry.number_points) * linear_part_22 + entry.number_points * (1.0 / entry.number_points ** 2.0) * linear_part_22 );
return (variance_part_first + variance_part_second + variance_part_third); | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/container/cftree.py#L366-L388 | [
"def",
"__get_variance_increase_distance",
"(",
"self",
",",
"entry",
")",
":",
"linear_part_12",
"=",
"list_math_addition",
"(",
"self",
".",
"linear_sum",
",",
"entry",
".",
"linear_sum",
")",
"variance_part_first",
"=",
"(",
"self",
".",
"square_sum",
"+",
"entry",
".",
"square_sum",
")",
"-",
"2.0",
"*",
"sum",
"(",
"list_math_multiplication",
"(",
"linear_part_12",
",",
"linear_part_12",
")",
")",
"/",
"(",
"self",
".",
"number_points",
"+",
"entry",
".",
"number_points",
")",
"+",
"(",
"self",
".",
"number_points",
"+",
"entry",
".",
"number_points",
")",
"*",
"sum",
"(",
"list_math_multiplication",
"(",
"linear_part_12",
",",
"linear_part_12",
")",
")",
"/",
"(",
"self",
".",
"number_points",
"+",
"entry",
".",
"number_points",
")",
"**",
"2.0",
"linear_part_11",
"=",
"sum",
"(",
"list_math_multiplication",
"(",
"self",
".",
"linear_sum",
",",
"self",
".",
"linear_sum",
")",
")",
"variance_part_second",
"=",
"-",
"(",
"self",
".",
"square_sum",
"-",
"(",
"2.0",
"*",
"linear_part_11",
"/",
"self",
".",
"number_points",
")",
"+",
"(",
"linear_part_11",
"/",
"self",
".",
"number_points",
")",
")",
"linear_part_22",
"=",
"sum",
"(",
"list_math_multiplication",
"(",
"entry",
".",
"linear_sum",
",",
"entry",
".",
"linear_sum",
")",
")",
"variance_part_third",
"=",
"-",
"(",
"entry",
".",
"square_sum",
"-",
"(",
"2.0",
"/",
"entry",
".",
"number_points",
")",
"*",
"linear_part_22",
"+",
"entry",
".",
"number_points",
"*",
"(",
"1.0",
"/",
"entry",
".",
"number_points",
"**",
"2.0",
")",
"*",
"linear_part_22",
")",
"return",
"(",
"variance_part_first",
"+",
"variance_part_second",
"+",
"variance_part_third",
")"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | cfnode.get_distance | !
@brief Calculates distance between nodes in line with specified type measurement.
@param[in] node (cfnode): CF-node that is used for calculation distance to the current node.
@param[in] type_measurement (measurement_type): Measurement type that is used for calculation distance.
@return (double) Distance between two nodes. | pyclustering/container/cftree.py | def get_distance(self, node, type_measurement):
"""!
@brief Calculates distance between nodes in line with specified type measurement.
@param[in] node (cfnode): CF-node that is used for calculation distance to the current node.
@param[in] type_measurement (measurement_type): Measurement type that is used for calculation distance.
@return (double) Distance between two nodes.
"""
return self.feature.get_distance(node.feature, type_measurement); | def get_distance(self, node, type_measurement):
"""!
@brief Calculates distance between nodes in line with specified type measurement.
@param[in] node (cfnode): CF-node that is used for calculation distance to the current node.
@param[in] type_measurement (measurement_type): Measurement type that is used for calculation distance.
@return (double) Distance between two nodes.
"""
return self.feature.get_distance(node.feature, type_measurement); | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/container/cftree.py#L437-L448 | [
"def",
"get_distance",
"(",
"self",
",",
"node",
",",
"type_measurement",
")",
":",
"return",
"self",
".",
"feature",
".",
"get_distance",
"(",
"node",
".",
"feature",
",",
"type_measurement",
")"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | non_leaf_node.insert_successor | !
@brief Insert successor to the node.
@param[in] successor (cfnode): Successor for adding. | pyclustering/container/cftree.py | def insert_successor(self, successor):
"""!
@brief Insert successor to the node.
@param[in] successor (cfnode): Successor for adding.
"""
self.feature += successor.feature;
self.successors.append(successor);
successor.parent = self; | def insert_successor(self, successor):
"""!
@brief Insert successor to the node.
@param[in] successor (cfnode): Successor for adding.
"""
self.feature += successor.feature;
self.successors.append(successor);
successor.parent = self; | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/container/cftree.py#L501-L512 | [
"def",
"insert_successor",
"(",
"self",
",",
"successor",
")",
":",
"self",
".",
"feature",
"+=",
"successor",
".",
"feature",
"self",
".",
"successors",
".",
"append",
"(",
"successor",
")",
"successor",
".",
"parent",
"=",
"self"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | non_leaf_node.remove_successor | !
@brief Remove successor from the node.
@param[in] successor (cfnode): Successor for removing. | pyclustering/container/cftree.py | def remove_successor(self, successor):
"""!
@brief Remove successor from the node.
@param[in] successor (cfnode): Successor for removing.
"""
self.feature -= successor.feature;
self.successors.append(successor);
successor.parent = self; | def remove_successor(self, successor):
"""!
@brief Remove successor from the node.
@param[in] successor (cfnode): Successor for removing.
"""
self.feature -= successor.feature;
self.successors.append(successor);
successor.parent = self; | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/container/cftree.py#L515-L526 | [
"def",
"remove_successor",
"(",
"self",
",",
"successor",
")",
":",
"self",
".",
"feature",
"-=",
"successor",
".",
"feature",
"self",
".",
"successors",
".",
"append",
"(",
"successor",
")",
"successor",
".",
"parent",
"=",
"self"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | non_leaf_node.merge | !
@brief Merge non-leaf node to the current.
@param[in] node (non_leaf_node): Non-leaf node that should be merged with current. | pyclustering/container/cftree.py | def merge(self, node):
"""!
@brief Merge non-leaf node to the current.
@param[in] node (non_leaf_node): Non-leaf node that should be merged with current.
"""
self.feature += node.feature;
for child in node.successors:
child.parent = self;
self.successors.append(child); | def merge(self, node):
"""!
@brief Merge non-leaf node to the current.
@param[in] node (non_leaf_node): Non-leaf node that should be merged with current.
"""
self.feature += node.feature;
for child in node.successors:
child.parent = self;
self.successors.append(child); | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/container/cftree.py#L529-L541 | [
"def",
"merge",
"(",
"self",
",",
"node",
")",
":",
"self",
".",
"feature",
"+=",
"node",
".",
"feature",
"for",
"child",
"in",
"node",
".",
"successors",
":",
"child",
".",
"parent",
"=",
"self",
"self",
".",
"successors",
".",
"append",
"(",
"child",
")"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | non_leaf_node.get_farthest_successors | !
@brief Find pair of farthest successors of the node in line with measurement type.
@param[in] type_measurement (measurement_type): Measurement type that is used for obtaining farthest successors.
@return (list) Pair of farthest successors represented by list [cfnode1, cfnode2]. | pyclustering/container/cftree.py | def get_farthest_successors(self, type_measurement):
"""!
@brief Find pair of farthest successors of the node in line with measurement type.
@param[in] type_measurement (measurement_type): Measurement type that is used for obtaining farthest successors.
@return (list) Pair of farthest successors represented by list [cfnode1, cfnode2].
"""
farthest_node1 = None;
farthest_node2 = None;
farthest_distance = 0;
for i in range(0, len(self.successors)):
candidate1 = self.successors[i];
for j in range(i + 1, len(self.successors)):
candidate2 = self.successors[j];
candidate_distance = candidate1.get_distance(candidate2, type_measurement);
if (candidate_distance > farthest_distance):
farthest_distance = candidate_distance;
farthest_node1 = candidate1;
farthest_node2 = candidate2;
return [farthest_node1, farthest_node2]; | def get_farthest_successors(self, type_measurement):
"""!
@brief Find pair of farthest successors of the node in line with measurement type.
@param[in] type_measurement (measurement_type): Measurement type that is used for obtaining farthest successors.
@return (list) Pair of farthest successors represented by list [cfnode1, cfnode2].
"""
farthest_node1 = None;
farthest_node2 = None;
farthest_distance = 0;
for i in range(0, len(self.successors)):
candidate1 = self.successors[i];
for j in range(i + 1, len(self.successors)):
candidate2 = self.successors[j];
candidate_distance = candidate1.get_distance(candidate2, type_measurement);
if (candidate_distance > farthest_distance):
farthest_distance = candidate_distance;
farthest_node1 = candidate1;
farthest_node2 = candidate2;
return [farthest_node1, farthest_node2]; | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/container/cftree.py#L544-L570 | [
"def",
"get_farthest_successors",
"(",
"self",
",",
"type_measurement",
")",
":",
"farthest_node1",
"=",
"None",
"farthest_node2",
"=",
"None",
"farthest_distance",
"=",
"0",
"for",
"i",
"in",
"range",
"(",
"0",
",",
"len",
"(",
"self",
".",
"successors",
")",
")",
":",
"candidate1",
"=",
"self",
".",
"successors",
"[",
"i",
"]",
"for",
"j",
"in",
"range",
"(",
"i",
"+",
"1",
",",
"len",
"(",
"self",
".",
"successors",
")",
")",
":",
"candidate2",
"=",
"self",
".",
"successors",
"[",
"j",
"]",
"candidate_distance",
"=",
"candidate1",
".",
"get_distance",
"(",
"candidate2",
",",
"type_measurement",
")",
"if",
"(",
"candidate_distance",
">",
"farthest_distance",
")",
":",
"farthest_distance",
"=",
"candidate_distance",
"farthest_node1",
"=",
"candidate1",
"farthest_node2",
"=",
"candidate2",
"return",
"[",
"farthest_node1",
",",
"farthest_node2",
"]"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | non_leaf_node.get_nearest_successors | !
@brief Find pair of nearest successors of the node in line with measurement type.
@param[in] type_measurement (measurement_type): Measurement type that is used for obtaining nearest successors.
@return (list) Pair of nearest successors represented by list. | pyclustering/container/cftree.py | def get_nearest_successors(self, type_measurement):
"""!
@brief Find pair of nearest successors of the node in line with measurement type.
@param[in] type_measurement (measurement_type): Measurement type that is used for obtaining nearest successors.
@return (list) Pair of nearest successors represented by list.
"""
nearest_node1 = None;
nearest_node2 = None;
nearest_distance = float("Inf");
for i in range(0, len(self.successors)):
candidate1 = self.successors[i];
for j in range(i + 1, len(self.successors)):
candidate2 = self.successors[j];
candidate_distance = candidate1.get_distance(candidate2, type_measurement);
if (candidate_distance < nearest_distance):
nearest_distance = candidate_distance;
nearest_node1 = candidate1;
nearest_node2 = candidate2;
return [nearest_node1, nearest_node2]; | def get_nearest_successors(self, type_measurement):
"""!
@brief Find pair of nearest successors of the node in line with measurement type.
@param[in] type_measurement (measurement_type): Measurement type that is used for obtaining nearest successors.
@return (list) Pair of nearest successors represented by list.
"""
nearest_node1 = None;
nearest_node2 = None;
nearest_distance = float("Inf");
for i in range(0, len(self.successors)):
candidate1 = self.successors[i];
for j in range(i + 1, len(self.successors)):
candidate2 = self.successors[j];
candidate_distance = candidate1.get_distance(candidate2, type_measurement);
if (candidate_distance < nearest_distance):
nearest_distance = candidate_distance;
nearest_node1 = candidate1;
nearest_node2 = candidate2;
return [nearest_node1, nearest_node2]; | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/container/cftree.py#L573-L599 | [
"def",
"get_nearest_successors",
"(",
"self",
",",
"type_measurement",
")",
":",
"nearest_node1",
"=",
"None",
"nearest_node2",
"=",
"None",
"nearest_distance",
"=",
"float",
"(",
"\"Inf\"",
")",
"for",
"i",
"in",
"range",
"(",
"0",
",",
"len",
"(",
"self",
".",
"successors",
")",
")",
":",
"candidate1",
"=",
"self",
".",
"successors",
"[",
"i",
"]",
"for",
"j",
"in",
"range",
"(",
"i",
"+",
"1",
",",
"len",
"(",
"self",
".",
"successors",
")",
")",
":",
"candidate2",
"=",
"self",
".",
"successors",
"[",
"j",
"]",
"candidate_distance",
"=",
"candidate1",
".",
"get_distance",
"(",
"candidate2",
",",
"type_measurement",
")",
"if",
"(",
"candidate_distance",
"<",
"nearest_distance",
")",
":",
"nearest_distance",
"=",
"candidate_distance",
"nearest_node1",
"=",
"candidate1",
"nearest_node2",
"=",
"candidate2",
"return",
"[",
"nearest_node1",
",",
"nearest_node2",
"]"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | leaf_node.insert_entry | !
@brief Insert new clustering feature to the leaf node.
@param[in] entry (cfentry): Clustering feature. | pyclustering/container/cftree.py | def insert_entry(self, entry):
"""!
@brief Insert new clustering feature to the leaf node.
@param[in] entry (cfentry): Clustering feature.
"""
self.feature += entry;
self.entries.append(entry); | def insert_entry(self, entry):
"""!
@brief Insert new clustering feature to the leaf node.
@param[in] entry (cfentry): Clustering feature.
"""
self.feature += entry;
self.entries.append(entry); | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/container/cftree.py#L656-L665 | [
"def",
"insert_entry",
"(",
"self",
",",
"entry",
")",
":",
"self",
".",
"feature",
"+=",
"entry",
"self",
".",
"entries",
".",
"append",
"(",
"entry",
")"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | leaf_node.remove_entry | !
@brief Remove clustering feature from the leaf node.
@param[in] entry (cfentry): Clustering feature. | pyclustering/container/cftree.py | def remove_entry(self, entry):
"""!
@brief Remove clustering feature from the leaf node.
@param[in] entry (cfentry): Clustering feature.
"""
self.feature -= entry;
self.entries.remove(entry); | def remove_entry(self, entry):
"""!
@brief Remove clustering feature from the leaf node.
@param[in] entry (cfentry): Clustering feature.
"""
self.feature -= entry;
self.entries.remove(entry); | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/container/cftree.py#L668-L677 | [
"def",
"remove_entry",
"(",
"self",
",",
"entry",
")",
":",
"self",
".",
"feature",
"-=",
"entry",
"self",
".",
"entries",
".",
"remove",
"(",
"entry",
")"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | leaf_node.merge | !
@brief Merge leaf node to the current.
@param[in] node (leaf_node): Leaf node that should be merged with current. | pyclustering/container/cftree.py | def merge(self, node):
"""!
@brief Merge leaf node to the current.
@param[in] node (leaf_node): Leaf node that should be merged with current.
"""
self.feature += node.feature;
# Move entries from merged node
for entry in node.entries:
self.entries.append(entry); | def merge(self, node):
"""!
@brief Merge leaf node to the current.
@param[in] node (leaf_node): Leaf node that should be merged with current.
"""
self.feature += node.feature;
# Move entries from merged node
for entry in node.entries:
self.entries.append(entry); | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/container/cftree.py#L680-L692 | [
"def",
"merge",
"(",
"self",
",",
"node",
")",
":",
"self",
".",
"feature",
"+=",
"node",
".",
"feature",
"# Move entries from merged node\r",
"for",
"entry",
"in",
"node",
".",
"entries",
":",
"self",
".",
"entries",
".",
"append",
"(",
"entry",
")"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | leaf_node.get_farthest_entries | !
@brief Find pair of farthest entries of the node.
@param[in] type_measurement (measurement_type): Measurement type that is used for obtaining farthest entries.
@return (list) Pair of farthest entries of the node that are represented by list. | pyclustering/container/cftree.py | def get_farthest_entries(self, type_measurement):
"""!
@brief Find pair of farthest entries of the node.
@param[in] type_measurement (measurement_type): Measurement type that is used for obtaining farthest entries.
@return (list) Pair of farthest entries of the node that are represented by list.
"""
farthest_entity1 = None;
farthest_entity2 = None;
farthest_distance = 0;
for i in range(0, len(self.entries)):
candidate1 = self.entries[i];
for j in range(i + 1, len(self.entries)):
candidate2 = self.entries[j];
candidate_distance = candidate1.get_distance(candidate2, type_measurement);
if (candidate_distance > farthest_distance):
farthest_distance = candidate_distance;
farthest_entity1 = candidate1;
farthest_entity2 = candidate2;
return [farthest_entity1, farthest_entity2]; | def get_farthest_entries(self, type_measurement):
"""!
@brief Find pair of farthest entries of the node.
@param[in] type_measurement (measurement_type): Measurement type that is used for obtaining farthest entries.
@return (list) Pair of farthest entries of the node that are represented by list.
"""
farthest_entity1 = None;
farthest_entity2 = None;
farthest_distance = 0;
for i in range(0, len(self.entries)):
candidate1 = self.entries[i];
for j in range(i + 1, len(self.entries)):
candidate2 = self.entries[j];
candidate_distance = candidate1.get_distance(candidate2, type_measurement);
if (candidate_distance > farthest_distance):
farthest_distance = candidate_distance;
farthest_entity1 = candidate1;
farthest_entity2 = candidate2;
return [farthest_entity1, farthest_entity2]; | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/container/cftree.py#L695-L721 | [
"def",
"get_farthest_entries",
"(",
"self",
",",
"type_measurement",
")",
":",
"farthest_entity1",
"=",
"None",
"farthest_entity2",
"=",
"None",
"farthest_distance",
"=",
"0",
"for",
"i",
"in",
"range",
"(",
"0",
",",
"len",
"(",
"self",
".",
"entries",
")",
")",
":",
"candidate1",
"=",
"self",
".",
"entries",
"[",
"i",
"]",
"for",
"j",
"in",
"range",
"(",
"i",
"+",
"1",
",",
"len",
"(",
"self",
".",
"entries",
")",
")",
":",
"candidate2",
"=",
"self",
".",
"entries",
"[",
"j",
"]",
"candidate_distance",
"=",
"candidate1",
".",
"get_distance",
"(",
"candidate2",
",",
"type_measurement",
")",
"if",
"(",
"candidate_distance",
">",
"farthest_distance",
")",
":",
"farthest_distance",
"=",
"candidate_distance",
"farthest_entity1",
"=",
"candidate1",
"farthest_entity2",
"=",
"candidate2",
"return",
"[",
"farthest_entity1",
",",
"farthest_entity2",
"]"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | leaf_node.get_nearest_index_entry | !
@brief Find nearest index of nearest entry of node for the specified entry.
@param[in] entry (cfentry): Entry that is used for calculation distance.
@param[in] type_measurement (measurement_type): Measurement type that is used for obtaining nearest entry to the specified.
@return (uint) Index of nearest entry of node for the specified entry. | pyclustering/container/cftree.py | def get_nearest_index_entry(self, entry, type_measurement):
"""!
@brief Find nearest index of nearest entry of node for the specified entry.
@param[in] entry (cfentry): Entry that is used for calculation distance.
@param[in] type_measurement (measurement_type): Measurement type that is used for obtaining nearest entry to the specified.
@return (uint) Index of nearest entry of node for the specified entry.
"""
minimum_distance = float('Inf');
nearest_index = 0;
for candidate_index in range(0, len(self.entries)):
candidate_distance = self.entries[candidate_index].get_distance(entry, type_measurement);
if (candidate_distance < minimum_distance):
nearest_index = candidate_index;
return nearest_index; | def get_nearest_index_entry(self, entry, type_measurement):
"""!
@brief Find nearest index of nearest entry of node for the specified entry.
@param[in] entry (cfentry): Entry that is used for calculation distance.
@param[in] type_measurement (measurement_type): Measurement type that is used for obtaining nearest entry to the specified.
@return (uint) Index of nearest entry of node for the specified entry.
"""
minimum_distance = float('Inf');
nearest_index = 0;
for candidate_index in range(0, len(self.entries)):
candidate_distance = self.entries[candidate_index].get_distance(entry, type_measurement);
if (candidate_distance < minimum_distance):
nearest_index = candidate_index;
return nearest_index; | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/container/cftree.py#L724-L743 | [
"def",
"get_nearest_index_entry",
"(",
"self",
",",
"entry",
",",
"type_measurement",
")",
":",
"minimum_distance",
"=",
"float",
"(",
"'Inf'",
")",
"nearest_index",
"=",
"0",
"for",
"candidate_index",
"in",
"range",
"(",
"0",
",",
"len",
"(",
"self",
".",
"entries",
")",
")",
":",
"candidate_distance",
"=",
"self",
".",
"entries",
"[",
"candidate_index",
"]",
".",
"get_distance",
"(",
"entry",
",",
"type_measurement",
")",
"if",
"(",
"candidate_distance",
"<",
"minimum_distance",
")",
":",
"nearest_index",
"=",
"candidate_index",
"return",
"nearest_index"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | leaf_node.get_nearest_entry | !
@brief Find nearest entry of node for the specified entry.
@param[in] entry (cfentry): Entry that is used for calculation distance.
@param[in] type_measurement (measurement_type): Measurement type that is used for obtaining nearest entry to the specified.
@return (cfentry) Nearest entry of node for the specified entry. | pyclustering/container/cftree.py | def get_nearest_entry(self, entry, type_measurement):
"""!
@brief Find nearest entry of node for the specified entry.
@param[in] entry (cfentry): Entry that is used for calculation distance.
@param[in] type_measurement (measurement_type): Measurement type that is used for obtaining nearest entry to the specified.
@return (cfentry) Nearest entry of node for the specified entry.
"""
min_key = lambda cur_entity: cur_entity.get_distance(entry, type_measurement);
return min(self.__entries, key = min_key); | def get_nearest_entry(self, entry, type_measurement):
"""!
@brief Find nearest entry of node for the specified entry.
@param[in] entry (cfentry): Entry that is used for calculation distance.
@param[in] type_measurement (measurement_type): Measurement type that is used for obtaining nearest entry to the specified.
@return (cfentry) Nearest entry of node for the specified entry.
"""
min_key = lambda cur_entity: cur_entity.get_distance(entry, type_measurement);
return min(self.__entries, key = min_key); | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/container/cftree.py#L746-L758 | [
"def",
"get_nearest_entry",
"(",
"self",
",",
"entry",
",",
"type_measurement",
")",
":",
"min_key",
"=",
"lambda",
"cur_entity",
":",
"cur_entity",
".",
"get_distance",
"(",
"entry",
",",
"type_measurement",
")",
"return",
"min",
"(",
"self",
".",
"__entries",
",",
"key",
"=",
"min_key",
")"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | cftree.get_level_nodes | !
@brief Traverses CF-tree to obtain nodes at the specified level.
@param[in] level (uint): CF-tree level from that nodes should be returned.
@return (list) List of CF-nodes that are located on the specified level of the CF-tree. | pyclustering/container/cftree.py | def get_level_nodes(self, level):
"""!
@brief Traverses CF-tree to obtain nodes at the specified level.
@param[in] level (uint): CF-tree level from that nodes should be returned.
@return (list) List of CF-nodes that are located on the specified level of the CF-tree.
"""
level_nodes = [];
if (level < self.__height):
level_nodes = self.__recursive_get_level_nodes(level, self.__root);
return level_nodes; | def get_level_nodes(self, level):
"""!
@brief Traverses CF-tree to obtain nodes at the specified level.
@param[in] level (uint): CF-tree level from that nodes should be returned.
@return (list) List of CF-nodes that are located on the specified level of the CF-tree.
"""
level_nodes = [];
if (level < self.__height):
level_nodes = self.__recursive_get_level_nodes(level, self.__root);
return level_nodes; | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/container/cftree.py#L881-L895 | [
"def",
"get_level_nodes",
"(",
"self",
",",
"level",
")",
":",
"level_nodes",
"=",
"[",
"]",
"if",
"(",
"level",
"<",
"self",
".",
"__height",
")",
":",
"level_nodes",
"=",
"self",
".",
"__recursive_get_level_nodes",
"(",
"level",
",",
"self",
".",
"__root",
")",
"return",
"level_nodes"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | cftree.__recursive_get_level_nodes | !
@brief Traverses CF-tree to obtain nodes at the specified level recursively.
@param[in] level (uint): Current CF-tree level.
@param[in] node (cfnode): CF-node from that traversing is performed.
@return (list) List of CF-nodes that are located on the specified level of the CF-tree. | pyclustering/container/cftree.py | def __recursive_get_level_nodes(self, level, node):
"""!
@brief Traverses CF-tree to obtain nodes at the specified level recursively.
@param[in] level (uint): Current CF-tree level.
@param[in] node (cfnode): CF-node from that traversing is performed.
@return (list) List of CF-nodes that are located on the specified level of the CF-tree.
"""
level_nodes = [];
if (level is 0):
level_nodes.append(node);
else:
for sucessor in node.successors:
level_nodes += self.__recursive_get_level_nodes(level - 1, sucessor);
return level_nodes; | def __recursive_get_level_nodes(self, level, node):
"""!
@brief Traverses CF-tree to obtain nodes at the specified level recursively.
@param[in] level (uint): Current CF-tree level.
@param[in] node (cfnode): CF-node from that traversing is performed.
@return (list) List of CF-nodes that are located on the specified level of the CF-tree.
"""
level_nodes = [];
if (level is 0):
level_nodes.append(node);
else:
for sucessor in node.successors:
level_nodes += self.__recursive_get_level_nodes(level - 1, sucessor);
return level_nodes; | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/container/cftree.py#L898-L917 | [
"def",
"__recursive_get_level_nodes",
"(",
"self",
",",
"level",
",",
"node",
")",
":",
"level_nodes",
"=",
"[",
"]",
"if",
"(",
"level",
"is",
"0",
")",
":",
"level_nodes",
".",
"append",
"(",
"node",
")",
"else",
":",
"for",
"sucessor",
"in",
"node",
".",
"successors",
":",
"level_nodes",
"+=",
"self",
".",
"__recursive_get_level_nodes",
"(",
"level",
"-",
"1",
",",
"sucessor",
")",
"return",
"level_nodes"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | cftree.insert_cluster | !
@brief Insert cluster that is represented as list of points where each point is represented by list of coordinates.
@details Clustering feature is created for that cluster and inserted to the tree.
@param[in] cluster (list): Cluster that is represented by list of points that should be inserted to the tree. | pyclustering/container/cftree.py | def insert_cluster(self, cluster):
"""!
@brief Insert cluster that is represented as list of points where each point is represented by list of coordinates.
@details Clustering feature is created for that cluster and inserted to the tree.
@param[in] cluster (list): Cluster that is represented by list of points that should be inserted to the tree.
"""
entry = cfentry(len(cluster), linear_sum(cluster), square_sum(cluster));
self.insert(entry); | def insert_cluster(self, cluster):
"""!
@brief Insert cluster that is represented as list of points where each point is represented by list of coordinates.
@details Clustering feature is created for that cluster and inserted to the tree.
@param[in] cluster (list): Cluster that is represented by list of points that should be inserted to the tree.
"""
entry = cfentry(len(cluster), linear_sum(cluster), square_sum(cluster));
self.insert(entry); | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/container/cftree.py#L920-L930 | [
"def",
"insert_cluster",
"(",
"self",
",",
"cluster",
")",
":",
"entry",
"=",
"cfentry",
"(",
"len",
"(",
"cluster",
")",
",",
"linear_sum",
"(",
"cluster",
")",
",",
"square_sum",
"(",
"cluster",
")",
")",
"self",
".",
"insert",
"(",
"entry",
")"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | cftree.insert | !
@brief Insert clustering feature to the tree.
@param[in] entry (cfentry): Clustering feature that should be inserted. | pyclustering/container/cftree.py | def insert(self, entry):
"""!
@brief Insert clustering feature to the tree.
@param[in] entry (cfentry): Clustering feature that should be inserted.
"""
if (self.__root is None):
node = leaf_node(entry, None, [ entry ], None);
self.__root = node;
self.__leafes.append(node);
# Update statistics
self.__amount_entries += 1;
self.__amount_nodes += 1;
self.__height += 1; # root has successor now
else:
child_node_updation = self.__recursive_insert(entry, self.__root);
if (child_node_updation is True):
# Splitting has been finished, check for possibility to merge (at least we have already two children).
if (self.__merge_nearest_successors(self.__root) is True):
self.__amount_nodes -= 1; | def insert(self, entry):
"""!
@brief Insert clustering feature to the tree.
@param[in] entry (cfentry): Clustering feature that should be inserted.
"""
if (self.__root is None):
node = leaf_node(entry, None, [ entry ], None);
self.__root = node;
self.__leafes.append(node);
# Update statistics
self.__amount_entries += 1;
self.__amount_nodes += 1;
self.__height += 1; # root has successor now
else:
child_node_updation = self.__recursive_insert(entry, self.__root);
if (child_node_updation is True):
# Splitting has been finished, check for possibility to merge (at least we have already two children).
if (self.__merge_nearest_successors(self.__root) is True):
self.__amount_nodes -= 1; | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/container/cftree.py#L933-L956 | [
"def",
"insert",
"(",
"self",
",",
"entry",
")",
":",
"if",
"(",
"self",
".",
"__root",
"is",
"None",
")",
":",
"node",
"=",
"leaf_node",
"(",
"entry",
",",
"None",
",",
"[",
"entry",
"]",
",",
"None",
")",
"self",
".",
"__root",
"=",
"node",
"self",
".",
"__leafes",
".",
"append",
"(",
"node",
")",
"# Update statistics\r",
"self",
".",
"__amount_entries",
"+=",
"1",
"self",
".",
"__amount_nodes",
"+=",
"1",
"self",
".",
"__height",
"+=",
"1",
"# root has successor now\r",
"else",
":",
"child_node_updation",
"=",
"self",
".",
"__recursive_insert",
"(",
"entry",
",",
"self",
".",
"__root",
")",
"if",
"(",
"child_node_updation",
"is",
"True",
")",
":",
"# Splitting has been finished, check for possibility to merge (at least we have already two children).\r",
"if",
"(",
"self",
".",
"__merge_nearest_successors",
"(",
"self",
".",
"__root",
")",
"is",
"True",
")",
":",
"self",
".",
"__amount_nodes",
"-=",
"1"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | cftree.find_nearest_leaf | !
@brief Search nearest leaf to the specified clustering feature.
@param[in] entry (cfentry): Clustering feature.
@param[in] search_node (cfnode): Node from that searching should be started, if None then search process will be started for the root.
@return (leaf_node) Nearest node to the specified clustering feature. | pyclustering/container/cftree.py | def find_nearest_leaf(self, entry, search_node = None):
"""!
@brief Search nearest leaf to the specified clustering feature.
@param[in] entry (cfentry): Clustering feature.
@param[in] search_node (cfnode): Node from that searching should be started, if None then search process will be started for the root.
@return (leaf_node) Nearest node to the specified clustering feature.
"""
if (search_node is None):
search_node = self.__root;
nearest_node = search_node;
if (search_node.type == cfnode_type.CFNODE_NONLEAF):
min_key = lambda child_node: child_node.feature.get_distance(entry, self.__type_measurement);
nearest_child_node = min(search_node.successors, key = min_key);
nearest_node = self.find_nearest_leaf(entry, nearest_child_node);
return nearest_node; | def find_nearest_leaf(self, entry, search_node = None):
"""!
@brief Search nearest leaf to the specified clustering feature.
@param[in] entry (cfentry): Clustering feature.
@param[in] search_node (cfnode): Node from that searching should be started, if None then search process will be started for the root.
@return (leaf_node) Nearest node to the specified clustering feature.
"""
if (search_node is None):
search_node = self.__root;
nearest_node = search_node;
if (search_node.type == cfnode_type.CFNODE_NONLEAF):
min_key = lambda child_node: child_node.feature.get_distance(entry, self.__type_measurement);
nearest_child_node = min(search_node.successors, key = min_key);
nearest_node = self.find_nearest_leaf(entry, nearest_child_node);
return nearest_node; | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/container/cftree.py#L959-L981 | [
"def",
"find_nearest_leaf",
"(",
"self",
",",
"entry",
",",
"search_node",
"=",
"None",
")",
":",
"if",
"(",
"search_node",
"is",
"None",
")",
":",
"search_node",
"=",
"self",
".",
"__root",
"nearest_node",
"=",
"search_node",
"if",
"(",
"search_node",
".",
"type",
"==",
"cfnode_type",
".",
"CFNODE_NONLEAF",
")",
":",
"min_key",
"=",
"lambda",
"child_node",
":",
"child_node",
".",
"feature",
".",
"get_distance",
"(",
"entry",
",",
"self",
".",
"__type_measurement",
")",
"nearest_child_node",
"=",
"min",
"(",
"search_node",
".",
"successors",
",",
"key",
"=",
"min_key",
")",
"nearest_node",
"=",
"self",
".",
"find_nearest_leaf",
"(",
"entry",
",",
"nearest_child_node",
")",
"return",
"nearest_node"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | cftree.__recursive_insert | !
@brief Recursive insert of the entry to the tree.
@details It performs all required procedures during insertion such as splitting, merging.
@param[in] entry (cfentry): Clustering feature.
@param[in] search_node (cfnode): Node from that insertion should be started.
@return (bool) True if number of nodes at the below level is changed, otherwise False. | pyclustering/container/cftree.py | def __recursive_insert(self, entry, search_node):
"""!
@brief Recursive insert of the entry to the tree.
@details It performs all required procedures during insertion such as splitting, merging.
@param[in] entry (cfentry): Clustering feature.
@param[in] search_node (cfnode): Node from that insertion should be started.
@return (bool) True if number of nodes at the below level is changed, otherwise False.
"""
# None-leaf node
if (search_node.type == cfnode_type.CFNODE_NONLEAF):
return self.__insert_for_noneleaf_node(entry, search_node);
# Leaf is reached
else:
return self.__insert_for_leaf_node(entry, search_node); | def __recursive_insert(self, entry, search_node):
"""!
@brief Recursive insert of the entry to the tree.
@details It performs all required procedures during insertion such as splitting, merging.
@param[in] entry (cfentry): Clustering feature.
@param[in] search_node (cfnode): Node from that insertion should be started.
@return (bool) True if number of nodes at the below level is changed, otherwise False.
"""
# None-leaf node
if (search_node.type == cfnode_type.CFNODE_NONLEAF):
return self.__insert_for_noneleaf_node(entry, search_node);
# Leaf is reached
else:
return self.__insert_for_leaf_node(entry, search_node); | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/container/cftree.py#L984-L1002 | [
"def",
"__recursive_insert",
"(",
"self",
",",
"entry",
",",
"search_node",
")",
":",
"# None-leaf node\r",
"if",
"(",
"search_node",
".",
"type",
"==",
"cfnode_type",
".",
"CFNODE_NONLEAF",
")",
":",
"return",
"self",
".",
"__insert_for_noneleaf_node",
"(",
"entry",
",",
"search_node",
")",
"# Leaf is reached \r",
"else",
":",
"return",
"self",
".",
"__insert_for_leaf_node",
"(",
"entry",
",",
"search_node",
")"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | cftree.__insert_for_leaf_node | !
@brief Recursive insert entry from leaf node to the tree.
@param[in] entry (cfentry): Clustering feature.
@param[in] search_node (cfnode): None-leaf node from that insertion should be started.
@return (bool) True if number of nodes at the below level is changed, otherwise False. | pyclustering/container/cftree.py | def __insert_for_leaf_node(self, entry, search_node):
"""!
@brief Recursive insert entry from leaf node to the tree.
@param[in] entry (cfentry): Clustering feature.
@param[in] search_node (cfnode): None-leaf node from that insertion should be started.
@return (bool) True if number of nodes at the below level is changed, otherwise False.
"""
node_amount_updation = False;
# Try to absorb by the entity
index_nearest_entry = search_node.get_nearest_index_entry(entry, self.__type_measurement);
merged_entry = search_node.entries[index_nearest_entry] + entry;
# Otherwise try to add new entry
if (merged_entry.get_diameter() > self.__threshold):
# If it's not exceeded append entity and update feature of the leaf node.
search_node.insert_entry(entry);
# Otherwise current node should be splitted
if (len(search_node.entries) > self.__max_entries):
self.__split_procedure(search_node);
node_amount_updation = True;
# Update statistics
self.__amount_entries += 1;
else:
search_node.entries[index_nearest_entry] = merged_entry;
search_node.feature += entry;
return node_amount_updation; | def __insert_for_leaf_node(self, entry, search_node):
"""!
@brief Recursive insert entry from leaf node to the tree.
@param[in] entry (cfentry): Clustering feature.
@param[in] search_node (cfnode): None-leaf node from that insertion should be started.
@return (bool) True if number of nodes at the below level is changed, otherwise False.
"""
node_amount_updation = False;
# Try to absorb by the entity
index_nearest_entry = search_node.get_nearest_index_entry(entry, self.__type_measurement);
merged_entry = search_node.entries[index_nearest_entry] + entry;
# Otherwise try to add new entry
if (merged_entry.get_diameter() > self.__threshold):
# If it's not exceeded append entity and update feature of the leaf node.
search_node.insert_entry(entry);
# Otherwise current node should be splitted
if (len(search_node.entries) > self.__max_entries):
self.__split_procedure(search_node);
node_amount_updation = True;
# Update statistics
self.__amount_entries += 1;
else:
search_node.entries[index_nearest_entry] = merged_entry;
search_node.feature += entry;
return node_amount_updation; | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/container/cftree.py#L1005-L1039 | [
"def",
"__insert_for_leaf_node",
"(",
"self",
",",
"entry",
",",
"search_node",
")",
":",
"node_amount_updation",
"=",
"False",
"# Try to absorb by the entity\r",
"index_nearest_entry",
"=",
"search_node",
".",
"get_nearest_index_entry",
"(",
"entry",
",",
"self",
".",
"__type_measurement",
")",
"merged_entry",
"=",
"search_node",
".",
"entries",
"[",
"index_nearest_entry",
"]",
"+",
"entry",
"# Otherwise try to add new entry\r",
"if",
"(",
"merged_entry",
".",
"get_diameter",
"(",
")",
">",
"self",
".",
"__threshold",
")",
":",
"# If it's not exceeded append entity and update feature of the leaf node.\r",
"search_node",
".",
"insert_entry",
"(",
"entry",
")",
"# Otherwise current node should be splitted\r",
"if",
"(",
"len",
"(",
"search_node",
".",
"entries",
")",
">",
"self",
".",
"__max_entries",
")",
":",
"self",
".",
"__split_procedure",
"(",
"search_node",
")",
"node_amount_updation",
"=",
"True",
"# Update statistics\r",
"self",
".",
"__amount_entries",
"+=",
"1",
"else",
":",
"search_node",
".",
"entries",
"[",
"index_nearest_entry",
"]",
"=",
"merged_entry",
"search_node",
".",
"feature",
"+=",
"entry",
"return",
"node_amount_updation"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | cftree.__insert_for_noneleaf_node | !
@brief Recursive insert entry from none-leaf node to the tree.
@param[in] entry (cfentry): Clustering feature.
@param[in] search_node (cfnode): None-leaf node from that insertion should be started.
@return (bool) True if number of nodes at the below level is changed, otherwise False. | pyclustering/container/cftree.py | def __insert_for_noneleaf_node(self, entry, search_node):
"""!
@brief Recursive insert entry from none-leaf node to the tree.
@param[in] entry (cfentry): Clustering feature.
@param[in] search_node (cfnode): None-leaf node from that insertion should be started.
@return (bool) True if number of nodes at the below level is changed, otherwise False.
"""
node_amount_updation = False;
min_key = lambda child_node: child_node.get_distance(search_node, self.__type_measurement);
nearest_child_node = min(search_node.successors, key = min_key);
child_node_updation = self.__recursive_insert(entry, nearest_child_node);
# Update clustering feature of none-leaf node.
search_node.feature += entry;
# Check branch factor, probably some leaf has been splitted and threshold has been exceeded.
if (len(search_node.successors) > self.__branch_factor):
# Check if it's aleady root then new root should be created (height is increased in this case).
if (search_node is self.__root):
self.__root = non_leaf_node(search_node.feature, None, [ search_node ], None);
search_node.parent = self.__root;
# Update statistics
self.__amount_nodes += 1;
self.__height += 1;
[new_node1, new_node2] = self.__split_nonleaf_node(search_node);
# Update parent list of successors
parent = search_node.parent;
parent.successors.remove(search_node);
parent.successors.append(new_node1);
parent.successors.append(new_node2);
# Update statistics
self.__amount_nodes += 1;
node_amount_updation = True;
elif (child_node_updation is True):
# Splitting has been finished, check for possibility to merge (at least we have already two children).
if (self.__merge_nearest_successors(search_node) is True):
self.__amount_nodes -= 1;
return node_amount_updation; | def __insert_for_noneleaf_node(self, entry, search_node):
"""!
@brief Recursive insert entry from none-leaf node to the tree.
@param[in] entry (cfentry): Clustering feature.
@param[in] search_node (cfnode): None-leaf node from that insertion should be started.
@return (bool) True if number of nodes at the below level is changed, otherwise False.
"""
node_amount_updation = False;
min_key = lambda child_node: child_node.get_distance(search_node, self.__type_measurement);
nearest_child_node = min(search_node.successors, key = min_key);
child_node_updation = self.__recursive_insert(entry, nearest_child_node);
# Update clustering feature of none-leaf node.
search_node.feature += entry;
# Check branch factor, probably some leaf has been splitted and threshold has been exceeded.
if (len(search_node.successors) > self.__branch_factor):
# Check if it's aleady root then new root should be created (height is increased in this case).
if (search_node is self.__root):
self.__root = non_leaf_node(search_node.feature, None, [ search_node ], None);
search_node.parent = self.__root;
# Update statistics
self.__amount_nodes += 1;
self.__height += 1;
[new_node1, new_node2] = self.__split_nonleaf_node(search_node);
# Update parent list of successors
parent = search_node.parent;
parent.successors.remove(search_node);
parent.successors.append(new_node1);
parent.successors.append(new_node2);
# Update statistics
self.__amount_nodes += 1;
node_amount_updation = True;
elif (child_node_updation is True):
# Splitting has been finished, check for possibility to merge (at least we have already two children).
if (self.__merge_nearest_successors(search_node) is True):
self.__amount_nodes -= 1;
return node_amount_updation; | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/container/cftree.py#L1042-L1092 | [
"def",
"__insert_for_noneleaf_node",
"(",
"self",
",",
"entry",
",",
"search_node",
")",
":",
"node_amount_updation",
"=",
"False",
"min_key",
"=",
"lambda",
"child_node",
":",
"child_node",
".",
"get_distance",
"(",
"search_node",
",",
"self",
".",
"__type_measurement",
")",
"nearest_child_node",
"=",
"min",
"(",
"search_node",
".",
"successors",
",",
"key",
"=",
"min_key",
")",
"child_node_updation",
"=",
"self",
".",
"__recursive_insert",
"(",
"entry",
",",
"nearest_child_node",
")",
"# Update clustering feature of none-leaf node.\r",
"search_node",
".",
"feature",
"+=",
"entry",
"# Check branch factor, probably some leaf has been splitted and threshold has been exceeded.\r",
"if",
"(",
"len",
"(",
"search_node",
".",
"successors",
")",
">",
"self",
".",
"__branch_factor",
")",
":",
"# Check if it's aleady root then new root should be created (height is increased in this case).\r",
"if",
"(",
"search_node",
"is",
"self",
".",
"__root",
")",
":",
"self",
".",
"__root",
"=",
"non_leaf_node",
"(",
"search_node",
".",
"feature",
",",
"None",
",",
"[",
"search_node",
"]",
",",
"None",
")",
"search_node",
".",
"parent",
"=",
"self",
".",
"__root",
"# Update statistics\r",
"self",
".",
"__amount_nodes",
"+=",
"1",
"self",
".",
"__height",
"+=",
"1",
"[",
"new_node1",
",",
"new_node2",
"]",
"=",
"self",
".",
"__split_nonleaf_node",
"(",
"search_node",
")",
"# Update parent list of successors\r",
"parent",
"=",
"search_node",
".",
"parent",
"parent",
".",
"successors",
".",
"remove",
"(",
"search_node",
")",
"parent",
".",
"successors",
".",
"append",
"(",
"new_node1",
")",
"parent",
".",
"successors",
".",
"append",
"(",
"new_node2",
")",
"# Update statistics\r",
"self",
".",
"__amount_nodes",
"+=",
"1",
"node_amount_updation",
"=",
"True",
"elif",
"(",
"child_node_updation",
"is",
"True",
")",
":",
"# Splitting has been finished, check for possibility to merge (at least we have already two children).\r",
"if",
"(",
"self",
".",
"__merge_nearest_successors",
"(",
"search_node",
")",
"is",
"True",
")",
":",
"self",
".",
"__amount_nodes",
"-=",
"1",
"return",
"node_amount_updation"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | cftree.__merge_nearest_successors | !
@brief Find nearest sucessors and merge them.
@param[in] node (non_leaf_node): Node whose two nearest successors should be merged.
@return (bool): True if merging has been successfully performed, otherwise False. | pyclustering/container/cftree.py | def __merge_nearest_successors(self, node):
"""!
@brief Find nearest sucessors and merge them.
@param[in] node (non_leaf_node): Node whose two nearest successors should be merged.
@return (bool): True if merging has been successfully performed, otherwise False.
"""
merging_result = False;
if (node.successors[0].type == cfnode_type.CFNODE_NONLEAF):
[nearest_child_node1, nearest_child_node2] = node.get_nearest_successors(self.__type_measurement);
if (len(nearest_child_node1.successors) + len(nearest_child_node2.successors) <= self.__branch_factor):
node.successors.remove(nearest_child_node2);
if (nearest_child_node2.type == cfnode_type.CFNODE_LEAF):
self.__leafes.remove(nearest_child_node2);
nearest_child_node1.merge(nearest_child_node2);
merging_result = True;
return merging_result; | def __merge_nearest_successors(self, node):
"""!
@brief Find nearest sucessors and merge them.
@param[in] node (non_leaf_node): Node whose two nearest successors should be merged.
@return (bool): True if merging has been successfully performed, otherwise False.
"""
merging_result = False;
if (node.successors[0].type == cfnode_type.CFNODE_NONLEAF):
[nearest_child_node1, nearest_child_node2] = node.get_nearest_successors(self.__type_measurement);
if (len(nearest_child_node1.successors) + len(nearest_child_node2.successors) <= self.__branch_factor):
node.successors.remove(nearest_child_node2);
if (nearest_child_node2.type == cfnode_type.CFNODE_LEAF):
self.__leafes.remove(nearest_child_node2);
nearest_child_node1.merge(nearest_child_node2);
merging_result = True;
return merging_result; | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/container/cftree.py#L1095-L1119 | [
"def",
"__merge_nearest_successors",
"(",
"self",
",",
"node",
")",
":",
"merging_result",
"=",
"False",
"if",
"(",
"node",
".",
"successors",
"[",
"0",
"]",
".",
"type",
"==",
"cfnode_type",
".",
"CFNODE_NONLEAF",
")",
":",
"[",
"nearest_child_node1",
",",
"nearest_child_node2",
"]",
"=",
"node",
".",
"get_nearest_successors",
"(",
"self",
".",
"__type_measurement",
")",
"if",
"(",
"len",
"(",
"nearest_child_node1",
".",
"successors",
")",
"+",
"len",
"(",
"nearest_child_node2",
".",
"successors",
")",
"<=",
"self",
".",
"__branch_factor",
")",
":",
"node",
".",
"successors",
".",
"remove",
"(",
"nearest_child_node2",
")",
"if",
"(",
"nearest_child_node2",
".",
"type",
"==",
"cfnode_type",
".",
"CFNODE_LEAF",
")",
":",
"self",
".",
"__leafes",
".",
"remove",
"(",
"nearest_child_node2",
")",
"nearest_child_node1",
".",
"merge",
"(",
"nearest_child_node2",
")",
"merging_result",
"=",
"True",
"return",
"merging_result"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | cftree.__split_procedure | !
@brief Starts node splitting procedure in the CF-tree from the specify node.
@param[in] split_node (cfnode): CF-tree node that should be splitted. | pyclustering/container/cftree.py | def __split_procedure(self, split_node):
"""!
@brief Starts node splitting procedure in the CF-tree from the specify node.
@param[in] split_node (cfnode): CF-tree node that should be splitted.
"""
if (split_node is self.__root):
self.__root = non_leaf_node(split_node.feature, None, [ split_node ], None);
split_node.parent = self.__root;
# Update statistics
self.__amount_nodes += 1;
self.__height += 1;
[new_node1, new_node2] = self.__split_leaf_node(split_node);
self.__leafes.remove(split_node);
self.__leafes.append(new_node1);
self.__leafes.append(new_node2);
# Update parent list of successors
parent = split_node.parent;
parent.successors.remove(split_node);
parent.successors.append(new_node1);
parent.successors.append(new_node2);
# Update statistics
self.__amount_nodes += 1; | def __split_procedure(self, split_node):
"""!
@brief Starts node splitting procedure in the CF-tree from the specify node.
@param[in] split_node (cfnode): CF-tree node that should be splitted.
"""
if (split_node is self.__root):
self.__root = non_leaf_node(split_node.feature, None, [ split_node ], None);
split_node.parent = self.__root;
# Update statistics
self.__amount_nodes += 1;
self.__height += 1;
[new_node1, new_node2] = self.__split_leaf_node(split_node);
self.__leafes.remove(split_node);
self.__leafes.append(new_node1);
self.__leafes.append(new_node2);
# Update parent list of successors
parent = split_node.parent;
parent.successors.remove(split_node);
parent.successors.append(new_node1);
parent.successors.append(new_node2);
# Update statistics
self.__amount_nodes += 1; | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/container/cftree.py#L1122-L1150 | [
"def",
"__split_procedure",
"(",
"self",
",",
"split_node",
")",
":",
"if",
"(",
"split_node",
"is",
"self",
".",
"__root",
")",
":",
"self",
".",
"__root",
"=",
"non_leaf_node",
"(",
"split_node",
".",
"feature",
",",
"None",
",",
"[",
"split_node",
"]",
",",
"None",
")",
"split_node",
".",
"parent",
"=",
"self",
".",
"__root",
"# Update statistics\r",
"self",
".",
"__amount_nodes",
"+=",
"1",
"self",
".",
"__height",
"+=",
"1",
"[",
"new_node1",
",",
"new_node2",
"]",
"=",
"self",
".",
"__split_leaf_node",
"(",
"split_node",
")",
"self",
".",
"__leafes",
".",
"remove",
"(",
"split_node",
")",
"self",
".",
"__leafes",
".",
"append",
"(",
"new_node1",
")",
"self",
".",
"__leafes",
".",
"append",
"(",
"new_node2",
")",
"# Update parent list of successors\r",
"parent",
"=",
"split_node",
".",
"parent",
"parent",
".",
"successors",
".",
"remove",
"(",
"split_node",
")",
"parent",
".",
"successors",
".",
"append",
"(",
"new_node1",
")",
"parent",
".",
"successors",
".",
"append",
"(",
"new_node2",
")",
"# Update statistics\r",
"self",
".",
"__amount_nodes",
"+=",
"1"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | cftree.__split_nonleaf_node | !
@brief Performs splitting of the specified non-leaf node.
@param[in] node (non_leaf_node): Non-leaf node that should be splitted.
@return (list) New pair of non-leaf nodes [non_leaf_node1, non_leaf_node2]. | pyclustering/container/cftree.py | def __split_nonleaf_node(self, node):
"""!
@brief Performs splitting of the specified non-leaf node.
@param[in] node (non_leaf_node): Non-leaf node that should be splitted.
@return (list) New pair of non-leaf nodes [non_leaf_node1, non_leaf_node2].
"""
[farthest_node1, farthest_node2] = node.get_farthest_successors(self.__type_measurement);
# create new non-leaf nodes
new_node1 = non_leaf_node(farthest_node1.feature, node.parent, [ farthest_node1 ], None);
new_node2 = non_leaf_node(farthest_node2.feature, node.parent, [ farthest_node2 ], None);
farthest_node1.parent = new_node1;
farthest_node2.parent = new_node2;
# re-insert other successors
for successor in node.successors:
if ( (successor is not farthest_node1) and (successor is not farthest_node2) ):
distance1 = new_node1.get_distance(successor, self.__type_measurement);
distance2 = new_node2.get_distance(successor, self.__type_measurement);
if (distance1 < distance2):
new_node1.insert_successor(successor);
else:
new_node2.insert_successor(successor);
return [new_node1, new_node2]; | def __split_nonleaf_node(self, node):
"""!
@brief Performs splitting of the specified non-leaf node.
@param[in] node (non_leaf_node): Non-leaf node that should be splitted.
@return (list) New pair of non-leaf nodes [non_leaf_node1, non_leaf_node2].
"""
[farthest_node1, farthest_node2] = node.get_farthest_successors(self.__type_measurement);
# create new non-leaf nodes
new_node1 = non_leaf_node(farthest_node1.feature, node.parent, [ farthest_node1 ], None);
new_node2 = non_leaf_node(farthest_node2.feature, node.parent, [ farthest_node2 ], None);
farthest_node1.parent = new_node1;
farthest_node2.parent = new_node2;
# re-insert other successors
for successor in node.successors:
if ( (successor is not farthest_node1) and (successor is not farthest_node2) ):
distance1 = new_node1.get_distance(successor, self.__type_measurement);
distance2 = new_node2.get_distance(successor, self.__type_measurement);
if (distance1 < distance2):
new_node1.insert_successor(successor);
else:
new_node2.insert_successor(successor);
return [new_node1, new_node2]; | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/container/cftree.py#L1153-L1183 | [
"def",
"__split_nonleaf_node",
"(",
"self",
",",
"node",
")",
":",
"[",
"farthest_node1",
",",
"farthest_node2",
"]",
"=",
"node",
".",
"get_farthest_successors",
"(",
"self",
".",
"__type_measurement",
")",
"# create new non-leaf nodes\r",
"new_node1",
"=",
"non_leaf_node",
"(",
"farthest_node1",
".",
"feature",
",",
"node",
".",
"parent",
",",
"[",
"farthest_node1",
"]",
",",
"None",
")",
"new_node2",
"=",
"non_leaf_node",
"(",
"farthest_node2",
".",
"feature",
",",
"node",
".",
"parent",
",",
"[",
"farthest_node2",
"]",
",",
"None",
")",
"farthest_node1",
".",
"parent",
"=",
"new_node1",
"farthest_node2",
".",
"parent",
"=",
"new_node2",
"# re-insert other successors\r",
"for",
"successor",
"in",
"node",
".",
"successors",
":",
"if",
"(",
"(",
"successor",
"is",
"not",
"farthest_node1",
")",
"and",
"(",
"successor",
"is",
"not",
"farthest_node2",
")",
")",
":",
"distance1",
"=",
"new_node1",
".",
"get_distance",
"(",
"successor",
",",
"self",
".",
"__type_measurement",
")",
"distance2",
"=",
"new_node2",
".",
"get_distance",
"(",
"successor",
",",
"self",
".",
"__type_measurement",
")",
"if",
"(",
"distance1",
"<",
"distance2",
")",
":",
"new_node1",
".",
"insert_successor",
"(",
"successor",
")",
"else",
":",
"new_node2",
".",
"insert_successor",
"(",
"successor",
")",
"return",
"[",
"new_node1",
",",
"new_node2",
"]"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | cftree.__split_leaf_node | !
@brief Performs splitting of the specified leaf node.
@param[in] node (leaf_node): Leaf node that should be splitted.
@return (list) New pair of leaf nodes [leaf_node1, leaf_node2].
@warning Splitted node is transformed to non_leaf. | pyclustering/container/cftree.py | def __split_leaf_node(self, node):
"""!
@brief Performs splitting of the specified leaf node.
@param[in] node (leaf_node): Leaf node that should be splitted.
@return (list) New pair of leaf nodes [leaf_node1, leaf_node2].
@warning Splitted node is transformed to non_leaf.
"""
# search farthest pair of entries
[farthest_entity1, farthest_entity2] = node.get_farthest_entries(self.__type_measurement);
# create new nodes
new_node1 = leaf_node(farthest_entity1, node.parent, [ farthest_entity1 ], None);
new_node2 = leaf_node(farthest_entity2, node.parent, [ farthest_entity2 ], None);
# re-insert other entries
for entity in node.entries:
if ( (entity is not farthest_entity1) and (entity is not farthest_entity2) ):
distance1 = new_node1.feature.get_distance(entity, self.__type_measurement);
distance2 = new_node2.feature.get_distance(entity, self.__type_measurement);
if (distance1 < distance2):
new_node1.insert_entry(entity);
else:
new_node2.insert_entry(entity);
return [new_node1, new_node2]; | def __split_leaf_node(self, node):
"""!
@brief Performs splitting of the specified leaf node.
@param[in] node (leaf_node): Leaf node that should be splitted.
@return (list) New pair of leaf nodes [leaf_node1, leaf_node2].
@warning Splitted node is transformed to non_leaf.
"""
# search farthest pair of entries
[farthest_entity1, farthest_entity2] = node.get_farthest_entries(self.__type_measurement);
# create new nodes
new_node1 = leaf_node(farthest_entity1, node.parent, [ farthest_entity1 ], None);
new_node2 = leaf_node(farthest_entity2, node.parent, [ farthest_entity2 ], None);
# re-insert other entries
for entity in node.entries:
if ( (entity is not farthest_entity1) and (entity is not farthest_entity2) ):
distance1 = new_node1.feature.get_distance(entity, self.__type_measurement);
distance2 = new_node2.feature.get_distance(entity, self.__type_measurement);
if (distance1 < distance2):
new_node1.insert_entry(entity);
else:
new_node2.insert_entry(entity);
return [new_node1, new_node2]; | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/container/cftree.py#L1186-L1216 | [
"def",
"__split_leaf_node",
"(",
"self",
",",
"node",
")",
":",
"# search farthest pair of entries\r",
"[",
"farthest_entity1",
",",
"farthest_entity2",
"]",
"=",
"node",
".",
"get_farthest_entries",
"(",
"self",
".",
"__type_measurement",
")",
"# create new nodes\r",
"new_node1",
"=",
"leaf_node",
"(",
"farthest_entity1",
",",
"node",
".",
"parent",
",",
"[",
"farthest_entity1",
"]",
",",
"None",
")",
"new_node2",
"=",
"leaf_node",
"(",
"farthest_entity2",
",",
"node",
".",
"parent",
",",
"[",
"farthest_entity2",
"]",
",",
"None",
")",
"# re-insert other entries\r",
"for",
"entity",
"in",
"node",
".",
"entries",
":",
"if",
"(",
"(",
"entity",
"is",
"not",
"farthest_entity1",
")",
"and",
"(",
"entity",
"is",
"not",
"farthest_entity2",
")",
")",
":",
"distance1",
"=",
"new_node1",
".",
"feature",
".",
"get_distance",
"(",
"entity",
",",
"self",
".",
"__type_measurement",
")",
"distance2",
"=",
"new_node2",
".",
"feature",
".",
"get_distance",
"(",
"entity",
",",
"self",
".",
"__type_measurement",
")",
"if",
"(",
"distance1",
"<",
"distance2",
")",
":",
"new_node1",
".",
"insert_entry",
"(",
"entity",
")",
"else",
":",
"new_node2",
".",
"insert_entry",
"(",
"entity",
")",
"return",
"[",
"new_node1",
",",
"new_node2",
"]"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | cftree.show_feature_destibution | !
@brief Shows feature distribution.
@details Only features in 1D, 2D, 3D space can be visualized.
@param[in] data (list): List of points that will be used for visualization, if it not specified than feature will be displayed only. | pyclustering/container/cftree.py | def show_feature_destibution(self, data = None):
"""!
@brief Shows feature distribution.
@details Only features in 1D, 2D, 3D space can be visualized.
@param[in] data (list): List of points that will be used for visualization, if it not specified than feature will be displayed only.
"""
visualizer = cluster_visualizer();
print("amount of nodes: ", self.__amount_nodes);
if (data is not None):
visualizer.append_cluster(data, marker = 'x');
for level in range(0, self.height):
level_nodes = self.get_level_nodes(level);
centers = [ node.feature.get_centroid() for node in level_nodes ];
visualizer.append_cluster(centers, None, markersize = (self.height - level + 1) * 5);
visualizer.show(); | def show_feature_destibution(self, data = None):
"""!
@brief Shows feature distribution.
@details Only features in 1D, 2D, 3D space can be visualized.
@param[in] data (list): List of points that will be used for visualization, if it not specified than feature will be displayed only.
"""
visualizer = cluster_visualizer();
print("amount of nodes: ", self.__amount_nodes);
if (data is not None):
visualizer.append_cluster(data, marker = 'x');
for level in range(0, self.height):
level_nodes = self.get_level_nodes(level);
centers = [ node.feature.get_centroid() for node in level_nodes ];
visualizer.append_cluster(centers, None, markersize = (self.height - level + 1) * 5);
visualizer.show(); | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/container/cftree.py#L1219-L1240 | [
"def",
"show_feature_destibution",
"(",
"self",
",",
"data",
"=",
"None",
")",
":",
"visualizer",
"=",
"cluster_visualizer",
"(",
")",
"print",
"(",
"\"amount of nodes: \"",
",",
"self",
".",
"__amount_nodes",
")",
"if",
"(",
"data",
"is",
"not",
"None",
")",
":",
"visualizer",
".",
"append_cluster",
"(",
"data",
",",
"marker",
"=",
"'x'",
")",
"for",
"level",
"in",
"range",
"(",
"0",
",",
"self",
".",
"height",
")",
":",
"level_nodes",
"=",
"self",
".",
"get_level_nodes",
"(",
"level",
")",
"centers",
"=",
"[",
"node",
".",
"feature",
".",
"get_centroid",
"(",
")",
"for",
"node",
"in",
"level_nodes",
"]",
"visualizer",
".",
"append_cluster",
"(",
"centers",
",",
"None",
",",
"markersize",
"=",
"(",
"self",
".",
"height",
"-",
"level",
"+",
"1",
")",
"*",
"5",
")",
"visualizer",
".",
"show",
"(",
")"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | agglomerative.process | !
@brief Performs cluster analysis in line with rules of agglomerative algorithm and similarity.
@see get_clusters() | pyclustering/cluster/agglomerative.py | def process(self):
"""!
@brief Performs cluster analysis in line with rules of agglomerative algorithm and similarity.
@see get_clusters()
"""
if (self.__ccore is True):
self.__clusters = wrapper.agglomerative_algorithm(self.__pointer_data, self.__number_clusters, self.__similarity);
else:
self.__clusters = [[index] for index in range(0, len(self.__pointer_data))];
current_number_clusters = len(self.__clusters);
while (current_number_clusters > self.__number_clusters):
self.__merge_similar_clusters();
current_number_clusters = len(self.__clusters); | def process(self):
"""!
@brief Performs cluster analysis in line with rules of agglomerative algorithm and similarity.
@see get_clusters()
"""
if (self.__ccore is True):
self.__clusters = wrapper.agglomerative_algorithm(self.__pointer_data, self.__number_clusters, self.__similarity);
else:
self.__clusters = [[index] for index in range(0, len(self.__pointer_data))];
current_number_clusters = len(self.__clusters);
while (current_number_clusters > self.__number_clusters):
self.__merge_similar_clusters();
current_number_clusters = len(self.__clusters); | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/cluster/agglomerative.py#L145-L163 | [
"def",
"process",
"(",
"self",
")",
":",
"if",
"(",
"self",
".",
"__ccore",
"is",
"True",
")",
":",
"self",
".",
"__clusters",
"=",
"wrapper",
".",
"agglomerative_algorithm",
"(",
"self",
".",
"__pointer_data",
",",
"self",
".",
"__number_clusters",
",",
"self",
".",
"__similarity",
")",
"else",
":",
"self",
".",
"__clusters",
"=",
"[",
"[",
"index",
"]",
"for",
"index",
"in",
"range",
"(",
"0",
",",
"len",
"(",
"self",
".",
"__pointer_data",
")",
")",
"]",
"current_number_clusters",
"=",
"len",
"(",
"self",
".",
"__clusters",
")",
"while",
"(",
"current_number_clusters",
">",
"self",
".",
"__number_clusters",
")",
":",
"self",
".",
"__merge_similar_clusters",
"(",
")",
"current_number_clusters",
"=",
"len",
"(",
"self",
".",
"__clusters",
")"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | agglomerative.__merge_similar_clusters | !
@brief Merges the most similar clusters in line with link type. | pyclustering/cluster/agglomerative.py | def __merge_similar_clusters(self):
"""!
@brief Merges the most similar clusters in line with link type.
"""
if (self.__similarity == type_link.AVERAGE_LINK):
self.__merge_by_average_link();
elif (self.__similarity == type_link.CENTROID_LINK):
self.__merge_by_centroid_link();
elif (self.__similarity == type_link.COMPLETE_LINK):
self.__merge_by_complete_link();
elif (self.__similarity == type_link.SINGLE_LINK):
self.__merge_by_signle_link();
else:
raise NameError('Not supported similarity is used'); | def __merge_similar_clusters(self):
"""!
@brief Merges the most similar clusters in line with link type.
"""
if (self.__similarity == type_link.AVERAGE_LINK):
self.__merge_by_average_link();
elif (self.__similarity == type_link.CENTROID_LINK):
self.__merge_by_centroid_link();
elif (self.__similarity == type_link.COMPLETE_LINK):
self.__merge_by_complete_link();
elif (self.__similarity == type_link.SINGLE_LINK):
self.__merge_by_signle_link();
else:
raise NameError('Not supported similarity is used'); | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/cluster/agglomerative.py#L194-L213 | [
"def",
"__merge_similar_clusters",
"(",
"self",
")",
":",
"if",
"(",
"self",
".",
"__similarity",
"==",
"type_link",
".",
"AVERAGE_LINK",
")",
":",
"self",
".",
"__merge_by_average_link",
"(",
")",
"elif",
"(",
"self",
".",
"__similarity",
"==",
"type_link",
".",
"CENTROID_LINK",
")",
":",
"self",
".",
"__merge_by_centroid_link",
"(",
")",
"elif",
"(",
"self",
".",
"__similarity",
"==",
"type_link",
".",
"COMPLETE_LINK",
")",
":",
"self",
".",
"__merge_by_complete_link",
"(",
")",
"elif",
"(",
"self",
".",
"__similarity",
"==",
"type_link",
".",
"SINGLE_LINK",
")",
":",
"self",
".",
"__merge_by_signle_link",
"(",
")",
"else",
":",
"raise",
"NameError",
"(",
"'Not supported similarity is used'",
")"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | agglomerative.__merge_by_average_link | !
@brief Merges the most similar clusters in line with average link type. | pyclustering/cluster/agglomerative.py | def __merge_by_average_link(self):
"""!
@brief Merges the most similar clusters in line with average link type.
"""
minimum_average_distance = float('Inf');
for index_cluster1 in range(0, len(self.__clusters)):
for index_cluster2 in range(index_cluster1 + 1, len(self.__clusters)):
# Find farthest objects
candidate_average_distance = 0.0;
for index_object1 in self.__clusters[index_cluster1]:
for index_object2 in self.__clusters[index_cluster2]:
candidate_average_distance += euclidean_distance_square(self.__pointer_data[index_object1], self.__pointer_data[index_object2]);
candidate_average_distance /= (len(self.__clusters[index_cluster1]) + len(self.__clusters[index_cluster2]));
if (candidate_average_distance < minimum_average_distance):
minimum_average_distance = candidate_average_distance;
indexes = [index_cluster1, index_cluster2];
self.__clusters[indexes[0]] += self.__clusters[indexes[1]];
self.__clusters.pop(indexes[1]); | def __merge_by_average_link(self):
"""!
@brief Merges the most similar clusters in line with average link type.
"""
minimum_average_distance = float('Inf');
for index_cluster1 in range(0, len(self.__clusters)):
for index_cluster2 in range(index_cluster1 + 1, len(self.__clusters)):
# Find farthest objects
candidate_average_distance = 0.0;
for index_object1 in self.__clusters[index_cluster1]:
for index_object2 in self.__clusters[index_cluster2]:
candidate_average_distance += euclidean_distance_square(self.__pointer_data[index_object1], self.__pointer_data[index_object2]);
candidate_average_distance /= (len(self.__clusters[index_cluster1]) + len(self.__clusters[index_cluster2]));
if (candidate_average_distance < minimum_average_distance):
minimum_average_distance = candidate_average_distance;
indexes = [index_cluster1, index_cluster2];
self.__clusters[indexes[0]] += self.__clusters[indexes[1]];
self.__clusters.pop(indexes[1]); | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/cluster/agglomerative.py#L216-L240 | [
"def",
"__merge_by_average_link",
"(",
"self",
")",
":",
"minimum_average_distance",
"=",
"float",
"(",
"'Inf'",
")",
"for",
"index_cluster1",
"in",
"range",
"(",
"0",
",",
"len",
"(",
"self",
".",
"__clusters",
")",
")",
":",
"for",
"index_cluster2",
"in",
"range",
"(",
"index_cluster1",
"+",
"1",
",",
"len",
"(",
"self",
".",
"__clusters",
")",
")",
":",
"# Find farthest objects",
"candidate_average_distance",
"=",
"0.0",
"for",
"index_object1",
"in",
"self",
".",
"__clusters",
"[",
"index_cluster1",
"]",
":",
"for",
"index_object2",
"in",
"self",
".",
"__clusters",
"[",
"index_cluster2",
"]",
":",
"candidate_average_distance",
"+=",
"euclidean_distance_square",
"(",
"self",
".",
"__pointer_data",
"[",
"index_object1",
"]",
",",
"self",
".",
"__pointer_data",
"[",
"index_object2",
"]",
")",
"candidate_average_distance",
"/=",
"(",
"len",
"(",
"self",
".",
"__clusters",
"[",
"index_cluster1",
"]",
")",
"+",
"len",
"(",
"self",
".",
"__clusters",
"[",
"index_cluster2",
"]",
")",
")",
"if",
"(",
"candidate_average_distance",
"<",
"minimum_average_distance",
")",
":",
"minimum_average_distance",
"=",
"candidate_average_distance",
"indexes",
"=",
"[",
"index_cluster1",
",",
"index_cluster2",
"]",
"self",
".",
"__clusters",
"[",
"indexes",
"[",
"0",
"]",
"]",
"+=",
"self",
".",
"__clusters",
"[",
"indexes",
"[",
"1",
"]",
"]",
"self",
".",
"__clusters",
".",
"pop",
"(",
"indexes",
"[",
"1",
"]",
")"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | agglomerative.__merge_by_centroid_link | !
@brief Merges the most similar clusters in line with centroid link type. | pyclustering/cluster/agglomerative.py | def __merge_by_centroid_link(self):
"""!
@brief Merges the most similar clusters in line with centroid link type.
"""
minimum_centroid_distance = float('Inf');
indexes = None;
for index1 in range(0, len(self.__centers)):
for index2 in range(index1 + 1, len(self.__centers)):
distance = euclidean_distance_square(self.__centers[index1], self.__centers[index2]);
if (distance < minimum_centroid_distance):
minimum_centroid_distance = distance;
indexes = [index1, index2];
self.__clusters[indexes[0]] += self.__clusters[indexes[1]];
self.__centers[indexes[0]] = self.__calculate_center(self.__clusters[indexes[0]]);
self.__clusters.pop(indexes[1]); # remove merged cluster.
self.__centers.pop(indexes[1]); | def __merge_by_centroid_link(self):
"""!
@brief Merges the most similar clusters in line with centroid link type.
"""
minimum_centroid_distance = float('Inf');
indexes = None;
for index1 in range(0, len(self.__centers)):
for index2 in range(index1 + 1, len(self.__centers)):
distance = euclidean_distance_square(self.__centers[index1], self.__centers[index2]);
if (distance < minimum_centroid_distance):
minimum_centroid_distance = distance;
indexes = [index1, index2];
self.__clusters[indexes[0]] += self.__clusters[indexes[1]];
self.__centers[indexes[0]] = self.__calculate_center(self.__clusters[indexes[0]]);
self.__clusters.pop(indexes[1]); # remove merged cluster.
self.__centers.pop(indexes[1]); | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/cluster/agglomerative.py#L243-L263 | [
"def",
"__merge_by_centroid_link",
"(",
"self",
")",
":",
"minimum_centroid_distance",
"=",
"float",
"(",
"'Inf'",
")",
"indexes",
"=",
"None",
"for",
"index1",
"in",
"range",
"(",
"0",
",",
"len",
"(",
"self",
".",
"__centers",
")",
")",
":",
"for",
"index2",
"in",
"range",
"(",
"index1",
"+",
"1",
",",
"len",
"(",
"self",
".",
"__centers",
")",
")",
":",
"distance",
"=",
"euclidean_distance_square",
"(",
"self",
".",
"__centers",
"[",
"index1",
"]",
",",
"self",
".",
"__centers",
"[",
"index2",
"]",
")",
"if",
"(",
"distance",
"<",
"minimum_centroid_distance",
")",
":",
"minimum_centroid_distance",
"=",
"distance",
"indexes",
"=",
"[",
"index1",
",",
"index2",
"]",
"self",
".",
"__clusters",
"[",
"indexes",
"[",
"0",
"]",
"]",
"+=",
"self",
".",
"__clusters",
"[",
"indexes",
"[",
"1",
"]",
"]",
"self",
".",
"__centers",
"[",
"indexes",
"[",
"0",
"]",
"]",
"=",
"self",
".",
"__calculate_center",
"(",
"self",
".",
"__clusters",
"[",
"indexes",
"[",
"0",
"]",
"]",
")",
"self",
".",
"__clusters",
".",
"pop",
"(",
"indexes",
"[",
"1",
"]",
")",
"# remove merged cluster.",
"self",
".",
"__centers",
".",
"pop",
"(",
"indexes",
"[",
"1",
"]",
")"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | agglomerative.__merge_by_complete_link | !
@brief Merges the most similar clusters in line with complete link type. | pyclustering/cluster/agglomerative.py | def __merge_by_complete_link(self):
"""!
@brief Merges the most similar clusters in line with complete link type.
"""
minimum_complete_distance = float('Inf');
indexes = None;
for index_cluster1 in range(0, len(self.__clusters)):
for index_cluster2 in range(index_cluster1 + 1, len(self.__clusters)):
candidate_maximum_distance = self.__calculate_farthest_distance(index_cluster1, index_cluster2);
if (candidate_maximum_distance < minimum_complete_distance):
minimum_complete_distance = candidate_maximum_distance;
indexes = [index_cluster1, index_cluster2];
self.__clusters[indexes[0]] += self.__clusters[indexes[1]];
self.__clusters.pop(indexes[1]); | def __merge_by_complete_link(self):
"""!
@brief Merges the most similar clusters in line with complete link type.
"""
minimum_complete_distance = float('Inf');
indexes = None;
for index_cluster1 in range(0, len(self.__clusters)):
for index_cluster2 in range(index_cluster1 + 1, len(self.__clusters)):
candidate_maximum_distance = self.__calculate_farthest_distance(index_cluster1, index_cluster2);
if (candidate_maximum_distance < minimum_complete_distance):
minimum_complete_distance = candidate_maximum_distance;
indexes = [index_cluster1, index_cluster2];
self.__clusters[indexes[0]] += self.__clusters[indexes[1]];
self.__clusters.pop(indexes[1]); | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/cluster/agglomerative.py#L266-L284 | [
"def",
"__merge_by_complete_link",
"(",
"self",
")",
":",
"minimum_complete_distance",
"=",
"float",
"(",
"'Inf'",
")",
"indexes",
"=",
"None",
"for",
"index_cluster1",
"in",
"range",
"(",
"0",
",",
"len",
"(",
"self",
".",
"__clusters",
")",
")",
":",
"for",
"index_cluster2",
"in",
"range",
"(",
"index_cluster1",
"+",
"1",
",",
"len",
"(",
"self",
".",
"__clusters",
")",
")",
":",
"candidate_maximum_distance",
"=",
"self",
".",
"__calculate_farthest_distance",
"(",
"index_cluster1",
",",
"index_cluster2",
")",
"if",
"(",
"candidate_maximum_distance",
"<",
"minimum_complete_distance",
")",
":",
"minimum_complete_distance",
"=",
"candidate_maximum_distance",
"indexes",
"=",
"[",
"index_cluster1",
",",
"index_cluster2",
"]",
"self",
".",
"__clusters",
"[",
"indexes",
"[",
"0",
"]",
"]",
"+=",
"self",
".",
"__clusters",
"[",
"indexes",
"[",
"1",
"]",
"]",
"self",
".",
"__clusters",
".",
"pop",
"(",
"indexes",
"[",
"1",
"]",
")"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | agglomerative.__calculate_farthest_distance | !
@brief Finds two farthest objects in two specified clusters in terms and returns distance between them.
@param[in] (uint) Index of the first cluster.
@param[in] (uint) Index of the second cluster.
@return The farthest euclidean distance between two clusters. | pyclustering/cluster/agglomerative.py | def __calculate_farthest_distance(self, index_cluster1, index_cluster2):
"""!
@brief Finds two farthest objects in two specified clusters in terms and returns distance between them.
@param[in] (uint) Index of the first cluster.
@param[in] (uint) Index of the second cluster.
@return The farthest euclidean distance between two clusters.
"""
candidate_maximum_distance = 0.0;
for index_object1 in self.__clusters[index_cluster1]:
for index_object2 in self.__clusters[index_cluster2]:
distance = euclidean_distance_square(self.__pointer_data[index_object1], self.__pointer_data[index_object2]);
if (distance > candidate_maximum_distance):
candidate_maximum_distance = distance;
return candidate_maximum_distance; | def __calculate_farthest_distance(self, index_cluster1, index_cluster2):
"""!
@brief Finds two farthest objects in two specified clusters in terms and returns distance between them.
@param[in] (uint) Index of the first cluster.
@param[in] (uint) Index of the second cluster.
@return The farthest euclidean distance between two clusters.
"""
candidate_maximum_distance = 0.0;
for index_object1 in self.__clusters[index_cluster1]:
for index_object2 in self.__clusters[index_cluster2]:
distance = euclidean_distance_square(self.__pointer_data[index_object1], self.__pointer_data[index_object2]);
if (distance > candidate_maximum_distance):
candidate_maximum_distance = distance;
return candidate_maximum_distance; | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/cluster/agglomerative.py#L287-L305 | [
"def",
"__calculate_farthest_distance",
"(",
"self",
",",
"index_cluster1",
",",
"index_cluster2",
")",
":",
"candidate_maximum_distance",
"=",
"0.0",
"for",
"index_object1",
"in",
"self",
".",
"__clusters",
"[",
"index_cluster1",
"]",
":",
"for",
"index_object2",
"in",
"self",
".",
"__clusters",
"[",
"index_cluster2",
"]",
":",
"distance",
"=",
"euclidean_distance_square",
"(",
"self",
".",
"__pointer_data",
"[",
"index_object1",
"]",
",",
"self",
".",
"__pointer_data",
"[",
"index_object2",
"]",
")",
"if",
"(",
"distance",
">",
"candidate_maximum_distance",
")",
":",
"candidate_maximum_distance",
"=",
"distance",
"return",
"candidate_maximum_distance"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | agglomerative.__merge_by_signle_link | !
@brief Merges the most similar clusters in line with single link type. | pyclustering/cluster/agglomerative.py | def __merge_by_signle_link(self):
"""!
@brief Merges the most similar clusters in line with single link type.
"""
minimum_single_distance = float('Inf');
indexes = None;
for index_cluster1 in range(0, len(self.__clusters)):
for index_cluster2 in range(index_cluster1 + 1, len(self.__clusters)):
candidate_minimum_distance = self.__calculate_nearest_distance(index_cluster1, index_cluster2);
if (candidate_minimum_distance < minimum_single_distance):
minimum_single_distance = candidate_minimum_distance;
indexes = [index_cluster1, index_cluster2];
self.__clusters[indexes[0]] += self.__clusters[indexes[1]];
self.__clusters.pop(indexes[1]); | def __merge_by_signle_link(self):
"""!
@brief Merges the most similar clusters in line with single link type.
"""
minimum_single_distance = float('Inf');
indexes = None;
for index_cluster1 in range(0, len(self.__clusters)):
for index_cluster2 in range(index_cluster1 + 1, len(self.__clusters)):
candidate_minimum_distance = self.__calculate_nearest_distance(index_cluster1, index_cluster2);
if (candidate_minimum_distance < minimum_single_distance):
minimum_single_distance = candidate_minimum_distance;
indexes = [index_cluster1, index_cluster2];
self.__clusters[indexes[0]] += self.__clusters[indexes[1]];
self.__clusters.pop(indexes[1]); | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/cluster/agglomerative.py#L308-L326 | [
"def",
"__merge_by_signle_link",
"(",
"self",
")",
":",
"minimum_single_distance",
"=",
"float",
"(",
"'Inf'",
")",
"indexes",
"=",
"None",
"for",
"index_cluster1",
"in",
"range",
"(",
"0",
",",
"len",
"(",
"self",
".",
"__clusters",
")",
")",
":",
"for",
"index_cluster2",
"in",
"range",
"(",
"index_cluster1",
"+",
"1",
",",
"len",
"(",
"self",
".",
"__clusters",
")",
")",
":",
"candidate_minimum_distance",
"=",
"self",
".",
"__calculate_nearest_distance",
"(",
"index_cluster1",
",",
"index_cluster2",
")",
"if",
"(",
"candidate_minimum_distance",
"<",
"minimum_single_distance",
")",
":",
"minimum_single_distance",
"=",
"candidate_minimum_distance",
"indexes",
"=",
"[",
"index_cluster1",
",",
"index_cluster2",
"]",
"self",
".",
"__clusters",
"[",
"indexes",
"[",
"0",
"]",
"]",
"+=",
"self",
".",
"__clusters",
"[",
"indexes",
"[",
"1",
"]",
"]",
"self",
".",
"__clusters",
".",
"pop",
"(",
"indexes",
"[",
"1",
"]",
")"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | agglomerative.__calculate_nearest_distance | !
@brief Finds two nearest objects in two specified clusters and returns distance between them.
@param[in] (uint) Index of the first cluster.
@param[in] (uint) Index of the second cluster.
@return The nearest euclidean distance between two clusters. | pyclustering/cluster/agglomerative.py | def __calculate_nearest_distance(self, index_cluster1, index_cluster2):
"""!
@brief Finds two nearest objects in two specified clusters and returns distance between them.
@param[in] (uint) Index of the first cluster.
@param[in] (uint) Index of the second cluster.
@return The nearest euclidean distance between two clusters.
"""
candidate_minimum_distance = float('Inf');
for index_object1 in self.__clusters[index_cluster1]:
for index_object2 in self.__clusters[index_cluster2]:
distance = euclidean_distance_square(self.__pointer_data[index_object1], self.__pointer_data[index_object2]);
if (distance < candidate_minimum_distance):
candidate_minimum_distance = distance;
return candidate_minimum_distance; | def __calculate_nearest_distance(self, index_cluster1, index_cluster2):
"""!
@brief Finds two nearest objects in two specified clusters and returns distance between them.
@param[in] (uint) Index of the first cluster.
@param[in] (uint) Index of the second cluster.
@return The nearest euclidean distance between two clusters.
"""
candidate_minimum_distance = float('Inf');
for index_object1 in self.__clusters[index_cluster1]:
for index_object2 in self.__clusters[index_cluster2]:
distance = euclidean_distance_square(self.__pointer_data[index_object1], self.__pointer_data[index_object2]);
if (distance < candidate_minimum_distance):
candidate_minimum_distance = distance;
return candidate_minimum_distance; | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/cluster/agglomerative.py#L329-L347 | [
"def",
"__calculate_nearest_distance",
"(",
"self",
",",
"index_cluster1",
",",
"index_cluster2",
")",
":",
"candidate_minimum_distance",
"=",
"float",
"(",
"'Inf'",
")",
"for",
"index_object1",
"in",
"self",
".",
"__clusters",
"[",
"index_cluster1",
"]",
":",
"for",
"index_object2",
"in",
"self",
".",
"__clusters",
"[",
"index_cluster2",
"]",
":",
"distance",
"=",
"euclidean_distance_square",
"(",
"self",
".",
"__pointer_data",
"[",
"index_object1",
"]",
",",
"self",
".",
"__pointer_data",
"[",
"index_object2",
"]",
")",
"if",
"(",
"distance",
"<",
"candidate_minimum_distance",
")",
":",
"candidate_minimum_distance",
"=",
"distance",
"return",
"candidate_minimum_distance"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | agglomerative.__calculate_center | !
@brief Calculates new center.
@return (list) New value of the center of the specified cluster. | pyclustering/cluster/agglomerative.py | def __calculate_center(self, cluster):
"""!
@brief Calculates new center.
@return (list) New value of the center of the specified cluster.
"""
dimension = len(self.__pointer_data[cluster[0]]);
center = [0] * dimension;
for index_point in cluster:
for index_dimension in range(0, dimension):
center[index_dimension] += self.__pointer_data[index_point][index_dimension];
for index_dimension in range(0, dimension):
center[index_dimension] /= len(cluster);
return center; | def __calculate_center(self, cluster):
"""!
@brief Calculates new center.
@return (list) New value of the center of the specified cluster.
"""
dimension = len(self.__pointer_data[cluster[0]]);
center = [0] * dimension;
for index_point in cluster:
for index_dimension in range(0, dimension):
center[index_dimension] += self.__pointer_data[index_point][index_dimension];
for index_dimension in range(0, dimension):
center[index_dimension] /= len(cluster);
return center; | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/cluster/agglomerative.py#L350-L367 | [
"def",
"__calculate_center",
"(",
"self",
",",
"cluster",
")",
":",
"dimension",
"=",
"len",
"(",
"self",
".",
"__pointer_data",
"[",
"cluster",
"[",
"0",
"]",
"]",
")",
"center",
"=",
"[",
"0",
"]",
"*",
"dimension",
"for",
"index_point",
"in",
"cluster",
":",
"for",
"index_dimension",
"in",
"range",
"(",
"0",
",",
"dimension",
")",
":",
"center",
"[",
"index_dimension",
"]",
"+=",
"self",
".",
"__pointer_data",
"[",
"index_point",
"]",
"[",
"index_dimension",
"]",
"for",
"index_dimension",
"in",
"range",
"(",
"0",
",",
"dimension",
")",
":",
"center",
"[",
"index_dimension",
"]",
"/=",
"len",
"(",
"cluster",
")",
"return",
"center"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | som_create | !
@brief Create of self-organized map using CCORE pyclustering library.
@param[in] rows (uint): Number of neurons in the column (number of rows).
@param[in] cols (uint): Number of neurons in the row (number of columns).
@param[in] conn_type (type_conn): Type of connection between oscillators in the network (grid four, grid eight, honeycomb, function neighbour).
@param[in] parameters (som_parameters): Other specific parameters.
@return (POINTER) C-pointer to object of self-organized feature in memory. | pyclustering/core/som_wrapper.py | def som_create(rows, cols, conn_type, parameters):
"""!
@brief Create of self-organized map using CCORE pyclustering library.
@param[in] rows (uint): Number of neurons in the column (number of rows).
@param[in] cols (uint): Number of neurons in the row (number of columns).
@param[in] conn_type (type_conn): Type of connection between oscillators in the network (grid four, grid eight, honeycomb, function neighbour).
@param[in] parameters (som_parameters): Other specific parameters.
@return (POINTER) C-pointer to object of self-organized feature in memory.
"""
ccore = ccore_library.get()
c_params = c_som_parameters()
c_params.init_type = parameters.init_type
c_params.init_radius = parameters.init_radius
c_params.init_learn_rate = parameters.init_learn_rate
c_params.adaptation_threshold = parameters.adaptation_threshold
ccore.som_create.restype = POINTER(c_void_p)
som_pointer = ccore.som_create(c_uint(rows), c_uint(cols), c_uint(conn_type), pointer(c_params))
return som_pointer | def som_create(rows, cols, conn_type, parameters):
"""!
@brief Create of self-organized map using CCORE pyclustering library.
@param[in] rows (uint): Number of neurons in the column (number of rows).
@param[in] cols (uint): Number of neurons in the row (number of columns).
@param[in] conn_type (type_conn): Type of connection between oscillators in the network (grid four, grid eight, honeycomb, function neighbour).
@param[in] parameters (som_parameters): Other specific parameters.
@return (POINTER) C-pointer to object of self-organized feature in memory.
"""
ccore = ccore_library.get()
c_params = c_som_parameters()
c_params.init_type = parameters.init_type
c_params.init_radius = parameters.init_radius
c_params.init_learn_rate = parameters.init_learn_rate
c_params.adaptation_threshold = parameters.adaptation_threshold
ccore.som_create.restype = POINTER(c_void_p)
som_pointer = ccore.som_create(c_uint(rows), c_uint(cols), c_uint(conn_type), pointer(c_params))
return som_pointer | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/core/som_wrapper.py#L45-L70 | [
"def",
"som_create",
"(",
"rows",
",",
"cols",
",",
"conn_type",
",",
"parameters",
")",
":",
"ccore",
"=",
"ccore_library",
".",
"get",
"(",
")",
"c_params",
"=",
"c_som_parameters",
"(",
")",
"c_params",
".",
"init_type",
"=",
"parameters",
".",
"init_type",
"c_params",
".",
"init_radius",
"=",
"parameters",
".",
"init_radius",
"c_params",
".",
"init_learn_rate",
"=",
"parameters",
".",
"init_learn_rate",
"c_params",
".",
"adaptation_threshold",
"=",
"parameters",
".",
"adaptation_threshold",
"ccore",
".",
"som_create",
".",
"restype",
"=",
"POINTER",
"(",
"c_void_p",
")",
"som_pointer",
"=",
"ccore",
".",
"som_create",
"(",
"c_uint",
"(",
"rows",
")",
",",
"c_uint",
"(",
"cols",
")",
",",
"c_uint",
"(",
"conn_type",
")",
",",
"pointer",
"(",
"c_params",
")",
")",
"return",
"som_pointer"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | som_load | !
@brief Load dump of the network to SOM.
@details Initialize SOM using existed weights, amount of captured objects by each neuron, captured
objects by each neuron. Initialization is not performed if weights are empty.
@param[in] som_pointer (POINTER): pointer to object of self-organized map.
@param[in] weights (list): weights that should assigned to neurons.
@param[in] awards (list): amount of captured objects by each neuron.
@param[in] capture_objects (list): captured objects by each neuron. | pyclustering/core/som_wrapper.py | def som_load(som_pointer, weights, award, capture_objects):
"""!
@brief Load dump of the network to SOM.
@details Initialize SOM using existed weights, amount of captured objects by each neuron, captured
objects by each neuron. Initialization is not performed if weights are empty.
@param[in] som_pointer (POINTER): pointer to object of self-organized map.
@param[in] weights (list): weights that should assigned to neurons.
@param[in] awards (list): amount of captured objects by each neuron.
@param[in] capture_objects (list): captured objects by each neuron.
"""
if len(weights) == 0:
return
ccore = ccore_library.get()
package_weights = package_builder(weights, c_double).create()
package_award = package_builder(award, c_size_t).create()
package_capture_objects = package_builder(capture_objects, c_size_t).create()
ccore.som_load(som_pointer, package_weights, package_award, package_capture_objects) | def som_load(som_pointer, weights, award, capture_objects):
"""!
@brief Load dump of the network to SOM.
@details Initialize SOM using existed weights, amount of captured objects by each neuron, captured
objects by each neuron. Initialization is not performed if weights are empty.
@param[in] som_pointer (POINTER): pointer to object of self-organized map.
@param[in] weights (list): weights that should assigned to neurons.
@param[in] awards (list): amount of captured objects by each neuron.
@param[in] capture_objects (list): captured objects by each neuron.
"""
if len(weights) == 0:
return
ccore = ccore_library.get()
package_weights = package_builder(weights, c_double).create()
package_award = package_builder(award, c_size_t).create()
package_capture_objects = package_builder(capture_objects, c_size_t).create()
ccore.som_load(som_pointer, package_weights, package_award, package_capture_objects) | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/core/som_wrapper.py#L73-L95 | [
"def",
"som_load",
"(",
"som_pointer",
",",
"weights",
",",
"award",
",",
"capture_objects",
")",
":",
"if",
"len",
"(",
"weights",
")",
"==",
"0",
":",
"return",
"ccore",
"=",
"ccore_library",
".",
"get",
"(",
")",
"package_weights",
"=",
"package_builder",
"(",
"weights",
",",
"c_double",
")",
".",
"create",
"(",
")",
"package_award",
"=",
"package_builder",
"(",
"award",
",",
"c_size_t",
")",
".",
"create",
"(",
")",
"package_capture_objects",
"=",
"package_builder",
"(",
"capture_objects",
",",
"c_size_t",
")",
".",
"create",
"(",
")",
"ccore",
".",
"som_load",
"(",
"som_pointer",
",",
"package_weights",
",",
"package_award",
",",
"package_capture_objects",
")"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | som_train | !
@brief Trains self-organized feature map (SOM) using CCORE pyclustering library.
@param[in] data (list): Input data - list of points where each point is represented by list of features, for example coordinates.
@param[in] epochs (uint): Number of epochs for training.
@param[in] autostop (bool): Automatic termination of learining process when adaptation is not occurred.
@return (uint) Number of learining iterations. | pyclustering/core/som_wrapper.py | def som_train(som_pointer, data, epochs, autostop):
"""!
@brief Trains self-organized feature map (SOM) using CCORE pyclustering library.
@param[in] data (list): Input data - list of points where each point is represented by list of features, for example coordinates.
@param[in] epochs (uint): Number of epochs for training.
@param[in] autostop (bool): Automatic termination of learining process when adaptation is not occurred.
@return (uint) Number of learining iterations.
"""
pointer_data = package_builder(data, c_double).create()
ccore = ccore_library.get()
ccore.som_train.restype = c_size_t
return ccore.som_train(som_pointer, pointer_data, c_uint(epochs), autostop) | def som_train(som_pointer, data, epochs, autostop):
"""!
@brief Trains self-organized feature map (SOM) using CCORE pyclustering library.
@param[in] data (list): Input data - list of points where each point is represented by list of features, for example coordinates.
@param[in] epochs (uint): Number of epochs for training.
@param[in] autostop (bool): Automatic termination of learining process when adaptation is not occurred.
@return (uint) Number of learining iterations.
"""
pointer_data = package_builder(data, c_double).create()
ccore = ccore_library.get()
ccore.som_train.restype = c_size_t
return ccore.som_train(som_pointer, pointer_data, c_uint(epochs), autostop) | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/core/som_wrapper.py#L110-L126 | [
"def",
"som_train",
"(",
"som_pointer",
",",
"data",
",",
"epochs",
",",
"autostop",
")",
":",
"pointer_data",
"=",
"package_builder",
"(",
"data",
",",
"c_double",
")",
".",
"create",
"(",
")",
"ccore",
"=",
"ccore_library",
".",
"get",
"(",
")",
"ccore",
".",
"som_train",
".",
"restype",
"=",
"c_size_t",
"return",
"ccore",
".",
"som_train",
"(",
"som_pointer",
",",
"pointer_data",
",",
"c_uint",
"(",
"epochs",
")",
",",
"autostop",
")"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | som_simulate | !
@brief Processes input pattern (no learining) and returns index of neuron-winner.
@details Using index of neuron winner catched object can be obtained using property capture_objects.
@param[in] som_pointer (c_pointer): pointer to object of self-organized map.
@param[in] pattern (list): input pattern.
@return Returns index of neuron-winner. | pyclustering/core/som_wrapper.py | def som_simulate(som_pointer, pattern):
"""!
@brief Processes input pattern (no learining) and returns index of neuron-winner.
@details Using index of neuron winner catched object can be obtained using property capture_objects.
@param[in] som_pointer (c_pointer): pointer to object of self-organized map.
@param[in] pattern (list): input pattern.
@return Returns index of neuron-winner.
"""
pointer_data = package_builder(pattern, c_double).create()
ccore = ccore_library.get()
ccore.som_simulate.restype = c_size_t
return ccore.som_simulate(som_pointer, pointer_data) | def som_simulate(som_pointer, pattern):
"""!
@brief Processes input pattern (no learining) and returns index of neuron-winner.
@details Using index of neuron winner catched object can be obtained using property capture_objects.
@param[in] som_pointer (c_pointer): pointer to object of self-organized map.
@param[in] pattern (list): input pattern.
@return Returns index of neuron-winner.
"""
pointer_data = package_builder(pattern, c_double).create()
ccore = ccore_library.get()
ccore.som_simulate.restype = c_size_t
return ccore.som_simulate(som_pointer, pointer_data) | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/core/som_wrapper.py#L129-L145 | [
"def",
"som_simulate",
"(",
"som_pointer",
",",
"pattern",
")",
":",
"pointer_data",
"=",
"package_builder",
"(",
"pattern",
",",
"c_double",
")",
".",
"create",
"(",
")",
"ccore",
"=",
"ccore_library",
".",
"get",
"(",
")",
"ccore",
".",
"som_simulate",
".",
"restype",
"=",
"c_size_t",
"return",
"ccore",
".",
"som_simulate",
"(",
"som_pointer",
",",
"pointer_data",
")"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | som_get_winner_number | !
@brief Returns of number of winner at the last step of learning process.
@param[in] som_pointer (c_pointer): pointer to object of self-organized map. | pyclustering/core/som_wrapper.py | def som_get_winner_number(som_pointer):
"""!
@brief Returns of number of winner at the last step of learning process.
@param[in] som_pointer (c_pointer): pointer to object of self-organized map.
"""
ccore = ccore_library.get()
ccore.som_get_winner_number.restype = c_size_t
return ccore.som_get_winner_number(som_pointer) | def som_get_winner_number(som_pointer):
"""!
@brief Returns of number of winner at the last step of learning process.
@param[in] som_pointer (c_pointer): pointer to object of self-organized map.
"""
ccore = ccore_library.get()
ccore.som_get_winner_number.restype = c_size_t
return ccore.som_get_winner_number(som_pointer) | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/core/som_wrapper.py#L148-L158 | [
"def",
"som_get_winner_number",
"(",
"som_pointer",
")",
":",
"ccore",
"=",
"ccore_library",
".",
"get",
"(",
")",
"ccore",
".",
"som_get_winner_number",
".",
"restype",
"=",
"c_size_t",
"return",
"ccore",
".",
"som_get_winner_number",
"(",
"som_pointer",
")"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | som_get_size | !
@brief Returns size of self-organized map (number of neurons).
@param[in] som_pointer (c_pointer): pointer to object of self-organized map. | pyclustering/core/som_wrapper.py | def som_get_size(som_pointer):
"""!
@brief Returns size of self-organized map (number of neurons).
@param[in] som_pointer (c_pointer): pointer to object of self-organized map.
"""
ccore = ccore_library.get()
ccore.som_get_size.restype = c_size_t
return ccore.som_get_size(som_pointer) | def som_get_size(som_pointer):
"""!
@brief Returns size of self-organized map (number of neurons).
@param[in] som_pointer (c_pointer): pointer to object of self-organized map.
"""
ccore = ccore_library.get()
ccore.som_get_size.restype = c_size_t
return ccore.som_get_size(som_pointer) | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/core/som_wrapper.py#L161-L171 | [
"def",
"som_get_size",
"(",
"som_pointer",
")",
":",
"ccore",
"=",
"ccore_library",
".",
"get",
"(",
")",
"ccore",
".",
"som_get_size",
".",
"restype",
"=",
"c_size_t",
"return",
"ccore",
".",
"som_get_size",
"(",
"som_pointer",
")"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | som_get_capture_objects | !
@brief Returns list of indexes of captured objects by each neuron.
@param[in] som_pointer (c_pointer): pointer to object of self-organized map. | pyclustering/core/som_wrapper.py | def som_get_capture_objects(som_pointer):
"""!
@brief Returns list of indexes of captured objects by each neuron.
@param[in] som_pointer (c_pointer): pointer to object of self-organized map.
"""
ccore = ccore_library.get()
ccore.som_get_capture_objects.restype = POINTER(pyclustering_package)
package = ccore.som_get_capture_objects(som_pointer)
result = package_extractor(package).extract()
return result | def som_get_capture_objects(som_pointer):
"""!
@brief Returns list of indexes of captured objects by each neuron.
@param[in] som_pointer (c_pointer): pointer to object of self-organized map.
"""
ccore = ccore_library.get()
ccore.som_get_capture_objects.restype = POINTER(pyclustering_package)
package = ccore.som_get_capture_objects(som_pointer)
result = package_extractor(package).extract()
return result | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/core/som_wrapper.py#L174-L188 | [
"def",
"som_get_capture_objects",
"(",
"som_pointer",
")",
":",
"ccore",
"=",
"ccore_library",
".",
"get",
"(",
")",
"ccore",
".",
"som_get_capture_objects",
".",
"restype",
"=",
"POINTER",
"(",
"pyclustering_package",
")",
"package",
"=",
"ccore",
".",
"som_get_capture_objects",
"(",
"som_pointer",
")",
"result",
"=",
"package_extractor",
"(",
"package",
")",
".",
"extract",
"(",
")",
"return",
"result"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | hysteresis_dynamic.allocate_sync_ensembles | !
@brief Allocate clusters in line with ensembles of synchronous oscillators where each
synchronous ensemble corresponds to only one cluster.
@param[in] tolerance (double): Maximum error for allocation of synchronous ensemble oscillators.
@param[in] threshold_steps (uint): Number of steps from the end of simulation that should be analysed for ensemble allocation.
If amout of simulation steps has been less than threshold steps than amount of steps will be reduced to amout
of simulation steps.
@return (list) Grours of indexes of synchronous oscillators, for example, [ [index_osc1, index_osc3], [index_osc2], [index_osc4, index_osc5] ]." | pyclustering/nnet/hysteresis.py | def allocate_sync_ensembles(self, tolerance = 0.1, threshold_steps = 1):
"""!
@brief Allocate clusters in line with ensembles of synchronous oscillators where each
synchronous ensemble corresponds to only one cluster.
@param[in] tolerance (double): Maximum error for allocation of synchronous ensemble oscillators.
@param[in] threshold_steps (uint): Number of steps from the end of simulation that should be analysed for ensemble allocation.
If amout of simulation steps has been less than threshold steps than amount of steps will be reduced to amout
of simulation steps.
@return (list) Grours of indexes of synchronous oscillators, for example, [ [index_osc1, index_osc3], [index_osc2], [index_osc4, index_osc5] ]."
"""
clusters = [ [0] ];
number_oscillators = len(self._dynamic[0]);
for i in range(1, number_oscillators, 1):
captured_neuron = True;
for cluster in clusters:
neuron_index = cluster[0];
analysis_steps = threshold_steps;
if (len(self._dynamic) < analysis_steps):
analysis_steps = len(self._dynamic);
analysis_start_step_index = len(self._dynamic) - 1;
for step in range(analysis_start_step_index, analysis_start_step_index - analysis_steps, -1):
neuron_amplitude = self._dynamic[step][neuron_index];
candidate_amplitude = self._dynamic[step][i];
if ( not (candidate_amplitude < (neuron_amplitude + tolerance)) or not (candidate_amplitude > (neuron_amplitude - tolerance)) ):
captured_neuron = False;
break;
if ( captured_neuron is True ):
cluster.append(i);
break;
if (captured_neuron is False):
clusters.append([i]);
return clusters; | def allocate_sync_ensembles(self, tolerance = 0.1, threshold_steps = 1):
"""!
@brief Allocate clusters in line with ensembles of synchronous oscillators where each
synchronous ensemble corresponds to only one cluster.
@param[in] tolerance (double): Maximum error for allocation of synchronous ensemble oscillators.
@param[in] threshold_steps (uint): Number of steps from the end of simulation that should be analysed for ensemble allocation.
If amout of simulation steps has been less than threshold steps than amount of steps will be reduced to amout
of simulation steps.
@return (list) Grours of indexes of synchronous oscillators, for example, [ [index_osc1, index_osc3], [index_osc2], [index_osc4, index_osc5] ]."
"""
clusters = [ [0] ];
number_oscillators = len(self._dynamic[0]);
for i in range(1, number_oscillators, 1):
captured_neuron = True;
for cluster in clusters:
neuron_index = cluster[0];
analysis_steps = threshold_steps;
if (len(self._dynamic) < analysis_steps):
analysis_steps = len(self._dynamic);
analysis_start_step_index = len(self._dynamic) - 1;
for step in range(analysis_start_step_index, analysis_start_step_index - analysis_steps, -1):
neuron_amplitude = self._dynamic[step][neuron_index];
candidate_amplitude = self._dynamic[step][i];
if ( not (candidate_amplitude < (neuron_amplitude + tolerance)) or not (candidate_amplitude > (neuron_amplitude - tolerance)) ):
captured_neuron = False;
break;
if ( captured_neuron is True ):
cluster.append(i);
break;
if (captured_neuron is False):
clusters.append([i]);
return clusters; | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/nnet/hysteresis.py#L87-L131 | [
"def",
"allocate_sync_ensembles",
"(",
"self",
",",
"tolerance",
"=",
"0.1",
",",
"threshold_steps",
"=",
"1",
")",
":",
"clusters",
"=",
"[",
"[",
"0",
"]",
"]",
"number_oscillators",
"=",
"len",
"(",
"self",
".",
"_dynamic",
"[",
"0",
"]",
")",
"for",
"i",
"in",
"range",
"(",
"1",
",",
"number_oscillators",
",",
"1",
")",
":",
"captured_neuron",
"=",
"True",
"for",
"cluster",
"in",
"clusters",
":",
"neuron_index",
"=",
"cluster",
"[",
"0",
"]",
"analysis_steps",
"=",
"threshold_steps",
"if",
"(",
"len",
"(",
"self",
".",
"_dynamic",
")",
"<",
"analysis_steps",
")",
":",
"analysis_steps",
"=",
"len",
"(",
"self",
".",
"_dynamic",
")",
"analysis_start_step_index",
"=",
"len",
"(",
"self",
".",
"_dynamic",
")",
"-",
"1",
"for",
"step",
"in",
"range",
"(",
"analysis_start_step_index",
",",
"analysis_start_step_index",
"-",
"analysis_steps",
",",
"-",
"1",
")",
":",
"neuron_amplitude",
"=",
"self",
".",
"_dynamic",
"[",
"step",
"]",
"[",
"neuron_index",
"]",
"candidate_amplitude",
"=",
"self",
".",
"_dynamic",
"[",
"step",
"]",
"[",
"i",
"]",
"if",
"(",
"not",
"(",
"candidate_amplitude",
"<",
"(",
"neuron_amplitude",
"+",
"tolerance",
")",
")",
"or",
"not",
"(",
"candidate_amplitude",
">",
"(",
"neuron_amplitude",
"-",
"tolerance",
")",
")",
")",
":",
"captured_neuron",
"=",
"False",
"break",
"if",
"(",
"captured_neuron",
"is",
"True",
")",
":",
"cluster",
".",
"append",
"(",
"i",
")",
"break",
"if",
"(",
"captured_neuron",
"is",
"False",
")",
":",
"clusters",
".",
"append",
"(",
"[",
"i",
"]",
")",
"return",
"clusters"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | hysteresis_network.outputs | !
@brief Sets outputs of neurons. | pyclustering/nnet/hysteresis.py | def outputs(self, values):
"""!
@brief Sets outputs of neurons.
"""
self._outputs = [val for val in values];
self._outputs_buffer = [val for val in values]; | def outputs(self, values):
"""!
@brief Sets outputs of neurons.
"""
self._outputs = [val for val in values];
self._outputs_buffer = [val for val in values]; | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/nnet/hysteresis.py#L192-L199 | [
"def",
"outputs",
"(",
"self",
",",
"values",
")",
":",
"self",
".",
"_outputs",
"=",
"[",
"val",
"for",
"val",
"in",
"values",
"]",
"self",
".",
"_outputs_buffer",
"=",
"[",
"val",
"for",
"val",
"in",
"values",
"]"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | hysteresis_network._neuron_states | !
@brief Returns new value of the neuron (oscillator).
@param[in] inputs (list): Initial values (current) of the neuron - excitatory.
@param[in] t (double): Current time of simulation.
@param[in] argv (tuple): Extra arguments that are not used for integration - index of the neuron.
@return (double) New value of the neuron. | pyclustering/nnet/hysteresis.py | def _neuron_states(self, inputs, t, argv):
"""!
@brief Returns new value of the neuron (oscillator).
@param[in] inputs (list): Initial values (current) of the neuron - excitatory.
@param[in] t (double): Current time of simulation.
@param[in] argv (tuple): Extra arguments that are not used for integration - index of the neuron.
@return (double) New value of the neuron.
"""
xi = inputs[0];
index = argv;
# own impact
impact = self._weight[index][index] * self._outputs[index];
for i in range(0, self._num_osc, 1):
if (self.has_connection(i, index)):
impact += self._weight[index][i] * self._outputs[i];
x = -xi + impact;
if (xi > 1): self._outputs_buffer[index] = 1;
if (xi < -1): self._outputs_buffer[index] = -1;
return x; | def _neuron_states(self, inputs, t, argv):
"""!
@brief Returns new value of the neuron (oscillator).
@param[in] inputs (list): Initial values (current) of the neuron - excitatory.
@param[in] t (double): Current time of simulation.
@param[in] argv (tuple): Extra arguments that are not used for integration - index of the neuron.
@return (double) New value of the neuron.
"""
xi = inputs[0];
index = argv;
# own impact
impact = self._weight[index][index] * self._outputs[index];
for i in range(0, self._num_osc, 1):
if (self.has_connection(i, index)):
impact += self._weight[index][i] * self._outputs[i];
x = -xi + impact;
if (xi > 1): self._outputs_buffer[index] = 1;
if (xi < -1): self._outputs_buffer[index] = -1;
return x; | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/nnet/hysteresis.py#L252-L279 | [
"def",
"_neuron_states",
"(",
"self",
",",
"inputs",
",",
"t",
",",
"argv",
")",
":",
"xi",
"=",
"inputs",
"[",
"0",
"]",
"index",
"=",
"argv",
"# own impact\r",
"impact",
"=",
"self",
".",
"_weight",
"[",
"index",
"]",
"[",
"index",
"]",
"*",
"self",
".",
"_outputs",
"[",
"index",
"]",
"for",
"i",
"in",
"range",
"(",
"0",
",",
"self",
".",
"_num_osc",
",",
"1",
")",
":",
"if",
"(",
"self",
".",
"has_connection",
"(",
"i",
",",
"index",
")",
")",
":",
"impact",
"+=",
"self",
".",
"_weight",
"[",
"index",
"]",
"[",
"i",
"]",
"*",
"self",
".",
"_outputs",
"[",
"i",
"]",
"x",
"=",
"-",
"xi",
"+",
"impact",
"if",
"(",
"xi",
">",
"1",
")",
":",
"self",
".",
"_outputs_buffer",
"[",
"index",
"]",
"=",
"1",
"if",
"(",
"xi",
"<",
"-",
"1",
")",
":",
"self",
".",
"_outputs_buffer",
"[",
"index",
"]",
"=",
"-",
"1",
"return",
"x"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | hysteresis_network.simulate_static | !
@brief Performs static simulation of hysteresis oscillatory network.
@param[in] steps (uint): Number steps of simulations during simulation.
@param[in] time (double): Time of simulation.
@param[in] solution (solve_type): Type of solution (solving).
@param[in] collect_dynamic (bool): If True - returns whole dynamic of oscillatory network, otherwise returns only last values of dynamics.
@return (hysteresis_dynamic) Dynamic of oscillatory network. If argument 'collect_dynamic' = True, than return dynamic for the whole simulation time,
otherwise returns only last values (last step of simulation) of dynamic. | pyclustering/nnet/hysteresis.py | def simulate_static(self, steps, time, solution = solve_type.RK4, collect_dynamic = False):
"""!
@brief Performs static simulation of hysteresis oscillatory network.
@param[in] steps (uint): Number steps of simulations during simulation.
@param[in] time (double): Time of simulation.
@param[in] solution (solve_type): Type of solution (solving).
@param[in] collect_dynamic (bool): If True - returns whole dynamic of oscillatory network, otherwise returns only last values of dynamics.
@return (hysteresis_dynamic) Dynamic of oscillatory network. If argument 'collect_dynamic' = True, than return dynamic for the whole simulation time,
otherwise returns only last values (last step of simulation) of dynamic.
"""
# Check solver before simulation
if (solution == solve_type.FAST):
raise NameError("Solver FAST is not support due to low accuracy that leads to huge error.");
elif (solution == solve_type.RKF45):
raise NameError("Solver RKF45 is not support in python version.");
dyn_state = None;
dyn_time = None;
if (collect_dynamic == True):
dyn_state = [];
dyn_time = [];
dyn_state.append(self._states);
dyn_time.append(0);
step = time / steps;
int_step = step / 10.0;
for t in numpy.arange(step, time + step, step):
# update states of oscillators
self._states = self._calculate_states(solution, t, step, int_step);
# update states of oscillators
if (collect_dynamic is True):
dyn_state.append(self._states);
dyn_time.append(t);
if (collect_dynamic is False):
dyn_state.append(self._states);
dyn_time.append(time);
return hysteresis_dynamic(dyn_state, dyn_time); | def simulate_static(self, steps, time, solution = solve_type.RK4, collect_dynamic = False):
"""!
@brief Performs static simulation of hysteresis oscillatory network.
@param[in] steps (uint): Number steps of simulations during simulation.
@param[in] time (double): Time of simulation.
@param[in] solution (solve_type): Type of solution (solving).
@param[in] collect_dynamic (bool): If True - returns whole dynamic of oscillatory network, otherwise returns only last values of dynamics.
@return (hysteresis_dynamic) Dynamic of oscillatory network. If argument 'collect_dynamic' = True, than return dynamic for the whole simulation time,
otherwise returns only last values (last step of simulation) of dynamic.
"""
# Check solver before simulation
if (solution == solve_type.FAST):
raise NameError("Solver FAST is not support due to low accuracy that leads to huge error.");
elif (solution == solve_type.RKF45):
raise NameError("Solver RKF45 is not support in python version.");
dyn_state = None;
dyn_time = None;
if (collect_dynamic == True):
dyn_state = [];
dyn_time = [];
dyn_state.append(self._states);
dyn_time.append(0);
step = time / steps;
int_step = step / 10.0;
for t in numpy.arange(step, time + step, step):
# update states of oscillators
self._states = self._calculate_states(solution, t, step, int_step);
# update states of oscillators
if (collect_dynamic is True):
dyn_state.append(self._states);
dyn_time.append(t);
if (collect_dynamic is False):
dyn_state.append(self._states);
dyn_time.append(time);
return hysteresis_dynamic(dyn_state, dyn_time); | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/nnet/hysteresis.py#L298-L344 | [
"def",
"simulate_static",
"(",
"self",
",",
"steps",
",",
"time",
",",
"solution",
"=",
"solve_type",
".",
"RK4",
",",
"collect_dynamic",
"=",
"False",
")",
":",
"# Check solver before simulation\r",
"if",
"(",
"solution",
"==",
"solve_type",
".",
"FAST",
")",
":",
"raise",
"NameError",
"(",
"\"Solver FAST is not support due to low accuracy that leads to huge error.\"",
")",
"elif",
"(",
"solution",
"==",
"solve_type",
".",
"RKF45",
")",
":",
"raise",
"NameError",
"(",
"\"Solver RKF45 is not support in python version.\"",
")",
"dyn_state",
"=",
"None",
"dyn_time",
"=",
"None",
"if",
"(",
"collect_dynamic",
"==",
"True",
")",
":",
"dyn_state",
"=",
"[",
"]",
"dyn_time",
"=",
"[",
"]",
"dyn_state",
".",
"append",
"(",
"self",
".",
"_states",
")",
"dyn_time",
".",
"append",
"(",
"0",
")",
"step",
"=",
"time",
"/",
"steps",
"int_step",
"=",
"step",
"/",
"10.0",
"for",
"t",
"in",
"numpy",
".",
"arange",
"(",
"step",
",",
"time",
"+",
"step",
",",
"step",
")",
":",
"# update states of oscillators\r",
"self",
".",
"_states",
"=",
"self",
".",
"_calculate_states",
"(",
"solution",
",",
"t",
",",
"step",
",",
"int_step",
")",
"# update states of oscillators\r",
"if",
"(",
"collect_dynamic",
"is",
"True",
")",
":",
"dyn_state",
".",
"append",
"(",
"self",
".",
"_states",
")",
"dyn_time",
".",
"append",
"(",
"t",
")",
"if",
"(",
"collect_dynamic",
"is",
"False",
")",
":",
"dyn_state",
".",
"append",
"(",
"self",
".",
"_states",
")",
"dyn_time",
".",
"append",
"(",
"time",
")",
"return",
"hysteresis_dynamic",
"(",
"dyn_state",
",",
"dyn_time",
")"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | hysteresis_network._calculate_states | !
@brief Calculates new states for neurons using differential calculus. Returns new states for neurons.
@param[in] solution (solve_type): Type solver of the differential equation.
@param[in] t (double): Current time of simulation.
@param[in] step (double): Step of solution at the end of which states of oscillators should be calculated.
@param[in] int_step (double): Step differentiation that is used for solving differential equation.
@return (list) New states for neurons. | pyclustering/nnet/hysteresis.py | def _calculate_states(self, solution, t, step, int_step):
"""!
@brief Calculates new states for neurons using differential calculus. Returns new states for neurons.
@param[in] solution (solve_type): Type solver of the differential equation.
@param[in] t (double): Current time of simulation.
@param[in] step (double): Step of solution at the end of which states of oscillators should be calculated.
@param[in] int_step (double): Step differentiation that is used for solving differential equation.
@return (list) New states for neurons.
"""
next_states = [0] * self._num_osc;
for index in range (0, self._num_osc, 1):
result = odeint(self._neuron_states, self._states[index], numpy.arange(t - step, t, int_step), (index , ));
next_states[index] = result[len(result) - 1][0];
self._outputs = [val for val in self._outputs_buffer];
return next_states; | def _calculate_states(self, solution, t, step, int_step):
"""!
@brief Calculates new states for neurons using differential calculus. Returns new states for neurons.
@param[in] solution (solve_type): Type solver of the differential equation.
@param[in] t (double): Current time of simulation.
@param[in] step (double): Step of solution at the end of which states of oscillators should be calculated.
@param[in] int_step (double): Step differentiation that is used for solving differential equation.
@return (list) New states for neurons.
"""
next_states = [0] * self._num_osc;
for index in range (0, self._num_osc, 1):
result = odeint(self._neuron_states, self._states[index], numpy.arange(t - step, t, int_step), (index , ));
next_states[index] = result[len(result) - 1][0];
self._outputs = [val for val in self._outputs_buffer];
return next_states; | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/nnet/hysteresis.py#L347-L367 | [
"def",
"_calculate_states",
"(",
"self",
",",
"solution",
",",
"t",
",",
"step",
",",
"int_step",
")",
":",
"next_states",
"=",
"[",
"0",
"]",
"*",
"self",
".",
"_num_osc",
"for",
"index",
"in",
"range",
"(",
"0",
",",
"self",
".",
"_num_osc",
",",
"1",
")",
":",
"result",
"=",
"odeint",
"(",
"self",
".",
"_neuron_states",
",",
"self",
".",
"_states",
"[",
"index",
"]",
",",
"numpy",
".",
"arange",
"(",
"t",
"-",
"step",
",",
"t",
",",
"int_step",
")",
",",
"(",
"index",
",",
")",
")",
"next_states",
"[",
"index",
"]",
"=",
"result",
"[",
"len",
"(",
"result",
")",
"-",
"1",
"]",
"[",
"0",
"]",
"self",
".",
"_outputs",
"=",
"[",
"val",
"for",
"val",
"in",
"self",
".",
"_outputs_buffer",
"]",
"return",
"next_states"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | legion_dynamic.output | !
@brief Returns output dynamic of the network. | pyclustering/nnet/legion.py | def output(self):
"""!
@brief Returns output dynamic of the network.
"""
if (self.__ccore_legion_dynamic_pointer is not None):
return wrapper.legion_dynamic_get_output(self.__ccore_legion_dynamic_pointer);
return self.__output; | def output(self):
"""!
@brief Returns output dynamic of the network.
"""
if (self.__ccore_legion_dynamic_pointer is not None):
return wrapper.legion_dynamic_get_output(self.__ccore_legion_dynamic_pointer);
return self.__output; | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/nnet/legion.py#L119-L127 | [
"def",
"output",
"(",
"self",
")",
":",
"if",
"(",
"self",
".",
"__ccore_legion_dynamic_pointer",
"is",
"not",
"None",
")",
":",
"return",
"wrapper",
".",
"legion_dynamic_get_output",
"(",
"self",
".",
"__ccore_legion_dynamic_pointer",
")",
"return",
"self",
".",
"__output"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | legion_dynamic.inhibitor | !
@brief Returns output dynamic of the global inhibitor of the network. | pyclustering/nnet/legion.py | def inhibitor(self):
"""!
@brief Returns output dynamic of the global inhibitor of the network.
"""
if (self.__ccore_legion_dynamic_pointer is not None):
return wrapper.legion_dynamic_get_inhibitory_output(self.__ccore_legion_dynamic_pointer);
return self.__inhibitor; | def inhibitor(self):
"""!
@brief Returns output dynamic of the global inhibitor of the network.
"""
if (self.__ccore_legion_dynamic_pointer is not None):
return wrapper.legion_dynamic_get_inhibitory_output(self.__ccore_legion_dynamic_pointer);
return self.__inhibitor; | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/nnet/legion.py#L131-L140 | [
"def",
"inhibitor",
"(",
"self",
")",
":",
"if",
"(",
"self",
".",
"__ccore_legion_dynamic_pointer",
"is",
"not",
"None",
")",
":",
"return",
"wrapper",
".",
"legion_dynamic_get_inhibitory_output",
"(",
"self",
".",
"__ccore_legion_dynamic_pointer",
")",
"return",
"self",
".",
"__inhibitor"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | legion_dynamic.time | !
@brief Returns simulation time. | pyclustering/nnet/legion.py | def time(self):
"""!
@brief Returns simulation time.
"""
if (self.__ccore_legion_dynamic_pointer is not None):
return wrapper.legion_dynamic_get_time(self.__ccore_legion_dynamic_pointer);
return list(range(len(self))); | def time(self):
"""!
@brief Returns simulation time.
"""
if (self.__ccore_legion_dynamic_pointer is not None):
return wrapper.legion_dynamic_get_time(self.__ccore_legion_dynamic_pointer);
return list(range(len(self))); | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/nnet/legion.py#L144-L152 | [
"def",
"time",
"(",
"self",
")",
":",
"if",
"(",
"self",
".",
"__ccore_legion_dynamic_pointer",
"is",
"not",
"None",
")",
":",
"return",
"wrapper",
".",
"legion_dynamic_get_time",
"(",
"self",
".",
"__ccore_legion_dynamic_pointer",
")",
"return",
"list",
"(",
"range",
"(",
"len",
"(",
"self",
")",
")",
")"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | legion_dynamic.allocate_sync_ensembles | !
@brief Allocate clusters in line with ensembles of synchronous oscillators where each synchronous ensemble corresponds to only one cluster.
@param[in] tolerance (double): Maximum error for allocation of synchronous ensemble oscillators.
@return (list) Grours of indexes of synchronous oscillators, for example, [ [index_osc1, index_osc3], [index_osc2], [index_osc4, index_osc5] ]. | pyclustering/nnet/legion.py | def allocate_sync_ensembles(self, tolerance = 0.1):
"""!
@brief Allocate clusters in line with ensembles of synchronous oscillators where each synchronous ensemble corresponds to only one cluster.
@param[in] tolerance (double): Maximum error for allocation of synchronous ensemble oscillators.
@return (list) Grours of indexes of synchronous oscillators, for example, [ [index_osc1, index_osc3], [index_osc2], [index_osc4, index_osc5] ].
"""
if (self.__ccore_legion_dynamic_pointer is not None):
self.__output = wrapper.legion_dynamic_get_output(self.__ccore_legion_dynamic_pointer);
return allocate_sync_ensembles(self.__output, tolerance); | def allocate_sync_ensembles(self, tolerance = 0.1):
"""!
@brief Allocate clusters in line with ensembles of synchronous oscillators where each synchronous ensemble corresponds to only one cluster.
@param[in] tolerance (double): Maximum error for allocation of synchronous ensemble oscillators.
@return (list) Grours of indexes of synchronous oscillators, for example, [ [index_osc1, index_osc3], [index_osc2], [index_osc4, index_osc5] ].
"""
if (self.__ccore_legion_dynamic_pointer is not None):
self.__output = wrapper.legion_dynamic_get_output(self.__ccore_legion_dynamic_pointer);
return allocate_sync_ensembles(self.__output, tolerance); | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/nnet/legion.py#L193-L206 | [
"def",
"allocate_sync_ensembles",
"(",
"self",
",",
"tolerance",
"=",
"0.1",
")",
":",
"if",
"(",
"self",
".",
"__ccore_legion_dynamic_pointer",
"is",
"not",
"None",
")",
":",
"self",
".",
"__output",
"=",
"wrapper",
".",
"legion_dynamic_get_output",
"(",
"self",
".",
"__ccore_legion_dynamic_pointer",
")",
"return",
"allocate_sync_ensembles",
"(",
"self",
".",
"__output",
",",
"tolerance",
")"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | legion_network.__create_stimulus | !
@brief Create stimulus for oscillators in line with stimulus map and parameters.
@param[in] stimulus (list): Stimulus for oscillators that is represented by list, number of stimulus should be equal number of oscillators. | pyclustering/nnet/legion.py | def __create_stimulus(self, stimulus):
"""!
@brief Create stimulus for oscillators in line with stimulus map and parameters.
@param[in] stimulus (list): Stimulus for oscillators that is represented by list, number of stimulus should be equal number of oscillators.
"""
if (len(stimulus) != self._num_osc):
raise NameError("Number of stimulus should be equal number of oscillators in the network.");
else:
self._stimulus = [];
for val in stimulus:
if (val > 0): self._stimulus.append(self._params.I);
else: self._stimulus.append(0); | def __create_stimulus(self, stimulus):
"""!
@brief Create stimulus for oscillators in line with stimulus map and parameters.
@param[in] stimulus (list): Stimulus for oscillators that is represented by list, number of stimulus should be equal number of oscillators.
"""
if (len(stimulus) != self._num_osc):
raise NameError("Number of stimulus should be equal number of oscillators in the network.");
else:
self._stimulus = [];
for val in stimulus:
if (val > 0): self._stimulus.append(self._params.I);
else: self._stimulus.append(0); | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/nnet/legion.py#L305-L320 | [
"def",
"__create_stimulus",
"(",
"self",
",",
"stimulus",
")",
":",
"if",
"(",
"len",
"(",
"stimulus",
")",
"!=",
"self",
".",
"_num_osc",
")",
":",
"raise",
"NameError",
"(",
"\"Number of stimulus should be equal number of oscillators in the network.\"",
")",
"else",
":",
"self",
".",
"_stimulus",
"=",
"[",
"]",
"for",
"val",
"in",
"stimulus",
":",
"if",
"(",
"val",
">",
"0",
")",
":",
"self",
".",
"_stimulus",
".",
"append",
"(",
"self",
".",
"_params",
".",
"I",
")",
"else",
":",
"self",
".",
"_stimulus",
".",
"append",
"(",
"0",
")"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | legion_network.__create_dynamic_connections | !
@brief Create dynamic connection in line with input stimulus. | pyclustering/nnet/legion.py | def __create_dynamic_connections(self):
"""!
@brief Create dynamic connection in line with input stimulus.
"""
if (self._stimulus is None):
raise NameError("Stimulus should initialed before creation of the dynamic connections in the network.");
self._dynamic_coupling = [ [0] * self._num_osc for i in range(self._num_osc)];
for i in range(self._num_osc):
neighbors = self.get_neighbors(i);
if ( (len(neighbors) > 0) and (self._stimulus[i] > 0) ):
number_stimulated_neighbors = 0.0;
for j in neighbors:
if (self._stimulus[j] > 0):
number_stimulated_neighbors += 1.0;
if (number_stimulated_neighbors > 0):
dynamic_weight = self._params.Wt / number_stimulated_neighbors;
for j in neighbors:
self._dynamic_coupling[i][j] = dynamic_weight; | def __create_dynamic_connections(self):
"""!
@brief Create dynamic connection in line with input stimulus.
"""
if (self._stimulus is None):
raise NameError("Stimulus should initialed before creation of the dynamic connections in the network.");
self._dynamic_coupling = [ [0] * self._num_osc for i in range(self._num_osc)];
for i in range(self._num_osc):
neighbors = self.get_neighbors(i);
if ( (len(neighbors) > 0) and (self._stimulus[i] > 0) ):
number_stimulated_neighbors = 0.0;
for j in neighbors:
if (self._stimulus[j] > 0):
number_stimulated_neighbors += 1.0;
if (number_stimulated_neighbors > 0):
dynamic_weight = self._params.Wt / number_stimulated_neighbors;
for j in neighbors:
self._dynamic_coupling[i][j] = dynamic_weight; | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/nnet/legion.py#L323-L347 | [
"def",
"__create_dynamic_connections",
"(",
"self",
")",
":",
"if",
"(",
"self",
".",
"_stimulus",
"is",
"None",
")",
":",
"raise",
"NameError",
"(",
"\"Stimulus should initialed before creation of the dynamic connections in the network.\"",
")",
"self",
".",
"_dynamic_coupling",
"=",
"[",
"[",
"0",
"]",
"*",
"self",
".",
"_num_osc",
"for",
"i",
"in",
"range",
"(",
"self",
".",
"_num_osc",
")",
"]",
"for",
"i",
"in",
"range",
"(",
"self",
".",
"_num_osc",
")",
":",
"neighbors",
"=",
"self",
".",
"get_neighbors",
"(",
"i",
")",
"if",
"(",
"(",
"len",
"(",
"neighbors",
")",
">",
"0",
")",
"and",
"(",
"self",
".",
"_stimulus",
"[",
"i",
"]",
">",
"0",
")",
")",
":",
"number_stimulated_neighbors",
"=",
"0.0",
"for",
"j",
"in",
"neighbors",
":",
"if",
"(",
"self",
".",
"_stimulus",
"[",
"j",
"]",
">",
"0",
")",
":",
"number_stimulated_neighbors",
"+=",
"1.0",
"if",
"(",
"number_stimulated_neighbors",
">",
"0",
")",
":",
"dynamic_weight",
"=",
"self",
".",
"_params",
".",
"Wt",
"/",
"number_stimulated_neighbors",
"for",
"j",
"in",
"neighbors",
":",
"self",
".",
"_dynamic_coupling",
"[",
"i",
"]",
"[",
"j",
"]",
"=",
"dynamic_weight"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | legion_network.simulate | !
@brief Performs static simulation of LEGION oscillatory network.
@param[in] steps (uint): Number steps of simulations during simulation.
@param[in] time (double): Time of simulation.
@param[in] stimulus (list): Stimulus for oscillators, number of stimulus should be equal to number of oscillators,
example of stimulus for 5 oscillators [0, 0, 1, 1, 0], value of stimulus is defined by parameter 'I'.
@param[in] solution (solve_type): Method that is used for differential equation.
@param[in] collect_dynamic (bool): If True - returns whole dynamic of oscillatory network, otherwise returns only last values of dynamics.
@return (list) Dynamic of oscillatory network. If argument 'collect_dynamic' = True, than return dynamic for the whole simulation time,
otherwise returns only last values (last step of simulation) of dynamic. | pyclustering/nnet/legion.py | def simulate(self, steps, time, stimulus, solution = solve_type.RK4, collect_dynamic = True):
"""!
@brief Performs static simulation of LEGION oscillatory network.
@param[in] steps (uint): Number steps of simulations during simulation.
@param[in] time (double): Time of simulation.
@param[in] stimulus (list): Stimulus for oscillators, number of stimulus should be equal to number of oscillators,
example of stimulus for 5 oscillators [0, 0, 1, 1, 0], value of stimulus is defined by parameter 'I'.
@param[in] solution (solve_type): Method that is used for differential equation.
@param[in] collect_dynamic (bool): If True - returns whole dynamic of oscillatory network, otherwise returns only last values of dynamics.
@return (list) Dynamic of oscillatory network. If argument 'collect_dynamic' = True, than return dynamic for the whole simulation time,
otherwise returns only last values (last step of simulation) of dynamic.
"""
if (self.__ccore_legion_pointer is not None):
pointer_dynamic = wrapper.legion_simulate(self.__ccore_legion_pointer, steps, time, solution, collect_dynamic, stimulus);
return legion_dynamic(None, None, None, pointer_dynamic);
# Check solver before simulation
if (solution == solve_type.FAST):
raise NameError("Solver FAST is not support due to low accuracy that leads to huge error.");
elif (solution == solve_type.RKF45):
raise NameError("Solver RKF45 is not support in python version. RKF45 is supported in CCORE implementation.");
# set stimulus
self.__create_stimulus(stimulus);
# calculate dynamic weights
self.__create_dynamic_connections();
dyn_exc = None;
dyn_time = None;
dyn_ginh = None;
# Store only excitatory of the oscillator
if (collect_dynamic == True):
dyn_exc = [];
dyn_time = [];
dyn_ginh = [];
step = time / steps;
int_step = step / 10.0;
for t in numpy.arange(step, time + step, step):
# update states of oscillators
self._calculate_states(solution, t, step, int_step);
# update states of oscillators
if (collect_dynamic == True):
dyn_exc.append(self._excitatory);
dyn_time.append(t);
dyn_ginh.append(self._global_inhibitor);
else:
dyn_exc = self._excitatory;
dyn_time = t;
dyn_ginh = self._global_inhibitor;
return legion_dynamic(dyn_exc, dyn_ginh, dyn_time); | def simulate(self, steps, time, stimulus, solution = solve_type.RK4, collect_dynamic = True):
"""!
@brief Performs static simulation of LEGION oscillatory network.
@param[in] steps (uint): Number steps of simulations during simulation.
@param[in] time (double): Time of simulation.
@param[in] stimulus (list): Stimulus for oscillators, number of stimulus should be equal to number of oscillators,
example of stimulus for 5 oscillators [0, 0, 1, 1, 0], value of stimulus is defined by parameter 'I'.
@param[in] solution (solve_type): Method that is used for differential equation.
@param[in] collect_dynamic (bool): If True - returns whole dynamic of oscillatory network, otherwise returns only last values of dynamics.
@return (list) Dynamic of oscillatory network. If argument 'collect_dynamic' = True, than return dynamic for the whole simulation time,
otherwise returns only last values (last step of simulation) of dynamic.
"""
if (self.__ccore_legion_pointer is not None):
pointer_dynamic = wrapper.legion_simulate(self.__ccore_legion_pointer, steps, time, solution, collect_dynamic, stimulus);
return legion_dynamic(None, None, None, pointer_dynamic);
# Check solver before simulation
if (solution == solve_type.FAST):
raise NameError("Solver FAST is not support due to low accuracy that leads to huge error.");
elif (solution == solve_type.RKF45):
raise NameError("Solver RKF45 is not support in python version. RKF45 is supported in CCORE implementation.");
# set stimulus
self.__create_stimulus(stimulus);
# calculate dynamic weights
self.__create_dynamic_connections();
dyn_exc = None;
dyn_time = None;
dyn_ginh = None;
# Store only excitatory of the oscillator
if (collect_dynamic == True):
dyn_exc = [];
dyn_time = [];
dyn_ginh = [];
step = time / steps;
int_step = step / 10.0;
for t in numpy.arange(step, time + step, step):
# update states of oscillators
self._calculate_states(solution, t, step, int_step);
# update states of oscillators
if (collect_dynamic == True):
dyn_exc.append(self._excitatory);
dyn_time.append(t);
dyn_ginh.append(self._global_inhibitor);
else:
dyn_exc = self._excitatory;
dyn_time = t;
dyn_ginh = self._global_inhibitor;
return legion_dynamic(dyn_exc, dyn_ginh, dyn_time); | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/nnet/legion.py#L350-L410 | [
"def",
"simulate",
"(",
"self",
",",
"steps",
",",
"time",
",",
"stimulus",
",",
"solution",
"=",
"solve_type",
".",
"RK4",
",",
"collect_dynamic",
"=",
"True",
")",
":",
"if",
"(",
"self",
".",
"__ccore_legion_pointer",
"is",
"not",
"None",
")",
":",
"pointer_dynamic",
"=",
"wrapper",
".",
"legion_simulate",
"(",
"self",
".",
"__ccore_legion_pointer",
",",
"steps",
",",
"time",
",",
"solution",
",",
"collect_dynamic",
",",
"stimulus",
")",
"return",
"legion_dynamic",
"(",
"None",
",",
"None",
",",
"None",
",",
"pointer_dynamic",
")",
"# Check solver before simulation\r",
"if",
"(",
"solution",
"==",
"solve_type",
".",
"FAST",
")",
":",
"raise",
"NameError",
"(",
"\"Solver FAST is not support due to low accuracy that leads to huge error.\"",
")",
"elif",
"(",
"solution",
"==",
"solve_type",
".",
"RKF45",
")",
":",
"raise",
"NameError",
"(",
"\"Solver RKF45 is not support in python version. RKF45 is supported in CCORE implementation.\"",
")",
"# set stimulus\r",
"self",
".",
"__create_stimulus",
"(",
"stimulus",
")",
"# calculate dynamic weights\r",
"self",
".",
"__create_dynamic_connections",
"(",
")",
"dyn_exc",
"=",
"None",
"dyn_time",
"=",
"None",
"dyn_ginh",
"=",
"None",
"# Store only excitatory of the oscillator\r",
"if",
"(",
"collect_dynamic",
"==",
"True",
")",
":",
"dyn_exc",
"=",
"[",
"]",
"dyn_time",
"=",
"[",
"]",
"dyn_ginh",
"=",
"[",
"]",
"step",
"=",
"time",
"/",
"steps",
"int_step",
"=",
"step",
"/",
"10.0",
"for",
"t",
"in",
"numpy",
".",
"arange",
"(",
"step",
",",
"time",
"+",
"step",
",",
"step",
")",
":",
"# update states of oscillators\r",
"self",
".",
"_calculate_states",
"(",
"solution",
",",
"t",
",",
"step",
",",
"int_step",
")",
"# update states of oscillators\r",
"if",
"(",
"collect_dynamic",
"==",
"True",
")",
":",
"dyn_exc",
".",
"append",
"(",
"self",
".",
"_excitatory",
")",
"dyn_time",
".",
"append",
"(",
"t",
")",
"dyn_ginh",
".",
"append",
"(",
"self",
".",
"_global_inhibitor",
")",
"else",
":",
"dyn_exc",
"=",
"self",
".",
"_excitatory",
"dyn_time",
"=",
"t",
"dyn_ginh",
"=",
"self",
".",
"_global_inhibitor",
"return",
"legion_dynamic",
"(",
"dyn_exc",
",",
"dyn_ginh",
",",
"dyn_time",
")"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | legion_network._calculate_states | !
@brief Calculates new state of each oscillator in the network.
@param[in] solution (solve_type): Type solver of the differential equation.
@param[in] t (double): Current time of simulation.
@param[in] step (double): Step of solution at the end of which states of oscillators should be calculated.
@param[in] int_step (double): Step differentiation that is used for solving differential equation. | pyclustering/nnet/legion.py | def _calculate_states(self, solution, t, step, int_step):
"""!
@brief Calculates new state of each oscillator in the network.
@param[in] solution (solve_type): Type solver of the differential equation.
@param[in] t (double): Current time of simulation.
@param[in] step (double): Step of solution at the end of which states of oscillators should be calculated.
@param[in] int_step (double): Step differentiation that is used for solving differential equation.
"""
next_excitatory = [0.0] * self._num_osc;
next_inhibitory = [0.0] * self._num_osc;
next_potential = [];
if (self._params.ENABLE_POTENTIONAL is True):
next_potential = [0.0] * self._num_osc;
# Update states of oscillators
for index in range (0, self._num_osc, 1):
if (self._params.ENABLE_POTENTIONAL is True):
result = odeint(self._legion_state, [self._excitatory[index], self._inhibitory[index], self._potential[index]], numpy.arange(t - step, t, int_step), (index , ));
[ next_excitatory[index], next_inhibitory[index], next_potential[index] ] = result[len(result) - 1][0:3];
else:
result = odeint(self._legion_state_simplify, [self._excitatory[index], self._inhibitory[index] ], numpy.arange(t - step, t, int_step), (index , ));
[ next_excitatory[index], next_inhibitory[index] ] = result[len(result) - 1][0:2];
# Update coupling term
neighbors = self.get_neighbors(index);
coupling = 0
for index_neighbor in neighbors:
coupling += self._dynamic_coupling[index][index_neighbor] * heaviside(self._excitatory[index_neighbor] - self._params.teta_x);
self._buffer_coupling_term[index] = coupling - self._params.Wz * heaviside(self._global_inhibitor - self._params.teta_xz);
# Update state of global inhibitory
result = odeint(self._global_inhibitor_state, self._global_inhibitor, numpy.arange(t - step, t, int_step), (None, ));
self._global_inhibitor = result[len(result) - 1][0];
self._noise = [random.random() * self._params.ro for i in range(self._num_osc)];
self._coupling_term = self._buffer_coupling_term[:];
self._inhibitory = next_inhibitory[:];
self._excitatory = next_excitatory[:];
if (self._params.ENABLE_POTENTIONAL is True):
self._potential = next_potential[:]; | def _calculate_states(self, solution, t, step, int_step):
"""!
@brief Calculates new state of each oscillator in the network.
@param[in] solution (solve_type): Type solver of the differential equation.
@param[in] t (double): Current time of simulation.
@param[in] step (double): Step of solution at the end of which states of oscillators should be calculated.
@param[in] int_step (double): Step differentiation that is used for solving differential equation.
"""
next_excitatory = [0.0] * self._num_osc;
next_inhibitory = [0.0] * self._num_osc;
next_potential = [];
if (self._params.ENABLE_POTENTIONAL is True):
next_potential = [0.0] * self._num_osc;
# Update states of oscillators
for index in range (0, self._num_osc, 1):
if (self._params.ENABLE_POTENTIONAL is True):
result = odeint(self._legion_state, [self._excitatory[index], self._inhibitory[index], self._potential[index]], numpy.arange(t - step, t, int_step), (index , ));
[ next_excitatory[index], next_inhibitory[index], next_potential[index] ] = result[len(result) - 1][0:3];
else:
result = odeint(self._legion_state_simplify, [self._excitatory[index], self._inhibitory[index] ], numpy.arange(t - step, t, int_step), (index , ));
[ next_excitatory[index], next_inhibitory[index] ] = result[len(result) - 1][0:2];
# Update coupling term
neighbors = self.get_neighbors(index);
coupling = 0
for index_neighbor in neighbors:
coupling += self._dynamic_coupling[index][index_neighbor] * heaviside(self._excitatory[index_neighbor] - self._params.teta_x);
self._buffer_coupling_term[index] = coupling - self._params.Wz * heaviside(self._global_inhibitor - self._params.teta_xz);
# Update state of global inhibitory
result = odeint(self._global_inhibitor_state, self._global_inhibitor, numpy.arange(t - step, t, int_step), (None, ));
self._global_inhibitor = result[len(result) - 1][0];
self._noise = [random.random() * self._params.ro for i in range(self._num_osc)];
self._coupling_term = self._buffer_coupling_term[:];
self._inhibitory = next_inhibitory[:];
self._excitatory = next_excitatory[:];
if (self._params.ENABLE_POTENTIONAL is True):
self._potential = next_potential[:]; | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/nnet/legion.py#L413-L460 | [
"def",
"_calculate_states",
"(",
"self",
",",
"solution",
",",
"t",
",",
"step",
",",
"int_step",
")",
":",
"next_excitatory",
"=",
"[",
"0.0",
"]",
"*",
"self",
".",
"_num_osc",
"next_inhibitory",
"=",
"[",
"0.0",
"]",
"*",
"self",
".",
"_num_osc",
"next_potential",
"=",
"[",
"]",
"if",
"(",
"self",
".",
"_params",
".",
"ENABLE_POTENTIONAL",
"is",
"True",
")",
":",
"next_potential",
"=",
"[",
"0.0",
"]",
"*",
"self",
".",
"_num_osc",
"# Update states of oscillators\r",
"for",
"index",
"in",
"range",
"(",
"0",
",",
"self",
".",
"_num_osc",
",",
"1",
")",
":",
"if",
"(",
"self",
".",
"_params",
".",
"ENABLE_POTENTIONAL",
"is",
"True",
")",
":",
"result",
"=",
"odeint",
"(",
"self",
".",
"_legion_state",
",",
"[",
"self",
".",
"_excitatory",
"[",
"index",
"]",
",",
"self",
".",
"_inhibitory",
"[",
"index",
"]",
",",
"self",
".",
"_potential",
"[",
"index",
"]",
"]",
",",
"numpy",
".",
"arange",
"(",
"t",
"-",
"step",
",",
"t",
",",
"int_step",
")",
",",
"(",
"index",
",",
")",
")",
"[",
"next_excitatory",
"[",
"index",
"]",
",",
"next_inhibitory",
"[",
"index",
"]",
",",
"next_potential",
"[",
"index",
"]",
"]",
"=",
"result",
"[",
"len",
"(",
"result",
")",
"-",
"1",
"]",
"[",
"0",
":",
"3",
"]",
"else",
":",
"result",
"=",
"odeint",
"(",
"self",
".",
"_legion_state_simplify",
",",
"[",
"self",
".",
"_excitatory",
"[",
"index",
"]",
",",
"self",
".",
"_inhibitory",
"[",
"index",
"]",
"]",
",",
"numpy",
".",
"arange",
"(",
"t",
"-",
"step",
",",
"t",
",",
"int_step",
")",
",",
"(",
"index",
",",
")",
")",
"[",
"next_excitatory",
"[",
"index",
"]",
",",
"next_inhibitory",
"[",
"index",
"]",
"]",
"=",
"result",
"[",
"len",
"(",
"result",
")",
"-",
"1",
"]",
"[",
"0",
":",
"2",
"]",
"# Update coupling term\r",
"neighbors",
"=",
"self",
".",
"get_neighbors",
"(",
"index",
")",
"coupling",
"=",
"0",
"for",
"index_neighbor",
"in",
"neighbors",
":",
"coupling",
"+=",
"self",
".",
"_dynamic_coupling",
"[",
"index",
"]",
"[",
"index_neighbor",
"]",
"*",
"heaviside",
"(",
"self",
".",
"_excitatory",
"[",
"index_neighbor",
"]",
"-",
"self",
".",
"_params",
".",
"teta_x",
")",
"self",
".",
"_buffer_coupling_term",
"[",
"index",
"]",
"=",
"coupling",
"-",
"self",
".",
"_params",
".",
"Wz",
"*",
"heaviside",
"(",
"self",
".",
"_global_inhibitor",
"-",
"self",
".",
"_params",
".",
"teta_xz",
")",
"# Update state of global inhibitory\r",
"result",
"=",
"odeint",
"(",
"self",
".",
"_global_inhibitor_state",
",",
"self",
".",
"_global_inhibitor",
",",
"numpy",
".",
"arange",
"(",
"t",
"-",
"step",
",",
"t",
",",
"int_step",
")",
",",
"(",
"None",
",",
")",
")",
"self",
".",
"_global_inhibitor",
"=",
"result",
"[",
"len",
"(",
"result",
")",
"-",
"1",
"]",
"[",
"0",
"]",
"self",
".",
"_noise",
"=",
"[",
"random",
".",
"random",
"(",
")",
"*",
"self",
".",
"_params",
".",
"ro",
"for",
"i",
"in",
"range",
"(",
"self",
".",
"_num_osc",
")",
"]",
"self",
".",
"_coupling_term",
"=",
"self",
".",
"_buffer_coupling_term",
"[",
":",
"]",
"self",
".",
"_inhibitory",
"=",
"next_inhibitory",
"[",
":",
"]",
"self",
".",
"_excitatory",
"=",
"next_excitatory",
"[",
":",
"]",
"if",
"(",
"self",
".",
"_params",
".",
"ENABLE_POTENTIONAL",
"is",
"True",
")",
":",
"self",
".",
"_potential",
"=",
"next_potential",
"[",
":",
"]"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | legion_network._global_inhibitor_state | !
@brief Returns new value of global inhibitory
@param[in] z (dobule): Current value of inhibitory.
@param[in] t (double): Current time of simulation.
@param[in] argv (tuple): It's not used, can be ignored.
@return (double) New value if global inhibitory (not assign). | pyclustering/nnet/legion.py | def _global_inhibitor_state(self, z, t, argv):
"""!
@brief Returns new value of global inhibitory
@param[in] z (dobule): Current value of inhibitory.
@param[in] t (double): Current time of simulation.
@param[in] argv (tuple): It's not used, can be ignored.
@return (double) New value if global inhibitory (not assign).
"""
sigma = 0.0;
for x in self._excitatory:
if (x > self._params.teta_zx):
sigma = 1.0;
break;
return self._params.fi * (sigma - z); | def _global_inhibitor_state(self, z, t, argv):
"""!
@brief Returns new value of global inhibitory
@param[in] z (dobule): Current value of inhibitory.
@param[in] t (double): Current time of simulation.
@param[in] argv (tuple): It's not used, can be ignored.
@return (double) New value if global inhibitory (not assign).
"""
sigma = 0.0;
for x in self._excitatory:
if (x > self._params.teta_zx):
sigma = 1.0;
break;
return self._params.fi * (sigma - z); | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/nnet/legion.py#L464-L483 | [
"def",
"_global_inhibitor_state",
"(",
"self",
",",
"z",
",",
"t",
",",
"argv",
")",
":",
"sigma",
"=",
"0.0",
"for",
"x",
"in",
"self",
".",
"_excitatory",
":",
"if",
"(",
"x",
">",
"self",
".",
"_params",
".",
"teta_zx",
")",
":",
"sigma",
"=",
"1.0",
"break",
"return",
"self",
".",
"_params",
".",
"fi",
"*",
"(",
"sigma",
"-",
"z",
")"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | legion_network._legion_state_simplify | !
@brief Returns new values of excitatory and inhibitory parts of oscillator of oscillator.
@details Simplify model doesn't consider oscillator potential.
@param[in] inputs (list): Initial values (current) of oscillator [excitatory, inhibitory].
@param[in] t (double): Current time of simulation.
@param[in] argv (uint): Extra arguments that are not used for integration - index of oscillator.
@return (list) New values of excitatoty and inhibitory part of oscillator (not assign). | pyclustering/nnet/legion.py | def _legion_state_simplify(self, inputs, t, argv):
"""!
@brief Returns new values of excitatory and inhibitory parts of oscillator of oscillator.
@details Simplify model doesn't consider oscillator potential.
@param[in] inputs (list): Initial values (current) of oscillator [excitatory, inhibitory].
@param[in] t (double): Current time of simulation.
@param[in] argv (uint): Extra arguments that are not used for integration - index of oscillator.
@return (list) New values of excitatoty and inhibitory part of oscillator (not assign).
"""
index = argv;
x = inputs[0]; # excitatory
y = inputs[1]; # inhibitory
dx = 3.0 * x - x ** 3.0 + 2.0 - y + self._stimulus[index] + self._coupling_term[index] + self._noise[index];
dy = self._params.eps * (self._params.gamma * (1.0 + math.tanh(x / self._params.betta)) - y);
neighbors = self.get_neighbors(index);
potential = 0.0;
for index_neighbor in neighbors:
potential += self._params.T * heaviside(self._excitatory[index_neighbor] - self._params.teta_x);
return [dx, dy]; | def _legion_state_simplify(self, inputs, t, argv):
"""!
@brief Returns new values of excitatory and inhibitory parts of oscillator of oscillator.
@details Simplify model doesn't consider oscillator potential.
@param[in] inputs (list): Initial values (current) of oscillator [excitatory, inhibitory].
@param[in] t (double): Current time of simulation.
@param[in] argv (uint): Extra arguments that are not used for integration - index of oscillator.
@return (list) New values of excitatoty and inhibitory part of oscillator (not assign).
"""
index = argv;
x = inputs[0]; # excitatory
y = inputs[1]; # inhibitory
dx = 3.0 * x - x ** 3.0 + 2.0 - y + self._stimulus[index] + self._coupling_term[index] + self._noise[index];
dy = self._params.eps * (self._params.gamma * (1.0 + math.tanh(x / self._params.betta)) - y);
neighbors = self.get_neighbors(index);
potential = 0.0;
for index_neighbor in neighbors:
potential += self._params.T * heaviside(self._excitatory[index_neighbor] - self._params.teta_x);
return [dx, dy]; | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/nnet/legion.py#L486-L513 | [
"def",
"_legion_state_simplify",
"(",
"self",
",",
"inputs",
",",
"t",
",",
"argv",
")",
":",
"index",
"=",
"argv",
"x",
"=",
"inputs",
"[",
"0",
"]",
"# excitatory\r",
"y",
"=",
"inputs",
"[",
"1",
"]",
"# inhibitory\r",
"dx",
"=",
"3.0",
"*",
"x",
"-",
"x",
"**",
"3.0",
"+",
"2.0",
"-",
"y",
"+",
"self",
".",
"_stimulus",
"[",
"index",
"]",
"+",
"self",
".",
"_coupling_term",
"[",
"index",
"]",
"+",
"self",
".",
"_noise",
"[",
"index",
"]",
"dy",
"=",
"self",
".",
"_params",
".",
"eps",
"*",
"(",
"self",
".",
"_params",
".",
"gamma",
"*",
"(",
"1.0",
"+",
"math",
".",
"tanh",
"(",
"x",
"/",
"self",
".",
"_params",
".",
"betta",
")",
")",
"-",
"y",
")",
"neighbors",
"=",
"self",
".",
"get_neighbors",
"(",
"index",
")",
"potential",
"=",
"0.0",
"for",
"index_neighbor",
"in",
"neighbors",
":",
"potential",
"+=",
"self",
".",
"_params",
".",
"T",
"*",
"heaviside",
"(",
"self",
".",
"_excitatory",
"[",
"index_neighbor",
"]",
"-",
"self",
".",
"_params",
".",
"teta_x",
")",
"return",
"[",
"dx",
",",
"dy",
"]"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | legion_network._legion_state | !
@brief Returns new values of excitatory and inhibitory parts of oscillator and potential of oscillator.
@param[in] inputs (list): Initial values (current) of oscillator [excitatory, inhibitory, potential].
@param[in] t (double): Current time of simulation.
@param[in] argv (uint): Extra arguments that are not used for integration - index of oscillator.
@return (list) New values of excitatoty and inhibitory part of oscillator and new value of potential (not assign). | pyclustering/nnet/legion.py | def _legion_state(self, inputs, t, argv):
"""!
@brief Returns new values of excitatory and inhibitory parts of oscillator and potential of oscillator.
@param[in] inputs (list): Initial values (current) of oscillator [excitatory, inhibitory, potential].
@param[in] t (double): Current time of simulation.
@param[in] argv (uint): Extra arguments that are not used for integration - index of oscillator.
@return (list) New values of excitatoty and inhibitory part of oscillator and new value of potential (not assign).
"""
index = argv;
x = inputs[0]; # excitatory
y = inputs[1]; # inhibitory
p = inputs[2]; # potential
potential_influence = heaviside(p + math.exp(-self._params.alpha * t) - self._params.teta);
dx = 3.0 * x - x ** 3.0 + 2.0 - y + self._stimulus[index] * potential_influence + self._coupling_term[index] + self._noise[index];
dy = self._params.eps * (self._params.gamma * (1.0 + math.tanh(x / self._params.betta)) - y);
neighbors = self.get_neighbors(index);
potential = 0.0;
for index_neighbor in neighbors:
potential += self._params.T * heaviside(self._excitatory[index_neighbor] - self._params.teta_x);
dp = self._params.lamda * (1.0 - p) * heaviside(potential - self._params.teta_p) - self._params.mu * p;
return [dx, dy, dp]; | def _legion_state(self, inputs, t, argv):
"""!
@brief Returns new values of excitatory and inhibitory parts of oscillator and potential of oscillator.
@param[in] inputs (list): Initial values (current) of oscillator [excitatory, inhibitory, potential].
@param[in] t (double): Current time of simulation.
@param[in] argv (uint): Extra arguments that are not used for integration - index of oscillator.
@return (list) New values of excitatoty and inhibitory part of oscillator and new value of potential (not assign).
"""
index = argv;
x = inputs[0]; # excitatory
y = inputs[1]; # inhibitory
p = inputs[2]; # potential
potential_influence = heaviside(p + math.exp(-self._params.alpha * t) - self._params.teta);
dx = 3.0 * x - x ** 3.0 + 2.0 - y + self._stimulus[index] * potential_influence + self._coupling_term[index] + self._noise[index];
dy = self._params.eps * (self._params.gamma * (1.0 + math.tanh(x / self._params.betta)) - y);
neighbors = self.get_neighbors(index);
potential = 0.0;
for index_neighbor in neighbors:
potential += self._params.T * heaviside(self._excitatory[index_neighbor] - self._params.teta_x);
dp = self._params.lamda * (1.0 - p) * heaviside(potential - self._params.teta_p) - self._params.mu * p;
return [dx, dy, dp]; | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/nnet/legion.py#L516-L547 | [
"def",
"_legion_state",
"(",
"self",
",",
"inputs",
",",
"t",
",",
"argv",
")",
":",
"index",
"=",
"argv",
"x",
"=",
"inputs",
"[",
"0",
"]",
"# excitatory\r",
"y",
"=",
"inputs",
"[",
"1",
"]",
"# inhibitory\r",
"p",
"=",
"inputs",
"[",
"2",
"]",
"# potential\r",
"potential_influence",
"=",
"heaviside",
"(",
"p",
"+",
"math",
".",
"exp",
"(",
"-",
"self",
".",
"_params",
".",
"alpha",
"*",
"t",
")",
"-",
"self",
".",
"_params",
".",
"teta",
")",
"dx",
"=",
"3.0",
"*",
"x",
"-",
"x",
"**",
"3.0",
"+",
"2.0",
"-",
"y",
"+",
"self",
".",
"_stimulus",
"[",
"index",
"]",
"*",
"potential_influence",
"+",
"self",
".",
"_coupling_term",
"[",
"index",
"]",
"+",
"self",
".",
"_noise",
"[",
"index",
"]",
"dy",
"=",
"self",
".",
"_params",
".",
"eps",
"*",
"(",
"self",
".",
"_params",
".",
"gamma",
"*",
"(",
"1.0",
"+",
"math",
".",
"tanh",
"(",
"x",
"/",
"self",
".",
"_params",
".",
"betta",
")",
")",
"-",
"y",
")",
"neighbors",
"=",
"self",
".",
"get_neighbors",
"(",
"index",
")",
"potential",
"=",
"0.0",
"for",
"index_neighbor",
"in",
"neighbors",
":",
"potential",
"+=",
"self",
".",
"_params",
".",
"T",
"*",
"heaviside",
"(",
"self",
".",
"_excitatory",
"[",
"index_neighbor",
"]",
"-",
"self",
".",
"_params",
".",
"teta_x",
")",
"dp",
"=",
"self",
".",
"_params",
".",
"lamda",
"*",
"(",
"1.0",
"-",
"p",
")",
"*",
"heaviside",
"(",
"potential",
"-",
"self",
".",
"_params",
".",
"teta_p",
")",
"-",
"self",
".",
"_params",
".",
"mu",
"*",
"p",
"return",
"[",
"dx",
",",
"dy",
",",
"dp",
"]"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | syncgcolor_analyser.allocate_map_coloring | !
@brief Allocates coloring map for graph that has been processed.
@param[in] tolerance (double): Defines maximum deviation between phases.
@return (list) Colors for each node (index of node in graph), for example [color1, color2, color2, ...]. | pyclustering/gcolor/sync.py | def allocate_map_coloring(self, tolerance = 0.1):
"""!
@brief Allocates coloring map for graph that has been processed.
@param[in] tolerance (double): Defines maximum deviation between phases.
@return (list) Colors for each node (index of node in graph), for example [color1, color2, color2, ...].
"""
clusters = self.allocate_color_clusters(tolerance);
number_oscillators = len(self._dynamic[0]);
coloring_map = [0] * number_oscillators;
for color_index in range(len(clusters)):
for node_index in clusters[color_index]:
coloring_map[node_index] = color_index;
return coloring_map; | def allocate_map_coloring(self, tolerance = 0.1):
"""!
@brief Allocates coloring map for graph that has been processed.
@param[in] tolerance (double): Defines maximum deviation between phases.
@return (list) Colors for each node (index of node in graph), for example [color1, color2, color2, ...].
"""
clusters = self.allocate_color_clusters(tolerance);
number_oscillators = len(self._dynamic[0]);
coloring_map = [0] * number_oscillators;
for color_index in range(len(clusters)):
for node_index in clusters[color_index]:
coloring_map[node_index] = color_index;
return coloring_map; | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/gcolor/sync.py#L64-L83 | [
"def",
"allocate_map_coloring",
"(",
"self",
",",
"tolerance",
"=",
"0.1",
")",
":",
"clusters",
"=",
"self",
".",
"allocate_color_clusters",
"(",
"tolerance",
")",
"number_oscillators",
"=",
"len",
"(",
"self",
".",
"_dynamic",
"[",
"0",
"]",
")",
"coloring_map",
"=",
"[",
"0",
"]",
"*",
"number_oscillators",
"for",
"color_index",
"in",
"range",
"(",
"len",
"(",
"clusters",
")",
")",
":",
"for",
"node_index",
"in",
"clusters",
"[",
"color_index",
"]",
":",
"coloring_map",
"[",
"node_index",
"]",
"=",
"color_index",
"return",
"coloring_map"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | syncgcolor._create_connections | !
@brief Creates connection in the network in line with graph.
@param[in] graph_matrix (list): Matrix representation of the graph. | pyclustering/gcolor/sync.py | def _create_connections(self, graph_matrix):
"""!
@brief Creates connection in the network in line with graph.
@param[in] graph_matrix (list): Matrix representation of the graph.
"""
for row in range(0, len(graph_matrix)):
for column in range (0, len(graph_matrix[row])):
if (graph_matrix[row][column] > 0):
self.set_connection(row, column); | def _create_connections(self, graph_matrix):
"""!
@brief Creates connection in the network in line with graph.
@param[in] graph_matrix (list): Matrix representation of the graph.
"""
for row in range(0, len(graph_matrix)):
for column in range (0, len(graph_matrix[row])):
if (graph_matrix[row][column] > 0):
self.set_connection(row, column); | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/gcolor/sync.py#L116-L127 | [
"def",
"_create_connections",
"(",
"self",
",",
"graph_matrix",
")",
":",
"for",
"row",
"in",
"range",
"(",
"0",
",",
"len",
"(",
"graph_matrix",
")",
")",
":",
"for",
"column",
"in",
"range",
"(",
"0",
",",
"len",
"(",
"graph_matrix",
"[",
"row",
"]",
")",
")",
":",
"if",
"(",
"graph_matrix",
"[",
"row",
"]",
"[",
"column",
"]",
">",
"0",
")",
":",
"self",
".",
"set_connection",
"(",
"row",
",",
"column",
")"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | syncgcolor._phase_kuramoto | !
@brief Returns result of phase calculation for oscillator in the network.
@param[in] teta (double): Value of phase of the oscillator with index argv in the network.
@param[in] t (double): Unused, can be ignored.
@param[in] argv (uint): Index of the oscillator in the network.
@return (double) New value of phase for oscillator with index argv. | pyclustering/gcolor/sync.py | def _phase_kuramoto(self, teta, t, argv):
"""!
@brief Returns result of phase calculation for oscillator in the network.
@param[in] teta (double): Value of phase of the oscillator with index argv in the network.
@param[in] t (double): Unused, can be ignored.
@param[in] argv (uint): Index of the oscillator in the network.
@return (double) New value of phase for oscillator with index argv.
"""
index = argv;
phase = 0;
for k in range(0, self._num_osc):
if (self.has_connection(index, k) == True):
phase += self._negative_weight * math.sin(self._phases[k] - teta);
else:
phase += self._positive_weight * math.sin(self._phases[k] - teta);
return ( phase / self._reduction ); | def _phase_kuramoto(self, teta, t, argv):
"""!
@brief Returns result of phase calculation for oscillator in the network.
@param[in] teta (double): Value of phase of the oscillator with index argv in the network.
@param[in] t (double): Unused, can be ignored.
@param[in] argv (uint): Index of the oscillator in the network.
@return (double) New value of phase for oscillator with index argv.
"""
index = argv;
phase = 0;
for k in range(0, self._num_osc):
if (self.has_connection(index, k) == True):
phase += self._negative_weight * math.sin(self._phases[k] - teta);
else:
phase += self._positive_weight * math.sin(self._phases[k] - teta);
return ( phase / self._reduction ); | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/gcolor/sync.py#L130-L151 | [
"def",
"_phase_kuramoto",
"(",
"self",
",",
"teta",
",",
"t",
",",
"argv",
")",
":",
"index",
"=",
"argv",
"phase",
"=",
"0",
"for",
"k",
"in",
"range",
"(",
"0",
",",
"self",
".",
"_num_osc",
")",
":",
"if",
"(",
"self",
".",
"has_connection",
"(",
"index",
",",
"k",
")",
"==",
"True",
")",
":",
"phase",
"+=",
"self",
".",
"_negative_weight",
"*",
"math",
".",
"sin",
"(",
"self",
".",
"_phases",
"[",
"k",
"]",
"-",
"teta",
")",
"else",
":",
"phase",
"+=",
"self",
".",
"_positive_weight",
"*",
"math",
".",
"sin",
"(",
"self",
".",
"_phases",
"[",
"k",
"]",
"-",
"teta",
")",
"return",
"(",
"phase",
"/",
"self",
".",
"_reduction",
")"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | syncgcolor.process | !
@brief Performs simulation of the network (performs solving of graph coloring problem).
@param[in] order (double): Defines when process of synchronization in the network is over, range from 0 to 1.
@param[in] solution (solve_type): defines type (method) of solving diff. equation.
@param[in] collect_dynamic (bool): If True - return full dynamic of the network, otherwise - last state of phases.
@return (syncnet_analyser) Returns analyser of results of coloring. | pyclustering/gcolor/sync.py | def process(self, order = 0.998, solution = solve_type.FAST, collect_dynamic = False):
"""!
@brief Performs simulation of the network (performs solving of graph coloring problem).
@param[in] order (double): Defines when process of synchronization in the network is over, range from 0 to 1.
@param[in] solution (solve_type): defines type (method) of solving diff. equation.
@param[in] collect_dynamic (bool): If True - return full dynamic of the network, otherwise - last state of phases.
@return (syncnet_analyser) Returns analyser of results of coloring.
"""
analyser = self.simulate_dynamic(order, solution, collect_dynamic);
return syncgcolor_analyser(analyser.output, analyser.time, None); | def process(self, order = 0.998, solution = solve_type.FAST, collect_dynamic = False):
"""!
@brief Performs simulation of the network (performs solving of graph coloring problem).
@param[in] order (double): Defines when process of synchronization in the network is over, range from 0 to 1.
@param[in] solution (solve_type): defines type (method) of solving diff. equation.
@param[in] collect_dynamic (bool): If True - return full dynamic of the network, otherwise - last state of phases.
@return (syncnet_analyser) Returns analyser of results of coloring.
"""
analyser = self.simulate_dynamic(order, solution, collect_dynamic);
return syncgcolor_analyser(analyser.output, analyser.time, None); | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/gcolor/sync.py#L154-L167 | [
"def",
"process",
"(",
"self",
",",
"order",
"=",
"0.998",
",",
"solution",
"=",
"solve_type",
".",
"FAST",
",",
"collect_dynamic",
"=",
"False",
")",
":",
"analyser",
"=",
"self",
".",
"simulate_dynamic",
"(",
"order",
",",
"solution",
",",
"collect_dynamic",
")",
"return",
"syncgcolor_analyser",
"(",
"analyser",
".",
"output",
",",
"analyser",
".",
"time",
",",
"None",
")"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | syncnet_analyser.allocate_clusters | !
@brief Returns list of clusters in line with state of ocillators (phases).
@param[in] eps (double): Tolerance level that define maximal difference between phases of oscillators in one cluster.
@param[in] indexes (list): List of real object indexes and it should be equal to amount of oscillators (in case of 'None' - indexes are in range [0; amount_oscillators]).
@param[in] iteration (uint): Iteration of simulation that should be used for allocation.
@return (list) List of clusters, for example [ [cluster1], [cluster2], ... ].) | pyclustering/cluster/syncnet.py | def allocate_clusters(self, eps = 0.01, indexes = None, iteration = None):
"""!
@brief Returns list of clusters in line with state of ocillators (phases).
@param[in] eps (double): Tolerance level that define maximal difference between phases of oscillators in one cluster.
@param[in] indexes (list): List of real object indexes and it should be equal to amount of oscillators (in case of 'None' - indexes are in range [0; amount_oscillators]).
@param[in] iteration (uint): Iteration of simulation that should be used for allocation.
@return (list) List of clusters, for example [ [cluster1], [cluster2], ... ].)
"""
return self.allocate_sync_ensembles(eps, indexes, iteration); | def allocate_clusters(self, eps = 0.01, indexes = None, iteration = None):
"""!
@brief Returns list of clusters in line with state of ocillators (phases).
@param[in] eps (double): Tolerance level that define maximal difference between phases of oscillators in one cluster.
@param[in] indexes (list): List of real object indexes and it should be equal to amount of oscillators (in case of 'None' - indexes are in range [0; amount_oscillators]).
@param[in] iteration (uint): Iteration of simulation that should be used for allocation.
@return (list) List of clusters, for example [ [cluster1], [cluster2], ... ].)
"""
return self.allocate_sync_ensembles(eps, indexes, iteration); | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/cluster/syncnet.py#L79-L91 | [
"def",
"allocate_clusters",
"(",
"self",
",",
"eps",
"=",
"0.01",
",",
"indexes",
"=",
"None",
",",
"iteration",
"=",
"None",
")",
":",
"return",
"self",
".",
"allocate_sync_ensembles",
"(",
"eps",
",",
"indexes",
",",
"iteration",
")"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | syncnet_visualizer.animate_cluster_allocation | !
@brief Shows animation of output dynamic (output of each oscillator) during simulation on a circle from [0; 2pi].
@param[in] dataset (list): Input data that was used for processing by the network.
@param[in] analyser (syncnet_analyser): Output dynamic analyser of the Sync network.
@param[in] animation_velocity (uint): Interval between frames in milliseconds.
@param[in] tolerance (double): Tolerance level that define maximal difference between phases of oscillators in one cluster.
@param[in] save_movie (string): If it is specified then animation will be stored to file that is specified in this parameter.
@param[in] title (string): If it is specified then title will be displayed on the animation plot. | pyclustering/cluster/syncnet.py | def animate_cluster_allocation(dataset, analyser, animation_velocity = 75, tolerance = 0.1, save_movie = None, title = None):
"""!
@brief Shows animation of output dynamic (output of each oscillator) during simulation on a circle from [0; 2pi].
@param[in] dataset (list): Input data that was used for processing by the network.
@param[in] analyser (syncnet_analyser): Output dynamic analyser of the Sync network.
@param[in] animation_velocity (uint): Interval between frames in milliseconds.
@param[in] tolerance (double): Tolerance level that define maximal difference between phases of oscillators in one cluster.
@param[in] save_movie (string): If it is specified then animation will be stored to file that is specified in this parameter.
@param[in] title (string): If it is specified then title will be displayed on the animation plot.
"""
figure = plt.figure();
def init_frame():
return frame_generation(0);
def frame_generation(index_dynamic):
figure.clf();
if (title is not None):
figure.suptitle(title, fontsize = 26, fontweight = 'bold');
ax1 = figure.add_subplot(121, projection='polar');
clusters = analyser.allocate_clusters(eps = tolerance, iteration = index_dynamic);
dynamic = analyser.output[index_dynamic];
visualizer = cluster_visualizer(size_row = 2);
visualizer.append_clusters(clusters, dataset);
artist1, = ax1.plot(dynamic, [1.0] * len(dynamic), marker = 'o', color = 'blue', ls = '');
visualizer.show(figure, display = False);
artist2 = figure.gca();
return [ artist1, artist2 ];
cluster_animation = animation.FuncAnimation(figure, frame_generation, len(analyser), interval = animation_velocity, init_func = init_frame, repeat_delay = 5000);
if (save_movie is not None):
# plt.rcParams['animation.ffmpeg_path'] = 'D:\\Program Files\\ffmpeg-3.3.1-win64-static\\bin\\ffmpeg.exe';
# ffmpeg_writer = animation.FFMpegWriter(fps = 15);
# cluster_animation.save(save_movie, writer = ffmpeg_writer);
cluster_animation.save(save_movie, writer = 'ffmpeg', fps = 15, bitrate = 1500);
else:
plt.show(); | def animate_cluster_allocation(dataset, analyser, animation_velocity = 75, tolerance = 0.1, save_movie = None, title = None):
"""!
@brief Shows animation of output dynamic (output of each oscillator) during simulation on a circle from [0; 2pi].
@param[in] dataset (list): Input data that was used for processing by the network.
@param[in] analyser (syncnet_analyser): Output dynamic analyser of the Sync network.
@param[in] animation_velocity (uint): Interval between frames in milliseconds.
@param[in] tolerance (double): Tolerance level that define maximal difference between phases of oscillators in one cluster.
@param[in] save_movie (string): If it is specified then animation will be stored to file that is specified in this parameter.
@param[in] title (string): If it is specified then title will be displayed on the animation plot.
"""
figure = plt.figure();
def init_frame():
return frame_generation(0);
def frame_generation(index_dynamic):
figure.clf();
if (title is not None):
figure.suptitle(title, fontsize = 26, fontweight = 'bold');
ax1 = figure.add_subplot(121, projection='polar');
clusters = analyser.allocate_clusters(eps = tolerance, iteration = index_dynamic);
dynamic = analyser.output[index_dynamic];
visualizer = cluster_visualizer(size_row = 2);
visualizer.append_clusters(clusters, dataset);
artist1, = ax1.plot(dynamic, [1.0] * len(dynamic), marker = 'o', color = 'blue', ls = '');
visualizer.show(figure, display = False);
artist2 = figure.gca();
return [ artist1, artist2 ];
cluster_animation = animation.FuncAnimation(figure, frame_generation, len(analyser), interval = animation_velocity, init_func = init_frame, repeat_delay = 5000);
if (save_movie is not None):
# plt.rcParams['animation.ffmpeg_path'] = 'D:\\Program Files\\ffmpeg-3.3.1-win64-static\\bin\\ffmpeg.exe';
# ffmpeg_writer = animation.FFMpegWriter(fps = 15);
# cluster_animation.save(save_movie, writer = ffmpeg_writer);
cluster_animation.save(save_movie, writer = 'ffmpeg', fps = 15, bitrate = 1500);
else:
plt.show(); | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/cluster/syncnet.py#L115-L161 | [
"def",
"animate_cluster_allocation",
"(",
"dataset",
",",
"analyser",
",",
"animation_velocity",
"=",
"75",
",",
"tolerance",
"=",
"0.1",
",",
"save_movie",
"=",
"None",
",",
"title",
"=",
"None",
")",
":",
"figure",
"=",
"plt",
".",
"figure",
"(",
")",
"def",
"init_frame",
"(",
")",
":",
"return",
"frame_generation",
"(",
"0",
")",
"def",
"frame_generation",
"(",
"index_dynamic",
")",
":",
"figure",
".",
"clf",
"(",
")",
"if",
"(",
"title",
"is",
"not",
"None",
")",
":",
"figure",
".",
"suptitle",
"(",
"title",
",",
"fontsize",
"=",
"26",
",",
"fontweight",
"=",
"'bold'",
")",
"ax1",
"=",
"figure",
".",
"add_subplot",
"(",
"121",
",",
"projection",
"=",
"'polar'",
")",
"clusters",
"=",
"analyser",
".",
"allocate_clusters",
"(",
"eps",
"=",
"tolerance",
",",
"iteration",
"=",
"index_dynamic",
")",
"dynamic",
"=",
"analyser",
".",
"output",
"[",
"index_dynamic",
"]",
"visualizer",
"=",
"cluster_visualizer",
"(",
"size_row",
"=",
"2",
")",
"visualizer",
".",
"append_clusters",
"(",
"clusters",
",",
"dataset",
")",
"artist1",
",",
"=",
"ax1",
".",
"plot",
"(",
"dynamic",
",",
"[",
"1.0",
"]",
"*",
"len",
"(",
"dynamic",
")",
",",
"marker",
"=",
"'o'",
",",
"color",
"=",
"'blue'",
",",
"ls",
"=",
"''",
")",
"visualizer",
".",
"show",
"(",
"figure",
",",
"display",
"=",
"False",
")",
"artist2",
"=",
"figure",
".",
"gca",
"(",
")",
"return",
"[",
"artist1",
",",
"artist2",
"]",
"cluster_animation",
"=",
"animation",
".",
"FuncAnimation",
"(",
"figure",
",",
"frame_generation",
",",
"len",
"(",
"analyser",
")",
",",
"interval",
"=",
"animation_velocity",
",",
"init_func",
"=",
"init_frame",
",",
"repeat_delay",
"=",
"5000",
")",
"if",
"(",
"save_movie",
"is",
"not",
"None",
")",
":",
"# plt.rcParams['animation.ffmpeg_path'] = 'D:\\\\Program Files\\\\ffmpeg-3.3.1-win64-static\\\\bin\\\\ffmpeg.exe';\r",
"# ffmpeg_writer = animation.FFMpegWriter(fps = 15);\r",
"# cluster_animation.save(save_movie, writer = ffmpeg_writer);\r",
"cluster_animation",
".",
"save",
"(",
"save_movie",
",",
"writer",
"=",
"'ffmpeg'",
",",
"fps",
"=",
"15",
",",
"bitrate",
"=",
"1500",
")",
"else",
":",
"plt",
".",
"show",
"(",
")"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | syncnet._create_connections | !
@brief Create connections between oscillators in line with input radius of connectivity.
@param[in] radius (double): Connectivity radius between oscillators. | pyclustering/cluster/syncnet.py | def _create_connections(self, radius):
"""!
@brief Create connections between oscillators in line with input radius of connectivity.
@param[in] radius (double): Connectivity radius between oscillators.
"""
if (self._ena_conn_weight is True):
self._conn_weight = [[0] * self._num_osc for _ in range(0, self._num_osc, 1)];
maximum_distance = 0;
minimum_distance = float('inf');
# Create connections
for i in range(0, self._num_osc, 1):
for j in range(i + 1, self._num_osc, 1):
dist = euclidean_distance(self._osc_loc[i], self._osc_loc[j]);
if (self._ena_conn_weight is True):
self._conn_weight[i][j] = dist;
self._conn_weight[j][i] = dist;
if (dist > maximum_distance): maximum_distance = dist;
if (dist < minimum_distance): minimum_distance = dist;
if (dist <= radius):
self.set_connection(i, j);
if (self._ena_conn_weight is True):
multiplier = 1;
subtractor = 0;
if (maximum_distance != minimum_distance):
multiplier = (maximum_distance - minimum_distance);
subtractor = minimum_distance;
for i in range(0, self._num_osc, 1):
for j in range(i + 1, self._num_osc, 1):
value_conn_weight = (self._conn_weight[i][j] - subtractor) / multiplier;
self._conn_weight[i][j] = value_conn_weight;
self._conn_weight[j][i] = value_conn_weight; | def _create_connections(self, radius):
"""!
@brief Create connections between oscillators in line with input radius of connectivity.
@param[in] radius (double): Connectivity radius between oscillators.
"""
if (self._ena_conn_weight is True):
self._conn_weight = [[0] * self._num_osc for _ in range(0, self._num_osc, 1)];
maximum_distance = 0;
minimum_distance = float('inf');
# Create connections
for i in range(0, self._num_osc, 1):
for j in range(i + 1, self._num_osc, 1):
dist = euclidean_distance(self._osc_loc[i], self._osc_loc[j]);
if (self._ena_conn_weight is True):
self._conn_weight[i][j] = dist;
self._conn_weight[j][i] = dist;
if (dist > maximum_distance): maximum_distance = dist;
if (dist < minimum_distance): minimum_distance = dist;
if (dist <= radius):
self.set_connection(i, j);
if (self._ena_conn_weight is True):
multiplier = 1;
subtractor = 0;
if (maximum_distance != minimum_distance):
multiplier = (maximum_distance - minimum_distance);
subtractor = minimum_distance;
for i in range(0, self._num_osc, 1):
for j in range(i + 1, self._num_osc, 1):
value_conn_weight = (self._conn_weight[i][j] - subtractor) / multiplier;
self._conn_weight[i][j] = value_conn_weight;
self._conn_weight[j][i] = value_conn_weight; | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/cluster/syncnet.py#L247-L289 | [
"def",
"_create_connections",
"(",
"self",
",",
"radius",
")",
":",
"if",
"(",
"self",
".",
"_ena_conn_weight",
"is",
"True",
")",
":",
"self",
".",
"_conn_weight",
"=",
"[",
"[",
"0",
"]",
"*",
"self",
".",
"_num_osc",
"for",
"_",
"in",
"range",
"(",
"0",
",",
"self",
".",
"_num_osc",
",",
"1",
")",
"]",
"maximum_distance",
"=",
"0",
"minimum_distance",
"=",
"float",
"(",
"'inf'",
")",
"# Create connections\r",
"for",
"i",
"in",
"range",
"(",
"0",
",",
"self",
".",
"_num_osc",
",",
"1",
")",
":",
"for",
"j",
"in",
"range",
"(",
"i",
"+",
"1",
",",
"self",
".",
"_num_osc",
",",
"1",
")",
":",
"dist",
"=",
"euclidean_distance",
"(",
"self",
".",
"_osc_loc",
"[",
"i",
"]",
",",
"self",
".",
"_osc_loc",
"[",
"j",
"]",
")",
"if",
"(",
"self",
".",
"_ena_conn_weight",
"is",
"True",
")",
":",
"self",
".",
"_conn_weight",
"[",
"i",
"]",
"[",
"j",
"]",
"=",
"dist",
"self",
".",
"_conn_weight",
"[",
"j",
"]",
"[",
"i",
"]",
"=",
"dist",
"if",
"(",
"dist",
">",
"maximum_distance",
")",
":",
"maximum_distance",
"=",
"dist",
"if",
"(",
"dist",
"<",
"minimum_distance",
")",
":",
"minimum_distance",
"=",
"dist",
"if",
"(",
"dist",
"<=",
"radius",
")",
":",
"self",
".",
"set_connection",
"(",
"i",
",",
"j",
")",
"if",
"(",
"self",
".",
"_ena_conn_weight",
"is",
"True",
")",
":",
"multiplier",
"=",
"1",
"subtractor",
"=",
"0",
"if",
"(",
"maximum_distance",
"!=",
"minimum_distance",
")",
":",
"multiplier",
"=",
"(",
"maximum_distance",
"-",
"minimum_distance",
")",
"subtractor",
"=",
"minimum_distance",
"for",
"i",
"in",
"range",
"(",
"0",
",",
"self",
".",
"_num_osc",
",",
"1",
")",
":",
"for",
"j",
"in",
"range",
"(",
"i",
"+",
"1",
",",
"self",
".",
"_num_osc",
",",
"1",
")",
":",
"value_conn_weight",
"=",
"(",
"self",
".",
"_conn_weight",
"[",
"i",
"]",
"[",
"j",
"]",
"-",
"subtractor",
")",
"/",
"multiplier",
"self",
".",
"_conn_weight",
"[",
"i",
"]",
"[",
"j",
"]",
"=",
"value_conn_weight",
"self",
".",
"_conn_weight",
"[",
"j",
"]",
"[",
"i",
"]",
"=",
"value_conn_weight"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | syncnet.process | !
@brief Peforms cluster analysis using simulation of the oscillatory network.
@param[in] order (double): Order of synchronization that is used as indication for stopping processing.
@param[in] solution (solve_type): Specified type of solving diff. equation.
@param[in] collect_dynamic (bool): Specified requirement to collect whole dynamic of the network.
@return (syncnet_analyser) Returns analyser of results of clustering. | pyclustering/cluster/syncnet.py | def process(self, order = 0.998, solution = solve_type.FAST, collect_dynamic = True):
"""!
@brief Peforms cluster analysis using simulation of the oscillatory network.
@param[in] order (double): Order of synchronization that is used as indication for stopping processing.
@param[in] solution (solve_type): Specified type of solving diff. equation.
@param[in] collect_dynamic (bool): Specified requirement to collect whole dynamic of the network.
@return (syncnet_analyser) Returns analyser of results of clustering.
"""
if (self._ccore_network_pointer is not None):
pointer_output_dynamic = syncnet_process(self._ccore_network_pointer, order, solution, collect_dynamic);
return syncnet_analyser(None, None, pointer_output_dynamic);
else:
output_sync_dynamic = self.simulate_dynamic(order, solution, collect_dynamic);
return syncnet_analyser(output_sync_dynamic.output, output_sync_dynamic.time, None); | def process(self, order = 0.998, solution = solve_type.FAST, collect_dynamic = True):
"""!
@brief Peforms cluster analysis using simulation of the oscillatory network.
@param[in] order (double): Order of synchronization that is used as indication for stopping processing.
@param[in] solution (solve_type): Specified type of solving diff. equation.
@param[in] collect_dynamic (bool): Specified requirement to collect whole dynamic of the network.
@return (syncnet_analyser) Returns analyser of results of clustering.
"""
if (self._ccore_network_pointer is not None):
pointer_output_dynamic = syncnet_process(self._ccore_network_pointer, order, solution, collect_dynamic);
return syncnet_analyser(None, None, pointer_output_dynamic);
else:
output_sync_dynamic = self.simulate_dynamic(order, solution, collect_dynamic);
return syncnet_analyser(output_sync_dynamic.output, output_sync_dynamic.time, None); | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/cluster/syncnet.py#L292-L309 | [
"def",
"process",
"(",
"self",
",",
"order",
"=",
"0.998",
",",
"solution",
"=",
"solve_type",
".",
"FAST",
",",
"collect_dynamic",
"=",
"True",
")",
":",
"if",
"(",
"self",
".",
"_ccore_network_pointer",
"is",
"not",
"None",
")",
":",
"pointer_output_dynamic",
"=",
"syncnet_process",
"(",
"self",
".",
"_ccore_network_pointer",
",",
"order",
",",
"solution",
",",
"collect_dynamic",
")",
"return",
"syncnet_analyser",
"(",
"None",
",",
"None",
",",
"pointer_output_dynamic",
")",
"else",
":",
"output_sync_dynamic",
"=",
"self",
".",
"simulate_dynamic",
"(",
"order",
",",
"solution",
",",
"collect_dynamic",
")",
"return",
"syncnet_analyser",
"(",
"output_sync_dynamic",
".",
"output",
",",
"output_sync_dynamic",
".",
"time",
",",
"None",
")"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | syncnet._phase_kuramoto | !
@brief Overrided method for calculation of oscillator phase.
@param[in] teta (double): Current value of phase.
@param[in] t (double): Time (can be ignored).
@param[in] argv (uint): Index of oscillator whose phase represented by argument teta.
@return (double) New value of phase of oscillator with index 'argv'. | pyclustering/cluster/syncnet.py | def _phase_kuramoto(self, teta, t, argv):
"""!
@brief Overrided method for calculation of oscillator phase.
@param[in] teta (double): Current value of phase.
@param[in] t (double): Time (can be ignored).
@param[in] argv (uint): Index of oscillator whose phase represented by argument teta.
@return (double) New value of phase of oscillator with index 'argv'.
"""
index = argv; # index of oscillator
phase = 0.0; # phase of a specified oscillator that will calculated in line with current env. states.
neighbors = self.get_neighbors(index);
for k in neighbors:
conn_weight = 1.0;
if (self._ena_conn_weight is True):
conn_weight = self._conn_weight[index][k];
phase += conn_weight * self._weight * math.sin(self._phases[k] - teta);
divider = len(neighbors);
if (divider == 0):
divider = 1.0;
return ( self._freq[index] + (phase / divider) ); | def _phase_kuramoto(self, teta, t, argv):
"""!
@brief Overrided method for calculation of oscillator phase.
@param[in] teta (double): Current value of phase.
@param[in] t (double): Time (can be ignored).
@param[in] argv (uint): Index of oscillator whose phase represented by argument teta.
@return (double) New value of phase of oscillator with index 'argv'.
"""
index = argv; # index of oscillator
phase = 0.0; # phase of a specified oscillator that will calculated in line with current env. states.
neighbors = self.get_neighbors(index);
for k in neighbors:
conn_weight = 1.0;
if (self._ena_conn_weight is True):
conn_weight = self._conn_weight[index][k];
phase += conn_weight * self._weight * math.sin(self._phases[k] - teta);
divider = len(neighbors);
if (divider == 0):
divider = 1.0;
return ( self._freq[index] + (phase / divider) ); | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/cluster/syncnet.py#L312-L339 | [
"def",
"_phase_kuramoto",
"(",
"self",
",",
"teta",
",",
"t",
",",
"argv",
")",
":",
"index",
"=",
"argv",
"# index of oscillator\r",
"phase",
"=",
"0.0",
"# phase of a specified oscillator that will calculated in line with current env. states.\r",
"neighbors",
"=",
"self",
".",
"get_neighbors",
"(",
"index",
")",
"for",
"k",
"in",
"neighbors",
":",
"conn_weight",
"=",
"1.0",
"if",
"(",
"self",
".",
"_ena_conn_weight",
"is",
"True",
")",
":",
"conn_weight",
"=",
"self",
".",
"_conn_weight",
"[",
"index",
"]",
"[",
"k",
"]",
"phase",
"+=",
"conn_weight",
"*",
"self",
".",
"_weight",
"*",
"math",
".",
"sin",
"(",
"self",
".",
"_phases",
"[",
"k",
"]",
"-",
"teta",
")",
"divider",
"=",
"len",
"(",
"neighbors",
")",
"if",
"(",
"divider",
"==",
"0",
")",
":",
"divider",
"=",
"1.0",
"return",
"(",
"self",
".",
"_freq",
"[",
"index",
"]",
"+",
"(",
"phase",
"/",
"divider",
")",
")"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | syncnet.show_network | !
@brief Shows connections in the network. It supports only 2-d and 3-d representation. | pyclustering/cluster/syncnet.py | def show_network(self):
"""!
@brief Shows connections in the network. It supports only 2-d and 3-d representation.
"""
if ( (self._ccore_network_pointer is not None) and (self._osc_conn is None) ):
self._osc_conn = sync_connectivity_matrix(self._ccore_network_pointer);
dimension = len(self._osc_loc[0]);
if ( (dimension != 3) and (dimension != 2) ):
raise NameError('Network that is located in different from 2-d and 3-d dimensions can not be represented');
from matplotlib.font_manager import FontProperties;
from matplotlib import rcParams;
rcParams['font.sans-serif'] = ['Arial'];
rcParams['font.size'] = 12;
fig = plt.figure();
axes = None;
if (dimension == 2):
axes = fig.add_subplot(111);
elif (dimension == 3):
axes = fig.gca(projection='3d');
surface_font = FontProperties();
surface_font.set_name('Arial');
surface_font.set_size('12');
for i in range(0, self._num_osc, 1):
if (dimension == 2):
axes.plot(self._osc_loc[i][0], self._osc_loc[i][1], 'bo');
if (self._conn_represent == conn_represent.MATRIX):
for j in range(i, self._num_osc, 1): # draw connection between two points only one time
if (self.has_connection(i, j) == True):
axes.plot([self._osc_loc[i][0], self._osc_loc[j][0]], [self._osc_loc[i][1], self._osc_loc[j][1]], 'b-', linewidth = 0.5);
else:
for j in self.get_neighbors(i):
if ( (self.has_connection(i, j) == True) and (i > j) ): # draw connection between two points only one time
axes.plot([self._osc_loc[i][0], self._osc_loc[j][0]], [self._osc_loc[i][1], self._osc_loc[j][1]], 'b-', linewidth = 0.5);
elif (dimension == 3):
axes.scatter(self._osc_loc[i][0], self._osc_loc[i][1], self._osc_loc[i][2], c = 'b', marker = 'o');
if (self._conn_represent == conn_represent.MATRIX):
for j in range(i, self._num_osc, 1): # draw connection between two points only one time
if (self.has_connection(i, j) == True):
axes.plot([self._osc_loc[i][0], self._osc_loc[j][0]], [self._osc_loc[i][1], self._osc_loc[j][1]], [self._osc_loc[i][2], self._osc_loc[j][2]], 'b-', linewidth = 0.5);
else:
for j in self.get_neighbors(i):
if ( (self.has_connection(i, j) == True) and (i > j) ): # draw connection between two points only one time
axes.plot([self._osc_loc[i][0], self._osc_loc[j][0]], [self._osc_loc[i][1], self._osc_loc[j][1]], [self._osc_loc[i][2], self._osc_loc[j][2]], 'b-', linewidth = 0.5);
plt.grid();
plt.show(); | def show_network(self):
"""!
@brief Shows connections in the network. It supports only 2-d and 3-d representation.
"""
if ( (self._ccore_network_pointer is not None) and (self._osc_conn is None) ):
self._osc_conn = sync_connectivity_matrix(self._ccore_network_pointer);
dimension = len(self._osc_loc[0]);
if ( (dimension != 3) and (dimension != 2) ):
raise NameError('Network that is located in different from 2-d and 3-d dimensions can not be represented');
from matplotlib.font_manager import FontProperties;
from matplotlib import rcParams;
rcParams['font.sans-serif'] = ['Arial'];
rcParams['font.size'] = 12;
fig = plt.figure();
axes = None;
if (dimension == 2):
axes = fig.add_subplot(111);
elif (dimension == 3):
axes = fig.gca(projection='3d');
surface_font = FontProperties();
surface_font.set_name('Arial');
surface_font.set_size('12');
for i in range(0, self._num_osc, 1):
if (dimension == 2):
axes.plot(self._osc_loc[i][0], self._osc_loc[i][1], 'bo');
if (self._conn_represent == conn_represent.MATRIX):
for j in range(i, self._num_osc, 1): # draw connection between two points only one time
if (self.has_connection(i, j) == True):
axes.plot([self._osc_loc[i][0], self._osc_loc[j][0]], [self._osc_loc[i][1], self._osc_loc[j][1]], 'b-', linewidth = 0.5);
else:
for j in self.get_neighbors(i):
if ( (self.has_connection(i, j) == True) and (i > j) ): # draw connection between two points only one time
axes.plot([self._osc_loc[i][0], self._osc_loc[j][0]], [self._osc_loc[i][1], self._osc_loc[j][1]], 'b-', linewidth = 0.5);
elif (dimension == 3):
axes.scatter(self._osc_loc[i][0], self._osc_loc[i][1], self._osc_loc[i][2], c = 'b', marker = 'o');
if (self._conn_represent == conn_represent.MATRIX):
for j in range(i, self._num_osc, 1): # draw connection between two points only one time
if (self.has_connection(i, j) == True):
axes.plot([self._osc_loc[i][0], self._osc_loc[j][0]], [self._osc_loc[i][1], self._osc_loc[j][1]], [self._osc_loc[i][2], self._osc_loc[j][2]], 'b-', linewidth = 0.5);
else:
for j in self.get_neighbors(i):
if ( (self.has_connection(i, j) == True) and (i > j) ): # draw connection between two points only one time
axes.plot([self._osc_loc[i][0], self._osc_loc[j][0]], [self._osc_loc[i][1], self._osc_loc[j][1]], [self._osc_loc[i][2], self._osc_loc[j][2]], 'b-', linewidth = 0.5);
plt.grid();
plt.show(); | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/cluster/syncnet.py#L342-L399 | [
"def",
"show_network",
"(",
"self",
")",
":",
"if",
"(",
"(",
"self",
".",
"_ccore_network_pointer",
"is",
"not",
"None",
")",
"and",
"(",
"self",
".",
"_osc_conn",
"is",
"None",
")",
")",
":",
"self",
".",
"_osc_conn",
"=",
"sync_connectivity_matrix",
"(",
"self",
".",
"_ccore_network_pointer",
")",
"dimension",
"=",
"len",
"(",
"self",
".",
"_osc_loc",
"[",
"0",
"]",
")",
"if",
"(",
"(",
"dimension",
"!=",
"3",
")",
"and",
"(",
"dimension",
"!=",
"2",
")",
")",
":",
"raise",
"NameError",
"(",
"'Network that is located in different from 2-d and 3-d dimensions can not be represented'",
")",
"from",
"matplotlib",
".",
"font_manager",
"import",
"FontProperties",
"from",
"matplotlib",
"import",
"rcParams",
"rcParams",
"[",
"'font.sans-serif'",
"]",
"=",
"[",
"'Arial'",
"]",
"rcParams",
"[",
"'font.size'",
"]",
"=",
"12",
"fig",
"=",
"plt",
".",
"figure",
"(",
")",
"axes",
"=",
"None",
"if",
"(",
"dimension",
"==",
"2",
")",
":",
"axes",
"=",
"fig",
".",
"add_subplot",
"(",
"111",
")",
"elif",
"(",
"dimension",
"==",
"3",
")",
":",
"axes",
"=",
"fig",
".",
"gca",
"(",
"projection",
"=",
"'3d'",
")",
"surface_font",
"=",
"FontProperties",
"(",
")",
"surface_font",
".",
"set_name",
"(",
"'Arial'",
")",
"surface_font",
".",
"set_size",
"(",
"'12'",
")",
"for",
"i",
"in",
"range",
"(",
"0",
",",
"self",
".",
"_num_osc",
",",
"1",
")",
":",
"if",
"(",
"dimension",
"==",
"2",
")",
":",
"axes",
".",
"plot",
"(",
"self",
".",
"_osc_loc",
"[",
"i",
"]",
"[",
"0",
"]",
",",
"self",
".",
"_osc_loc",
"[",
"i",
"]",
"[",
"1",
"]",
",",
"'bo'",
")",
"if",
"(",
"self",
".",
"_conn_represent",
"==",
"conn_represent",
".",
"MATRIX",
")",
":",
"for",
"j",
"in",
"range",
"(",
"i",
",",
"self",
".",
"_num_osc",
",",
"1",
")",
":",
"# draw connection between two points only one time\r",
"if",
"(",
"self",
".",
"has_connection",
"(",
"i",
",",
"j",
")",
"==",
"True",
")",
":",
"axes",
".",
"plot",
"(",
"[",
"self",
".",
"_osc_loc",
"[",
"i",
"]",
"[",
"0",
"]",
",",
"self",
".",
"_osc_loc",
"[",
"j",
"]",
"[",
"0",
"]",
"]",
",",
"[",
"self",
".",
"_osc_loc",
"[",
"i",
"]",
"[",
"1",
"]",
",",
"self",
".",
"_osc_loc",
"[",
"j",
"]",
"[",
"1",
"]",
"]",
",",
"'b-'",
",",
"linewidth",
"=",
"0.5",
")",
"else",
":",
"for",
"j",
"in",
"self",
".",
"get_neighbors",
"(",
"i",
")",
":",
"if",
"(",
"(",
"self",
".",
"has_connection",
"(",
"i",
",",
"j",
")",
"==",
"True",
")",
"and",
"(",
"i",
">",
"j",
")",
")",
":",
"# draw connection between two points only one time\r",
"axes",
".",
"plot",
"(",
"[",
"self",
".",
"_osc_loc",
"[",
"i",
"]",
"[",
"0",
"]",
",",
"self",
".",
"_osc_loc",
"[",
"j",
"]",
"[",
"0",
"]",
"]",
",",
"[",
"self",
".",
"_osc_loc",
"[",
"i",
"]",
"[",
"1",
"]",
",",
"self",
".",
"_osc_loc",
"[",
"j",
"]",
"[",
"1",
"]",
"]",
",",
"'b-'",
",",
"linewidth",
"=",
"0.5",
")",
"elif",
"(",
"dimension",
"==",
"3",
")",
":",
"axes",
".",
"scatter",
"(",
"self",
".",
"_osc_loc",
"[",
"i",
"]",
"[",
"0",
"]",
",",
"self",
".",
"_osc_loc",
"[",
"i",
"]",
"[",
"1",
"]",
",",
"self",
".",
"_osc_loc",
"[",
"i",
"]",
"[",
"2",
"]",
",",
"c",
"=",
"'b'",
",",
"marker",
"=",
"'o'",
")",
"if",
"(",
"self",
".",
"_conn_represent",
"==",
"conn_represent",
".",
"MATRIX",
")",
":",
"for",
"j",
"in",
"range",
"(",
"i",
",",
"self",
".",
"_num_osc",
",",
"1",
")",
":",
"# draw connection between two points only one time\r",
"if",
"(",
"self",
".",
"has_connection",
"(",
"i",
",",
"j",
")",
"==",
"True",
")",
":",
"axes",
".",
"plot",
"(",
"[",
"self",
".",
"_osc_loc",
"[",
"i",
"]",
"[",
"0",
"]",
",",
"self",
".",
"_osc_loc",
"[",
"j",
"]",
"[",
"0",
"]",
"]",
",",
"[",
"self",
".",
"_osc_loc",
"[",
"i",
"]",
"[",
"1",
"]",
",",
"self",
".",
"_osc_loc",
"[",
"j",
"]",
"[",
"1",
"]",
"]",
",",
"[",
"self",
".",
"_osc_loc",
"[",
"i",
"]",
"[",
"2",
"]",
",",
"self",
".",
"_osc_loc",
"[",
"j",
"]",
"[",
"2",
"]",
"]",
",",
"'b-'",
",",
"linewidth",
"=",
"0.5",
")",
"else",
":",
"for",
"j",
"in",
"self",
".",
"get_neighbors",
"(",
"i",
")",
":",
"if",
"(",
"(",
"self",
".",
"has_connection",
"(",
"i",
",",
"j",
")",
"==",
"True",
")",
"and",
"(",
"i",
">",
"j",
")",
")",
":",
"# draw connection between two points only one time\r",
"axes",
".",
"plot",
"(",
"[",
"self",
".",
"_osc_loc",
"[",
"i",
"]",
"[",
"0",
"]",
",",
"self",
".",
"_osc_loc",
"[",
"j",
"]",
"[",
"0",
"]",
"]",
",",
"[",
"self",
".",
"_osc_loc",
"[",
"i",
"]",
"[",
"1",
"]",
",",
"self",
".",
"_osc_loc",
"[",
"j",
"]",
"[",
"1",
"]",
"]",
",",
"[",
"self",
".",
"_osc_loc",
"[",
"i",
"]",
"[",
"2",
"]",
",",
"self",
".",
"_osc_loc",
"[",
"j",
"]",
"[",
"2",
"]",
"]",
",",
"'b-'",
",",
"linewidth",
"=",
"0.5",
")",
"plt",
".",
"grid",
"(",
")",
"plt",
".",
"show",
"(",
")"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | hhn_network.simulate_static | !
@brief Performs static simulation of oscillatory network based on Hodgkin-Huxley neuron model.
@details Output dynamic is sensible to amount of steps of simulation and solver of differential equation.
Python implementation uses 'odeint' from 'scipy', CCORE uses classical RK4 and RFK45 methods,
therefore in case of CCORE HHN (Hodgkin-Huxley network) amount of steps should be greater than in
case of Python HHN.
@param[in] steps (uint): Number steps of simulations during simulation.
@param[in] time (double): Time of simulation.
@param[in] solution (solve_type): Type of solver for differential equations.
@return (tuple) Dynamic of oscillatory network represented by (time, peripheral neurons dynamic, central elements
dynamic), where types are (list, list, list). | pyclustering/nnet/hhn.py | def simulate_static(self, steps, time, solution = solve_type.RK4):
"""!
@brief Performs static simulation of oscillatory network based on Hodgkin-Huxley neuron model.
@details Output dynamic is sensible to amount of steps of simulation and solver of differential equation.
Python implementation uses 'odeint' from 'scipy', CCORE uses classical RK4 and RFK45 methods,
therefore in case of CCORE HHN (Hodgkin-Huxley network) amount of steps should be greater than in
case of Python HHN.
@param[in] steps (uint): Number steps of simulations during simulation.
@param[in] time (double): Time of simulation.
@param[in] solution (solve_type): Type of solver for differential equations.
@return (tuple) Dynamic of oscillatory network represented by (time, peripheral neurons dynamic, central elements
dynamic), where types are (list, list, list).
"""
# Check solver before simulation
if (solution == solve_type.FAST):
raise NameError("Solver FAST is not support due to low accuracy that leads to huge error.");
self._membrane_dynamic_pointer = None;
if (self.__ccore_hhn_pointer is not None):
self.__ccore_hhn_dynamic_pointer = wrapper.hhn_dynamic_create(True, False, False, False);
wrapper.hhn_simulate(self.__ccore_hhn_pointer, steps, time, solution, self._stimulus, self.__ccore_hhn_dynamic_pointer);
peripheral_membrane_potential = wrapper.hhn_dynamic_get_peripheral_evolution(self.__ccore_hhn_dynamic_pointer, 0);
central_membrane_potential = wrapper.hhn_dynamic_get_central_evolution(self.__ccore_hhn_dynamic_pointer, 0);
dynamic_time = wrapper.hhn_dynamic_get_time(self.__ccore_hhn_dynamic_pointer);
self._membrane_dynamic_pointer = peripheral_membrane_potential;
wrapper.hhn_dynamic_destroy(self.__ccore_hhn_dynamic_pointer);
return (dynamic_time, peripheral_membrane_potential, central_membrane_potential);
if (solution == solve_type.RKF45):
raise NameError("Solver RKF45 is not support in python version.");
dyn_peripheral = [ self._membrane_potential[:] ];
dyn_central = [ [0.0, 0.0] ];
dyn_time = [ 0.0 ];
step = time / steps;
int_step = step / 10.0;
for t in numpy.arange(step, time + step, step):
# update states of oscillators
(memb_peripheral, memb_central) = self._calculate_states(solution, t, step, int_step);
# update states of oscillators
dyn_peripheral.append(memb_peripheral);
dyn_central.append(memb_central);
dyn_time.append(t);
self._membrane_dynamic_pointer = dyn_peripheral;
return (dyn_time, dyn_peripheral, dyn_central); | def simulate_static(self, steps, time, solution = solve_type.RK4):
"""!
@brief Performs static simulation of oscillatory network based on Hodgkin-Huxley neuron model.
@details Output dynamic is sensible to amount of steps of simulation and solver of differential equation.
Python implementation uses 'odeint' from 'scipy', CCORE uses classical RK4 and RFK45 methods,
therefore in case of CCORE HHN (Hodgkin-Huxley network) amount of steps should be greater than in
case of Python HHN.
@param[in] steps (uint): Number steps of simulations during simulation.
@param[in] time (double): Time of simulation.
@param[in] solution (solve_type): Type of solver for differential equations.
@return (tuple) Dynamic of oscillatory network represented by (time, peripheral neurons dynamic, central elements
dynamic), where types are (list, list, list).
"""
# Check solver before simulation
if (solution == solve_type.FAST):
raise NameError("Solver FAST is not support due to low accuracy that leads to huge error.");
self._membrane_dynamic_pointer = None;
if (self.__ccore_hhn_pointer is not None):
self.__ccore_hhn_dynamic_pointer = wrapper.hhn_dynamic_create(True, False, False, False);
wrapper.hhn_simulate(self.__ccore_hhn_pointer, steps, time, solution, self._stimulus, self.__ccore_hhn_dynamic_pointer);
peripheral_membrane_potential = wrapper.hhn_dynamic_get_peripheral_evolution(self.__ccore_hhn_dynamic_pointer, 0);
central_membrane_potential = wrapper.hhn_dynamic_get_central_evolution(self.__ccore_hhn_dynamic_pointer, 0);
dynamic_time = wrapper.hhn_dynamic_get_time(self.__ccore_hhn_dynamic_pointer);
self._membrane_dynamic_pointer = peripheral_membrane_potential;
wrapper.hhn_dynamic_destroy(self.__ccore_hhn_dynamic_pointer);
return (dynamic_time, peripheral_membrane_potential, central_membrane_potential);
if (solution == solve_type.RKF45):
raise NameError("Solver RKF45 is not support in python version.");
dyn_peripheral = [ self._membrane_potential[:] ];
dyn_central = [ [0.0, 0.0] ];
dyn_time = [ 0.0 ];
step = time / steps;
int_step = step / 10.0;
for t in numpy.arange(step, time + step, step):
# update states of oscillators
(memb_peripheral, memb_central) = self._calculate_states(solution, t, step, int_step);
# update states of oscillators
dyn_peripheral.append(memb_peripheral);
dyn_central.append(memb_central);
dyn_time.append(t);
self._membrane_dynamic_pointer = dyn_peripheral;
return (dyn_time, dyn_peripheral, dyn_central); | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/nnet/hhn.py#L286-L343 | [
"def",
"simulate_static",
"(",
"self",
",",
"steps",
",",
"time",
",",
"solution",
"=",
"solve_type",
".",
"RK4",
")",
":",
"# Check solver before simulation\r",
"if",
"(",
"solution",
"==",
"solve_type",
".",
"FAST",
")",
":",
"raise",
"NameError",
"(",
"\"Solver FAST is not support due to low accuracy that leads to huge error.\"",
")",
"self",
".",
"_membrane_dynamic_pointer",
"=",
"None",
"if",
"(",
"self",
".",
"__ccore_hhn_pointer",
"is",
"not",
"None",
")",
":",
"self",
".",
"__ccore_hhn_dynamic_pointer",
"=",
"wrapper",
".",
"hhn_dynamic_create",
"(",
"True",
",",
"False",
",",
"False",
",",
"False",
")",
"wrapper",
".",
"hhn_simulate",
"(",
"self",
".",
"__ccore_hhn_pointer",
",",
"steps",
",",
"time",
",",
"solution",
",",
"self",
".",
"_stimulus",
",",
"self",
".",
"__ccore_hhn_dynamic_pointer",
")",
"peripheral_membrane_potential",
"=",
"wrapper",
".",
"hhn_dynamic_get_peripheral_evolution",
"(",
"self",
".",
"__ccore_hhn_dynamic_pointer",
",",
"0",
")",
"central_membrane_potential",
"=",
"wrapper",
".",
"hhn_dynamic_get_central_evolution",
"(",
"self",
".",
"__ccore_hhn_dynamic_pointer",
",",
"0",
")",
"dynamic_time",
"=",
"wrapper",
".",
"hhn_dynamic_get_time",
"(",
"self",
".",
"__ccore_hhn_dynamic_pointer",
")",
"self",
".",
"_membrane_dynamic_pointer",
"=",
"peripheral_membrane_potential",
"wrapper",
".",
"hhn_dynamic_destroy",
"(",
"self",
".",
"__ccore_hhn_dynamic_pointer",
")",
"return",
"(",
"dynamic_time",
",",
"peripheral_membrane_potential",
",",
"central_membrane_potential",
")",
"if",
"(",
"solution",
"==",
"solve_type",
".",
"RKF45",
")",
":",
"raise",
"NameError",
"(",
"\"Solver RKF45 is not support in python version.\"",
")",
"dyn_peripheral",
"=",
"[",
"self",
".",
"_membrane_potential",
"[",
":",
"]",
"]",
"dyn_central",
"=",
"[",
"[",
"0.0",
",",
"0.0",
"]",
"]",
"dyn_time",
"=",
"[",
"0.0",
"]",
"step",
"=",
"time",
"/",
"steps",
"int_step",
"=",
"step",
"/",
"10.0",
"for",
"t",
"in",
"numpy",
".",
"arange",
"(",
"step",
",",
"time",
"+",
"step",
",",
"step",
")",
":",
"# update states of oscillators\r",
"(",
"memb_peripheral",
",",
"memb_central",
")",
"=",
"self",
".",
"_calculate_states",
"(",
"solution",
",",
"t",
",",
"step",
",",
"int_step",
")",
"# update states of oscillators\r",
"dyn_peripheral",
".",
"append",
"(",
"memb_peripheral",
")",
"dyn_central",
".",
"append",
"(",
"memb_central",
")",
"dyn_time",
".",
"append",
"(",
"t",
")",
"self",
".",
"_membrane_dynamic_pointer",
"=",
"dyn_peripheral",
"return",
"(",
"dyn_time",
",",
"dyn_peripheral",
",",
"dyn_central",
")"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | hhn_network._calculate_states | !
@brief Caclculates new state of each oscillator in the network. Returns only excitatory state of oscillators.
@param[in] solution (solve_type): Type solver of the differential equations.
@param[in] t (double): Current time of simulation.
@param[in] step (uint): Step of solution at the end of which states of oscillators should be calculated.
@param[in] int_step (double): Differentiation step that is used for solving differential equation.
@return (list) New states of membrance potentials for peripheral oscillators and for cental elements as a list where
the last two values correspond to central element 1 and 2. | pyclustering/nnet/hhn.py | def _calculate_states(self, solution, t, step, int_step):
"""!
@brief Caclculates new state of each oscillator in the network. Returns only excitatory state of oscillators.
@param[in] solution (solve_type): Type solver of the differential equations.
@param[in] t (double): Current time of simulation.
@param[in] step (uint): Step of solution at the end of which states of oscillators should be calculated.
@param[in] int_step (double): Differentiation step that is used for solving differential equation.
@return (list) New states of membrance potentials for peripheral oscillators and for cental elements as a list where
the last two values correspond to central element 1 and 2.
"""
next_membrane = [0.0] * self._num_osc;
next_active_sodium = [0.0] * self._num_osc;
next_inactive_sodium = [0.0] * self._num_osc;
next_active_potassium = [0.0] * self._num_osc;
# Update states of oscillators
for index in range (0, self._num_osc, 1):
result = odeint(self.hnn_state,
[ self._membrane_potential[index], self._active_cond_sodium[index], self._inactive_cond_sodium[index], self._active_cond_potassium[index] ],
numpy.arange(t - step, t, int_step),
(index , ));
[ next_membrane[index], next_active_sodium[index], next_inactive_sodium[index], next_active_potassium[index] ] = result[len(result) - 1][0:4];
next_cn_membrane = [0.0, 0.0];
next_cn_active_sodium = [0.0, 0.0];
next_cn_inactive_sodium = [0.0, 0.0];
next_cn_active_potassium = [0.0, 0.0];
# Update states of central elements
for index in range(0, len(self._central_element)):
result = odeint(self.hnn_state,
[ self._central_element[index].membrane_potential, self._central_element[index].active_cond_sodium, self._central_element[index].inactive_cond_sodium, self._central_element[index].active_cond_potassium ],
numpy.arange(t - step, t, int_step),
(self._num_osc + index , ));
[ next_cn_membrane[index], next_cn_active_sodium[index], next_cn_inactive_sodium[index], next_cn_active_potassium[index] ] = result[len(result) - 1][0:4];
# Noise generation
self._noise = [ 1.0 + 0.01 * (random.random() * 2.0 - 1.0) for i in range(self._num_osc)];
# Updating states of PNs
self.__update_peripheral_neurons(t, step, next_membrane, next_active_sodium, next_inactive_sodium, next_active_potassium);
# Updation states of CN
self.__update_central_neurons(t, next_cn_membrane, next_cn_active_sodium, next_cn_inactive_sodium, next_cn_active_potassium);
return (next_membrane, next_cn_membrane); | def _calculate_states(self, solution, t, step, int_step):
"""!
@brief Caclculates new state of each oscillator in the network. Returns only excitatory state of oscillators.
@param[in] solution (solve_type): Type solver of the differential equations.
@param[in] t (double): Current time of simulation.
@param[in] step (uint): Step of solution at the end of which states of oscillators should be calculated.
@param[in] int_step (double): Differentiation step that is used for solving differential equation.
@return (list) New states of membrance potentials for peripheral oscillators and for cental elements as a list where
the last two values correspond to central element 1 and 2.
"""
next_membrane = [0.0] * self._num_osc;
next_active_sodium = [0.0] * self._num_osc;
next_inactive_sodium = [0.0] * self._num_osc;
next_active_potassium = [0.0] * self._num_osc;
# Update states of oscillators
for index in range (0, self._num_osc, 1):
result = odeint(self.hnn_state,
[ self._membrane_potential[index], self._active_cond_sodium[index], self._inactive_cond_sodium[index], self._active_cond_potassium[index] ],
numpy.arange(t - step, t, int_step),
(index , ));
[ next_membrane[index], next_active_sodium[index], next_inactive_sodium[index], next_active_potassium[index] ] = result[len(result) - 1][0:4];
next_cn_membrane = [0.0, 0.0];
next_cn_active_sodium = [0.0, 0.0];
next_cn_inactive_sodium = [0.0, 0.0];
next_cn_active_potassium = [0.0, 0.0];
# Update states of central elements
for index in range(0, len(self._central_element)):
result = odeint(self.hnn_state,
[ self._central_element[index].membrane_potential, self._central_element[index].active_cond_sodium, self._central_element[index].inactive_cond_sodium, self._central_element[index].active_cond_potassium ],
numpy.arange(t - step, t, int_step),
(self._num_osc + index , ));
[ next_cn_membrane[index], next_cn_active_sodium[index], next_cn_inactive_sodium[index], next_cn_active_potassium[index] ] = result[len(result) - 1][0:4];
# Noise generation
self._noise = [ 1.0 + 0.01 * (random.random() * 2.0 - 1.0) for i in range(self._num_osc)];
# Updating states of PNs
self.__update_peripheral_neurons(t, step, next_membrane, next_active_sodium, next_inactive_sodium, next_active_potassium);
# Updation states of CN
self.__update_central_neurons(t, next_cn_membrane, next_cn_active_sodium, next_cn_inactive_sodium, next_cn_active_potassium);
return (next_membrane, next_cn_membrane); | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/nnet/hhn.py#L346-L397 | [
"def",
"_calculate_states",
"(",
"self",
",",
"solution",
",",
"t",
",",
"step",
",",
"int_step",
")",
":",
"next_membrane",
"=",
"[",
"0.0",
"]",
"*",
"self",
".",
"_num_osc",
"next_active_sodium",
"=",
"[",
"0.0",
"]",
"*",
"self",
".",
"_num_osc",
"next_inactive_sodium",
"=",
"[",
"0.0",
"]",
"*",
"self",
".",
"_num_osc",
"next_active_potassium",
"=",
"[",
"0.0",
"]",
"*",
"self",
".",
"_num_osc",
"# Update states of oscillators\r",
"for",
"index",
"in",
"range",
"(",
"0",
",",
"self",
".",
"_num_osc",
",",
"1",
")",
":",
"result",
"=",
"odeint",
"(",
"self",
".",
"hnn_state",
",",
"[",
"self",
".",
"_membrane_potential",
"[",
"index",
"]",
",",
"self",
".",
"_active_cond_sodium",
"[",
"index",
"]",
",",
"self",
".",
"_inactive_cond_sodium",
"[",
"index",
"]",
",",
"self",
".",
"_active_cond_potassium",
"[",
"index",
"]",
"]",
",",
"numpy",
".",
"arange",
"(",
"t",
"-",
"step",
",",
"t",
",",
"int_step",
")",
",",
"(",
"index",
",",
")",
")",
"[",
"next_membrane",
"[",
"index",
"]",
",",
"next_active_sodium",
"[",
"index",
"]",
",",
"next_inactive_sodium",
"[",
"index",
"]",
",",
"next_active_potassium",
"[",
"index",
"]",
"]",
"=",
"result",
"[",
"len",
"(",
"result",
")",
"-",
"1",
"]",
"[",
"0",
":",
"4",
"]",
"next_cn_membrane",
"=",
"[",
"0.0",
",",
"0.0",
"]",
"next_cn_active_sodium",
"=",
"[",
"0.0",
",",
"0.0",
"]",
"next_cn_inactive_sodium",
"=",
"[",
"0.0",
",",
"0.0",
"]",
"next_cn_active_potassium",
"=",
"[",
"0.0",
",",
"0.0",
"]",
"# Update states of central elements\r",
"for",
"index",
"in",
"range",
"(",
"0",
",",
"len",
"(",
"self",
".",
"_central_element",
")",
")",
":",
"result",
"=",
"odeint",
"(",
"self",
".",
"hnn_state",
",",
"[",
"self",
".",
"_central_element",
"[",
"index",
"]",
".",
"membrane_potential",
",",
"self",
".",
"_central_element",
"[",
"index",
"]",
".",
"active_cond_sodium",
",",
"self",
".",
"_central_element",
"[",
"index",
"]",
".",
"inactive_cond_sodium",
",",
"self",
".",
"_central_element",
"[",
"index",
"]",
".",
"active_cond_potassium",
"]",
",",
"numpy",
".",
"arange",
"(",
"t",
"-",
"step",
",",
"t",
",",
"int_step",
")",
",",
"(",
"self",
".",
"_num_osc",
"+",
"index",
",",
")",
")",
"[",
"next_cn_membrane",
"[",
"index",
"]",
",",
"next_cn_active_sodium",
"[",
"index",
"]",
",",
"next_cn_inactive_sodium",
"[",
"index",
"]",
",",
"next_cn_active_potassium",
"[",
"index",
"]",
"]",
"=",
"result",
"[",
"len",
"(",
"result",
")",
"-",
"1",
"]",
"[",
"0",
":",
"4",
"]",
"# Noise generation\r",
"self",
".",
"_noise",
"=",
"[",
"1.0",
"+",
"0.01",
"*",
"(",
"random",
".",
"random",
"(",
")",
"*",
"2.0",
"-",
"1.0",
")",
"for",
"i",
"in",
"range",
"(",
"self",
".",
"_num_osc",
")",
"]",
"# Updating states of PNs\r",
"self",
".",
"__update_peripheral_neurons",
"(",
"t",
",",
"step",
",",
"next_membrane",
",",
"next_active_sodium",
",",
"next_inactive_sodium",
",",
"next_active_potassium",
")",
"# Updation states of CN\r",
"self",
".",
"__update_central_neurons",
"(",
"t",
",",
"next_cn_membrane",
",",
"next_cn_active_sodium",
",",
"next_cn_inactive_sodium",
",",
"next_cn_active_potassium",
")",
"return",
"(",
"next_membrane",
",",
"next_cn_membrane",
")"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
valid | hhn_network.__update_peripheral_neurons | !
@brief Update peripheral neurons in line with new values of current in channels.
@param[in] t (doubles): Current time of simulation.
@param[in] step (uint): Step (time duration) during simulation when states of oscillators should be calculated.
@param[in] next_membrane (list): New values of membrane potentials for peripheral neurons.
@Param[in] next_active_sodium (list): New values of activation conductances of the sodium channels for peripheral neurons.
@param[in] next_inactive_sodium (list): New values of inactivaton conductances of the sodium channels for peripheral neurons.
@param[in] next_active_potassium (list): New values of activation conductances of the potassium channel for peripheral neurons. | pyclustering/nnet/hhn.py | def __update_peripheral_neurons(self, t, step, next_membrane, next_active_sodium, next_inactive_sodium, next_active_potassium):
"""!
@brief Update peripheral neurons in line with new values of current in channels.
@param[in] t (doubles): Current time of simulation.
@param[in] step (uint): Step (time duration) during simulation when states of oscillators should be calculated.
@param[in] next_membrane (list): New values of membrane potentials for peripheral neurons.
@Param[in] next_active_sodium (list): New values of activation conductances of the sodium channels for peripheral neurons.
@param[in] next_inactive_sodium (list): New values of inactivaton conductances of the sodium channels for peripheral neurons.
@param[in] next_active_potassium (list): New values of activation conductances of the potassium channel for peripheral neurons.
"""
self._membrane_potential = next_membrane[:];
self._active_cond_sodium = next_active_sodium[:];
self._inactive_cond_sodium = next_inactive_sodium[:];
self._active_cond_potassium = next_active_potassium[:];
for index in range(0, self._num_osc):
if (self._pulse_generation[index] is False):
if (self._membrane_potential[index] >= 0.0):
self._pulse_generation[index] = True;
self._pulse_generation_time[index].append(t);
elif (self._membrane_potential[index] < 0.0):
self._pulse_generation[index] = False;
# Update connection from CN2 to PN
if (self._link_weight3[index] == 0.0):
if (self._membrane_potential[index] > self._params.threshold):
self._link_pulse_counter[index] += step;
if (self._link_pulse_counter[index] >= 1 / self._params.eps):
self._link_weight3[index] = self._params.w3;
self._link_activation_time[index] = t;
elif ( not ((self._link_activation_time[index] < t) and (t < self._link_activation_time[index] + self._params.deltah)) ):
self._link_weight3[index] = 0.0;
self._link_pulse_counter[index] = 0.0; | def __update_peripheral_neurons(self, t, step, next_membrane, next_active_sodium, next_inactive_sodium, next_active_potassium):
"""!
@brief Update peripheral neurons in line with new values of current in channels.
@param[in] t (doubles): Current time of simulation.
@param[in] step (uint): Step (time duration) during simulation when states of oscillators should be calculated.
@param[in] next_membrane (list): New values of membrane potentials for peripheral neurons.
@Param[in] next_active_sodium (list): New values of activation conductances of the sodium channels for peripheral neurons.
@param[in] next_inactive_sodium (list): New values of inactivaton conductances of the sodium channels for peripheral neurons.
@param[in] next_active_potassium (list): New values of activation conductances of the potassium channel for peripheral neurons.
"""
self._membrane_potential = next_membrane[:];
self._active_cond_sodium = next_active_sodium[:];
self._inactive_cond_sodium = next_inactive_sodium[:];
self._active_cond_potassium = next_active_potassium[:];
for index in range(0, self._num_osc):
if (self._pulse_generation[index] is False):
if (self._membrane_potential[index] >= 0.0):
self._pulse_generation[index] = True;
self._pulse_generation_time[index].append(t);
elif (self._membrane_potential[index] < 0.0):
self._pulse_generation[index] = False;
# Update connection from CN2 to PN
if (self._link_weight3[index] == 0.0):
if (self._membrane_potential[index] > self._params.threshold):
self._link_pulse_counter[index] += step;
if (self._link_pulse_counter[index] >= 1 / self._params.eps):
self._link_weight3[index] = self._params.w3;
self._link_activation_time[index] = t;
elif ( not ((self._link_activation_time[index] < t) and (t < self._link_activation_time[index] + self._params.deltah)) ):
self._link_weight3[index] = 0.0;
self._link_pulse_counter[index] = 0.0; | [
"!"
] | annoviko/pyclustering | python | https://github.com/annoviko/pyclustering/blob/98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0/pyclustering/nnet/hhn.py#L400-L436 | [
"def",
"__update_peripheral_neurons",
"(",
"self",
",",
"t",
",",
"step",
",",
"next_membrane",
",",
"next_active_sodium",
",",
"next_inactive_sodium",
",",
"next_active_potassium",
")",
":",
"self",
".",
"_membrane_potential",
"=",
"next_membrane",
"[",
":",
"]",
"self",
".",
"_active_cond_sodium",
"=",
"next_active_sodium",
"[",
":",
"]",
"self",
".",
"_inactive_cond_sodium",
"=",
"next_inactive_sodium",
"[",
":",
"]",
"self",
".",
"_active_cond_potassium",
"=",
"next_active_potassium",
"[",
":",
"]",
"for",
"index",
"in",
"range",
"(",
"0",
",",
"self",
".",
"_num_osc",
")",
":",
"if",
"(",
"self",
".",
"_pulse_generation",
"[",
"index",
"]",
"is",
"False",
")",
":",
"if",
"(",
"self",
".",
"_membrane_potential",
"[",
"index",
"]",
">=",
"0.0",
")",
":",
"self",
".",
"_pulse_generation",
"[",
"index",
"]",
"=",
"True",
"self",
".",
"_pulse_generation_time",
"[",
"index",
"]",
".",
"append",
"(",
"t",
")",
"elif",
"(",
"self",
".",
"_membrane_potential",
"[",
"index",
"]",
"<",
"0.0",
")",
":",
"self",
".",
"_pulse_generation",
"[",
"index",
"]",
"=",
"False",
"# Update connection from CN2 to PN\r",
"if",
"(",
"self",
".",
"_link_weight3",
"[",
"index",
"]",
"==",
"0.0",
")",
":",
"if",
"(",
"self",
".",
"_membrane_potential",
"[",
"index",
"]",
">",
"self",
".",
"_params",
".",
"threshold",
")",
":",
"self",
".",
"_link_pulse_counter",
"[",
"index",
"]",
"+=",
"step",
"if",
"(",
"self",
".",
"_link_pulse_counter",
"[",
"index",
"]",
">=",
"1",
"/",
"self",
".",
"_params",
".",
"eps",
")",
":",
"self",
".",
"_link_weight3",
"[",
"index",
"]",
"=",
"self",
".",
"_params",
".",
"w3",
"self",
".",
"_link_activation_time",
"[",
"index",
"]",
"=",
"t",
"elif",
"(",
"not",
"(",
"(",
"self",
".",
"_link_activation_time",
"[",
"index",
"]",
"<",
"t",
")",
"and",
"(",
"t",
"<",
"self",
".",
"_link_activation_time",
"[",
"index",
"]",
"+",
"self",
".",
"_params",
".",
"deltah",
")",
")",
")",
":",
"self",
".",
"_link_weight3",
"[",
"index",
"]",
"=",
"0.0",
"self",
".",
"_link_pulse_counter",
"[",
"index",
"]",
"=",
"0.0"
] | 98aa0dd89fd36f701668fb1eb29c8fb5662bf7d0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.