Ejemplo n.º 1
0
def solver(fobj, x0, lb=None, ub=None, options={}, method="lmmcp", jac="default", verbose=False):

    in_shape = x0.shape

    ffobj = lambda x: fobj(x.reshape(in_shape)).flatten()

    if not isinstance(jac, str):
        pp = np.prod(in_shape)

        def Dffobj(t):
            tt = t.reshape(in_shape)
            dval = jac(tt)
            return dval.reshape((pp, pp))

    elif jac == "precise":
        from numdifftools import Jacobian

        Dffobj = Jacobian(ffobj)
    else:
        Dffobj = MyJacobian(ffobj)

    if method == "fsolve":
        import scipy.optimize as optimize

        factor = options.get("factor")
        factor = factor if factor else 1
        [sol, infodict, ier, msg] = optimize.fsolve(
            ffobj, x0.flatten(), fprime=Dffobj, factor=factor, full_output=True, xtol=1e-10, epsfcn=1e-9
        )
        if ier != 1:
            print msg
    elif method == "anderson":
        import scipy.optimize as optimize

        sol = optimize.anderson(ffobj, x0.flatten())
    elif method == "newton_krylov":
        import scipy.optimize as optimize

        sol = optimize.newton_krylov(ffobj, x0.flatten())
    elif method == "lmmcp":
        from dolo.numeric.extern.lmmcp import lmmcp, Big

        if lb == None:
            lb = -Big * np.ones(len(x0.flatten()))
        else:
            lb = lb.flatten()
        if ub == None:
            ub = Big * np.ones(len(x0.flatten()))
        else:
            ub = ub.flatten()

        sol = lmmcp(ffobj, Dffobj, x0.flatten(), lb, ub, verbose=verbose, options=options)

    return sol.reshape(in_shape)
Ejemplo n.º 2
0
    def test_josephy(self):

        from dolo.numeric.extern import lmmcp

        x0=np.array( [1.25, 0.00, 0.00, 0.50] )
        lb=np.array( [0.00, 0.00, 0.00, 0.00] )
        ub=np.array( [1e20, 1e20, 1e20, 1e20] )

        resp = lmmcp.lmmcp(josephy, Djosephy, x0, lb, ub)

        sol = np.array([1.224746243, -0.0000, 0.0000, 0.5000])

        assert( abs(sol - resp).max()<1e-6 )
Ejemplo n.º 3
0
def solve_lcp(q, J, lb, x0, options={}, verbose=True):
    def fun(x):
        res = q + J @ x
        return res

    #
    def dfun(x):
        return J

    ub = numpy.zeros_like(lb) + numpy.inf

    opts = {'preprocess': True, 'eps2': 1e-10, 'presteps': 40}

    opts.update(options)

    from dolo.numeric.extern.lmmcp import lmmcp
    res = lmmcp(fun, dfun, x0, lb, ub, verbose=verbose, options=opts)

    return res
