modeldiff module

Created on Tue Oct 22 22:47:37 2013

Developement Module - only for the adventeous

This module handels symbolic differentiation of models

calculates the values of all the partial differentialkoifficients and creates matrices for each lag

@author: Ib Hansen

modeldiff.findallvar(model, v)

Finds all endogenous variables which is on the right side of = in the expresion for variable v lagged variables are included

modeldiff.findendocur(model, v)

Finds all endegenoujs variables which is on the right side of = in the expresion for variable v lagged variables are not included

modeldiff.modeldiff(model, silent=False, onlyendocur=False, endovar=None, maxdif=9999999999999999, forcenum=False)

Differentiate all relations with respect to all variable The result is placed in a dictory in the model instanse: model.diffendocur

modeldiff.diffout(model)

modeldiff.diffprint(model, udfil='')

modeldiff.vardiff(model, var='*')

Displays espressions for differential koifficients for a variable if var ends with * all matchning variables are displayes

modeldiff.invdiff(model, var)

Displays espressions for differential koifficients for a variable if var ends with * all matchning variables are displayes

modeldiff.rettet(ind)

modeldiff.fouteval(model, databank)

takes a dict of derivatives for a model and makes a function which returns a function which evaluates the derivatives in a period. The derivatives is both returned from the function and places in

:model.difvalue

modeldiff.calculate_diffvalue(model, bank, per)

calculates the numeric value of derivatives. the values are returnes and also places in model.diffvalue

modeldiff.calculate_delta(databank)

calculates the standard deviation of the change in all variable in a databank returns a panda series

modeldiff.calculate_impact(model, bank)

Calculate the impact of every variable in equation on the result based on the standard deviation and differential coefficient

modeldiff.calculate_diffvalue_d3d(model)

creates a 3D dictonary derivatives for each lag

modeldiff.calculate_mat(model, lag=0)

calcultae matrix of derivative values. very slow should be reworked

modeldiff.calculate_endocurmat(model, df, per)

for Newton solution find jacobi

modeldiff.calculate_allmat(model, df, per, show=False)

Calculate and return a dictionary with a matrix of derivative values for each lag

modeldiff.calculate_matold(model, lag=0, endo=True)

calcultae matrix of derivative values. endo deteriins if it is with respect to endogeneous og exogeneous variables

modeldiff.modelnet_dict(d, model, lag)

creates a network where weight is determined by a 3d dict of impacts d: 3 d dictinorary

modeldiff.pagerank(g)

ranks the equations in a model according to the pagerank algoritme returns order in pagerank

modeldiff.display_diff(model, bank, var='')

modeldiff.display_ip_old(model, ivar)

modeldiff.display_all(model, df, per)

modeldiff.display_ip(model, ivar)

modeldiff.settozero(instring)

sets subst() or Derivative() to zero in string the purpose is to get rid of derivatives of logical espressions

modeldiff.get_A(model, df, per)

modeldiff.get_AINV(A)

modeldiff.get_compagnion(model, df, per, show=False)

modeldiff.get_eigen(model, df, per)

modeldiff.eigplot0(w)

modeldiff.eigplot(w, size=(3, 3))

modeldiff.stabilitet(model, minnumber=8, maxnumber=8)

modeldiff.tout(t)

modeldiff.numdif(model, v, rhv, delta=0.005, silent=True)