Ch25_GMM.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# GMM\n",
    "\n",
    "This notebook shows a simple example of how GMM can be used to estimate model parameters. It starts with an exactly identified case and then moves on to different ways of estimating an overidentified case (pre-defined weighting matrix, recombining the moment conditions, optimal weighting matrix)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load Packages and Extra Functions\n",
    "\n",
    "The general GMM functions are from the (local) `FinEcmt_MLEGMM` module. In contrast, the functions for the moment conditions (\"the model\") are coded in the notebook below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "MyModulePath = joinpath(pwd(),\"jlFiles\")\n",
    "!in(MyModulePath,LOAD_PATH) && push!(LOAD_PATH,MyModulePath);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "using FinEcmt_OLS, DelimitedFiles, Statistics, NLsolve, LinearAlgebra\n",
    "using FinEcmt_MLEGMM: GMMAgbar, GMMExactlyIdentified, GMMgbarWgbar, meanV"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Loading Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "388"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = readdlm(\"Data/FFmFactorsPs.csv\",',',skipstart=1)   #start on line 2, column 1\n",
    "x = x[:,2]         #excess market returns, in %\n",
    "\n",
    "T = size(x,1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exactly Identified GMM\n",
    "\n",
    "This section describes the exactly identified GMM, that is, when we have as many moment conditions as parameters. In this case GMM is the same as the classical method of moments."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Traditional Estimation of Mean and Variance\n",
    "\n",
    "The next cell applies the traditional way of estimating the mean and the variance. The standard errors are text book formulas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[34m\u001b[1mTraditional estimates:\u001b[22m\u001b[39m\n",
      "\n",
      "        coef       std\n",
      "μ      0.602     0.233\n",
      "σ²    21.142     1.518\n",
      "\n"
     ]
    }
   ],
   "source": [
    "μ  = mean(x)\n",
    "σ² = var(x,corrected=false)       #corrected=\"false\" to use 1/T formula\n",
    "\n",
    "par_a = [μ,σ²]\n",
    "\n",
    "printblue(\"Traditional estimates:\\n\")\n",
    "xx = [par_a [sqrt((σ²/T));sqrt(2*σ²^2/T)]]\n",
    "colNames = [\"coef\",\"std\"]\n",
    "parNames = [\"μ\",\"σ²\"]\n",
    "printmat(xx;colNames,rowNames=parNames)      # ; since keywords with same name"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## GMM Point Estimates\n",
    "\n",
    "To estimate the mean and variance of $x_{t}$, use the following moment condition\n",
    "\n",
    "$\n",
    "g_{t}(\\beta)=\n",
    "\\begin{bmatrix}\n",
    "x_{t}-\\mu\\\\\n",
    "(x_{t}-\\mu)^{2}-\\sigma^{2}\n",
    "\\end{bmatrix},\n",
    "$\n",
    "\n",
    "where $\\beta = [\\mu,\\sigma^{2}]$.\n",
    "\n",
    "The parameter values ($\\mu,\\sigma^2$) that make these moment conditions hold are the same as from the traditional method. It is easy to solve for these parameters when the moment conditions are linear in the parameters (as they are here). However, to facilitate adapting the code to non-linear models, we solve for the parameters by a numerical method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Gmm2MomFn"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "    Gmm2MomFn(par,x)\n",
    "\n",
    "Calculate traditional 2 moment conditions for estimating [μ,σ²]. Returns a Tx2 matrix\n",
    "\n",
    "# Input\n",
    "- `par::Vector`: [μ,σ²]\n",
    "- `x::Vector`:   T-vector with data\n",
    "\n",
    "# Output\n",
    "- `g::Matrix`:    Tx2, moment conditions\n",
    "\n",
    "\"\"\"\n",
    "function Gmm2MomFn(par,x)\n",
    "    (μ,σ²) = (par[1],par[2])\n",
    "    g      = hcat(x .- μ, abs2.(x .- μ) .- σ²)  #Tx2\n",
    "    return g\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "### A Remark on the Code\n",
    "\n",
    "...in the next cells.\n",
    "\n",
    "- The `meanV()` function calculates the sample mean of each column in a matrix and returns a vector.\n",
    "\n",
    "- The `p->meanV(Gmm2MomFn(p,x))` defines an anonymous function (in terms of the vector of parameters `p`) that returns a vector of the sample averages of the moment conditions.\n",
    "\n",
    "- `Sol = nlsolve(p->meanV(Gmm2MomFn(p,x)),par_a)` solves for the vector `p` that makes the average moment conditions equal to `[0,0]`.    \n",
    "    \n",
    "- To extract the solution, use `Sol.zero`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[34m\u001b[1mGMM estimates:\u001b[22m\u001b[39m\n",
      "μ      0.602\n",
      "σ²    21.142\n",
      "\n",
      "\u001b[34m\u001b[1mChecking if mean of moment conditions = 0\u001b[22m\u001b[39m\n",
      "g₁     0.000\n",
      "g₂     0.000\n",
      "\n"
     ]
    }
   ],
   "source": [
    "Sol   = nlsolve(p->meanV(Gmm2MomFn(p,x)),par_a)   #numerically solve for the estimates\n",
    "par_1 = Sol.zero\n",
    "\n",
    "printblue(\"GMM estimates:\")\n",
    "printmat(par_1;rowNames=parNames)\n",
    "\n",
    "g    = Gmm2MomFn(par_1,x)        #Tx2, moment conditions\n",
    "gbar = meanV(g)                  #2-vector with average moment conditions\n",
    "\n",
    "printblue(\"Checking if mean of moment conditions = 0\")\n",
    "printmat(gbar;rowNames=[\"g₁\",\"g₂\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "## GMM Distribution\n",
    "\n",
    "The distribution of the basic GMM estimates is\n",
    "\n",
    "$\n",
    "\\hat{\\beta} \\overset{a}{\\rightarrow}N(\\beta_{0},Q), \n",
    "$\n",
    "\n",
    "where \n",
    "\n",
    "$\n",
    "Q = (D_{0}^{\\prime}S_{0}^{-1}D_{0})  ^{-1} /T,\n",
    "$\n",
    "\n",
    "$\n",
    "S_{0}=\\mathrm{Var}(\\sqrt{T}\\bar{g}),\n",
    "$\n",
    "\n",
    "$\n",
    "D_{0}=\\mathrm{plim}\\frac{\\partial\\bar{g}}{\\partial\\beta^{\\prime}}.\n",
    "$\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "(This holds for exactly identified models and models using the optimal weighting matrix.)\n",
    "\n",
    "\n",
    "### A Remark on the Code\n",
    "\n",
    "- `CovNW(g,1,1)` estimates $S_0$ by using the Newey-West method with one lag.\n",
    "\n",
    "- We can notice that $D_{0}=-I_2$ for the moment conditions used above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[34m\u001b[1mGMM estimates:\u001b[22m\u001b[39m\n",
      "\n",
      "        coef       std\n",
      "μ      0.602     0.244\n",
      "σ²    21.142     2.381\n",
      "\n",
      "\u001b[31m\u001b[1mCompare with the traditional estimates\u001b[22m\u001b[39m"
     ]
    }
   ],
   "source": [
    "D  = -I(2)                   #Jacobian, does not really matter here\n",
    "S  = CovNW(g,1,1)            #variance of sqrt(T)*gbar, NW with 1 lag\n",
    "V1 = inv(D'inv(S)*D)/T\n",
    "\n",
    "printblue(\"GMM estimates:\\n\")\n",
    "printmat(par_1,sqrt.(diag(V1));colNames,rowNames=parNames)\n",
    "\n",
    "printstyled(\"Compare with the traditional estimates\",color=:red,bold=true)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## A Function for Exactly Identified GMM\n",
    "\n",
    "The functions printed in the next cell combines the previous code into a function for getting both point estimates and standard errors. The Jacobian is calculated numerically. The result should be the same as before. (For the rest of the notebook, the code will come in functions like this.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "```\n",
       "GMMExactlyIdentified(GmmMomFn::Function,x,par0,m)\n",
       "```\n",
       "\n",
       "Estimates GMM coeffs and variance-covariance matrix from an exactly identified model. The Jacobian is calculated numerically.\n",
       "\n",
       "### Input\n",
       "\n",
       "  * `GmmMomFn::Function`:    for the moment conditions, called as `GmmMomFn(p,x)` where `p` are the coefficients and `x` is the data.\n",
       "  * `x::VecOrMat`:            data\n",
       "  * `par0::Vector`:           initial guess\n",
       "  * `m::Int`:                 number of lags in NW covariance matrix\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "@doc2 GMMExactlyIdentified"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "#using CodeTracking\n",
    "#println(@code_string GMMExactlyIdentified(cos,[1],[1],1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[34m\u001b[1mResults from GMMExactlyIdentified():\u001b[22m\u001b[39m\n",
      "\n",
      "        coef       std\n",
      "μ      0.602     0.244\n",
      "σ²    21.142     2.381\n",
      "\n",
      "\u001b[31m\u001b[1mCompare with GMM results from above\u001b[22m\u001b[39m"
     ]
    }
   ],
   "source": [
    "(par_1b,Std_1b,) = GMMExactlyIdentified(Gmm2MomFn,x,par_a,1)\n",
    "\n",
    "printblue(\"Results from GMMExactlyIdentified():\\n\")\n",
    "printmat(par_1,sqrt.(diag(V1));colNames,rowNames=parNames)\n",
    "\n",
    "printstyled(\"Compare with GMM results from above\",color=:red,bold=true)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Overidentified GMM\n",
    "\n",
    "This section discusses an overidentified case: more moment conditions than parameters.\n",
    "\n",
    "Warning: some of the variables (`g,S`, etc) are overwritten with new values.\n",
    "\n",
    "## The Moment Conditions\n",
    "\n",
    "If $x_{t}$ is $N(\\mu,\\sigma^{2})$, then the following moment conditions should\n",
    "all be zero (in expectation)\n",
    "\n",
    "$\n",
    "g_{t}(\\beta)=\n",
    "\\begin{bmatrix}\n",
    "x_{t}-\\mu\\\\\n",
    "(x_{t}-\\mu)^{2}-\\sigma^{2}\\\\\n",
    "(x_{t}-\\mu)^{3}\\\\\n",
    "(x_{t}-\\mu)^{4}-3\\sigma^{4}\n",
    "\\end{bmatrix},\n",
    "$\n",
    "\n",
    "where $\\beta = [\\mu,\\sigma^{2}]$.\n",
    "\n",
    "The first moment condition defines the mean $\\mu$, the second defines the\n",
    "variance $\\sigma^{2}$, while the third and forth are the skewness and excess\n",
    "kurtosis respectively."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Gmm4MomFn"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "    Gmm4MomFn(par,x)\n",
    "\n",
    "Calculate 4 moment conditions for estimating [μ,σ²]\n",
    "\n",
    "# Input\n",
    "- `par::Vector`: [μ,σ²]\n",
    "- `x::Vector`:   T-vector with data\n",
    "\n",
    "# Output\n",
    "- `g::Matrix`:    Tx4, moment conditions\n",
    "\n",
    "\"\"\"\n",
    "function Gmm4MomFn(par,x)\n",
    "  (μ,σ²) = (par[1],par[2])\n",
    "  g      = hcat(x .- μ, (x .- μ).^2 .- σ², (x .- μ).^3, (x .- μ).^4 .- 3*σ²^2)    #Tx4\n",
    "  return g\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Overidentified GMM: Minimizing gbar'W*gbar\n",
    "\n",
    "\n",
    "The following code applies a numerical method to solve a minimization problem with the weighting matrix \n",
    "\n",
    "$\n",
    "W=\n",
    "\\begin{bmatrix}\n",
    "1 & 0 & 0 & 0\\\\\n",
    "0 & 1 & 0 & 0\\\\\n",
    "0 & 0 & 0 & 0\\\\\n",
    "0 & 0 & 0 & 0\n",
    "\\end{bmatrix}\n",
    "$\n",
    "\n",
    "The results should be the same (or at least very close to) the previous results, since this $W$ matrix puts all weight on the first two moments. Changing $W$, for instance, by setting `W[3,3]=0.0001` will give other estimates.\n",
    "\n",
    "We define the loss function as $\\bar{g}'W\\bar{g}$.\n",
    "\n",
    "The expressions for variance-covatriance matrix are in the lecture notes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## A Function for gbar'W*gbar Estimation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "```\n",
       "GMMgbarWgbar(GmmMomFn::Function,W,x,par0,m;SkipCovQ=false)\n",
       "```\n",
       "\n",
       "Estimates GMM coeffs and variance-covariance matrix from A*gbar. The Jacobian is calculated numerically.\n",
       "\n",
       "### Input\n",
       "\n",
       "  * `GmmMomFn::Function`:    for the moment conditions, called as `GmmMomFn(p,x)` where `p` are the coefficients and `x` is the data.\n",
       "  * `W::Matrix`:              length(gbar)xlength(gbar)\n",
       "  * `x::VecOrMat`:            data\n",
       "  * `par0::Vector`:           initial guess\n",
       "  * `m::Int`:                 number of lags in NW covariance matrix\n",
       "  * `SkipCovQ::Bool`:         if true: the Jacobian and variance-covariance matrix are not calculated. This can be used to speed up calculations in iterative computations.\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "@doc2 GMMgbarWgbar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "#println(@code_string GMMgbarWgbar(cos,[1],[1],[1],1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[34m\u001b[1mGMM estimates (gbar'W*gbar):\u001b[22m\u001b[39m\n",
      "\n",
      "        coef       std\n",
      "μ      0.602     0.244\n",
      "σ²    21.142     2.381\n",
      "\n"
     ]
    }
   ],
   "source": [
    "W     = diagm(0=>[1.0,1.0,0.0,0.0])   #weighting matrix, try changing it\n",
    "#W[3,3] = 0.0001\n",
    "(par2,StdErr2,_,S2,_) = GMMgbarWgbar(Gmm4MomFn,W,x,par_a,1)\n",
    "\n",
    "printblue(\"GMM estimates (gbar'W*gbar):\\n\")\n",
    "printmat(par2,StdErr2;colNames,rowNames=parNames)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Overidentified GMM: Minimizing gbar'W*gbar, Iterating over W\n",
    "\n",
    "\n",
    "The following code iterates over the weighting matrix by using $W=S^{-1}$, where\n",
    "$S = \\text{Cov}(\\sqrt{T}\\bar{g})$\n",
    "is from the previous iteration.\n",
    "\n",
    "### A Remark on the Code\n",
    "\n",
    "- `(maximum(abs,par - par_old) > 1e-3) || (i < 2)` loops while the |change| in the parameters > 1e-3 (and at least once).\n",
    "\n",
    "- `par_old = copy(par)` makes an independent copy of the `par`. This is not needed here (since `par` is overwritten further below), but often a good routine."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "iterated GMM, using optimal weighting matrix, starting with S from previous estimation\n",
      "\n",
      "\n",
      "iterating over W starting with the W choice above\n",
      "-------iteration  1, old and new parameters--------\n",
      "     0.602    21.142          \n",
      "     0.877    16.916\n",
      "-------iteration  2, old and new parameters--------\n",
      "     0.877    16.916          \n",
      "     0.879    16.648\n",
      "-------iteration  3, old and new parameters--------\n",
      "     0.879    16.648          \n",
      "     0.879    16.645\n",
      "-------iteration  4, old and new parameters--------\n",
      "     0.879    16.645          \n",
      "     0.879    16.647\n",
      "-------iteration  5, old and new parameters--------\n",
      "     0.879    16.647          \n",
      "     0.879    16.647\n",
      "\n",
      "\u001b[34m\u001b[1mGMM estimates (gbar'W*gbar, iteration over W):\u001b[22m\u001b[39m\n",
      "          coef         std\n",
      "μ        0.879       0.219\n",
      "σ²      16.647       1.341\n",
      "\n"
     ]
    }
   ],
   "source": [
    "println(\"\\niterated GMM, using optimal weighting matrix, starting with S from previous estimation\")\n",
    "\n",
    "(par,par_old,S,i) = (copy(par2),fill(Inf,length(par2)),copy(S2),1)\n",
    "\n",
    "println(\"\\n\\niterating over W starting with the W choice above\")\n",
    "while (maximum(abs,par - par_old) > 1e-3) || (i < 2)    #require at least one iteration\n",
    "    #global par, par_old, i, W, S    #only needed in script\n",
    "    global StdErr2, D\n",
    "    println(\"-------iteration  $i, old and new parameters--------\")\n",
    "    par_old = copy(par)              #update par_old\n",
    "    W       = inv(S)\n",
    "    (par,StdErr2,_,S,D) = GMMgbarWgbar(Gmm4MomFn,W,x,par_old,1)\n",
    "    i       = i + 1\n",
    "    printlnPs(par_old',\"\\n\",par')\n",
    " end\n",
    "\n",
    "printblue(\"\\nGMM estimates (gbar'W*gbar, iteration over W):\")\n",
    "xx = [par StdErr2]\n",
    "printmat(xx;colNames,rowNames=parNames,width=12)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[34m\u001b[1mW matrix used in the last iteration, (times 10000):\u001b[22m\u001b[39m\n",
      "\n",
      "          g₁        g₂        g₃        g₄\n",
      "g₁  1525.564    39.433   -16.963    -0.674\n",
      "g₂    39.433    18.778    -0.297    -0.050\n",
      "g₃   -16.963    -0.297     0.306     0.012\n",
      "g₄    -0.674    -0.050     0.012     0.001\n",
      "\n"
     ]
    }
   ],
   "source": [
    "printblue(\"W matrix used in the last iteration, (times 10000):\\n\")\n",
    "\n",
    "momNames = [\"g₁\",\"g₂\",\"g₃\",\"g₄\"]\n",
    "printmat(W*10000,colNames=momNames,rowNames=momNames)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\u001b[34m\u001b[1mGMM estimates (gbar'W*gbar, iteration over W):\u001b[22m\u001b[39m\n",
      "          coef         std  std ver. 2\n",
      "μ        0.879       0.219       0.219\n",
      "σ²      16.647       1.341       1.341\n",
      "\n",
      "\u001b[31m\u001b[1mNotice that the standard errors (calculated in two ways) are the same after the iterations\u001b[22m\u001b[39m\n"
     ]
    }
   ],
   "source": [
    "V1 = inv(D'inv(S)*D)/T                      #with optimal weighting matrix\n",
    "\n",
    "printblue(\"\\nGMM estimates (gbar'W*gbar, iteration over W):\")\n",
    "xx = [par StdErr2 sqrt.(diag(V1))]\n",
    "printmat(xx;colNames=[colNames;\"std ver. 2\"],rowNames=parNames,width=12)\n",
    "\n",
    "printred(\"Notice that the standard errors (calculated in two ways) are the same after the iterations\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Overidentified GMM: A*g = 0\n",
    "\n",
    "The following code from estimates the parameters by combining the 4 original moment conditions in $\\bar{g}$ into 2\n",
    "effective moment conditions, $A\\bar{g}$, where $A$ is a $2\\times4$ matrix\n",
    "\n",
    "$\n",
    "A=\n",
    "\\begin{bmatrix}\n",
    "1 & 0 & 0 & 0\\\\\n",
    "0 & 1 & 0 & 0\n",
    "\\end{bmatrix}\n",
    "$\n",
    "\n",
    "This particular $A$ matrix implies that we use the classical\n",
    "estimators of the mean and variance. Changing $A$, for instance, by setting $A[1,3]=0.001$ will give different estimates.\n",
    "\n",
    "The next cell prints a function for doing A*gbar GMM."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "```\n",
       "GMMAgbar(GmmMomFn::Function,A,x,par0,m)\n",
       "```\n",
       "\n",
       "Estimates GMM coeffs and variance-covariance matrix from A*gbar. The Jacobian is calculated numerically.\n",
       "\n",
       "### Input\n",
       "\n",
       "  * `GmmMomFn::Function`:    for the moment conditions, called as `GmmMomFn(p,x)` where `p` are the coefficients and `x` is the data.\n",
       "  * `A::Matrix`:              length(p) x length(gbar)\n",
       "  * `x::VecOrMat`:            data\n",
       "  * `par0::Vector`:           initial guess\n",
       "  * `m::Int`:                 number of lags in NW covariance matrix\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "@doc2 GMMAgbar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "#using CodeTracking\n",
    "#println(@code_string GMMAgbar(cos,[1],[1],[1],1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[34m\u001b[1mGMM estimates (A*gbar) from GMMAgbar():\u001b[22m\u001b[39m\n",
      "\n",
      "        coef       std\n",
      "μ      0.602     0.244\n",
      "σ²    21.142     2.381\n",
      "\n"
     ]
    }
   ],
   "source": [
    "A = [1 0 0 0;                   #A in A*gbar=0 (here: all weight on first two moments)\n",
    "     0 1 0 0]                   #try setting A[1,3] = 0.001\n",
    "\n",
    "(par_3b,Std_3b) = GMMAgbar(Gmm4MomFn,A,x,par_a,1)\n",
    "\n",
    "\n",
    "printblue(\"GMM estimates (A*gbar) from GMMAgbar():\\n\")\n",
    "printmat(par_3b,Std_3b;colNames,rowNames=parNames)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "@webio": {
   "lastCommId": null,
   "lastKernelId": null
  },
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Julia 1.11.1",
   "language": "julia",
   "name": "julia-1.11"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "1.11.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}