Ejemplo n.º 4
0
    def solve(self,
              verbose=False,
              jacs=None,
              linear=True,
              init_guess={},
              return_problem=False,
              solver_options={},
              xb0=0.1):

        if linear:

            model = self
            import numpy

            if jacs is None:
                constants, mat, lb = self.compute_jacobian()
            else:
                constants, mat, lb = jacs

            J = -numpy.array(mat).astype(dtype=float)
            q = numpy.array(constants).astype(dtype=float).flatten()
            lb = numpy.array(lb).astype(dtype=float).flatten()

            lb[lb < -1000] = -numpy.inf
            x0 = q * 0 + xb0
            ub = numpy.zeros_like(lb) + numpy.inf

            if return_problem:
                return {"q": q, "J": J, "x0": x0, "lb": lb, "ub": ub}

            res = solve_lcp(q,
                            J,
                            lb,
                            x0,
                            options=solver_options,
                            verbose=verbose)

            from collections import OrderedDict
            return OrderedDict(zip(map(str, model.full_variables), res))
        else:

            model = self
            import numpy

            constants, mat, lb = self.compute_jacobian(
                values=init_guess)  # warmup
            lb[lb < -1000] = -numpy.inf
            v = numpy.array(constants).astype(dtype=float).flatten()
            if len(init_guess) > 0:
                x0 = numpy.array([init_guess[s] for s in self.full_variables])
            else:
                x0 = v * 0 + 0.1
            ub = numpy.zeros_like(lb) + numpy.inf

            def resid(x):
                vals = {self.full_variables[i]: x[i] for i in range(len(x))}

                constants, mat, trash = self.compute_jacobian(values=vals)
                mm = numpy.array(mat).astype(dtype=float)
                v = numpy.array(constants).astype(dtype=float).flatten()
                # lb = numpy.array(lb).astype(dtype=float).flatten()

                # res = v-numpy.dot(mm, x)
                # return res
                return [v, -mm]

            def fun(x):
                return resid(x)[0]

            #
            def dfun(x):
                return resid(x)[1]

            from dolo.numeric.extern.lmmcp import lmmcp
            res = lmmcp(fun,
                        dfun,
                        x0,
                        lb,
                        ub,
                        verbose=verbose,
                        options={
                            'preprocess': True,
                            'eps2': 1e-10
                        })

            from collections import OrderedDict
            return OrderedDict(zip(map(str, model.full_variables), res))
