FlowEdge.__str__() - Code Metrics - Inspection of "Fix error with the min cut implementation" - chen0040/pyalgs - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 98f158...7fc1ac )

by Xianshun

created 2017-04-30 04:25 UTC

FlowEdge.str() A

↳ Parent: FlowEdge

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
c	0
b	0
f	0
dl	0
loc	2
rs	10

from pyalgs.algorithms.commons import util
from pyalgs.data_structures.commons.bag import Bag



class Graph(object):
    V = 0
    adjList = None

    def __init__(self, V):
        self.V = V
        self.adjList = [None] * V
        for v in range(V):
            self.adjList[v] = Bag()

    def vertex_count(self):
        return self.V

    def adj(self, v):
        return self.adjList[v].iterate()

    def add_edge(self, v, w):
        self.adjList[v].add(w)
        self.adjList[w].add(v)



class Digraph(object):
    V = 0
    adjList = None

    def __init__(self, V):
        self.V = V
        self.adjList = [None] * V
        for v in range(V):
            self.adjList[v] = Bag()

    def vertex_count(self):
        return self.V

    def adj(self, v):
        return self.adjList[v].iterate()

    def add_edge(self, v, w):
        self.adjList[v].add(w)

    def reverse(self):
        g = Digraph(self.V)
        for v in range(self.V):
            for w in self.adjList[v].iterate():
                g.add_edge(w, v)

        return g


class Edge(object):
    v = None
    w = None
    weight = 0

    def __init__(self, v=None, w=None, weight=None):
        if weight is None:
            weight = 0
        self.v = v
        self.w = w
        self.weight = weight

    def start(self):
        return self.v

    def end(self):
        return self.w

    def reverse(self):
        return Edge(self.w, self.v, self.weight)

    def either(self):
        return self.v

    def other(self, v):
        if self.v == v:
            return self.w
        elif self.w == v:
            return self.v
        else:
            raise ValueError('mismatched vertex detected')

    # use for python 2 comparison
    def __cmp__(self, other):
        return util.cmp(self.weight, other.weight)

    # user for python 3 comparison
    def __lt__(self, other):
        return util.less(self.weight, other.weight)

    # user for python 3 comparison
    def __gt__(self, other):
        return util.greater(self.weight, other.weight)

    def __str__(self):
        return str(self.v) + ' =(' + str(self.weight) + ')=> ' + str(self.w)


class EdgeWeightedGraph(object):
    adjList = None
    V = 0

    def __init__(self, vertex_count):
        self.V = vertex_count
        self.adjList = [None] * vertex_count
        for v in range(vertex_count):
            self.adjList[v] = Bag()

    def add_edge(self, edge):
        v = edge.either()
        w = edge.other(v)
        self.adjList[v].add(edge)
        self.adjList[w].add(edge)

    def adj(self, v):
        return self.adjList[v].iterate()

    def vertex_count(self):
        return self.V

    def edges(self):
        for v in range(self.V):
            for e in self.adj(v):
                if e.either() == v:
                    yield e

    def to_graph(self):
        g = Graph()

        for e in self.edges():
            g.add_edge(e.start(), e.end())
        return g

    def to_edge_weighted_digraph(self):
        g = DirectedEdgeWeightedGraph(self.V)

        for e in self.edges():
            g.add_edge(e)
            g.add_edge(e.reverse())
        return g


class DirectedEdgeWeightedGraph(object):
    adjList = None
    V = 0

    def __init__(self, vertex_count):
        self.V = vertex_count
        self.adjList = [None] * vertex_count
        for v in range(vertex_count):
            self.adjList[v] = Bag()

    def add_edge(self, edge):
        v = edge.start()
        self.adjList[v].add(edge)

    def adj(self, v):
        return self.adjList[v].iterate()

    def vertex_count(self):
        return self.V

    def edges(self):
        for v in range(self.V):
            for e in self.adj(v):
                yield e

    def to_graph(self):
        g = Graph()

        for e in self.edges():
            g.add_edge(e.start(), e.end())
        return g

    def to_digraph(self):
        g = Digraph(self.V)

        for e in self.edges():
            g.add_edge(e.start(), e.end())

        return g


