I want to create the code to follow the edges backwards of graph to construct the subgraph from target graph(directed).
For better explanation, I drew an example.
First, randomly select the initial node from target graph.(colored green in example figure)
Then, I want to get "backwards" neighbor nodes set of initial node.(possible "backwards" neighbor nodes are encircled by red line)
Here is the code that extract subgraph from directed graph. In this subgraph constructiing process, neighbor nodes are taken according to the direction of the edges.
import networkx as nx
import numpy as np
import matplotlib.pyplot as plt
def RWS(G, r=0.5, S=4):
#initialize subgraph
Gk = nx.DiGraph()
#initialize nodes
Vk = []
#randomly select the initial node from G
vs = np.random.randint(0, G.size())
print(vs)
#add vs to Gk
Gk.add_node(vs)
Vk.append(vs)
while len(Vk) < S:
#get neighbor nodes set of Vk (step 4) (Also appending j just for the purpose of adding edge)
NS = [(n, j) for j in Vk for n in G.neighbors(j) if n not in Vk]
print("{} {} {} {}".format('length of NS is', len(NS), 'and vs =', vs))
# randomly select r of nodes in NS, add them into the Vk
if not len(NS) == 0:
for node, j in NS:
if np.random.uniform() < r:
Vk.append(node)
Gk.add_edge(j, node)
if len(Vk) == S or len(NS) < S:
break
else:
break
return Gk
if __name__ == '__main__':
# "Undirected" graph adjacency matrix
m = np.matrix([
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[1, 0, 0, 0, 0, 1, 0, 0, 0, 0],
[0, 1, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 1, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 1, 0, 1, 1, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 1, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 1, 0, 0]])
# G = nx.from_numpy_matrix(m, create_using=nx.MultiDiGraph())
G = nx.from_numpy_matrix(m, create_using=nx.DiGraph)
#expansion ratio
r = 0.5
#subgraph size
S = 4
Gk = RWS(G, r, S)
# VISUALIZATION
pos = nx.spring_layout(G)
nx.draw_networkx_nodes(G, pos)
nx.draw_networkx_nodes(G, pos, nodelist=list(Gk.nodes()), node_color='r')
nx.draw_networkx_labels(G, pos)
nx.draw_networkx_edges(G, pos, edge_color='b', width=0.5)
nx.draw_networkx_edges(G, pos, edgelist=list(Gk.edges()), edge_color='g', width=1, arrowstyle='->')
plt.axis('off')
plt.show()
Yes, you already understand that I want to do the opposite of this code, to get subgraph of the backwards neighbor nodes.
maybe this question of mine will be helpful for better understanding.
You can fix your algorithm with minimal modifications by
Running it with the reversed graph. You can reverse a graph with DiGraph.reverse. In your case, you could perform Gi = G.reverse() and use that instead of G in RWS;
Reversing the result, again with DiGraph.reverse.
A modified implementation of RWS could look like this:
def RWS(G, r=0.5, S=4):
#initialize subgraph
Gk = nx.DiGraph()
#initialize nodes
Vk = []
#randomly select the initial node from G
vs = np.random.randint(0, G.size())
print(vs)
#add vs to Gk
Gk.add_node(vs)
Vk.append(vs)
Gi = G.reverse() # reverse input graph so we can just follow the edges
while len(Vk) < S:
#get neighbor nodes set of Vk (step 4) (Also appending j just for the purpose of adding edge)
NS = [(n, j) for j in Vk for n in Gi.neighbors(j) if n not in Vk]
print("{} {} {} {}".format('length of NS is', len(NS), 'and vs =', vs))
# randomly select r of nodes in NS, add them into the Vk
if not len(NS) == 0:
for node, j in NS:
if np.random.uniform() < r:
Vk.append(node)
Gk.add_edge(j, node)
if len(Vk) == S or len(NS) < S:
break
else:
break
return Gk.reverse() # Reverse result
Related
I writing a Battleship game, however I'm not sure on how to change the 1 in the first players grid to a 0, so that the player can not see where the ship is.
import random
# formatt to access certain grid point print (grid_1[1][2])
grid_1 = [[0, 0, 0, 0],
[0, 0, 0, 0],
[0, 0, 0, 0],
[0, 0, 0, 0]]
row_random = random.randint(0,3)
column_random = random.randint(0,3)
ship_1 = grid_1[row_random][column_random] = 1
# creates a random spot in the grid where the ship will be
def Player_1():
for i in grid_1:
print (i)
#loops through grid so the output is in row and column form
x = int(input("Enter row:"))
y = int(input("Enter column:"))
co_ordinates_1 = (grid_1[x][y])
# user guses where the ship will be
if co_ordinates_1 == 1:
print("BATTLESHIP HIT")
elif co_ordinates_1 != 1:
print("You missed!")
# shows the user if they hit the target or not
Player_1()
You need to check if a value is equal to 1 (ship). Here is the code below
for i in grid_1:
row = i.copy()
for j in range(0, 4):
if row[j] == 1:
row[j] = 0
print(row)
This code loops through each item and checks if it equal to 1. If it is, then the value is set to 0. This should print out
[0, 0, 0, 0]
[0, 0, 0, 0]
[0, 0, 0, 0]
[0, 0, 0, 0]
Knight's tour problem described in the image here, with diagram.
A knight was initially located in a square labeled 1. It then proceeded to make a
series of moves, never re-visiting a square, and labeled the visited squares in
order. When the knight was finished, the labeled squares in each region of connected
squares had the same sum.
A short while later, many of the labels were erased. The remaining labels can be seen
above.
Complete the grid by re-entering the missing labels. The answer to this puzzle is
the sum of the squares of the largest label in each row of the completed grid, as in
the example.
[1]: E.g. the 14 and 33 are in different regions.
The picture explains it a lot more clearly, but in summary a Knight has gone around a 10 x 10 grid. The picture shows a 10 x 10 board that shows some positions in has been in, and at what point of its journey. You do not know which position the Knight started in, or how many movements it made.
The coloured groups on the board need to all sum to the same amount.
I’ve built a python solver, but it runs for ages - uses recursion. I’ve noted that the maximum sum of a group is 197, based on there being 100 squares and the smallest group is 2 adjacent squares.
My code at this link: https://pastebin.com/UMQn1HZa
import sys, numpy as np
fixedLocationsArray = [[ 12, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[ 0, 0, 0, 0, 0, 0, 5, 0, 23, 0],
[ 0, 0, 0, 0, 0, 0, 8, 0, 0, 0],
[ 0, 0, 0, 14, 0, 0, 0, 0, 0, 0],
[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[ 0, 2, 0, 0, 0, 0, 0, 0, 0, 0],
[ 0, 0, 0, 0, 20, 0, 0, 0, 0, 0],
[ 0, 0, 0, 0, 33, 0, 0, 0, 0, 0],
[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 28]]
groupsArray = [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 1, 0, 0, 0, 0,10, 0],
[0, 0, 0, 1, 0, 0, 0, 0,10, 0],
[0, 0, 1, 1, 1, 1, 9,10,10,10],
[2, 0, 1, 0, 0,11, 9, 9, 9, 9],
[2, 0, 0, 0,11,11,11,15,15, 9],
[2, 4, 4,14,11,12,12,15,15, 8],
[2, 3, 4,14,14,13,13,13,15, 8],
[2, 3, 5,14,16,16,16, 7, 7, 8],
[3, 3, 5, 6, 6, 6, 6, 6, 7, 8]]
'''
Solver
- Noted that the maximum sum of a group is 197 since the group of only 2 can have the 100 filled and then 97 on return
'''
class KnightsTour:
def __init__(self, width, height, fixedLocations, groupsArray):
self.w = width
self.h = height
self.fixedLocationsArray = fixedLocations
self.groupsArray = groupsArray
self.npfixedLocationsArray = np.array(fixedLocations)
self.npgroupsArray = np.array(groupsArray)
self.board = [] # Contains the solution
self.generate_board()
def generate_board(self):
"""
Creates a nested list to represent the game board
"""
for i in range(self.h):
self.board.append([0]*self.w)
def print_board(self): # Prints out the final board solution
print(" ")
print("------")
for elem in self.board:
print(elem)
print("------")
print(" ")
def generate_legal_moves(self, cur_pos, n):
"""
Generates a list of legal moves for the knight to take next
"""
possible_pos = []
move_offsets = [(1, 2), (1, -2), (-1, 2), (-1, -2),
(2, 1), (2, -1), (-2, 1), (-2, -1)]
locationOfNumberInFixed = [(ix,iy) for ix, row in enumerate(self.fixedLocationsArray) for iy, i in enumerate(row) if i == n+1]
groupsizeIsNotExcessive = self.groupsNotExcessiveSize(self.board, self.groupsArray)
for move in move_offsets:
new_x = cur_pos[0] + move[0]
new_y = cur_pos[1] + move[1]
new_pos = (new_x, new_y)
if groupsizeIsNotExcessive:
if locationOfNumberInFixed:
print(f"This number {n+1} exists in the fixed grid at {locationOfNumberInFixed[0]}")
if locationOfNumberInFixed[0] == new_pos:
print(f"Next position is {new_pos} and matches location in fixed")
possible_pos.append((new_x, new_y))
else:
continue
elif not locationOfNumberInFixed: # if the current index of move is not in table, then evaluate if it is a legal move
if (new_x >= self.h): # if it is out of height of the board, continue, don't app onto the list of possible moves
continue
elif (new_x < 0):
continue
elif (new_y >= self.w):
continue
elif (new_y < 0):
continue
else:
possible_pos.append((new_x, new_y))
else:
continue
print(f"The legal moves for index {n} are {possible_pos}")
print(f"The current board looks like:")
self.print_board()
return possible_pos
def sort_lonely_neighbors(self, to_visit, n):
"""
It is more efficient to visit the lonely neighbors first,
since these are at the edges of the chessboard and cannot
be reached easily if done later in the traversal
"""
neighbor_list = self.generate_legal_moves(to_visit, n)
empty_neighbours = []
for neighbor in neighbor_list:
np_value = self.board[neighbor[0]][neighbor[1]]
if np_value == 0:
empty_neighbours.append(neighbor)
scores = []
for empty in empty_neighbours:
score = [empty, 0]
moves = self.generate_legal_moves(empty, n)
for m in moves:
if self.board[m[0]][m[1]] == 0:
score[1] += 1
scores.append(score)
scores_sort = sorted(scores, key = lambda s: s[1])
sorted_neighbours = [s[0] for s in scores_sort]
return sorted_neighbours
def groupby_perID_and_sum(self, board, groups):
# Convert into numpy arrays
npboard = np.array(board)
npgroups = np.array(groups)
# Get argsort indices, to be used to sort a and b in the next steps
board_flattened = npboard.ravel()
groups_flattened = npgroups.ravel()
sidx = groups_flattened.argsort(kind='mergesort')
board_sorted = board_flattened[sidx]
groups_sorted = groups_flattened[sidx]
# Get the group limit indices (start, stop of groups)
cut_idx = np.flatnonzero(np.r_[True,groups_sorted[1:] != groups_sorted[:-1],True])
# Create cut indices for all unique IDs in b
n = groups_sorted[-1]+2
cut_idxe = np.full(n, cut_idx[-1], dtype=int)
insert_idx = groups_sorted[cut_idx[:-1]]
cut_idxe[insert_idx] = cut_idx[:-1]
cut_idxe = np.minimum.accumulate(cut_idxe[::-1])[::-1]
# Split input array with those start, stop ones
arrayGroups = [board_sorted[i:j] for i,j in zip(cut_idxe[:-1],cut_idxe[1:])]
arraySum = [np.sum(a) for a in arrayGroups]
sumsInListSame = arraySum.count(arraySum[0]) == len(arraySum)
return sumsInListSame
def groupsNotExcessiveSize(self, board, groups):
# Convert into numpy arrays
npboard = np.array(board)
npgroups = np.array(groups)
# Get argsort indices, to be used to sort a and b in the next steps
board_flattened = npboard.ravel()
groups_flattened = npgroups.ravel()
sidx = groups_flattened.argsort(kind='mergesort')
board_sorted = board_flattened[sidx]
groups_sorted = groups_flattened[sidx]
# Get the group limit indices (start, stop of groups)
cut_idx = np.flatnonzero(np.r_[True,groups_sorted[1:] != groups_sorted[:-1],True])
# Create cut indices for all unique IDs in b
n = groups_sorted[-1]+2
cut_idxe = np.full(n, cut_idx[-1], dtype=int)
insert_idx = groups_sorted[cut_idx[:-1]]
cut_idxe[insert_idx] = cut_idx[:-1]
cut_idxe = np.minimum.accumulate(cut_idxe[::-1])[::-1]
# Split input array with those start, stop ones
arrayGroups = [board_sorted[i:j] for i,j in zip(cut_idxe[:-1],cut_idxe[1:])]
arraySum = [np.sum(a) for a in arrayGroups]
print(arraySum)
# Check if either groups aren't too large
groupSizeNotExcessive = all(sum <= 197 for sum in arraySum)
return groupSizeNotExcessive
def tour(self, n, path, to_visit):
"""
Recursive definition of knights tour. Inputs are as follows:
n = current depth of search tree
path = current path taken
to_visit = node to visit, i.e. the coordinate
"""
self.board[to_visit[0]][to_visit[1]] = n # This writes the number on the grid
path.append(to_visit) #append the newest vertex to the current point
print(f"Added {n}")
print(f"For {n+1} visiting: ", to_visit)
if self.groupby_perID_and_sum(self.board, self.npgroupsArray): #if all areas sum
self.print_board()
print(path)
print("Done! All areas sum equal")
sys.exit(1)
else:
sorted_neighbours = self.sort_lonely_neighbors(to_visit, n)
for neighbor in sorted_neighbours:
self.tour(n+1, path, neighbor)
#If we exit this loop, all neighbours failed so we reset
self.board[to_visit[0]][to_visit[1]] = 0
try:
path.pop()
print("Going back to: ", path[-1])
except IndexError:
print("No path found")
sys.exit(1)
if __name__ == '__main__':
#Define the size of grid. We are currently solving for an 8x8 grid
kt0 = KnightsTour(10, 10, fixedLocationsArray, groupsArray)
kt0.tour(1, [], (3, 0))
# kt0.tour(1, [], (7, 0))
# kt0.tour(1, [], (7,2))
# kt0.tour(1, [], (6,3))
# kt0.tour(1, [], (4,3))
# kt0.tour(1, [], (3,2))
# startingPositions = [(3, 0), (7, 0), (7,2), (6,3), (4,3), (3,2)]
kt0.print_board()
Here are some observations that you could include to be able to stop more early in your backtracking.
First of all remember that for n steps the total sum in all areas can be computed with the formula n(n+1)/2. This number has to be divisible evenly into the groups i.e. it has to be divisible by 17 which is the amount of groups.
Furthermore if we look at the 12 we can conclude that the 11 and 13 must have been in the same area so we get a lower bound on the number for each area as 2+5+8+11+12+13=51.
And lastly we have groups of size two so the largest two step numbers must make up the total sum for one group.
Using those conditions we can calculate the remaining possible amount of steps with
# the total sum is divisible by 17:
# n*(n+1)/2 % 17 == 0
# the sum for each group is at least the predictable sum for
# the biggest given group 2+5+8+11+12+13=51:
# n*(n+1)/(2*17) >= 51
# since there are groups of two elements the sum of the biggest
# two numbers must be as least as big as the sum for each group
# n+n-1 >= n*(n+1)/(2*17)
[n for n in range(101) if n*(n+1)/2 % 17 == 0 and n*(n+1)/(2*17) >= 51 and n+n-1 >= n*(n+1)/(2*17)]
giving us
[50,51].
So the knight must have taken either 50 or 51 steps and the sum for each area must be either 75 or 78.
I can use the following English algorithm to find shortest paths using Dijkstra's Algorithm on paper:
Step 1: Assign permanent label and order to starting node
Step 2: Assign temporary labels to all nodes directly reached by starting node
Step 3: Select the lowest temporary label and make it permanent
Step 4: Assign an order to the node
Step 5: Update and assign temporary labels for nodes directly reached from the new permanent node
Step 6: Repeat steps 3, 4 & 5 until the destination node is made permanent
I have searched for a Python implementation and many are quite complex or use data structures I'm not familiar with. Eventually I found the one below. I have spent quite some time tracing it's execution in a Python visualizer, and I can get a sense of how it works but it has not yet clicked for me.
Could someone please explain how the code relates to the English algorithm? For example, how does the notion of "predecessors" relate to the "permanent labels" in the English version?
from math import inf
graph = {'a':{'b':10,'c':3},'b':{'c':1,'d':2},'c':{'b':4,'d':8,'e':2},'d':{'e':7},'e':{'d':9}}
def dijkstra(graph,start,goal):
shortest_distance = {}
predecessor = {}
unseenNodes = graph
infinity = inf
path = []
for node in unseenNodes:
shortest_distance[node] = infinity
shortest_distance[start] = 0
# Determine which is minimum node. What does that mean?
while unseenNodes:
minNode = None
for node in unseenNodes:
if minNode is None:
minNode = node
elif shortest_distance[node] < shortest_distance[minNode]:
minNode = node
for edge, weight in graph[minNode].items():
if weight + shortest_distance[minNode] < shortest_distance[edge]:
shortest_distance[edge] = weight + shortest_distance[minNode]
predecessor[edge] = minNode
unseenNodes.pop(minNode)
currentNode = goal
while currentNode != start:
try:
path.insert(0,currentNode)
currentNode = predecessor[currentNode]
except KeyError:
print('Path not reachable')
break
path.insert(0,start)
if shortest_distance[goal] != infinity:
print('Shortest distance is ' + str(shortest_distance[goal]))
print('And the path is ' + str(path))
dijkstra(graph, 'a', 'b')
Dijkstra’s algorithm same to prim’s algorithm for minimum spanning tree. Like Prim’s MST, we generate a shortest path tree with given source as root. We maintain two sets, one set contains vertices included in shortest path tree, other set includes vertices not yet included in shortest path tree. At every step of the algorithm, we find a vertex which is in the other set (set of not yet included) and has a minimum distance from the source.
import sys
class Graph():
def __init__(self, vertices):
self.V = vertices
self.graph = [[0 for column in range(vertices)]
for row in range(vertices)]
def printSolution(self, dist):
print("Vertex tDistance from Source")
for node in range(self.V):
print(node, "t", dist[node])
def minDistance(self, dist, sptSet):
min = sys.maxint
for v in range(self.V):
if dist[v] < min and sptSet[v] == False:
min = dist[v]
min_index = v
return min_index
def dijkstra(self, src):
dist = [sys.maxint] * self.V
dist[src] = 0
sptSet = [False] * self.V
for cout in range(self.V):
u = self.minDistance(dist, sptSet)
sptSet[u] = True
for v in range(self.V):
if self.graph[u][v] > 0 and sptSet[v] == False and \
dist[v] > dist[u] + self.graph[u][v]:
dist[v] = dist[u] + self.graph[u][v]
self.printSolution(dist)
g = Graph(9)
g.graph = [[0, 4, 0, 0, 0, 0, 0, 8, 0],
[4, 0, 8, 0, 0, 0, 0, 11, 0],
[0, 8, 0, 7, 0, 4, 0, 0, 2],
[0, 0, 7, 0, 9, 14, 0, 0, 0],
[0, 0, 0, 9, 0, 10, 0, 0, 0],
[0, 0, 4, 14, 10, 0, 2, 0, 0],
[0, 0, 0, 0, 0, 2, 0, 1, 6],
[8, 11, 0, 0, 0, 0, 1, 0, 7],
[0, 0, 2, 0, 0, 0, 6, 7, 0]]
g.dijkstra(0)
I don't want the answer, but I'm having trouble keeping track of the nodes. Meaning, say I have nodes 0, 1, 2, 3,4, 5, 6, 7, where 0 is start, and 7 is goal, I made an adjacency matrix like so:
[
[0, 3, 0, 0, 4, 0, 0, 0],
[3, 0, 0, 0, 5, 0, 8, 0],
[0, 0, 0, 4, 0, 5, 0, 0],
[0, 0, 4, 0, 0, 0, 0, 14],
[4, 5, 0, 0, 0, 2, 0, 0],
[0, 0, 5, 0, 2, 0, 4, 0],
[0, 8, 0, 5, 0, 4, 0, 0],
[0, 0, 0, 14, 0, 0, 0, 0]
]
if it's a 0, there is no link between the nodes, otherwise, if it's greater than 1, then the number is the weight of the edge between those nodes.
I'm having trouble identifying what the actual node would be, versus a path.
I can find the goal, but I wouldn't know how to show the path to the goal, and what the total weight would be?
EDIT:
Here is what I am trying to achieve (this will not work, but this is the general idea):
def dfs(graph, start, goal):
stack = []
visited = []
stack.append(graph[start])
visited.append(start)
while (len(stack) != 0):
current_node = stack.pop()
if current_node not in visited:
visited.append(current_node)
if current_node = goal:
return path
else:
for nodes in current_node:
if nodes not in visited:
stack.append(nodes)
if the edges were unweighed this would be easier, but I'm basically adding all neighbors of the current node as long as I haven't visited it to the stack, until I find the goal node, and then I want to return the path. but in this case I know it's broken because 1) I'm not sure how to check if it's the goal node, since I'm only storing the nodes neighbors, and 2) not checking for the full path.
Maintain a path variable to store the vertex as u encounter them. When u found end vertex, the path variable will have the path.
Find the pseudo code for reference. Pardon any minor mistake in the code
DFS (vertex start, vertex end, Graph G, list path):
if(start==end):
return TRUE
for vertex in adjacent(start):
if vertex not in path: # has not been traversed
path = path + [vertex]
a = DFS(vertex, end, G, path)
if a==TRUE: # end vertex was found
return TRUE
path.delete(vertex) # delete the vertex added,as its not in the path from start to end
Acc. to your code, when u found the goal vertex, the visited stack is contains the element in the path.
I hope it helped.
So I am having a strange problem in python. I am using the code below to create a plot of places where the object has been. Here is my code:
def GoForward(self, duration):
if (self.TowardsX - self.X == 0):
Myro.robot.motors(self.Speed, self.Speed)
Myro.wait(abs(duration))
Myro.robot.stop()
#get the amount of points forward
divisible = (int) (duration / self.Scale)
#add them to the direction
self.TowardsY += divisible
tempY = self.Y
for y in xrange(self.Y, divisible + tempY):
if (y % self.Scale == 0):
self.Plot[(int) (self.X)][y] = 1
return
#calc slope
slope = (self.TowardsY - self.Y) / (self.TowardsX - self.X)
tempX = self.X
tempY = self.Y
#go forward
#get the amount of points forward
divisible = duration / self.Scale
#add them to the direction
self.TowardsX += divisible
self.TowardsY += divisible
Xs = []
Ys = []
for x in xrange(self.X, tempX + divisible):
#find out if it is a plottable point
if (((slope * (x - self.X)) + self.Y) % self.Scale == 0.0):
Xs.append(x)
Ys.append((int)((slope * (x - self.X)) + self.Y))
#Plot the points
for i in xrange(0, len(Xs)):
for j in xrange(0, len(Ys)):
if (self.Plot[Xs[i]][Ys[j]] == 0):
self.Plot[Xs[i]][Ys[j]] = 1
self.X += divisible
self.Y += divisible
But, when I call GoForward(2) it fills five columns with ones, instead of the few points. Example:
[[0,0,0,0,1,1,0,0,0,0]
[0,0,0,0,1,1,0,0,0,0]
[0,0,0,0,1,1,0,0,0,0]
[0,0,0,0,1,1,0,0,0,0]
[0,0,0,0,1,1,0,0,0,0]
[0,0,0,0,1,1,0,0,0,0]
[0,0,0,0,1,1,0,0,0,0]
[0,0,0,0,1,1,0,0,0,0]
[0,0,0,0,1,1,0,0,0,0]
[0,0,0,0,1,1,0,0,0,0]]
Based off the parameter given to GoForward(n) it creates that many columns full of 0s... Why is this behavior happening? My code should not produce this effect, but I am inexperienced with python so is that why this is happening? Thanks in advance
EDIT
So I have changed the code for plotting the points to
for i in xrange(0, len(Xs)):
if (self.Plot[Xs[i]][Ys[i]] == 0):
self.Plot[Xs[i]][Ys[i]] = 1
Which will have the correct values, however it is still producing this strange behavior, and the problem lies in this code here.
EDIT 2
When I use the code:
self.Plot[3][3] = 1
It still produces an array of:
[[0, 0, 0, 1, 0, 0, 0, 0, 0, 0]
[0, 0, 0, 1, 0, 0, 0, 0, 0, 0]
[0, 0, 0, 1, 0, 0, 0, 0, 0, 0]
[0, 0, 0, 1, 0, 0, 0, 0, 0, 0]
[0, 0, 0, 1, 0, 0, 0, 0, 0, 0]
[0, 0, 0, 1, 0, 0, 0, 0, 0, 0]
[0, 0, 0, 1, 0, 0, 0, 0, 0, 0]
[0, 0, 0, 1, 0, 0, 0, 0, 0, 0]
[0, 0, 0, 1, 0, 0, 0, 0, 0, 0]
[0, 0, 0, 1, 0, 0, 0, 0, 0, 0]]
So to produce that grid you are showing you are printing self.Plot? And your saying this grid gets initialized to 0? What exactly is self.Plot? A list of lists and that's it? When you print self.Plot before running that loop does it print what you expect (which I assume should be all zeros)?
So if Xs and Ys are the points that should be 1 you could simplify the code to using one list of plottable points:
plottable_points = []
# for loop
plottable_points.append( (x, int((slope * (x - self.X)) + self.Y)) )
for x, y in plottable_points:
self.Plot[x][y] = 1
I'm not sure exactly how self.Plot is being initialized or used, but if you print things before and after each step you should be able to figure out where your logic is wrong.
Edit 1:
Extra little python tip:
for x, y in zip(Xs, Ys):
self.Plot[x][y] = 1
Does the same thing as my first code example does, but with your variables.
Edit 2:
The problem is actually with how you are initializing self.Plot. When you repeat a list like that, your outer list becomes a list of pointers...all pointing to the same object (in this case a list). So when you say self.Plot[3][3] = 1, you are actually setting that column in each row. Try initializing self.Plot with something like this (there may be a better way to do this, but I'm tired):
self.Plot = []
for col in range(height * multiplyBy):
self.Plot.append([0] * width * multiplyBy)
# or:
self.Plot = [ [0] * width * multiply for col in range(height * multiplyBy) ]
I would say that you should do a simple import (from future import division) before doing any more modifications. To me it seems the problem is the division. In Python 2.7 it returns you an integer.
Take a look at this:
>>> 4/3
1
>>> 4//3
1
But if you import the new division functionality...
>>> from __future__ import division
>>> 4/3
1.3333333333333333