Ejemplo n.º 5
0
def deterministic_solve(
    model,
    exogenous=None,
    s0=None,
    m0=None,
    T=100,
    ignore_constraints=False,
    maxit=100,
    initial_guess=None,
    verbose=True,
    solver="ncpsolve",
    keep_steady_state=False,
    s1=None,  # deprecated
    shocks=None,  # deprecated
    tol=1e-6,
):
    """
    Computes a perfect foresight simulation using a stacked-time algorithm.

    Typical simulation exercises are:
    - start from an out-of-equilibrium exogenous and/or endogenous state: specify `s0` and or `m0`. Missing values are taken from the calibration (`model.calibration`).
    - specify an exogenous path for shocks `exogenous`. Initial exogenous state `m0` is then first value of exogenous values. Economy is supposed to have been at the equilibrium for $t<0$, which pins
    down initial endogenous state `s0`. `x0` is a jump variable.

    If $s0$ is not specified it is then set
    equal to the steady-state consistent with the first value

    The initial state is specified either by providing a series of exogenous
    shocks and assuming the model is initially in equilibrium with the first
    value of the shock, or by specifying an initial value for the states.

    Parameters
    ----------
    model : Model
        Model to be solved
    exogenous : array-like, dict, or pandas.DataFrame
        A specification for the path of exogenous variables (aka shocks). Can be any of the
        following (note by "declaration order" below we mean the order
        of `model.symbols["exogenous"]`):

        - A 1d numpy array-like specifying a time series for a single
          exogenous variable, or all exogenous variables stacked into a single array.
        - A 2d numpy array where each column specifies the time series
          for one of the shocks in declaration order. This must be an
          `N` by number of shocks 2d array.
        - A dict where keys are strings found in
          `model.symbols["exogenous"]` and values are a time series of
          values for that shock. For exogenous variables that do not appear in
          this dict, the shock is set to the calibrated value. Note
          that this interface is the most flexible as it allows the user
          to pass values for only a subset of the model shocks and it
          allows the passed time series to be of different lengths.
        - A DataFrame where columns map shock names into time series.
          The same assumptions and behavior that are used in the dict
          case apply here

        If nothing is given here, `exogenous` is set equal to the
        calibrated values found in `model.calibration["exogenous"]` for
        all periods.

        If the length of any time-series in shocks is less than `T`
        (see below) it is assumed that that particular shock will
        remain at the final given value for the duration of the
        simulation.
    s0 : None or ndarray or dict
        If vector with the value of initial states
        If an exogenous timeseries is given for exogenous shocks, `s0` will be computed as the steady-state value that is consistent with its first value.

    T : int
        horizon for the perfect foresight simulation
    maxit : int
        maximum number of iteration for the nonlinear solver
    verbose : boolean
        if True, the solver displays iterations
    tol : float
        stopping criterium for the nonlinear solver
    ignore_constraints : bool
        if True, complementarity constraints are ignored.
    keep_steady_state : bool
        if True, initial steady-states and steady-controls are appended to the simulation with date -1.
    Returns
    -------
    pandas dataframe
        a dataframe with T+1 observations of the model variables along the
        simulation (states, controls, auxiliaries). The  simulation should return to a steady-state
        consistent with the last specified value of the exogenous shocks.

    """

    if shocks is not None:
        import warnings

        warnings.warn(
            "`shocks` argument is deprecated. Use `exogenous` instead.")
        exogenous = shocks

    if s1 is not None:
        import warnings

        warnings.warn("`s1` argument is deprecated. Use `s0` instead.")
        s0 = s1

    # definitions
    n_s = len(model.calibration["states"])
    n_x = len(model.calibration["controls"])
    p = model.calibration["parameters"]

    if exogenous is not None:
        epsilons = _shocks_to_epsilons(model, exogenous, T)
        m0 = epsilons[0, :]
        # get initial steady-state
        from dolo.algos.steady_state import find_steady_state

        start_state = find_steady_state(model, m=m0)
        s0 = start_state["states"]
        x0 = start_state["controls"]
        m1 = epsilons[1, :]
        s1 = model.functions["transition"](m0, s0, x0, m1, p)
    else:
        if s0 is None:
            s0 = model.calibration["states"]
        if m0 is None:
            m0 = model.calibration["exogenous"]
        # if m0 is None:
        #     m0 = np.zeros(len(model.symbols['exogenous']))
        # we should probably do something here with the nature of the exogenous process if specified
        # i.e. compute nonlinear irf
        epsilons = _shocks_to_epsilons(model, exogenous, T)
        x0 = model.calibration["controls"]
        m1 = epsilons[1, :]
        s1 = model.functions["transition"](m0, s0, x0, m1, p)
        s1 = np.array(s1)

    x1_g = model.calibration["controls"]  # we can do better here
    sT_g = model.calibration["states"]  # we can do better here
    xT_g = model.calibration["controls"]  # we can do better here

    if initial_guess is None:
        start = np.concatenate([s1, x1_g])
        final = np.concatenate([sT_g, xT_g])
        initial_guess = np.row_stack(
            [start * (1 - l) + final * l for l in linspace(0.0, 1.0, T + 1)])

    else:
        if isinstance(initial_guess, pd.DataFrame):
            initial_guess = np.array(initial_guess[model.symbols["states"] +
                                                   model.symbols["controls"]])
        initial_guess = initial_guess[1:, :]
        initial_guess = initial_guess[:, :n_s + n_x]

    sh = initial_guess.shape

    if model.x_bounds and not ignore_constraints:
        initial_states = initial_guess[:, :n_s]
        [lb,
         ub] = [u(epsilons[:, :], initial_states, p) for u in model.x_bounds]
        lower_bound = initial_guess * 0 - np.inf
        lower_bound[:, n_s:] = lb
        upper_bound = initial_guess * 0 + np.inf
        upper_bound[:, n_s:] = ub
        test1 = max(lb.max(axis=0) - lb.min(axis=0))
        test2 = max(ub.max(axis=0) - ub.min(axis=0))
        if test1 > 0.00000001 or test2 > 0.00000001:
            msg = "Not implemented: perfect foresight solution requires that "
            msg += "controls have constant bounds."
            raise Exception(msg)
    else:
        ignore_constraints = True
        lower_bound = None
        upper_bound = None

    print(initial_guess.shape)
    print(epsilons.shape)
    det_residual(model, initial_guess, s1, xT_g, epsilons)

    if not ignore_constraints:

        def ff(vec):
            return det_residual(model,
                                vec.reshape(sh),
                                s1,
                                xT_g,
                                epsilons,
                                jactype="sparse")

        v0 = initial_guess.ravel()
        if solver == "ncpsolve":
            sol, nit = ncpsolve(
                ff,
                lower_bound.ravel(),
                upper_bound.ravel(),
                initial_guess.ravel(),
                verbose=verbose,
                maxit=maxit,
                tol=tol,
                jactype="sparse",
            )
        else:
            from dolo.numeric.extern.lmmcp import lmmcp

            sol = lmmcp(
                lambda u: ff(u)[0],
                lambda u: ff(u)[1].todense(),
                lower_bound.ravel(),
                upper_bound.ravel(),
                initial_guess.ravel(),
                verbose=verbose,
            )
            nit = -1

        sol = sol.reshape(sh)

    else:

        def ff(vec):
            ll = det_residual(model,
                              vec.reshape(sh),
                              s1,
                              xT_g,
                              epsilons,
                              diff=True)
            return ll

        v0 = initial_guess.ravel()
        # from scipy.optimize import root
        # sol = root(ff, v0, jac=True)
        # sol = sol.x.reshape(sh)
        from dolo.numeric.optimize.newton import newton

        sol, nit = newton(ff, v0, jactype="sparse")
        sol = sol.reshape(sh)

    # sol = sol[:-1, :]

    if (exogenous is not None) and keep_steady_state:
        sx = np.concatenate([s0, x0])
        sol = np.concatenate([sx[None, :], sol], axis=0)
        epsilons = np.concatenate([epsilons[:1:], epsilons], axis=0)
        index = range(-1, T + 1)
    else:
        index = range(0, T + 1)
    # epsilons = np.concatenate([epsilons[:1,:], epsilons], axis=0)

    if "auxiliary" in model.functions:
        colnames = (model.symbols["states"] + model.symbols["controls"] +
                    model.symbols["auxiliaries"])
        # compute auxiliaries
        y = model.functions["auxiliary"](epsilons, sol[:, :n_s], sol[:, n_s:],
                                         p)
        sol = np.column_stack([sol, y])
    else:
        colnames = model.symbols["states"] + model.symbols["controls"]

    sol = np.column_stack([sol, epsilons])
    colnames = colnames + model.symbols["exogenous"]

    ts = pd.DataFrame(sol, columns=colnames, index=index)
    return ts
