network - Code Metrics - Inspection of "[refactoring] ant_colony params [phase 2 - final]" - annoviko/pyclustering - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( a63a82...61f52c )

unknown

created 2016-04-12 15:26 UTC

network F

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	342
Duplicated Lines	0 %

Metric	Value
dl	0
loc	342
rs	1.5789
wmc	87

15 Methods

Rating	Name	Size	Complexity
C	__init__()	34	7
F	__create_list_bidir_connections()	25	9
B	__create_all_to_all_connections()	14	7
F	__create_grid_four_connections()	45	16
A	structure()	7	1
B	get_neighbors()	16	5
F	__create_grid_eight_connections()	44	14
A	__len__()	6	1
B	has_connection()	19	5
A	set_connection()	20	3
B	__create_none_connections()	10	5
C	_create_structure()	30	7
A	width()	9	1
A	height()	9	1
B	__create_dynamic_connection()	10	5

How to fix Complexity

"""!

@brief Neural and oscillatory network module. Consists of models of bio-inspired networks.

@authors Andrei Novikov ([email protected])
@date 2014-2016
@copyright GNU Public License

@cond GNU_PUBLIC_LICENSE
    PyClustering is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
    
    PyClustering is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
    
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
@endcond

"""

import math;

from enum import IntEnum;

class initial_type(IntEnum):
    """!
    @brief Enumerator of types of oscillator output initialization.
    
    """
    
    ## Output of oscillators are random in line with gaussian distribution.
    RANDOM_GAUSSIAN = 0;
    
    ## Output of oscillators are equidistant from each other (uniformly distributed, not randomly).
    EQUIPARTITION = 1;


class solve_type(IntEnum):
    """!
    @brief Enumerator of solver types that are used for network simulation.
    
    """
    
    ## Forward Euler first-order method.
    FAST = 0;                   # Usual calculation: x(k + 1) = x(k) + f(x(k)).
    
    ## Classic fourth-order Runge-Kutta method (fixed step).
    RK4 = 1;
    
    ## Runge-Kutta-Fehlberg method with order 4 and 5 (float step)."
    RKF45 = 2;


class conn_type(IntEnum):
    """!
    @brief Enumerator of connection types between oscillators.
    
    """
    
    ## No connection between oscillators.
    NONE = 0;
    
    ##All oscillators have connection with each other.
    ALL_TO_ALL = 1;
    
    ## Connections between oscillators represent grid where one oscillator can be connected with four neighbor oscillators: right, upper, left, lower.
    GRID_FOUR = 2;
    
    ## Connections between oscillators represent grid where one oscillator can be connected with eight neighbor oscillators: right, right-upper, upper, upper-left, left, left-lower, lower, lower-right.
    GRID_EIGHT = 3;
    
    ## Connections between oscillators represent bidirectional list.
    LIST_BIDIR = 4; 
    
    ## Connections are defined by user or by network during simulation.
    DYNAMIC = 5;


class conn_represent(IntEnum):
    """!
    @brief Enumerator of internal network connection representation between oscillators.
    
    """
    
    ## Each oscillator has list of his neighbors.
    LIST = 0;
    
    ## Connections are represented my matrix connection NxN, where N is number of oscillators.
    MATRIX = 1;    