class FlowEdge(object):
    v = 0
    w = 0
    capacity = 0
    flow = 0

    def __init__(self, v, w, capacity):
        self.v = v
        self.w = w
        self.capacity = capacity

    def residual_capacity_to(self, end_v):
        if self.w == end_v:
            return self.capacity - self.flow
        elif self.v == end_v:
            return self.flow
        else:
            raise ValueError('end point not belong to flow edge')

    def add_residual_flow_to(self, end_v, delta):
        if self.v == end_v:
            self.flow -= delta
        elif self.w == end_v:
            self.flow += delta
        else:
            raise ValueError('end point not belong to flow edge')

    def start(self):
        return self.v

    def end(self):
        return self.w

    def other(self, x):
        if x == self.v:
            return self.w
        else:
            return self.v

    def __str__(self):
        return str(self.v) + ' =(' + str(self.capacity) + ', ' + str(self.flow) + ')=> ' + str(self.w)


class FlowNetwork(object):

    V = None
    adjList = None

    def __init__(self, V):
        self.V = V
        self.adjList = [None] * V

        for v in range(self.V):
            self.adjList[v] = Bag()

    def adj(self, v):
        return self.adjList[v].iterate()

    def add_edge(self, edge):
        self.adjList[edge.start()].add(edge)
        self.adjList[edge.end()].add(edge)

    def vertex_count(self):
        return self.V

    def edges(self):
        for v in range(self.V):
            for e in self.adjList[v].iterate():
                if e.start() == v:
                    yield e




1		from pyalgs.algorithms.commons import util
2		from pyalgs.data_structures.commons.bag import Bag
3
4	View Code Duplication
		0 ignored issues – show Duplication introduced 2017-04-26 15:07 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
5		class Graph(object):
6		V = 0
7		adjList = None
8
9		def __init__(self, V):
10		self.V = V
11		self.adjList = [None] * V
12		for v in range(V):
13		self.adjList[v] = Bag()
14
15		def vertex_count(self):
16		return self.V
17
18		def adj(self, v):
19		return self.adjList[v].iterate()
20
21		def add_edge(self, v, w):
22		self.adjList[v].add(w)
23		self.adjList[w].add(v)
24
25	View Code Duplication
		0 ignored issues – show Duplication introduced 2017-04-26 15:07 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