Ejemplo n.º 6
0
def deterministic_solve(model,
                        shocks=None,
                        s1=None,
                        T=100,
                        ignore_constraints=False,
                        maxit=100,
                        initial_guess=None,
                        verbose=True,
                        solver='ncpsolve',
                        tol=1e-6):
    """
    Computes a perfect foresight simulation using a stacked-time algorithm.

    The initial state is specified either by providing a series of exogenous
    shocks and assuming the model is initially in equilibrium with the first
    value of the shock, or by specifying an initial value for the states.

    Parameters
    ----------
    model : Model
        Model to be solved
    shocks : array-like, dict, or pandas.DataFrame
        A specification of the shocks to the model. Can be any of the
        following (note by "declaration order" below we mean the order
        of `model.symbols["shocks"]`):

        - A 1d numpy array-like specifying a time series for a single
          shock, or all shocks stacked into a single array.
        - A 2d numpy array where each column specifies the time series
          for one of the shocks in declaration order. This must be an
          `N` by number of shocks 2d array.
        - A dict where keys are strings found in
          `model.symbols["shocks"]` and values are a time series of
          values for that shock. For model shocks that do not appear in
          this dict, the shock is set to the calibrated value. Note
          that this interface is the most flexible as it allows the user
          to pass values for only a subset of the model shocks and it
          allows the passed time series to be of different lengths.
        - A DataFrame where columns map shock names into time series.
          The same assumptions and behavior that are used in the dict
          case apply here

        If nothing is given here, `shocks` is set equal to the
        calibrated values found in `model.calibration["shocks"]` for
        all periods.

        If the length of any time-series in shocks is less than `T`
        (see below) it is assumed that that particular shock will
        remain at the final given value for the duration of the
        simulaiton.
    s1 : ndarray or dict
        a vector with the value of initial states
    T : int
        horizon for the perfect foresight simulation
    maxit : int
        maximum number of iteration for the nonlinear solver
    verbose : boolean
        if True, the solver displays iterations
    tol : float
        stopping criterium for the nonlinear solver
    ignore_constraints : bool
        if True, complementarity constraints are ignored.

    Returns
    -------
    pandas dataframe
        a dataframe with T+1 observations of the model variables along the
        simulation (states, controls, auxiliaries). The first observation is
        the steady-state corresponding to the first value of the shocks. The
        simulation should return to a steady-state corresponding to the last
        value of the exogenous shocks.

    """

    # definitions
    n_s = len(model.calibration['states'])
    n_x = len(model.calibration['controls'])
    p = model.calibration['parameters']

    epsilons = _shocks_to_epsilons(model, shocks, T)

    m0 = epsilons[0, :]

    # get initial steady-state
    from dolo.algos.steady_state import find_steady_state
    # TODO: use initial_guess for steady_state
    # TODO:

    if s1 is None:
        start_state = find_steady_state(model, m=m0)
        s0 = start_state['states']
        x0 = start_state['controls']
        m1 = epsilons[1, :]
        s1 = model.functions['transition'](m0, s0, x0, m1, p)
    else:
        s0 = model.calibration['states'] * np.nan
        x0 = model.calibration['controls'] * np.nan
        s1 = np.array(s1)

    x1_g = model.calibration['controls']  # we can do better here
    sT_g = model.calibration['states']  # we can do better here
    xT_g = model.calibration['controls']  # we can do better here

    if initial_guess is None:
        start = np.concatenate([s1, x1_g])
        final = np.concatenate([sT_g, xT_g])
        initial_guess = np.row_stack(
            [start * (1 - l) + final * l for l in linspace(0.0, 1.0, T)])

    else:
        if isinstance(initial_guess, pd.DataFrame):
            initial_guess = np.array(initial_guess[model.symbols['states'] +
                                                   model.symbols['controls']])
        initial_guess = initial_guess[1:, :]
        initial_guess = initial_guess[:, :n_s + n_x]

    sh = initial_guess.shape

    if model.x_bounds and not ignore_constraints:
        initial_states = initial_guess[:, :n_s]
        [lb,
         ub] = [u(epsilons[1:, :], initial_states, p) for u in model.x_bounds]
        lower_bound = initial_guess * 0 - np.inf
        lower_bound[:, n_s:] = lb
        upper_bound = initial_guess * 0 + np.inf
        upper_bound[:, n_s:] = ub
        test1 = max(lb.max(axis=0) - lb.min(axis=0))
        test2 = max(ub.max(axis=0) - ub.min(axis=0))
        if test1 > 0.00000001 or test2 > 0.00000001:
            msg = "Not implemented: perfect foresight solution requires that "
            msg += "controls have constant bounds."
            raise Exception(msg)
    else:
        ignore_constraints = True
        lower_bound = None
        upper_bound = None

    if not ignore_constraints:

        def ff(vec):
            return det_residual(model,
                                vec.reshape(sh),
                                s1,
                                xT_g,
                                epsilons[1:, :],
                                jactype='sparse')

        v0 = initial_guess.ravel()
        if solver == 'ncpsolve':
            sol, nit = ncpsolve(ff,
                                lower_bound.ravel(),
                                upper_bound.ravel(),
                                initial_guess.ravel(),
                                verbose=verbose,
                                maxit=maxit,
                                tol=tol,
                                jactype='sparse')
        else:
            from dolo.numeric.extern.lmmcp import lmmcp
            sol = lmmcp(lambda u: ff(u)[0],
                        lambda u: ff(u)[1].todense(),
                        lower_bound.ravel(),
                        upper_bound.ravel(),
                        initial_guess.ravel(),
                        verbose=verbose)
            nit = -1

        sol = sol.reshape(sh)

    else:

        def ff(vec):
            ll = det_residual(model,
                              vec.reshape(sh),
                              s1,
                              xT_g,
                              epsilons[1:, :],
                              diff=True)
            return (ll)

        v0 = initial_guess.ravel()
        # from scipy.optimize import root
        # sol = root(ff, v0, jac=True)
        # sol = sol.x.reshape(sh)
        from dolo.numeric.optimize.newton import newton
        sol, nit = newton(ff, v0, jactype='sparse')
        sol = sol.reshape(sh)

    sx = np.concatenate([s0, x0])
    # sol = sol[:-1, :]

    sol = np.concatenate([sx[None, :], sol], axis=0)
    # epsilons = np.concatenate([epsilons[:1,:], epsilons], axis=0)

    if 'auxiliary' in model.functions:
        colnames = (model.symbols['states'] + model.symbols['controls'] +
                    model.symbols['auxiliaries'])
        # compute auxiliaries
        y = model.functions['auxiliary'](epsilons, sol[:, :n_s], sol[:, n_s:],
                                         p)
        sol = np.column_stack([sol, y])
    else:
        colnames = model.symbols['states'] + model.symbols['controls']

    sol = np.column_stack([sol, epsilons])
    colnames = colnames + model.symbols['exogenous']

    ts = pd.DataFrame(sol, columns=colnames)
    return ts