class network:
    """!
    @brief Common network description that consists of information about oscillators and connection between them.
    
    """
    
    _num_osc = 0;
    
    __osc_conn = None;
    __conn_represent = None;
    __conn_type = None;
    
    __height = 0;
    __width = 0;
    
    
    @property
    def height(self):
        """!
        @brief Height of the network grid (that is defined by amout of oscillators in each column), this value is zero in case of non-grid structure.
        
        @note This property returns valid value only for network with grid structure.
        
        """
        return self.__height;
    

    @property
    def width(self):
        """!
        @brief Width of the network grid, this value is zero in case of non-grid structure.
        
        @note This property returns valid value only for network with grid structure.
        
        """
        return self.__width;


    @property
    def structure(self):
        """!
        @brief Type of network structure that is used for connecting oscillators.
        
        """        
        return self.__conn_type;
   
   
    def __init__(self, num_osc, type_conn = conn_type.ALL_TO_ALL, conn_represent = conn_represent.MATRIX, height = None, width = None):
        """!
        @brief Constructor of the network.
        
        @param[in] num_osc (uint): Number of oscillators in the network that defines size of the network.
        @param[in] type_conn (conn_type): Type of connections that are used in the network between oscillators.
        @param[in] conn_represent (conn_represent): Type of representation of connections.
        @param[in] height (uint): Number of oscillators in column of the network, this argument is used 
                    only for network with grid structure (GRID_FOUR, GRID_EIGHT), for other types this argument is ignored.
        @param[in] width (uint): Number of oscillotors in row of the network, this argument is used only 
                    for network with grid structure (GRID_FOUR, GRID_EIGHT), for other types this argument is ignored.
        
        """
        
        self._num_osc = num_osc;
        self.__conn_represent = conn_represent;
        self.__conn_type = type_conn;
        
        if ( (type_conn == conn_type.GRID_EIGHT) or (type_conn == conn_type.GRID_FOUR) ):
            if ( (height is not None) and (width is not None) ):
                self.__height = height;
                self.__width = width;
            else:
                side_size = self._num_osc ** (0.5);
                if (side_size - math.floor(side_size) > 0):
                    raise NameError('Invalid number of oscillators in the network in case of grid structure');
                
                self.__height = int(side_size);
                self.__width = self.__height;
        
            if (self.__height * self.__width != self._num_osc):
                raise NameError('Width (' + str(self.__width) + ') x Height (' + str(self.__height) + ') must be equal to Size (' + str(self._num_osc) + ') in case of grid structure');
        
        self._create_structure(type_conn);
    
    
    def __len__(self):
        """!
        @brief Returns size of the network that is defined by amount of oscillators.
        
        """
        return self._num_osc;
    
    
    def __create_all_to_all_connections(self):
        """!
        @brief Creates connections between all oscillators.
        
        """
        
        if (self.__conn_represent == conn_represent.MATRIX):
            for index in range(0, self._num_osc, 1):
                self.__osc_conn.append([True] * self._num_osc);
                self.__osc_conn[index][index] = False;    
        
        elif (self.__conn_represent == conn_represent.LIST):
            for index in range(0, self._num_osc, 1):
                self.__osc_conn.append([neigh for neigh in range(0, self._num_osc, 1) if index != neigh]); 
          
            
    def __create_grid_four_connections(self):
        """!
        @brief Creates network with connections that make up four grid structure.
        @details Each oscillator may be connected with four neighbors in line with 'grid' structure: right, upper, left, lower.
        
        """
        
        side_size = self.__width;
        if (self.__conn_represent == conn_represent.MATRIX):
            self.__osc_conn = [[0] * self._num_osc for index in range(0, self._num_osc, 1)];
        elif (self.__conn_represent == conn_represent.LIST):
            self.__osc_conn = [[] for index in range(0, self._num_osc, 1)];
        else:
            raise NameError("Unknown type of representation of connections");
        
        for index in range(0, self._num_osc, 1):
            upper_index = index - side_size;
            lower_index = index + side_size;
            left_index = index - 1;
            right_index = index + 1;
            
            node_row_index = math.ceil(index / side_size);
            if (upper_index >= 0):
                if (self.__conn_represent == conn_represent.MATRIX):
                    self.__osc_conn[index][upper_index] = True;
                else:
                    self.__osc_conn[index].append(upper_index);
            
            if (lower_index < self._num_osc):
                if (self.__conn_represent == conn_represent.MATRIX):
                    self.__osc_conn[index][lower_index] = True;
                else:
                    self.__osc_conn[index].append(lower_index);
            
            if ( (left_index >= 0) and (math.ceil(left_index / side_size) == node_row_index) ):
                if (self.__conn_represent == conn_represent.MATRIX):
                    self.__osc_conn[index][left_index] = True;
                else:
                    self.__osc_conn[index].append(left_index);
            
            if ( (right_index < self._num_osc) and (math.ceil(right_index / side_size) == node_row_index) ):
                if (self.__conn_represent == conn_represent.MATRIX):
                    self.__osc_conn[index][right_index] = True;
                else:
                    self.__osc_conn[index].append(right_index);  
    
    
    def __create_grid_eight_connections(self):
        """!
        @brief Creates network with connections that make up eight grid structure.
        @details Each oscillator may be connected with eight neighbors in line with grid structure: right, right-upper, upper, upper-left, left, left-lower, lower, lower-right.
        
        """
        
        self.__create_grid_four_connections();     # create connection with right, upper, left, lower.
        side_size = self.__width;
        
        for index in range(0, self._num_osc, 1):
            upper_left_index = index - side_size - 1;
            upper_right_index = index - side_size + 1;
            
            lower_left_index = index + side_size - 1;
            lower_right_index = index + side_size + 1;
            
            node_row_index = math.floor(index / side_size);
            upper_row_index = node_row_index - 1;
            lower_row_index = node_row_index + 1;
            
            if ( (upper_left_index >= 0) and (math.floor(upper_left_index / side_size) == upper_row_index) ):
                if (self.__conn_represent == conn_represent.MATRIX):
                    self.__osc_conn[index][upper_left_index] = True;
                else:
                    self.__osc_conn[index].append(upper_left_index);
            
            if ( (upper_right_index >= 0) and (math.floor(upper_right_index / side_size) == upper_row_index) ):
                if (self.__conn_represent == conn_represent.MATRIX):
                    self.__osc_conn[index][upper_right_index] = True;
                else:
                    self.__osc_conn[index].append(upper_right_index);
                
            if ( (lower_left_index < self._num_osc) and (math.floor(lower_left_index / side_size) == lower_row_index) ):
                if (self.__conn_represent == conn_represent.MATRIX):
                    self.__osc_conn[index][lower_left_index] = True;
                else:
                    self.__osc_conn[index].append(lower_left_index);
                
            if ( (lower_right_index < self._num_osc) and (math.floor(lower_right_index / side_size) == lower_row_index) ):
                if (self.__conn_represent == conn_represent.MATRIX):
                    self.__osc_conn[index][lower_right_index] = True;
                else:
                    self.__osc_conn[index].append(lower_right_index);     
    
    
    def __create_list_bidir_connections(self):
        """!
        @brief Creates network as bidirectional list.
        @details Each oscillator may be conneted with two neighbors in line with classical list structure: right, left.
        
        """
        
        if (self.__conn_represent == conn_represent.MATRIX):
            for index in range(0, self._num_osc, 1):
                self.__osc_conn.append([0] * self._num_osc);
                self.__osc_conn[index][index] = False;
                if (index > 0):
                    self.__osc_conn[index][index - 1] = True;
                    
                if (index < (self._num_osc - 1)):
                    self.__osc_conn[index][index + 1] = True;   
                    
        elif (self.__conn_represent == conn_represent.LIST):
            for index in range(self._num_osc):
                self.__osc_conn.append([]);
                if (index > 0):
                    self.__osc_conn[index].append(index - 1);
                
                if (index < (self._num_osc - 1)):
                    self.__osc_conn[index].append(index + 1);
    
    
    def __create_none_connections(self):
        """!
        @brief Creates network without connections.
        
        """
        if (self.__conn_represent == conn_represent.MATRIX):
            for index in range(0, self._num_osc, 1):
                self.__osc_conn.append([False] * self._num_osc);   
        elif (self.__conn_represent == conn_represent.LIST):
            self.__osc_conn = [[] for index in range(0, self._num_osc, 1)];

    
    def __create_dynamic_connection(self):
        """!
        @brief Prepare storage for dynamic connections.
        
        """   
        if (self.__conn_represent == conn_represent.MATRIX):
            for index in range(0, self._num_osc, 1):
                self.__osc_conn.append([False] * self._num_osc);   
        elif (self.__conn_represent == conn_represent.LIST):
            self.__osc_conn = [[] for index in range(0, self._num_osc, 1)];
        
    
    def _create_structure(self, type_conn = conn_type.ALL_TO_ALL):
        """!
        @brief Creates connection in line with representation of matrix connections [NunOsc x NumOsc].
        
        @param[in] type_conn (conn_type): Connection type (all-to-all, bidirectional list, grid structure, etc.) that is used by the network.
        
        """
        
        self.__osc_conn = list();
        
        if (type_conn == conn_type.NONE):
            self.__create_none_connections();
        
        elif (type_conn == conn_type.ALL_TO_ALL):
            self.__create_all_to_all_connections();
        
        elif (type_conn == conn_type.GRID_FOUR):
            self.__create_grid_four_connections();
            
        elif (type_conn == conn_type.GRID_EIGHT):
            self.__create_grid_eight_connections();
            
        elif (type_conn == conn_type.LIST_BIDIR):
            self.__create_list_bidir_connections();
        
        elif (type_conn == conn_type.DYNAMIC):
            self.__create_dynamic_connection();
        
        else:
            raise NameError('The unknown type of connections');
         
         
    def has_connection(self, i, j):
        """!
        @brief Returns True if there is connection between i and j oscillators and False - if connection doesn't exist.
        
        @param[in] i (uint): index of an oscillator in the network.
        @param[in] j (uint): index of an oscillator in the network.
        
        """
        if (self.__conn_represent == conn_represent.MATRIX):
            return (self.__osc_conn[i][j]);
        
        elif (self.__conn_represent == conn_represent.LIST):
            for neigh_index in range(0, len(self.__osc_conn[i]), 1):
                if (self.__osc_conn[i][neigh_index] == j):
                    return True;
            return False;
        
        else:
            raise NameError("Unknown type of representation of coupling");
    
    
    def set_connection(self, i, j):
        """!
        @brief Couples two specified oscillators in the network with dynamic connections.
        
        @param[in] i (uint): index of an oscillator that should be coupled with oscillator 'j' in the network.
        @param[in] j (uint): index of an oscillator that should be coupled with oscillator 'i' in the network.
        
        @note This method can be used only in case of DYNAMIC connections, otherwise it throws expection.
        
        """
        
        if (self.structure != conn_type.DYNAMIC):
            raise NameError("Connection between oscillators can be changed only in case of dynamic type.");
        
        if (self.__conn_represent == conn_represent.MATRIX):
            self.__osc_conn[i][j] = True;
            self.__osc_conn[j][i] = True;
        else:
            self.__osc_conn[i].append(j);
            self.__osc_conn[j].append(i); 
    
    
    def get_neighbors(self, index):
        """!
        @brief Finds neighbors of the oscillator with specified index.
        
        @param[in] index (uint): index of oscillator for which neighbors should be found in the network.
        
        @return (list) Indexes of neighbors of the specified oscillator.
        
        """
        
        if (self.__conn_represent == conn_represent.LIST):
            return self.__osc_conn[index];      # connections are represented by list.
        elif (self.__conn_represent == conn_represent.MATRIX):
            return [neigh_index for neigh_index in range(self._num_osc) if self.__osc_conn[index][neigh_index] == True];
        else:
            raise NameError("Unknown type of representation of connections");

