Example #1
0
    def x_bounds(self):

        model = self.model

        states = model.symbols_s['states']
        parameters = model.parameters
        from dolo.compiler.function_compiler import compile_multiargument_function

        [lower_bounds_symbolic, upper_bounds_symbolic] = self.model.get_complementarities()['arbitrage']
        lb = compile_multiargument_function( lower_bounds_symbolic, [states], ['s'], parameters, fname='lb')
        ub = compile_multiargument_function( upper_bounds_symbolic, [states], ['s'], parameters, fname='ub' )

        return [lb,ub]
Example #2
0
    def x_bounds(self):

        model = self.model

        states = model.symbols_s['states']
        parameters = model.parameters
        from dolo.compiler.function_compiler import compile_multiargument_function

        [lower_bounds_symbolic, upper_bounds_symbolic
         ] = self.model.get_complementarities()['arbitrage']
        lb = compile_multiargument_function(lower_bounds_symbolic, [states],
                                            ['s'],
                                            parameters,
                                            fname='lb')
        ub = compile_multiargument_function(upper_bounds_symbolic, [states],
                                            ['s'],
                                            parameters,
                                            fname='ub')

        return [lb, ub]
Example #3
0
    def __create_functions__(self, compiler, order='rows'):
        recipe = self.recipe

        model = self.model
        parms = model.symbols_s['parameters']

        if compiler == 'numexpr':
            from dolo.compiler.function_compiler_numexpr import compile_multiargument_function
        elif compiler == 'theano':
            from dolo.compiler.function_compiler_theano import compile_multiargument_function
        elif compiler == 'numba':
            from dolo.compiler.function_compiler_numba import compile_multiargument_function
        elif compiler == 'numba_gpu':
            from dolo.compiler.function_compiler_numba_gpu import compile_multiargument_function
        else:
            from dolo.compiler.function_compiler import compile_multiargument_function


        functions = {}

        for eqg in self.model.equations_groups:
            args = []
            is_a_definition = 'definition' in recipe['equation_type'][eqg]
            if is_a_definition:
                arg_specs = recipe['equation_type'][eqg]['rhs']
            else:
                arg_specs = recipe['equation_type'][eqg]
            arg_names = []
            for syms in arg_specs:
                [sgn,time] = syms
                if syms[0] == 'shocks':
                    args.append( [ s(time) for s in model.symbols_s['shocks'] ] )
                else:
                    args.append( [ s(time) for s in model.symbols_s[sgn] ] )
                if time == 1:
                    stime = '_f'
                elif time == -1:
                    stime = '_p'
                else:
                    stime = ''
                arg_names.append( sgn + stime)

            equations = self.model.equations_groups[eqg]

            if is_a_definition:
                from dolo.compiler.common import solve_recursive_block
                equations = solve_recursive_block(equations)
                equations = [eq.rhs for eq in equations]
            else:
                equations = [eq.gap for eq in equations]


            functions[eqg] = compile_multiargument_function(equations, args, arg_names, parms, fname = eqg, order=order)


        self.__update_calibration__()

        from collections import OrderedDict
        l =  [ (vg, [str(s) for s in model.symbols_s[vg]] ) for vg in (recipe['variable_type'] + ['shocks','parameters']) ]
        symbols = OrderedDict( l )

        self.symbols = symbols
        self.functions = functions
Example #4
0
    def __create_functions__(self, compiler, order='rows'):
        recipe = self.recipe

        model = self.model
        parms = model.symbols_s['parameters']

        if compiler == 'numexpr':
            from dolo.compiler.function_compiler_numexpr import compile_multiargument_function
        elif compiler == 'theano':
            from dolo.compiler.function_compiler_theano import compile_multiargument_function
        elif compiler == 'numba':
            from dolo.compiler.function_compiler_numba import compile_multiargument_function
        elif compiler == 'numba_gpu':
            from dolo.compiler.function_compiler_numba_gpu import compile_multiargument_function
        else:
            from dolo.compiler.function_compiler import compile_multiargument_function

        functions = {}

        for eqg in self.model.equations_groups:
            args = []
            is_a_definition = 'definition' in recipe['equation_type'][eqg]
            if is_a_definition:
                arg_specs = recipe['equation_type'][eqg]['rhs']
            else:
                arg_specs = recipe['equation_type'][eqg]
            arg_names = []
            for syms in arg_specs:
                [sgn, time] = syms
                if syms[0] == 'shocks':
                    args.append([s(time) for s in model.symbols_s['shocks']])
                else:
                    args.append([s(time) for s in model.symbols_s[sgn]])
                if time == 1:
                    stime = '_f'
                elif time == -1:
                    stime = '_p'
                else:
                    stime = ''
                arg_names.append(sgn + stime)

            equations = self.model.equations_groups[eqg]

            if is_a_definition:
                from dolo.compiler.common import solve_recursive_block
                equations = solve_recursive_block(equations)
                equations = [eq.rhs for eq in equations]
            else:
                equations = [eq.gap for eq in equations]

            functions[eqg] = compile_multiargument_function(equations,
                                                            args,
                                                            arg_names,
                                                            parms,
                                                            fname=eqg,
                                                            order=order)

        self.__update_calibration__()

        from collections import OrderedDict
        l = [(vg, [str(s) for s in model.symbols_s[vg]])
             for vg in (recipe['variable_type'] + ['shocks', 'parameters'])]
        symbols = OrderedDict(l)

        self.symbols = symbols
        self.functions = functions
Example #5
0
    def __create_functions__(self, compiler):
        recipe = self.recipe

        model = self.model
        parms = model['parameters_ordering']

        functions = {}

        for eqg in self.model['equations_groups']:
            args = []
            is_a_definition = 'definition' in recipe['equation_type'][eqg]
            if is_a_definition:
                arg_specs = recipe['equation_type'][eqg]['rhs']
            else:
                arg_specs = recipe['equation_type'][eqg]
            arg_names = []
            for syms in arg_specs:
                [sgn,time] = syms
                if syms[0] == 'shocks':
                    args.append( [ s(time) for s in model['shocks_ordering'] ] )
                else:
                    args.append( [ s(time) for s in model['variables_groups'][sgn] ] )
                if time == 1:
                    stime = '_f'
                elif time == -1:
                    stime = '_p'
                else:
                    stime = ''
                arg_names.append( sgn + stime)

            equations = self.model['equations_groups'][eqg]

            if is_a_definition:
                from dolo.compiler.common import solve_recursive_block
                equations = solve_recursive_block(equations)
                equations = [eq.rhs for eq in equations]
            else:
                equations = [eq.gap for eq in equations]

            if compiler == 'numexpr':
                from dolo.compiler.function_compiler_numexpr import compile_multiargument_function
            elif compiler == 'theano':
                from dolo.compiler.function_compiler_theano import compile_multiargument_function
            else:
                from dolo.compiler.function_compiler import compile_multiargument_function

            functions[eqg] = compile_multiargument_function(equations, args, arg_names, parms, fname = eqg)


        calibration = model.calibration

        import numpy
        from collections import OrderedDict
        for k,v in calibration.iteritems():
            if isinstance(v, OrderedDict):
                for l in v:
                    v[l] = numpy.array(v[l], dtype=numpy.double)
            else:
                calibration[k] = numpy.array(calibration[k], dtype=numpy.double)

        symbols = {}
        for vn, vg in model['variables_groups'].iteritems():
            symbols[vn] = [str(v) for v in vg]
        symbols['shocks'] = [str(v) for v in model.shocks]
        symbols['parameters'] = [str(v) for v in model.parameters]

        self.calibration = calibration
        self.symbols = symbols
        self.functions = functions