Ejemplo n.º 7
0
def solver(fobj,
           x0,
           lb=None,
           ub=None,
           options={},
           method='lmmcp',
           jac='default',
           verbose=False):

    in_shape = x0.shape

    ffobj = lambda x: fobj(x.reshape(in_shape)).flatten()

    if not isinstance(jac, str):
        pp = np.prod(in_shape)

        def Dffobj(t):
            tt = t.reshape(in_shape)
            dval = jac(tt)
            return dval.reshape((pp, pp))

    elif jac == 'precise':
        from numdifftools import Jacobian
        Dffobj = Jacobian(ffobj)
    else:
        Dffobj = MyJacobian(ffobj)

    if method == 'fsolve':
        import scipy.optimize as optimize
        factor = options.get('factor')
        factor = factor if factor else 1
        [sol, infodict, ier, msg] = optimize.fsolve(ffobj,
                                                    x0.flatten(),
                                                    fprime=Dffobj,
                                                    factor=factor,
                                                    full_output=True,
                                                    xtol=1e-10,
                                                    epsfcn=1e-9)
        if ier != 1:
            print msg
    elif method == 'anderson':
        import scipy.optimize as optimize
        sol = optimize.anderson(ffobj, x0.flatten())
    elif method == 'newton_krylov':
        import scipy.optimize as optimize
        sol = optimize.newton_krylov(ffobj, x0.flatten())
    elif method == 'lmmcp':
        from dolo.numeric.extern.lmmcp import lmmcp, Big
        if lb == None:
            lb = -Big * np.ones(len(x0.flatten()))
        else:
            lb = lb.flatten()
        if ub == None:
            ub = Big * np.ones(len(x0.flatten()))
        else:
            ub = ub.flatten()

        sol = lmmcp(ffobj,
                    Dffobj,
                    x0.flatten(),
                    lb,
                    ub,
                    verbose=verbose,
                    options=options)

    return sol.reshape(in_shape)
