DDPShared.ox

Functions, classes and methods shared among all components of DDP.

Global variables, functions, enumerations

Variables
ClockTypeLabels	static const	parallel array of labels for the built-in clock types.
exogoffs	static	$\eta$ and $\epsilon$ subspaces.
Fgamma	static	2-dimensiona array pointing to $\Gamma$, [r,f].
Gamma	static	$\Gamma$: array (list) of groups of fixed and random effects, $\gamma$.
groupoffs	static	$\Gamma$ related subspaces.
ilistnames	static const
maskoffs	static
NDPlabels	const
Theta	static	$\Theta$: array (list) of endogenous states $\theta$.
thetaoffs	static	$\theta$ tracking or iterating indices.
Functions
ReverseState		Recreate a State vector from an index and offset vector.
Enumerations
ClockTypes		Send one of these tags as first argument to SetClock() to use that clock.
DataColumnTypes		Kinds of variables in data sets.
DPPhases		Phases of DP computations.
FlatOptions		Flat views of panel data.
GMMWeightOptions		Weighting of moments in GMM.
HookTimes		Points in the solution process that users can insert static functions or methods.
InteractionTypes		Type of Interaction Auxiliary Values.
LikelihoodTypes		Type of likelihood function to build based on observability.
NReachTypes		Categories of Endgoenous State Reachability.
SmoothingMethods		Ways to smooth choice probabilities without adding an explicit continuous error ζ.
StateCategories		Categories of state variables.
SubSpaces		Groups of continguous SubVectorNames.
SubVectorNames		Vectors of state variables.
TransStore		Elements of array stored at each theta.
UpdateTimes		Point in solving when updating of parameters and transitions needs to occur.
Vspace		Names for 0 and 1 for Bellman iteration.

Alpha : DDPauxiliary : Zauxiliary

Aspects of the Action Space $A(\theta)$.

See also:: FeasibleActions

Public fields
A	static	Current ACTUAL feasible actions.
aA	static	Simulated actual realized action .
aC	static	Simulated realized action (row of C).
aI	static	row index of simulated alpha.
AIlist	static	Array of indices into Matrix for each feasible set .
aL1	static	First character of action labels.
AList	static	List of actual feasible action matrices (AV values), automatically updated.
C	static	Current feasible action matrix.
CList	static	list of feasible action matrices (CV) values.
Count	static	(vector) Number of states for each A set.
Matrix	static	matrix of all action vectors, A.
N	static	Rows of A, # of feasible actions.
Rlabels	static	Array of Array labels for rows of A that look like α.
Sets	static	List of Feasible Action indicators (column vector of 0s and 1s).
Public methods
AddA	static
Aprint	static
ClearA	static
Initialize	static
ResetA	static
SetA	static

DDPauxiliary : Zauxiliary

Container for auxiliary classes used in DDP but not elsewhere (directly).

Flags : DDPauxiliary : Zauxiliary

Indicators related to the DP problem. All elements are static. A user's code can reference these variables but should not change them unless building a new solution method.