26		class Digraph(object):
27		V = 0
28		adjList = None
29
30		def __init__(self, V):
31		self.V = V
32		self.adjList = [None] * V
33		for v in range(V):
34		self.adjList[v] = Bag()
35
36		def vertex_count(self):
37		return self.V
38
39		def adj(self, v):
40		return self.adjList[v].iterate()
41
42		def add_edge(self, v, w):
43		self.adjList[v].add(w)
44
45		def reverse(self):
46		g = Digraph(self.V)
47		for v in range(self.V):
48		for w in self.adjList[v].iterate():
49		g.add_edge(w, v)
50
51		return g
52
53
54		class Edge(object):
55		v = None
56		w = None
57		weight = 0
58
59		def __init__(self, v=None, w=None, weight=None):
60		if weight is None:
61		weight = 0
62		self.v = v
63		self.w = w
64		self.weight = weight
65
66		def start(self):
67		return self.v
68
69		def end(self):
70		return self.w
71
72		def reverse(self):
73		return Edge(self.w, self.v, self.weight)
74
75		def either(self):
76		return self.v
77
78		def other(self, v):
79		if self.v == v:
80		return self.w
81		elif self.w == v:
82		return self.v
83		else:
84		raise ValueError('mismatched vertex detected')
85
86		# use for python 2 comparison
87		def __cmp__(self, other):
88		return util.cmp(self.weight, other.weight)
89
90		# user for python 3 comparison
91		def __lt__(self, other):
92		return util.less(self.weight, other.weight)
93
94		# user for python 3 comparison
95		def __gt__(self, other):
96		return util.greater(self.weight, other.weight)
97
98		def __str__(self):
99		return str(self.v) + ' =(' + str(self.weight) + ')=> ' + str(self.w)
100
101
102		class EdgeWeightedGraph(object):
103		adjList = None
104		V = 0
105
106		def __init__(self, vertex_count):
107		self.V = vertex_count
108		self.adjList = [None] * vertex_count
109		for v in range(vertex_count):
110		self.adjList[v] = Bag()
111
112		def add_edge(self, edge):
113		v = edge.either()
114		w = edge.other(v)
115		self.adjList[v].add(edge)
116		self.adjList[w].add(edge)
117
118		def adj(self, v):
119		return self.adjList[v].iterate()
120
121		def vertex_count(self):
122		return self.V
123
124		def edges(self):
125		for v in range(self.V):
126		for e in self.adj(v):
127		if e.either() == v:
128		yield e
129
130		def to_graph(self):
131		g = Graph()
132
133		for e in self.edges():
134		g.add_edge(e.start(), e.end())
135		return g
136
137		def to_edge_weighted_digraph(self):
138		g = DirectedEdgeWeightedGraph(self.V)
139
140		for e in self.edges():
141		g.add_edge(e)
142		g.add_edge(e.reverse())
143		return g
144
145
146		class DirectedEdgeWeightedGraph(object):
147		adjList = None
148		V = 0
149
150		def __init__(self, vertex_count):
151		self.V = vertex_count
152		self.adjList = [None] * vertex_count
153		for v in range(vertex_count):
154		self.adjList[v] = Bag()
155
156		def add_edge(self, edge):
157		v = edge.start()
158		self.adjList[v].add(edge)
159
160		def adj(self, v):
161		return self.adjList[v].iterate()
162
163		def vertex_count(self):
164		return self.V
165
166		def edges(self):
167		for v in range(self.V):
168		for e in self.adj(v):
169		yield e
170
171		def to_graph(self):
172		g = Graph()
173
174		for e in self.edges():
175		g.add_edge(e.start(), e.end())
176		return g
177
178		def to_digraph(self):
179		g = Digraph(self.V)
180
181		for e in self.edges():
182		g.add_edge(e.start(), e.end())
183
184		return g
185
186
187		class FlowEdge(object):
188		v = 0
189		w = 0
190		capacity = 0
191		flow = 0
192
193		def __init__(self, v, w, capacity):
194		self.v = v
195		self.w = w
196		self.capacity = capacity
197
198		def residual_capacity_to(self, end_v):
199		if self.w == end_v:
200		return self.capacity - self.flow
201		elif self.v == end_v:
202		return self.flow
203		else:
204		raise ValueError('end point not belong to flow edge')
205
206		def add_residual_flow_to(self, end_v, delta):
207		if self.v == end_v:
208		self.flow -= delta
209		elif self.w == end_v:
210		self.flow += delta
211		else:
212		raise ValueError('end point not belong to flow edge')
213
214		def start(self):
215		return self.v
216
217		def end(self):
218		return self.w
219
220		def other(self, x):
221		if x == self.v:
222		return self.w
223		else:
224		return self.v
225
226		def __str__(self):
227		return str(self.v) + ' =(' + str(self.capacity) + ', ' + str(self.flow) + ')=> ' + str(self.w)
228
229
230		class FlowNetwork(object):
231
232		V = None
233		adjList = None
234
235		def __init__(self, V):
236		self.V = V
237		self.adjList = [None] * V
238
239		for v in range(self.V):
240		self.adjList[v] = Bag()
241
242		def adj(self, v):
243		return self.adjList[v].iterate()
244
245		def add_edge(self, edge):
246		self.adjList[edge.start()].add(edge)
247		self.adjList[edge.end()].add(edge)
248
249		def vertex_count(self):
250		return self.V
251
252		def edges(self):
253		for v in range(self.V):
254		for e in self.adjList[v].iterate():
255		if e.start() == v:
256		yield e
257
258
259

chen0040 / pyalgs

Push — master ( 98f158...7fc1ac )

FlowEdge.__str__() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

FlowEdge.str() A