1			"""!
2
3			@brief Neural and oscillatory network module. Consists of models of bio-inspired networks.
4
5			@authors Andrei Novikov ([email protected])
6			@date 2014-2016
7			@copyright GNU Public License
8
9			@cond GNU_PUBLIC_LICENSE
10			PyClustering is free software: you can redistribute it and/or modify
11			it under the terms of the GNU General Public License as published by
12			the Free Software Foundation, either version 3 of the License, or
13			(at your option) any later version.
14
15			PyClustering is distributed in the hope that it will be useful,
16			but WITHOUT ANY WARRANTY; without even the implied warranty of
17			MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18			GNU General Public License for more details.
19
20			You should have received a copy of the GNU General Public License
21			along with this program. If not, see <http://www.gnu.org/licenses/>.
22			@endcond
23
24			"""
25
26			import math;
27
28			from enum import IntEnum;
29
30			class initial_type(IntEnum):
31			"""!
32			@brief Enumerator of types of oscillator output initialization.
33
34			"""
35
36			## Output of oscillators are random in line with gaussian distribution.
37			RANDOM_GAUSSIAN = 0;
38
39			## Output of oscillators are equidistant from each other (uniformly distributed, not randomly).
40			EQUIPARTITION = 1;
41
42
43			class solve_type(IntEnum):
44			"""!
45			@brief Enumerator of solver types that are used for network simulation.
46
47			"""
48
49			## Forward Euler first-order method.
50			FAST = 0; # Usual calculation: x(k + 1) = x(k) + f(x(k)).
51
52			## Classic fourth-order Runge-Kutta method (fixed step).
53			RK4 = 1;
54
55			## Runge-Kutta-Fehlberg method with order 4 and 5 (float step)."
56			RKF45 = 2;
57
58
59			class conn_type(IntEnum):
60			"""!
61			@brief Enumerator of connection types between oscillators.
62
63			"""
64
65			## No connection between oscillators.
66			NONE = 0;
67
68			##All oscillators have connection with each other.
69			ALL_TO_ALL = 1;
70
71			## Connections between oscillators represent grid where one oscillator can be connected with four neighbor oscillators: right, upper, left, lower.
72			GRID_FOUR = 2;
73
74			## Connections between oscillators represent grid where one oscillator can be connected with eight neighbor oscillators: right, right-upper, upper, upper-left, left, left-lower, lower, lower-right.
75			GRID_EIGHT = 3;
76
77			## Connections between oscillators represent bidirectional list.
78			LIST_BIDIR = 4;
79
80			## Connections are defined by user or by network during simulation.
81			DYNAMIC = 5;
82
83
84			class conn_represent(IntEnum):
85			"""!
86			@brief Enumerator of internal network connection representation between oscillators.
87
88			"""
89
90			## Each oscillator has list of his neighbors.
91			LIST = 0;
92
93			## Connections are represented my matrix connection NxN, where N is number of oscillators.
94			MATRIX = 1;
95
96
97			class network:
98			"""!
99			@brief Common network description that consists of information about oscillators and connection between them.
100
101			"""
102
103			_num_osc = 0;
104
105			__osc_conn = None;
106			__conn_represent = None;
107			__conn_type = None;
108
109			__height = 0;
110			__width = 0;
111
112
113			@property
114			def height(self):
115			"""!
116			@brief Height of the network grid (that is defined by amout of oscillators in each column), this value is zero in case of non-grid structure.
117
118			@note This property returns valid value only for network with grid structure.
119
120			"""
121			return self.__height;
122
123
124			@property
125			def width(self):
126			"""!
127			@brief Width of the network grid, this value is zero in case of non-grid structure.
128
129			@note This property returns valid value only for network with grid structure.
130
131			"""
132			return self.__width;
133
134
135			@property
136			def structure(self):
137			"""!
138			@brief Type of network structure that is used for connecting oscillators.
139
140			"""
141			return self.__conn_type;
142
143
144			def __init__(self, num_osc, type_conn = conn_type.ALL_TO_ALL, conn_represent = conn_represent.MATRIX, height = None, width = None):
145			"""!
146			@brief Constructor of the network.
147
148			@param[in] num_osc (uint): Number of oscillators in the network that defines size of the network.
149			@param[in] type_conn (conn_type): Type of connections that are used in the network between oscillators.
150			@param[in] conn_represent (conn_represent): Type of representation of connections.
151			@param[in] height (uint): Number of oscillators in column of the network, this argument is used
152			only for network with grid structure (GRID_FOUR, GRID_EIGHT), for other types this argument is ignored.
153			@param[in] width (uint): Number of oscillotors in row of the network, this argument is used only
154			for network with grid structure (GRID_FOUR, GRID_EIGHT), for other types this argument is ignored.
155
156			"""
157
158			self._num_osc = num_osc;
159			self.__conn_represent = conn_represent;
160			self.__conn_type = type_conn;
161
162			if ( (type_conn == conn_type.GRID_EIGHT) or (type_conn == conn_type.GRID_FOUR) ):
163			if ( (height is not None) and (width is not None) ):
164			self.__height = height;
165			self.__width = width;
166			else:
167			side_size = self._num_osc ** (0.5);
168			if (side_size - math.floor(side_size) > 0):
169			raise NameError('Invalid number of oscillators in the network in case of grid structure');
170
171			self.__height = int(side_size);
172			self.__width = self.__height;
173
174			if (self.__height * self.__width != self._num_osc):
175			raise NameError('Width (' + str(self.__width) + ') x Height (' + str(self.__height) + ') must be equal to Size (' + str(self._num_osc) + ') in case of grid structure');
176
177			self._create_structure(type_conn);
178
179
180			def __len__(self):
181			"""!
182			@brief Returns size of the network that is defined by amount of oscillators.
183
184			"""
185			return self._num_osc;
186
187
188			def __create_all_to_all_connections(self):
189			"""!
190			@brief Creates connections between all oscillators.
191
192			"""
193
194			if (self.__conn_represent == conn_represent.MATRIX):
195			for index in range(0, self._num_osc, 1):
196			self.__osc_conn.append([True] * self._num_osc);
197			self.__osc_conn[index][index] = False;
198
199			elif (self.__conn_represent == conn_represent.LIST):
200			for index in range(0, self._num_osc, 1):
201			self.__osc_conn.append([neigh for neigh in range(0, self._num_osc, 1) if index != neigh]);
202
203
204			def __create_grid_four_connections(self):
205			"""!
206			@brief Creates network with connections that make up four grid structure.
207			@details Each oscillator may be connected with four neighbors in line with 'grid' structure: right, upper, left, lower.
208
209			"""
210
211			side_size = self.__width;
212			if (self.__conn_represent == conn_represent.MATRIX):
213			self.__osc_conn = [[0] * self._num_osc for index in range(0, self._num_osc, 1)];
214			elif (self.__conn_represent == conn_represent.LIST):
215			self.__osc_conn = [[] for index in range(0, self._num_osc, 1)];
216			else:
217			raise NameError("Unknown type of representation of connections");
218
219			for index in range(0, self._num_osc, 1):
220			upper_index = index - side_size;
221			lower_index = index + side_size;
222			left_index = index - 1;
223			right_index = index + 1;
224
225			node_row_index = math.ceil(index / side_size);
226			if (upper_index >= 0):
227			if (self.__conn_represent == conn_represent.MATRIX):
228			self.__osc_conn[index][upper_index] = True;
229			else:
230			self.__osc_conn[index].append(upper_index);
231
232			if (lower_index < self._num_osc):
233			if (self.__conn_represent == conn_represent.MATRIX):
234			self.__osc_conn[index][lower_index] = True;
235			else:
236			self.__osc_conn[index].append(lower_index);
237
238			if ( (left_index >= 0) and (math.ceil(left_index / side_size) == node_row_index) ):
239			if (self.__conn_represent == conn_represent.MATRIX):
240			self.__osc_conn[index][left_index] = True;
241			else:
242			self.__osc_conn[index].append(left_index);
243
244			if ( (right_index < self._num_osc) and (math.ceil(right_index / side_size) == node_row_index) ):
245			if (self.__conn_represent == conn_represent.MATRIX):
246			self.__osc_conn[index][right_index] = True;
247			else:
248			self.__osc_conn[index].append(right_index);
249
250
251			def __create_grid_eight_connections(self):
252			"""!
253			@brief Creates network with connections that make up eight grid structure.
254			@details Each oscillator may be connected with eight neighbors in line with grid structure: right, right-upper, upper, upper-left, left, left-lower, lower, lower-right.
255
256			"""
257
258			self.__create_grid_four_connections(); # create connection with right, upper, left, lower.
259			side_size = self.__width;
260
261			for index in range(0, self._num_osc, 1):
262			upper_left_index = index - side_size - 1;
263			upper_right_index = index - side_size + 1;
264
265			lower_left_index = index + side_size - 1;
266			lower_right_index = index + side_size + 1;
267
268			node_row_index = math.floor(index / side_size);
269			upper_row_index = node_row_index - 1;
270			lower_row_index = node_row_index + 1;
271
272			if ( (upper_left_index >= 0) and (math.floor(upper_left_index / side_size) == upper_row_index) ):
273			if (self.__conn_represent == conn_represent.MATRIX):
274			self.__osc_conn[index][upper_left_index] = True;
275			else:
276			self.__osc_conn[index].append(upper_left_index);
277
278			if ( (upper_right_index >= 0) and (math.floor(upper_right_index / side_size) == upper_row_index) ):
279			if (self.__conn_represent == conn_represent.MATRIX):
280			self.__osc_conn[index][upper_right_index] = True;
281			else:
282			self.__osc_conn[index].append(upper_right_index);
283
284			if ( (lower_left_index < self._num_osc) and (math.floor(lower_left_index / side_size) == lower_row_index) ):
285			if (self.__conn_represent == conn_represent.MATRIX):
286			self.__osc_conn[index][lower_left_index] = True;
287			else:
288			self.__osc_conn[index].append(lower_left_index);
289
290			if ( (lower_right_index < self._num_osc) and (math.floor(lower_right_index / side_size) == lower_row_index) ):
291			if (self.__conn_represent == conn_represent.MATRIX):
292			self.__osc_conn[index][lower_right_index] = True;
293			else:
294			self.__osc_conn[index].append(lower_right_index);
295
296
297			def __create_list_bidir_connections(self):
298			"""!
299			@brief Creates network as bidirectional list.
300			@details Each oscillator may be conneted with two neighbors in line with classical list structure: right, left.
301
302			"""
303
304			if (self.__conn_represent == conn_represent.MATRIX):
305			for index in range(0, self._num_osc, 1):
306			self.__osc_conn.append([0] * self._num_osc);
307			self.__osc_conn[index][index] = False;
308			if (index > 0):
309			self.__osc_conn[index][index - 1] = True;
310
311			if (index < (self._num_osc - 1)):
312			self.__osc_conn[index][index + 1] = True;
313
314			elif (self.__conn_represent == conn_represent.LIST):
315			for index in range(self._num_osc):
316			self.__osc_conn.append([]);
317			if (index > 0):
318			self.__osc_conn[index].append(index - 1);
319
320			if (index < (self._num_osc - 1)):
321			self.__osc_conn[index].append(index + 1);
322
323
324			def __create_none_connections(self):
325			"""!
326			@brief Creates network without connections.
327
328			"""
329			if (self.__conn_represent == conn_represent.MATRIX):
330			for index in range(0, self._num_osc, 1):
331			self.__osc_conn.append([False] * self._num_osc);
332			elif (self.__conn_represent == conn_represent.LIST):
333			self.__osc_conn = [[] for index in range(0, self._num_osc, 1)];
334
335
336			def __create_dynamic_connection(self):
337			"""!
338			@brief Prepare storage for dynamic connections.
339
340			"""
341			if (self.__conn_represent == conn_represent.MATRIX):
342			for index in range(0, self._num_osc, 1):
343			self.__osc_conn.append([False] * self._num_osc);
344			elif (self.__conn_represent == conn_represent.LIST):
345			self.__osc_conn = [[] for index in range(0, self._num_osc, 1)];
346
347
348			def _create_structure(self, type_conn = conn_type.ALL_TO_ALL):
349			"""!
350			@brief Creates connection in line with representation of matrix connections [NunOsc x NumOsc].
351
352			@param[in] type_conn (conn_type): Connection type (all-to-all, bidirectional list, grid structure, etc.) that is used by the network.
353
354			"""
355
356			self.__osc_conn = list();
357
358			if (type_conn == conn_type.NONE):
359			self.__create_none_connections();
360
361			elif (type_conn == conn_type.ALL_TO_ALL):
362			self.__create_all_to_all_connections();
363
364			elif (type_conn == conn_type.GRID_FOUR):
365			self.__create_grid_four_connections();
366
367			elif (type_conn == conn_type.GRID_EIGHT):
368			self.__create_grid_eight_connections();
369
370			elif (type_conn == conn_type.LIST_BIDIR):
371			self.__create_list_bidir_connections();
372
373			elif (type_conn == conn_type.DYNAMIC):
374			self.__create_dynamic_connection();
375
376			else:
377			raise NameError('The unknown type of connections');
378
379
380			def has_connection(self, i, j):
381			"""!
382			@brief Returns True if there is connection between i and j oscillators and False - if connection doesn't exist.
383
384			@param[in] i (uint): index of an oscillator in the network.
385			@param[in] j (uint): index of an oscillator in the network.
386
387			"""
388			if (self.__conn_represent == conn_represent.MATRIX):
389			return (self.__osc_conn[i][j]);
390
391			elif (self.__conn_represent == conn_represent.LIST):
392			for neigh_index in range(0, len(self.__osc_conn[i]), 1):
393			if (self.__osc_conn[i][neigh_index] == j):
394			return True;
395			return False;
396
397			else:
398			raise NameError("Unknown type of representation of coupling");
399
400
401			def set_connection(self, i, j):
402			"""!
403			@brief Couples two specified oscillators in the network with dynamic connections.
404
405			@param[in] i (uint): index of an oscillator that should be coupled with oscillator 'j' in the network.
406			@param[in] j (uint): index of an oscillator that should be coupled with oscillator 'i' in the network.
407
408			@note This method can be used only in case of DYNAMIC connections, otherwise it throws expection.
409
410			"""
411
412			if (self.structure != conn_type.DYNAMIC):
413			raise NameError("Connection between oscillators can be changed only in case of dynamic type.");
414
415			if (self.__conn_represent == conn_represent.MATRIX):
416			self.__osc_conn[i][j] = True;
417			self.__osc_conn[j][i] = True;
418			else:
419			self.__osc_conn[i].append(j);
420			self.__osc_conn[j].append(i);
421
422
423			def get_neighbors(self, index):
424			"""!
425			@brief Finds neighbors of the oscillator with specified index.
426
427			@param[in] index (uint): index of oscillator for which neighbors should be found in the network.
428
429			@return (list) Indexes of neighbors of the specified oscillator.
430
431			"""
432
433			if (self.__conn_represent == conn_represent.LIST):
434			return self.__osc_conn[index]; # connections are represented by list.
435			elif (self.__conn_represent == conn_represent.MATRIX):
436			return [neigh_index for neigh_index in range(self._num_osc) if self.__osc_conn[index][neigh_index] == True];
437			else:
438			raise NameError("Unknown type of representation of connections");

annoviko / pyclustering

Push — master ( a63a82...61f52c )

network F

Complexity

Size/Duplication

15 Methods

How to fix Complexity

Complex Class

Duplication Side-by-Side

Filter issues like