Ejemplo n.º 8
0
def solver(fobj,
           x0,
           lb=None,
           ub=None,
           jac=None,
           method='lmmcp',
           infos=False,
           serial_problem=False,
           verbose=False,
           options={}):

    in_shape = x0.shape

    if serial_problem:
        ffobj = fobj
    else:
        ffobj = lambda x: fobj(x.reshape(in_shape)).flatten()

    # standardize jacobian
    if jac is not None:
        if not serial_problem:
            pp = np.prod(in_shape)

            def Dffobj(t):
                tt = t.reshape(in_shape)
                dval = jac(tt)
                return dval.reshape((pp, pp))
        else:
            Dffobj = jac
    elif serial_problem:
        from dolo.numeric.newton import SerialDifferentiableFunction
        Dffobj = SerialDifferentiableFunction(fobj, in_shape)
    else:
        Dffobj = MyJacobian(ffobj)

    if lb == None:
        lb = -np.inf * np.ones(len(x0.flatten()))
    if ub == None:
        ub = np.inf * np.ones(len(x0.flatten())).flatten()

    if not serial_problem:
        lb = lb.flatten()
        ub = ub.flatten()

    if not serial_problem:
        x0 = x0.flatten()

    if method == 'fsolve':
        import scipy.optimize as optimize
        factor = options.get('factor')
        factor = factor if factor else 1
        [sol, infodict, ier, msg] = optimize.fsolve(ffobj,
                                                    x0,
                                                    fprime=Dffobj,
                                                    factor=factor,
                                                    full_output=True,
                                                    xtol=1e-10,
                                                    epsfcn=1e-9)
        if ier != 1:
            print(msg)

    elif method == 'newton':
        from dolo.numeric.newton import serial_newton as newton_solver
        fun = lambda x: [ffobj(x), Dffobj(x)]
        [sol, nit] = newton_solver(fun, x0, verbose=verbose)

    elif method == 'lmmcp':
        from dolo.numeric.extern.lmmcp import lmmcp
        sol = lmmcp(lambda t: -ffobj(t),
                    lambda u: -Dffobj(u),
                    x0,
                    lb,
                    ub,
                    verbose=verbose,
                    options=options)

    elif method == 'ncpsolve':
        from dolo.numeric.ncpsolve import ncpsolve
        fun = lambda x: [ffobj(x), Dffobj(x)]
        if serial_problem:
            jactype = 'serial'
        [sol, nit] = ncpsolve(fun,
                              lb,
                              ub,
                              x0,
                              verbose=verbose,
                              infos=True,
                              jactype='serial')

    else:
        raise Exception('Unknown method : ' + str(method))
    sol = sol.reshape(in_shape)

    if infos:
        return [sol, nit]
    else:
        return sol
