class.model.COR: Construction of Catania's Operant Reserve
In Don-Li/CAB_original:

Description Usage Arguments Details Slots References See Also Examples

Catania's Operant Reserve (COR; Catania, 2005) has been implemented in the CAB package. This is the documentation for the implementation.

1 2	make.COR(DOR_control, emission_control, dep_control, initial_reserve_control, stimulus_control, termination_control, food_duration_control, input)

`DOR_control`	A `DOR_control` object.
`emission_control`	A `emission_control` object.
`dep_control`	A `dep_control` object.
`initial_reserve_control`	A `initial_reserve_control` object.
`stimulus_control`	A `stimulus_control` object.
`termination_control`	A `termination_control` object.
`food_duration_control`	A `food_duration_control` object.
`input`	An `input` object.

COR is implemented as the model.COR class. COR requires the following control classes: DOR_control, emission_control, dep_control, initial_reserve_control, stimulus_control, termination_control, food_duration_control. See slot information.

In brief, COR is a model where the probability of responding is controlled by a construct referred to as the 'reserve'. The emission of responses depletes the value of the reserve. Reinforcement replenishes the reserve based on where reinforcement has occurred within the most recent inter-reinforcement interval. The rule that controls the replenishment to the reserve is the "delay of reinforcement gradient". See Catania (2005) and Berg & McDowell (2011) for more details.

Previous implentations of COR simulate the model at each possible discrete time point. That is, the model is asked at each point in time whether or not a response occurred. Our implementation asks when the next response will occur. This allows us to save a lot of computational time.

DOR_control: For the delay-of-reinforcement gradient.
emission_control: For the function that relates the reserve value to the time at which the next response will occur.
dep_control: For the depletion of the reserve after responding.
initial_reserve_control: For the initial level of the reserve.
stimulus_control: For the reinforcement schedule.
termination_control: For the conditions that terminate the experiment.
food_duration_control: For the food duration.
control_list: A mandatory slot for models. Inherited from the model class. The underlying representation is an environment.
enumerated_conditions: A mandatory slot for models. Inherited from the model class.
iterator: A mandatory slot for models. Inherited from the model class.
input: A mandatory slot for models. Contains all of the inputs required to run the necessary functions. Inherited from the model class.

Berg, J. P., & McDowell, J. J (2011). Quantitative, steady-state properties of Catania's computational model of the operant reserve. Behavioural Processes, 87(1), 71-83. https://doi.org/10.1016/j.beproc.2011.01.006

Catania, A. C. (2005). The operant reserve: A computer simulation in (accelerated) real time. Behavioural Processes, 69(2), 257-278. https://doi.org/10.1016/j.beproc.2005.02.009

class.control for control objects.

class.DOR for DOR objects.

class.dep for dep objects.

class.emission for emission objects.

class.initial_reserve for initial_reserve objects.

class.stimulus for stimulus objects.

class.termination for termination objects.

class.food_duration for food_duration objects.

class.input for input objects.

class.model for the model parent class.

# Make a 'model.COR' object
# Set up inputs
time_input = make.input( name = "time_input" )
resp_time = make.input( name = "resp_time" )
rft_time = make.input( name = "rft_time" )
reserve = make.input( name = "reserve" )
# Set up input object
my_inputs = make.input( time_input, resp_time, rft_time, reserve )

# Set up DOR and DOR_control
linear_DOR = make.DOR( DOR_fx = linear_DOR_fx, name = "linear_DOR" )
DOR_params = list( scale = 100, max = c(1, 0.5), "resp_time", "rft_time", "reserve" )
DOR_ctrl = make.control( linear_DOR, DOR_params )

# Set up dep and dep_control
constant_dep = make.dep( dep_fx = constant_dep_fx, name = "constant_dep" )
dep_params = list( deplete = 0.01, "reserve" )
dep_ctrl = make.control( constant_dep, dep_params )

# Set up initial_reserve and initial_reserve_control
constant_initial = make.initial_reserve( initial_reserve_fx = constant_initial_fx, name = "constant_initial" )
initial_params = list( initial = 0.75 )
initial_ctrl = make.control( constant_initial, initial_params )

# Set up stimulus and stimulus_control
vi = make.stimulus( stimulus_fx = true_VI_fx, name = "vi" )
vi_params = list( VI_interval = 2, time  = "time_input" )
schedule_ctrl = make.control( vi, vi_params )

# Set up emission and emission_control
G_E_emission = make.emission( G_E_emission_fx, name = "G_E_emission" )
emission_params = list( reserve_value = "reserve", time = "time_input", min_IRT = 1 )
emission_ctrl = make.control( G_E_emission, emission_params )

# Set up termination and termination_control
time_termination = make.termination( termination_fx = time_termination_fx, name = "time_termination" )
termination_params = list( "time", 1000 )
termination_ctrl = make.control( time_termination, termination_params )

# Set up food_duration and food_duration control
food_duration = make.food_duration( food_duration_fx = constant_food_duration_fx, name = "constant_food_duration" )
food_duration_params = list( food_dur = 3, time = "time_input" )
food_duration_ctrl = make.control( food_duration, food_duration_params )

# Make the cOR model
my_COR = make.COR( DOR_ctrl, emission_ctrl, dep_ctrl, initial_ctrl, schedule_ctrl, termination_ctrl, food_duration_ctrl, my_inputs )