Oddhair fucked around with this message at 14:58 on May 10, 2011

def Update(grid):
    newgrid = zeros(grid.shape, dtype=int)
    for r in range(1,grid.shape[0]-3):
        for c in range(1,grid.shape[1]-3):
            neighborhood = ((r-1,c-1),(r-1,c),(r-1,c+1),(r,c-1),(r,c+1),(r+1,c-1),(r+1,c),(r+1,c+1))
            value = 0
            for i in neighborhood:
                if grid[i[0]][i[1]]:
                    value += 1
            if grid[r][c]:
                if value in S:
                    newgrid[r][c] = 1
            else:
                if value in B:
                    newgrid[r][c] = 1
    return newgrid

            for i in neighborhood:
                if grid[i[0]][i[1]]:
                    value += 1

fart simpson fucked around with this message at 19:28 on May 10, 2011

fart simpson fucked around with this message at 19:20 on May 11, 2011

VirtuaSpy fucked around with this message at 18:25 on May 15, 2011

function_name = 'push_widget'
function_parameters =     ['widget_name','distance','backwards']
function_param_optional = [False        ,False     ,True       ]
funtion_body = generic_handler

# do stuff that causes the equivalent of:
# def push_widget(widget_name, distance, backwards=None):
#     generic_handler(widget_name, distance, backwards)

Stabby McDamage fucked around with this message at 22:26 on May 16, 2011

#valid:
mygeneratedfunction(myfirstparam=a, mysecondparam=b)

#not valid:
mygeneratedfunction(a, b)

def generate_function(param_names, param_optional, body_function):
    def impl(**kwargs):
        num_used_params = 0
        params = []
        # Find the parameters we want to pass on in the order we want to pass them
        for param, optional in zip(param_names, param_optional):
            if param in kwargs:
                num_used_params += 1
                params.append(kwargs[param])
            elif optional:
                params.append(None)
            else:
                raise ValueError("Parameter {} is required".format(param))
                    
        # Make sure there weren't any we don't want
        if num_used_params != len(kwargs):
            invalid_params = [p for p in kwargs.keys() if p not in param_names]
            raise ValueError("The following parameters are invalid: {!s}".format(invalid_params))
            
        #Pass it on to the real implementation
        return body_function(*params)
    return impl

brosmike fucked around with this message at 23:27 on May 16, 2011

import re
_valid_re = re.compile('^[a-zA-Z_]+$')
def valid(*names):
        for name in names:
                if not _valid_re.match(name):
                        raise ValueError("%r is not a valid function or parameter name" % name)

def construct_function(name, parameters, optional, body):
        valid(name, *parameters)
        param_chunks_1 = []
        param_chunks_2 = []
        for param, param_optional in zip(parameters, optional):
                param_chunks_1.append(param)
                if param_optional:
                        param_chunks_2.append(param + "=None")
                else:
                        param_chunks_2.append(param)
        
        capture = {'function_body': body}
        source = "def %s(%s): function_body(%s)" % ( 
                name,
                ",".join(param_chunks_2),
                ",".join(param_chunks_1))
        exec source in capture
        return capture[name]

TOO SCSI FOR MY CAT fucked around with this message at 04:15 on May 17, 2011

Modern Pragmatist fucked around with this message at 16:39 on May 19, 2011