Ejemplo n.º 9
0
def solver(fobj, x0, lb=None, ub=None, jac=None, method='lmmcp', infos=False, serial_problem=False, verbose=False, options={}):


    in_shape = x0.shape

    if serial_problem:
        ffobj = fobj
    else:
        ffobj = lambda x: fobj(x.reshape(in_shape)).flatten()


    # standardize jacobian
    if jac is not None:
        if not serial_problem:
            pp = np.prod(in_shape)
            def Dffobj(t):
                tt = t.reshape(in_shape)
                dval = jac(tt)
                return dval.reshape( (pp,pp) )
        else:
            Dffobj = jac
    elif serial_problem:
        Dffobj = MySerialJacobian(fobj, in_shape)
    else:
        Dffobj = MyJacobian(ffobj)


    if lb == None:
        lb = -np.inf*np.ones(len(x0.flatten()))
    if ub == None:
        ub = np.inf*np.ones(len(x0.flatten())).flatten()

    if not serial_problem:
         lb = lb.flatten()
         ub = ub.flatten()

    if not serial_problem:
        x0 = x0.flatten()


    if method == 'fsolve':
        import scipy.optimize as optimize
        factor = options.get('factor')
        factor = factor if factor else 1
        [sol,infodict,ier,msg] = optimize.fsolve(ffobj, x0, fprime=Dffobj, factor=factor, full_output=True, xtol=1e-10, epsfcn=1e-9)
        if ier != 1:
            print(msg)

    elif method == 'newton':
        from dolo.numeric.newton import newton_solver
        fun = lambda x: [ffobj(x), Dffobj(x) ]
        [sol,nit] = newton_solver(fun,x0, verbose=verbose, infos=True)

    elif method == 'lmmcp':
        from dolo.numeric.extern.lmmcp import lmmcp
        sol = lmmcp(lambda t: -ffobj(t), lambda u: -Dffobj(u),x0,lb,ub,verbose=verbose,options=options)

    elif method == 'ncpsolve':
        from dolo.numeric.ncpsolve import ncpsolve
        fun = lambda x: [ffobj(x), Dffobj(x) ]
        [sol,nit] = ncpsolve(fun,lb,ub,x0, verbose=verbose, infos=True, serial=serial_problem)


    sol = sol.reshape(in_shape)

    if infos:
        return [sol, nit]
    else:
        return sol