Public fields
AllGroupsExist	static	Integer TRUE (default) means all possible combination of fixed and random groups exist in the group space Γ and should be created.
CallTrans	static	If UpdateTime=WhenFlagIsSet then next Solve() will update transitions.
HasBeenUpdated	static	Transitions has been called.
HasFixedEffect	static	Γ already includes fixed effects
HasKeptZ	static	Includes a kept continuous state variable.
inctime	static	time increment.
IsErgodic	static	create space to store $P(\theta';\alpha,\theta)$ and update it if SetPstar during interation.
NKstep	static	Newton-Kantorovich Step is active.
onlyDryRun	static	Do not create Θ, but do everything else.
Phase	static	Phase of model solution or use.
Prunable	static	TRUE if clock is finite horizon so automatic pruning can apply.
ReadIN	static	Read I and N objects from .dim file (avoids one span of the state space to find reachable indices.
runtime	static	vector of time spent in each phase.
setPstar	static	set $P^*(\alpha,\cdots)$ in Bellman
StatStage	static	Stationary Stage of value iteration.
StorePA	static	store Α.D x Θ.D matrix of choice probabilities
ThetaCreated	static	CreateSpaces() has been called or not.
time0	static	base time mark.
UpdateTime	static	Indicators for when transit update occurs.
UseStateList	static	.
Public methods
NewPhase	static	Cumulate time on current phase, report time, set new phase.
Reset	static
SetPrunable	static	Sets Prunable to TRUE if the clock setting makes automatic pruning of the state space valid.
TimeProfile	static	Report the time spent in different phases of the calculations.

Hooks : DDPauxiliary : Zauxiliary

Manages an array (stored in hooks) that holds user-defined static functions/methods to call at different points in the solution process.

Hooks are places in the DP solution process where the user can add code to be carried out. This is done using the Add() procedure. Hooks are a list of procedures to be called so more than one procedure can be carried out.

Reset() will re-initialize hooks so that you can change what is done between one solution method and the next.

See also:: HookTimes, SetUpdateTime

Public fields
h	static
hooks	static
Public methods
Add	static	Add a static function or method to a hook.
Do	static	Call all the methods on the hook.
Reset	static	Empty the hooks (delete first if already created).

I : DDPauxiliary : Zauxiliary

Dynamically updated indices into state spaces.

Public fields
all	static	vector of current indices into spaces.
curg	static	current point in group space, γ..
curth	static	current point in state space, θ.
CVdelta	static	The current value of δ.
f	static	index of current fixed group.
g	static	index of current γ group.
later	static	.
majt	static	Current value of majt.
OO	static	matrix of offsets.
r	static	index of current random group.
rtran	static	index into dynamic random group.
subt	static	Current value of sub period s.
t	static	Current value of t.
Public methods
Initialize	static
NowSet	static	Initialize now and later indices for Bellman iteration.
NowSwap	static	Swap the now and later indices for Bellman iteration.
Set	static
SetExogOnly	static
SetGroup	static

Labels : DDPauxiliary : Zauxiliary

Contains arrays of labels for variables.

Public fields
V	static	arrays of labels of variable objects.
Vprt	static	abbreviated labels of variable objects.
Public methods
Initialize	static

N : DDPauxiliary : Zauxiliary

Numbers and sizes of vectors related to the dynamic program. All elements are static and now object is created. A user's code can reference these variables but should never change them.

Public fields
A	static	Α.N=rows(ActionMatrix), N unconstrained actions.
AA	static	rows of feasible action sizes.
All	static	uninitialized state.
Approximated	static	Number of states approximated (not subsampled).
aux	static	number of auxiliary variables, sizeof of Chi
Av	static	columns(ActionMatrix), action variables
DynR	static	either 0 or R
Ewidth	static	Width of columns in pandv for given eta.
F	static	number of fixed effect groups.
G	static	number of groups, Γ.D
insamp	static	T array of indices in subsample.
invLam	static	storage for (I-Lam) inverse.
J	static	Number of different action sets.
MaxSZ	static	Submsample parameter.
MinSZ	static	Submsample parameter.
Mitstates	static	# of iteration points SS[iterating].size.
Options	static	vector of sizes of feasible action sets.
R	static	number of random groups
ReachableIndices	static	.
ReachableStates	static	Count of reachable states.
S	static	number of all state variables.
SampleProportion	static	FALSE means no subsampling.
T	static	counter.t.N, the decision horizon.
TerminalStates	static	Count of terminal states.
tfirst	static	lowest state index for each t.
VV	static	Scratch space for value iteration.
Public methods
Initialize	static
IsReachable	static
picked	static
print	static
Reached	static
Reset	static
SetSubSample	static
Sizes	static
SubSample	static
SubSampleDone	static
ZeroVV	static

TrackObj : DDPauxiliary : Zauxiliary

Contains information on an object (variable, auxiliary outcome, etc) to be tracked.

Public fields
hist
hN
hv
LorC	const	column label of index
mean
pos	const	Position in the flat list
sqmean
v
Public methods
print	virtual
TrackObj		Track an object in a prediction path.
Update	virtual

Global

Enumerations

ClockTypes

Send one of these tags as first argument to SetClock() to use that clock.

Tag	Clock Type
InfiniteHorizon	Stationary(FALSE)
Ergodic	Stationary(TRUE)
SubPeriods	Divided(…)
NormalAging	Aging(…)
StaticProgram	StaticP(…)
RandomAging	AgeBrackets(…)
RandomMortality	Mortality(…)
UncertainLongevity	Longevity(…)
RegimeChange	Not Coded Yet
SocialExperiment	PhasedTreatment(…)

InfiniteHorizon, Ergodic, SubPeriods, NormalAging, StaticProgram, RandomAging, RandomMortality, UncertainLongevity, RegimeChange, SocialExperiment, UserDefined, NClockTypes

DataColumnTypes

Kinds of variables in data sets.

idvar	Identifier for the path (agent)
avar	ActionVariable
svar	StateVariable
idvar	AuxiliaryValue
freqvar	Frequency (weight to apply to this observation)

idvar, avar, svar, auxvar, freqvar, NColumnTypes

DPPhases

Phases of DP computations. The current phase is set by the code and time spent in each phase is tracked.

See also:: TimeProfile

INBETWEEN, INITIALIZING, SOLVING, SIMULATING, LIKING, PREDICTING, NDPhases

FlatOptions Flat views of panel data. LONG, WIDE, FlatOptions

GMMWeightOptions

Weighting of moments in GMM. \

`UNWEIGHTED`	No weighting occurs
`UNCORRELATED`	Each difference between empirical and predicted moments is weighted by the inverse of its (bounded) sample standard deviation. This treats each moment as uncorrelated with other moments, including contemporaneous moments. In addition, each moment has an ad hoc influnce weight that is read in from the data for time value t=-1.
`IGNOREINFLUENCE`	Same as UNCORRELATED, but any influence weight in the data (at t=-1) is ignored.
`CONTEMPORANEOUS`	[NOT YET IMPLEMENTED]. This reads in a matrix of weights to apply to each time period's differences pre
`INTERTEMPORAL`	This applies a matrix of weights to the full path, read in from files with names `pathW_ff.mat` and ff is the index of the fixed group. These files are created by
`AUGMENTEDPATHW`	This augments path weighting matrices. Moments that do not vary have weight 0. This weights these moments by 0.01 so that they are matched as well as variable moments.

UNWEIGHTED, UNCORRELATED, IGNOREINFLUENCE, CONTEMPORANEOUS, INTERTEMPORAL, AUGMENTEDPATHW, GMMWeightOptions

HookTimes

Points in the solution process that users can insert static functions or methods.

PreAuxOutcomes Called by ExpectedOutcomes() and AuxLikelihood() as they run, which only happen if there are AuxiliaryValues added to the model. At this point all state variables have been synched and each aux value's Realize() or Likelihood method will be called. This allows the model to compute realized values at a given value of $\eta$ and $\theta$ and store them temporarily.

PreUpdate Called by Transitions(). The point this occurs depends on UpdateTime

The times below are ordered in decreasing frequency of execution.

AtThetaTrans Called by Method::Run() for each endogenous state θ before the transition is computed.

PostSmooth Called by Run() after each time the value of a state has been computed and Smooth() has been called to compute choice probabilities. That is, it is called only when setPstar is TRUE. For stationary models this is only when convergence has been reached. For non-stationary times it is after each value iteration.

PostGSolve Called by RandomSolve::Run() after a call to GSolve has traversed the state space. That is, after the value of all states has been found.

PostRESolve Called by Run() after all random effects have been solved. That is, after all choice probabilities relevant to observationally-equivalent problems have been computed. At this point a mixture over choice probabilities coudl be could be computed.

PostFESolve Called by Solve() after all fixed effect groups have been solved. That is, after all problems defined by the user's DP model have been solved.

GroupCreate Called by the task that sets up the group space Gamma (Γ) before creation of each separate group. The function added here should return TRUE if the group should be created and FALSE otherwise.

See also:: Hooks, UpdateTime

PreAuxOutcomes, PreUpdate, AtThetaTrans, PostSmooth, PostGSolve, PostRESolve, PostFESolve, GroupCreate, NHooks

InteractionTypes Type of Interaction Auxiliary Values. NoInt, StateInt, ActInt, AuxInt, InteractionTypes

LikelihoodTypes

Type of likelihood function to build based on observability. CCLikeExogLikePartObsLike [default]

Tag	Explanation
	Everything is observed except for the additive choice-specific error ζ. Auxiliary values cannot contribute anything extra information. See CCLikelihood
	The exogenous vector ε is also unobserved. Under this form the likelihood of AuxiliaryValues is relevant and AuxLikelihood() is called for each observation and each value of ε
	Account for (sum over) any form of unobservability in states and actions. Currently this form cannot incorporate likelihood of auxiliary values.

See also:: OutcomeDataSet, IIDLikelihood, PartialObservedLikelihood

CCLike, ExogLike, PartObsLike, LikelihoodTypes

NReachTypes

Categories of Endgoenous State Reachability.

Tag	Means
InUnRchble	Unreachable because a state variable is inherently unreachable
UUnRchble	Unreacheable because a user Reachable returns FALSE
Rchble	Reachable

InUnRchble, UUnRchble, Rchble, NReachTypes

SmoothingMethods

Ways to smooth choice probabilities without adding an explicit continuous error ζ.

NoSmoothing

Optimal choices are equally likely, sub-optimal choices have zero choice probability:

$n^\star = $ number of feasible choices in $\arg\max\ v(\alpha;\theta)$.

$P^\star (\alpha;\theta) = I\left\{\alpha \in \arg\max_{\alpha}\ v(\alpha;\theta)\right\} / n^\star$

Note: exogenous (ε) and semi-exogenous (η) state variables are allowed but they are suppressed in the notation for readibility.

LogitKernel

$$P^\star = {e^{\rho\left(v(\alpha)-V\right)} \over \sum_{a\in A(\theta) } e^{\rho\left(v(a)-V\right)}}$$

GaussKernel

… to be added

NoSmoothing, LogitKernel, GaussKernel, ExPostSmoothingMethods

StateCategories Categories of state variables. These categories are used mainly for summarizing the model. NONRANDOMSV, RANDOMSV, COEVOLVINGSV, AUGMENTEDV, TIMINGV, TIMEINVARIANTV, NStateCategories

SubSpaces

Groups of continguous SubVectorNames.

Explanation

Many aspects of a model solution or application require processing more than one of the vector types organized by SubVectorNames. In essentially all such tasks the vectors to be processed are next to each other in the order they are stored in S.

The different sets of vectors that might be needed to carry out a task are then group into a range of elements of the sub vector list.

Different ranges of subvectors are represented as objects of the SubSpace class. Subspace information is somewhat similar to the information in Space, and neither class stores the state variables themselves.

Many of these ranges consist of only one vector. They are the ones that have only in their name. For example, onlyexog is the subspace that consists of only the endog space (the ε vector in the mathematical description.).

The table below only describes the subspaces that are not the same as a vector.

, except only the leftmost element of the clock (the actual t variable) is included. This avoids storing unnecessary information about t'.

bothexog	All state variables that either exogenous or semi-exogenous. That is, mathematically it is the concatentation of ε and η
tracking	All state variables that are required for tracking results of the model solution. In the model this is simply θ again, but internally it is both the `endog` and `clock` vectors
iterating	State variables needed when iterating on Bellman's equation. This subspace includes all elements of the clock block.
bothgroup	The full group vector γ, concatenating the `rgroup` and `fgroup` spaces.

onlyacts, onlyexog, onlysemiexog, bothexog, onlyendog, tracking, onlyclock, allstates, iterating, onlyrand, onlydynrand, onlyfixed, bothgroup, DSubSpaces

SubVectorNames

Vectors of state variables.

Explanation

Typically the user does not need to use these names unless building a new solution method or similar core programming. This information is for those curious about how the underlying code is organized.

In the mathematical description of a DDP model, there are several vectors of variables. These variables are represented by objects in the model and the overall list of variable objects added to the model is stored in States.

The vectors themselves are lists (oxarrays) of objects which store store a pointer to (not a separate copy of) the state variables in States. This list of lists of variables is stored in SubVectors.

To get things done the aspects of the separate state variables has to be combined into information about the vector they belong. The list SubVectors itself cannot capture that aggregate information.

This aggreate information about the variables in a vector include how many endogenous state variables there are and how many points in the space they create. This information is constructed by CreateSpaces() for each vector and storedin objects of the Space class. The list of Space objects is itself an oxarray held in DP::S (which is documented only in the internal version of this documentation).

The integer tags listed here are the internal names of the elements of both that array and the array SubVectors of variable objects.

For example, when the user's code calls EndogenousStates() it adds the objects sent as arguments to the list DP::SubVectors[endog]. Then CreateSpaces() will go through that list and create information about the endogenous space Θ and store it in object DP::S[endog]

acts The components of the action vector α. Including action variables in the same list of lists makes the internal code a little cleaner.

exog The fully exogenous vector ε

semiexog The semi-exogenous vector η

endog The endogenous vector θ (not including the clock).

clock The clock block. In the mathematical description the clock is an element of θ to avoid yet another vector and Greek letter. However, internally it is easier to separate the clock block from θ

rgroup The RandomEffect elements of the group vector γ. Again, to avoid extra notation, the mathematical description puts both random and fixed effects into one vector, but internally they are stored on separate lists.

fgroup The FixedEffect elements of γ.

DSubVectors The number of different vectors.

LeftSV Equivalent to exog. This is the index of the leftmost true state vector. This ensures some internal loops over vectors start at the right place even if additional vectors have to be added later to the code.

acts, exog, semiexog, endog, clock, rgroup, fgroup, DSubVectors, LeftSV

TransStore Elements of array stored at each theta. Qtr, Qit, Qrho, TransStore

UpdateTimes

Point in solving when updating of parameters and transitions needs to occur.

InCreateSpaces	Transitions do not depend on any parameters that change so they can be initialized in CreateSpaces() and never recalculated.
WhenFlagIsSet	Update transitions at the start of Solve() but ONLY if the RecomputeTrans() has been called. This ensures that if transitions depend on parameters that are controlled by the outside but multiple calls to solve will be made for the same parameter values (say while computing equilibrium prices and transitions only depend on parameters)
OnlyOnce	Update transitions just once on each call to Solve(). This ensures that if transitions depend on parameters that are controlled by the outside (say by an optimization algorithm) the probabilities used in solving the model will reflect any changes in the parameters since the last time the solution method was applied.
AfterFixed	Update transitions after the value of the fixed groups is set. This will allow transitions to depend on the value of fixed effect variables.
AfterRandom	Update transitions after the value of the random groups is set. This will allow transitions to depend on the value of both fixed and random effect variables.

There is a potentially large computational cost of updating the transitions more often than is necessary.

See also:: SetUpdateTime

InCreateSpaces, WhenFlagIsSet, OnlyOnce, AfterFixed, AfterRandom, UpdateTimes

Vspace Names for 0 and 1 for Bellman iteration. In ValueIteration an 2-array of vectors are stored as scratch-space for Bellman iteration. now and later toggled back and forth between 0 and 1 as iteration procedes which avoids copy potentially large vectors each time. NOW, LATER, DVspace

ClockTypeLabels

static const decl ClockTypeLabels

parallel array of labels for the built-in clock types.

exogoffs

static decl exogoffs

$\eta$ and $\epsilon$ subspaces.

Fgamma

static decl Fgamma

2-dimensiona array pointing to $\Gamma$, [r,f].

Gamma

static decl Gamma

$\Gamma$: array (list) of groups of fixed and random effects, $\gamma$.

groupoffs

static decl groupoffs

$\Gamma$ related subspaces.

ilistnames

static const decl ilistnames

maskoffs

static decl maskoffs

NDPlabels

const decl NDPlabels

ReverseState

ReverseState ( Ind , subsp )

Recreate a State vector from an index and offset vector.

Parameters:

Ind,	integer or row vector of integers
subsp	SubSpaces, index into offset vector OO

Returns:

matrix of state vectors with index Ind given subspace

Theta

static decl Theta

$\Theta$: array (list) of endogenous states $\theta$.

thetaoffs

static decl thetaoffs

$\theta$ tracking or iterating indices.

Alpha

A

static decl A [public]

Current ACTUAL feasible actions.

aA

static decl aA [public]

Simulated actual realized action .

aC

static decl aC [public]

Simulated realized action (row of C).

AddA

aI

static decl aI [public]

row index of simulated alpha.

AIlist

static decl AIlist [public]

Array of indices into Matrix for each feasible set .

aL1

static decl aL1 [public]

First character of action labels.

AList

static decl AList [public]

List of actual feasible action matrices (AV values), automatically updated. Each point in the endogenous state space has an index: Aind into this list.

Aprint

C

static decl C [public]

Current feasible action matrix.

See also:: CV

ClearA

CList

static decl CList [public]

list of feasible action matrices (CV) values. Each point in the endogenous state space has an index: Aind into this list. .

Count

static decl Count [public]

(vector) Number of states for each A set.

Initialize

Matrix

static decl Matrix [public]

matrix of all action vectors, A. This is a copy of CList[0]. As action variables are added to the model using Actions(), this matrix is built up. CreateSpaces() then calls FeasibleActions() for each endogenous state θ. Different feasible sets are then added to CList.

N

static decl N [public]

Rows of A, # of feasible actions.

ResetA

Rlabels

static decl Rlabels [public]

Array of Array labels for rows of A that look like α.

SetA

Sets

static decl Sets [public]

List of Feasible Action indicators (column vector of 0s and 1s).

Flags

AllGroupsExist

static decl AllGroupsExist [public]

Integer TRUE (default) means all possible combination of fixed and random groups exist in the group space Γ and should be created. If you add a function to the GroupCreate Hooks then this is set FALSE. Your function should return TRUE if the current group oup should be created.

See also:: Hooks, HookTimes, Add, FixedEffect, RandomEffect

CallTrans

static decl CallTrans [public]

If UpdateTime=WhenFlagIsSet then next Solve() will update transitions.

HasBeenUpdated

static decl HasBeenUpdated [public]

Transitions has been called.

HasFixedEffect

static decl HasFixedEffect [public]

Γ already includes fixed effects

HasKeptZ

static decl HasKeptZ [public]

Includes a kept continuous state variable.

inctime

static decl inctime [public]

time increment.

IsErgodic

static decl IsErgodic [public]

create space to store $P(\theta';\alpha,\theta)$ and update it if SetPstar during interation.

NewPhase

static Flags :: NewPhase ( nuphase , report )

Cumulate time on current phase, report time, set new phase.

Parameters:

nuphase	DDPhases to start. If INITIALIZING all runtimes are set to 0. INBETWEEN [default]. Next phase is not determined at this point.
report	FALSE [default] silent TRUE print out time report for the ending phase This is called internally to track time spent in different stages of the program.

NKstep

static decl NKstep [public]

Newton-Kantorovich Step is active.

onlyDryRun

static decl onlyDryRun [public]

Do not create Θ, but do everything else.

Phase

static decl Phase [public]

Phase of model solution or use.

See also:: DPPhases

Prunable

static decl Prunable [public]

TRUE if clock is finite horizon so automatic pruning can apply.

ReadIN

static decl ReadIN [public]

Read I and N objects from .dim file (avoids one span of the state space to find reachable indices.

Reset

runtime

static decl runtime [public]

vector of time spent in each phase.

SetPrunable

static Flags :: SetPrunable ( clock )

Sets Prunable to TRUE if the clock setting makes automatic pruning of the state space valid.

User code does not call this.

Clocks that are prunable:

See also:: IsReachable

setPstar

static decl setPstar [public]

set $P^*(\alpha,\cdots)$ in Bellman

StatStage

static decl StatStage [public]

Stationary Stage of value iteration.

StorePA

static decl StorePA [public]

store Α.D x Θ.D matrix of choice probabilities

ThetaCreated

static decl ThetaCreated [public]

CreateSpaces() has been called or not.

time0

static decl time0 [public]

base time mark.

TimeProfile

static Flags :: TimeProfile ( fn )

Report the time spent in different phases of the calculations.

Parameters:

fn	a file pointer or an integer (print to screen)

UpdateTime

static decl UpdateTime [public]

Indicators for when transit update occurs.

See also:: SetUpdateTime

UseStateList

static decl UseStateList [public]

Hooks

Add

static Hooks :: Add ( time , proc )

Add a static function or method to a hook.

Parameters:

time	integer tag HookTimes, point in time (where in model solution) to call the routine.
proc	static function or method to call.

Example:

Say hello after every Bellman iteration is complete:

 sayhello() { print("hello"); }
 Hooks::Add(PostGSolve,sayhello);

See also:

HookTimes, SetUpdateTime

Do

static Hooks :: Do ( ht )

Call all the methods on the hook. This is called internally. User code should not do this.

Parameters:

ht	one of the HookTimes

Returns:

vector of integer return values of hooks (currently not used)

h

static decl h [public]

hooks

static decl hooks [public]

Reset

static Hooks :: Reset ( )

Empty the hooks (delete first if already created).

I

all

static decl all [public]

vector of current indices into spaces.

curg

static decl curg [public]

current point in group space, γ.. Set in Set.

curth

static decl curth [public]

current point in state space, θ. Set in Set.

CVdelta

static decl CVdelta [public]

The current value of δ. This is set in Transitions() to avoid repeated calls to CV.

See also:: delta

f

static decl f [public]

index of current fixed group.

g

static decl g [public]

index of current γ group.

Initialize

later

static decl later [public]

. @interanl

majt

static decl majt [public]

Current value of majt. This equals t unless the clock is Divided.

NowSet

static I :: NowSet ( )

Initialize now and later indices for Bellman iteration.

NowSwap

static I :: NowSwap ( )

Swap the now and later indices for Bellman iteration.

OO

static decl OO [public]

matrix of offsets.

r

static decl r [public]

index of current random group.

rtran

static decl rtran [public]

index into dynamic random group.

Set

SetExogOnly

SetGroup

subt

static decl subt [public]

Current value of sub period s. This identically 0 unless the clock is Divided.

See also:: Divided

t

static decl t [public]

Current value of t.

Labels

Initialize

V

static decl V [public]

arrays of labels of variable objects.

Vprt

static decl Vprt [public]

abbreviated labels of variable objects.

N

A

static decl A [public]

Α.N=rows(ActionMatrix), N unconstrained actions.

AA

static decl AA [public]

rows of feasible action sizes.

All

static decl All [public]

uninitialized state.

Approximated

static decl Approximated [public]

Number of states approximated (not subsampled).

aux

static decl aux [public]

number of auxiliary variables, sizeof of Chi

Av

static decl Av [public]

columns(ActionMatrix), action variables

DynR

static decl DynR [public]

either 0 or R

Ewidth

static decl Ewidth [public]

Width of columns in pandv for given eta.

F

static decl F [public]

number of fixed effect groups.

G

static decl G [public]

number of groups, Γ.D

Initialize

insamp

static decl insamp [public]

T array of indices in subsample.

invLam

static decl invLam [public]

storage for (I-Lam) inverse.

IsReachable

J

static decl J [public]

Number of different action sets.

MaxSZ

static decl MaxSZ [public]

Submsample parameter.

MinSZ

static decl MinSZ [public]

Submsample parameter.

Mitstates

static decl Mitstates [public]

# of iteration points SS[iterating].size.

Options

static decl Options [public]

vector of sizes of feasible action sets.

picked

print

R

static decl R [public]

number of random groups

ReachableIndices

static decl ReachableIndices [public]

ReachableStates

static decl ReachableStates [public]

Count of reachable states.

Reached

Reset

S

static decl S [public]

number of all state variables.

SampleProportion

static decl SampleProportion [public]

FALSE means no subsampling. Otherwise, pattern of subsampling of the state space.

See also:: SubSampleStates

SetSubSample

Sizes

SubSample

SubSampleDone

T

static decl T [public]

counter.t.N, the decision horizon.

TerminalStates

static decl TerminalStates [public]

Count of terminal states.

tfirst

static decl tfirst [public]

lowest state index for each t.

VV

static decl VV [public]

Scratch space for value iteration.

ZeroVV

TrackObj

hist

decl hist [public]

hN

decl hN [public]

hv

decl hv [public]

LorC

const decl LorC [public]

column label of index

mean

decl mean [public]

pos

const decl pos [public]

Position in the flat list

print

sqmean

decl sqmean [public]

TrackObj

TrackObj :: TrackObj ( LorC , obj , pos )

Track an object in a prediction path.

Parameters:

LorC

obj

pos

Update

v

decl v [public]