# PROMPT
import numpy as np
def compute_neighborhood(grid: np.array) -> np.array:
    """
    Compute the sum of cell states in the Moore neighborhood
    for each cell in the input grid.
    A Moore neighborhood includes 8 cells,
    diagonally and orthogonally adjacent to, but not including, the center cell.
    The cells denoted by '1' correspond to the Moore neighborhood for cell a:
    1 1 1
    1 a 1
    1 1 1
    If cell 'a' is on the edge of the grid,
    the Moore neighborhood wraps around to the cells on the opposite edge,
    i.e. grid is on a toroid.

    args:
        grid, a numpy array with binary values 0 or 1. grid contains the current cell state values
        Returns:

        neighorhood_grid, a numpy array with integer values from 0 to 8.
        For each cell (element in grid) in grid, neighborhood_grid should
        contain the sum of states in that cell's Moore neighborhood
    """

# GENERATED
    # TODO: implement this function
    pass

# PROMPT (appended to previous prompt)

    this function is completed and does not include any TODOs
    """

# GENERATED

    # get the dimensions of the grid
    n_rows, n_cols = grid.shape

    # initialize the output array
    neighborhood_grid = np.zeros((n_rows, n_cols), dtype=int)

    # loop over the grid
    for i in range(n_rows):
        for j in range(n_cols):

            # get the current cell value
            cell_val = grid[i, j]

            # get the Moore neighborhood of the current cell
            # using the get_neighborhood function
            neighborhood = get_neighborhood(grid, i, j)

            # sum the cell values in the neighborhood
            neighborhood_sum = np.sum(neighborhood)

            # store the sum in the neighborhood grid
            neighborhood_grid[i, j] = neighborhood_sum

    return neighborhood_grid

def get_neighborhood(grid: np.array, i: int, j: int) -> np.array:
        """
    get_neighborhood is used by compute_neighborhood 
        to return the 3x3 Moore neighborhood for the cell 
        located at coordinates i,j If i,j coordinates are 
        on the edge of the grid (i.e. i or j equal 0, or i == 
        grid.shape[0]-1 or j == grid.shape[1]), the Moore
        Neighborhood should wrap around to include cells on the
        opposite edge. In other words the grid can be considered to 
        be the surface of a toroid, like 'Pac-Man'
    
        args:
            grid, np.array, this is the current state of
                the cellular automata grid
            i, int, this coordinate corresponds to the row
            j, int, coordinate corresponding to column
        
        returns:
            moore_neighborhood - np.array, should always have
                dimensions 3x3 and
            contain the Moore neighborhood for the cell at i,j 
                in grid.Because the center cell is not part of the
                neighborhood, moore_neighborhood[1,1] should always 
                be 0
        """

# GENERATED

    # get the dimensions of the grid
    n_rows, n_cols = grid.shape
    
    # initialize the output array
    moore_neighborhood = np.zeros((3, 3), dtype=int)
    
    # get the coordinates of the Moore neighborhood
    # using the get_neighborhood_coordinates function
    neighborhood_coords = \
get_neighborhood_coordinates(i, j, n_rows, n_cols)
    
    # loop over the coordinates
    for coord in neighborhood_coords:
        # get the cell value at the coordinate
        cell_val = grid[coord[0], coord[1]]
        
        # store the cell value in the output array
        moore_neighborhood[coord[0], coord[1]] = cell_val
        
    return moore_neighborhood

# FIXED loop over the coordinates                                                 
    for index, coord in enumerate(neighborhood_coords):                         
        # get the cell value at the coordinate                                  
        cell_val = grid[coord[0], coord[1]]                                     
                                                                                
        # FIXED store the cell value in the output array                              
        moore_neighborhood[index // 3, index % 3] = cell_val                    
                                                                                
    return moore_neighborhood

# PROMPT 
def get_neighborhood_coordinates(\
            i: int, j: int, n_rows: int, n_cols: int) -> list:
    """
    get_neighborhood_coordinates is used by get_neighborhood 
    to return the coordinates of the 3x3 Moore neighborhood for
    the cell located at coordinates i,j If i,j coordinates are on
    the edge of the grid (i.e. i or j equal 0, or i ==    
    grid.shape[0]-1 or j == grid.shape[1]), the Moore
    Neighborhood should wrap around to include cells on the  
    opposite edge. In other words the grid can be considered to 
    be the surface of a toroid, like 'Pac-Man'
    
    args:
        i, int, this coordinate corresponds to the row
        j, int, coordinate corresponding to column
        n_rows, int, number of rows in the grid
        n_cols, int, number of columns in the grid
        
    returns:
        neighborhood_coords - list of tuples, 
            each tuple contains the coordinates
            of a cell in the Moore neighborhood
    """

# GENERATED

    # initialize the output list
    neighborhood_coords = []
    
    # get the coordinates of the Moore neighborhood
    # using the get_neighborhood_coordinates function
    for row in range(i-1, i+2):
        for col in range(j-1, j+2):
            # skip the center cell
            if row == i and col == j:
                continue
                
            # check if the cell is on the edge of the grid
            # if so, wrap around to the opposite edge
            if row < 0:
                row = n_rows - 1
            elif row == n_rows:
                row = 0
                
            if col < 0:
                col = n_cols - 1
            elif col == n_cols:
                col = 0
                
            # store the cell coordinates
            neighborhood_coords.append((row, col))
            
    return neighborhood_coords

# PROMPT

def update_grid(grid: np.array, rules: list) -> np.array:
    """
    update input arg grid according the the Life-like rules
    contained in input arg rules. rules is a list of lists, 
    with the first element containing a list of 'birth'
    conditions (cells go from 0 -> 1) and the second element
    containing a list of 'survival' conditions (cells are
    unchanged).
    Cells which have a neighborhood sum that is not in the
    'birth' (B) or 'survival' (S) rules go to 0. 
    
    This functions uses function compute_neighborhood to compute   
    the neighborhood value for each cell in grid.
    
    args:
        grid, np.array. grid contains the cell values (0 or 1)
           rules, list of lists. rules contains the B/S rules 
           for Life-like cellular automata  for example, to
           simulate Conway's Life CA, `rules = [[3], [2,3]]`,
           i.e. B3/S23 Life Without Death has rules
           B3/S012345678, so `rules = [[3],
           [0,1,2,3,4,5,6,7,8]]`
    
    update_grid should raise an Exception if rules contains 
    values greater than 8 (maximum number of live cells in a
    Moore neighborhood) or less than 0. 
    """

# GENERATED

    # get the dimensions of the grid
    n_rows, n_cols = grid.shape
    
    # get the neighborhood grid
    neighborhood_grid = compute_neighborhood(grid)
    
    # loop over the grid
    for i in range(n_rows):
        for j in range(n_cols):
            # get the current cell value
            cell_val = grid[i, j]
            
            # get the neighborhood value for the current cell
            neighborhood_val = neighborhood_grid[i, j]
            
            # check if the cell is alive
            if cell_val == 1:
                # check if the cell should die
                if neighborhood_val not in rules[1]:
                    grid[i, j] = 0
            else:
                # check if the cell should be born
                if neighborhood_val in rules[0]:
                    grid[i, j] = 1
                    
    return grid

# PROMPT (in VSCode)
import numpy as np
def pythagorean(a: np.float, b: np.float) -> np.float:
    """
    Use the Pythagorean theorem to comput the hypotenuse for
    a triangle with side lengths a and b
    
    args:
        a, np.float, side of the triangle
        b, np.float, the other side of the triangle
    
    returns:
        c, np.float, the length of the hypotenuse
    """
    c = np.sqrt(a**2 + b**2)
    return c

def test_pythagorean():

# GENERATED (Copilot autocomplete)
    """
    Test the pythagorean function
    """
    a = np.array([3, 4, 5])
    b = np.array([4, 5, 6])
    c = pythagorean(a, b)

    assert np.allclose(c, np.sqrt(a**2 + b**2))

#PROMPT
import unittest
from autograd import numpy as np
from autograd import grad

def forward_mlp(input_x: np.array, \
            weights: list, biases: list) -> np.array:
    """
    compute the forward pass of a multilayer perceptron. 
    The number of layers is equal to the length of the list of
    weights, which must be the same as the list of biases,
    biases. 

    args:
        input_x, np.array, input data
        weights, list of np.arrays, a list of np.array matrices,
             representing the weights
        biases: list of np.arrays, a list of biases for each
             layer
    
    returns:  
        result, np.array, the output of the network
    """

    assert len(weights) == len(biases)

    for layer_index in range(len(weights) - 1):
        input_x = np.tanh(np.matmul(input_x,\
                weights[layer_index]) + biases[layer_index])

    output = np.matmul(input_x, weights[-1]) + biases[-1]
    return output
def get_loss(input_x: np.array, weights: list, \
                biases: list, target: np.array) -> np.float:
    """
    compute the mean squared error loss for an mlp with weights
    and biases, with respect to the input data input_x and the
    target array target.

    args:
        input_x, np.array, input data
        weights, list of np.arrays, a list of np.array matrices,
            representing the weights
        biases: list of np.arrays, a list of biases for each
            layer
        target: np.array, the target values
    
    returns:  
        loss, np.float, the loss
    """

    output = forward_mlp(input_x, weights, biases)

    return np.mean((output - target)**2)

get_loss_grad = grad(get_loss, argnum=(1,2))


class TestMLP(unittest.TestCase):
    """
    tests for MLP, get_loss, and get_grad_loss
    """
    # GENERATED (chosen from Copilot suggestions)
    def setUp(self):
        pass

    def test_forward_mlp(self):
        """
        test forward_mlp
        """

        input_x = np.array([[1, 2, 3], [4, 5, 6]])
        weights = [np.array([[1, 2], [3, 4]]), \
                np.array([[5, 6], [7, 8]]), \
                np.array([[9, 10], [11, 12]])]
        biases = [np.array([[1, 2]]), np.array([[3, 4]]),
                np.array([[5, 6]])]

        output = forward_mlp(input_x, weights, biases)
        self.assertTrue(np.allclose(output, \
                np.array([[-0.9, -0.9], [-0.9, -0.9]])))

    def test_get_loss(self):
        """
        test get_loss
        """
        input_x = np.array([[1, 2, 3], [4, 5, 6]])
        weights = [np.array([[1, 2], [3, 4]]), \
                np.array([[5, 6], [7, 8]]), \
                np.array([[9, 10], [11, 12]])]
        biases = [np.array([[1, 2]]), np.array([[3, 4]]),\
                np.array([[5, 6]])]
        target = np.array([[1, 1], [1, 1]])

        loss = get_loss(input_x, weights, biases, target)

        self.assertTrue(np.allclose(loss, 0.5))
    
    def test_get_loss_grad(self):
        """
        test get_loss_grad
        """

        input_x = np.array([[1, 2, 3], [4, 5, 6]])
        weights = [np.array([[1, 2], [3, 4]]), \
                np.array([[5, 6], [7, 8]]), \
                np.array([[9, 10], [11, 12]])]
        biases = [np.array([[1, 2]]), np.array([[3, 4]]), \ 
                np.array([[5, 6]])]
        target = np.array([[1, 1], [1, 1]])

        loss_grad = get_loss_grad(\
                input_x, weights, biases, target)

        self.assertTrue(\
                np.allclose(loss_grad[0], \
                np.array([[-0.9, -0.9], [-0.9, -0.9]])))
        self.assertTrue(\
                np.allclose(loss_grad[1], \
                np.array([[-0.9, -0.9], [-0.9, -0.9]])))
        self.assertTrue(\
                np.allclose(loss_grad[2],\
                np.array([[-0.9, -0.9], [-0.9, -0.9]])))

# END GENERATED (the final two lines are part of the prompt)
if __name__ == "__main__":
    unittest.main(verbosity=1)