More succinct naming

Author: Frankie Robertson

benchmark/benchmarks.jl

@@ -38,10 +38,10 @@ function prepare_4pls(group)
     response_idxs = sample(rng, 1:20, 10)
 
     for (est_nick, ability_estimator) in ability_estimators
-        next_item_rule = ItemStrategyNextItemRule(
+        next_item_rule = ItemCriterionRule(
             ExhaustiveSearch(),
             ExpectationBasedItemCriterion(PointResponseExpectation(ability_estimator),
-                AbilityVarianceStateCriterion(
+                AbilityVariance(
                     integrator, distribution_estimator(ability_estimator)))
         )
         next_item_rule = preallocate(next_item_rule)

docs/examples/examples/ability_convergence_3pl.jl

@@ -20,8 +20,8 @@ using Distributions: Normal, cdf
 using AlgebraOfGraphics
 using ComputerAdaptiveTesting
 using ComputerAdaptiveTesting.Sim: auto_responder
-using ComputerAdaptiveTesting.NextItemRules: AbilityVarianceStateCriterion
-using ComputerAdaptiveTesting.TerminationConditions: FixedItemsTerminationCondition
+using ComputerAdaptiveTesting.NextItemRules: AbilityVariance
+using ComputerAdaptiveTesting.TerminationConditions: FixedLength
 using ComputerAdaptiveTesting.Aggregators: PosteriorAbilityEstimator,
     MeanAbilityEstimator, LikelihoodAbilityEstimator
 using FittedItemBanks
@@ -49,8 +49,8 @@ integrator = FixedGKIntegrator(-6, 6, 80)
 dist_ability_est = PosteriorAbilityEstimator(std_normal)
 ability_estimator = MeanAbilityEstimator(dist_ability_est, integrator)
 rules = CatRules(ability_estimator,
-    AbilityVarianceStateCriterion(dist_ability_est, integrator),
-    FixedItemsTerminationCondition(max_questions))
+    AbilityVariance(dist_ability_est, integrator),
+    FixedLength(max_questions))
 
 points = 500
 xs = range(-2.5, 2.5, length = points)

docs/examples/examples/ability_convergence_mirt.jl

@@ -21,7 +21,7 @@ using AlgebraOfGraphics
 using ComputerAdaptiveTesting
 using ComputerAdaptiveTesting.Sim: auto_responder
 using ComputerAdaptiveTesting.NextItemRules: DRuleItemCriterion
-using ComputerAdaptiveTesting.TerminationConditions: FixedItemsTerminationCondition
+using ComputerAdaptiveTesting.TerminationConditions: FixedLength
 using ComputerAdaptiveTesting.Aggregators: PosteriorAbilityEstimator,
     MeanAbilityEstimator, LikelihoodAbilityEstimator
 using FittedItemBanks
@@ -53,7 +53,7 @@ ability_estimator = MeanAbilityEstimator(PosteriorAbilityEstimator(std_mv_normal
     integrator)
 rules = CatRules(ability_estimator,
     DRuleItemCriterion(ability_estimator),
-    FixedItemsTerminationCondition(max_questions))
+    FixedLength(max_questions))
 
 # XXX: We shouldn't need to specify xs here since the distributions are not used -- rework
 points = 3

docs/examples/examples/vocab_iq.jl

@@ -42,8 +42,8 @@ function run_vocab_iq_cat()
     ability_estimator = ModeAbilityEstimator(dist_ability_est, optimizer)
     @info "run_cat" ability_estimator
     rules = CatRules(ability_estimator,
-        AbilityVarianceStateCriterion(dist_ability_est, ability_integrator),
-        FixedItemsTerminationCondition(45))
+        AbilityVariance(dist_ability_est, ability_integrator),
+        FixedLength(45))
     function get_response(response_idx, response_name)
         params = item_params(item_bank, response_idx)
         println("Parameters for next question: $params")

docs/src/creating_a_cat.md

@@ -79,13 +79,13 @@ ComputerAdaptiveTesting.NextItemRules.RandomNextItemRule
 
 Other rules are created by combining a `ItemCriterion` -- which somehow rates
 items according to how good they are -- with a `NextItemStrategy` using an
-`ItemStrategyNextItemRule`, which acts as an adapter. The default
+`ItemCriterionRule`, which acts as an adapter. The default
 `NextItemStrategy` (and currently only) is `ExhaustiveSearch`. When using
 the implicit constructors, `ItemCriterion` can therefore be used directly
 without wrapping in any place an NextItemRule is expected.
 
 ```@docs; canonical=false
-ComputerAdaptiveTesting.NextItemRules.ItemStrategyNextItemRule
+ComputerAdaptiveTesting.NextItemRules.ItemCriterionRule
 ```
 
 ```@docs; canonical=false
@@ -114,17 +114,17 @@ takes a `ResponseExpectation`: either `PointResponseExpectation` or
 good a particular state is in terms getting a good estimate of the test takers
 ability. They look one ply ahead to get the expected value of the
 ``StateCriterion`` after selecting the given item. The
-`AbilityVarianceStateCriterion` looks at the variance of the ability ``\theta``
+`AbilityVariance` looks at the variance of the ability ``\theta``
 estimate at that state.
 
 ### Stopping rules with `TerminationCondition`
 
-Currently the only `TerminationCondition` is `FixedItemsTerminationCondition`, which ends the test after a fixed number of items.
+Currently the only `TerminationCondition` is `FixedLength`, which ends the test after a fixed number of items.
 
 ```@docs; canonical=false
 ComputerAdaptiveTesting.TerminationConditions.TerminationCondition
 ```
 
 ```@docs; canonical=false
-ComputerAdaptiveTesting.TerminationConditions.FixedItemsTerminationCondition
+ComputerAdaptiveTesting.TerminationConditions.FixedLength
 ```

docs/src/stateful.md

@@ -28,7 +28,7 @@ Stateful.get_ability
 There is an implementation in terms of [CatRules](@ref):
 
 ```@docs
-Stateful.StatefulCatConfig
+Stateful.StatefulCatRules
 ```
 
 ## Usage

src/Compat/CatR.jl

@@ -6,7 +6,7 @@ using ComputerAdaptiveTesting.Aggregators: AbilityIntegrator,
                                            ModeAbilityEstimator,
                                            MeanAbilityEstimator,
                                            PosteriorAbilityEstimator
-using ComputerAdaptiveTesting.TerminationConditions: RunForeverTerminationCondition
+using ComputerAdaptiveTesting.TerminationConditions: RunForever
 using ComputerAdaptiveTesting.Rules: CatRules
 using ComputerAdaptiveTesting.NextItemRules
 using PsychometricsBazaarBase: Integrators, Optimizers
@@ -19,15 +19,15 @@ function _next_item_aliases()
         "MFI" => InformationItemCriterion,
         "bOpt" => UrryItemCriterion,
     )
-        res[nick] = (bits...; kwargs...) -> ItemStrategyNextItemRule(
+        res[nick] = (bits...; kwargs...) -> ItemCriterionRule(
             ExhaustiveSearch(),
             mk_item_criterion(bits...))
     end
-    res["MEPV"] = (bits...; posterior_ability_estimator, kwargs...) -> ItemStrategyNextItemRule(
+    res["MEPV"] = (bits...; posterior_ability_estimator, kwargs...) -> ItemCriterionRule(
         ExhaustiveSearch(),
         ExpectationBasedItemCriterion(bits...,
-            AbilityVarianceStateCriterion(posterior_ability_estimator, AbilityIntegrator(bits...))))
-    res["MEI"] = (bits...; kwargs...) -> ItemStrategyNextItemRule(
+            AbilityVariance(posterior_ability_estimator, AbilityIntegrator(bits...))))
+    res["MEI"] = (bits...; kwargs...) -> ItemCriterionRule(
         ExhaustiveSearch(),
         ExpectationBasedItemCriterion(bits...,
             InformationItemCriterion(bits...)))
@@ -64,7 +64,7 @@ const ability_estimator_aliases = _ability_estimator_aliases()
 #=
         for (resp_exp, resp_exp_nick) in resp_exp_nick_pairs
             next_item_rule = NextItemRule(
-                ExpectationBasedItemCriterion(resp_exp, AbilityVarianceStateCriterion(numtools.integrator, distribution_estimator(abil_est)))
+                ExpectationBasedItemCriterion(resp_exp, AbilityVariance(numtools.integrator, distribution_estimator(abil_est)))
             )
             next_item_rule = preallocate(next_item_rule)
             est_next_item_rule_pairs[Symbol("$(abil_est_str)_mepv_$(resp_exp_nick)")] = (abil_est, next_item_rule)
@@ -99,10 +99,10 @@ function assemble_rules(;
     ability_estimator = ability_estimator_aliases[method](; integrator, optimizer)
     posterior_ability_estimator = PosteriorAbilityEstimator()
     raw_next_item = next_item_aliases[criterion](ability_estimator, integrator, optimizer; posterior_ability_estimator=posterior_ability_estimator)
-    next_item = FixedFirstItemNextItemRule(start_item, raw_next_item)
+    next_item = FixedFirstItem(start_item, raw_next_item)
     CatRules(;
         next_item,
-        termination_condition = RunForeverTerminationCondition(),
+        termination_condition = RunForever(),
         ability_estimator,
         #ability_tracker::AbilityTrackerT = NullAbilityTracker()
     )

src/Compat/MirtCAT.jl

@@ -8,7 +8,7 @@ using ComputerAdaptiveTesting.Aggregators: SafeLikelihoodAbilityEstimator,
                                            PosteriorAbilityEstimator,
                                            AbilityEstimator,
                                            distribution_estimator
-using ComputerAdaptiveTesting.TerminationConditions: RunForeverTerminationCondition
+using ComputerAdaptiveTesting.TerminationConditions: RunForever
 using ComputerAdaptiveTesting.NextItemRules
 using ComputerAdaptiveTesting.Rules: CatRules
 using PsychometricsBazaarBase: Integrators, Optimizers
@@ -23,7 +23,7 @@ function _next_item_helper(item_criterion_callback)
             optimizer,
         ]
         item_criterion = item_criterion_callback(; bits, ability_estimator, posterior_ability_estimator, integrator, optimizer)
-        return ItemStrategyNextItemRule(ExhaustiveSearch(), item_criterion)
+        return ItemCriterionRule(ExhaustiveSearch(), item_criterion)
     end
     return _helper
 end
@@ -34,7 +34,7 @@ const next_item_aliases = Dict(
     # 'MEPV' for minimum expected posterior variance
     "MEPV" => _next_item_helper((; bits, ability_estimator, posterior_ability_estimator, integrator, rest...) -> ExpectationBasedItemCriterion(
         ability_estimator,
-        AbilityVarianceStateCriterion(posterior_ability_estimator, integrator))),
+        AbilityVariance(posterior_ability_estimator, integrator))),
     "MEI" => _next_item_helper((; bits, ability_estimator, rest...) -> ExpectationBasedItemCriterion(
         ability_estimator,
         PointItemCategoryCriterion(EmpiricalInformationPointwiseItemCategoryCriterion(), ability_estimator)
@@ -145,11 +145,11 @@ function assemble_rules(;
     ability_estimator = ability_estimator_aliases[method](; integrator, optimizer, ncomp)
     posterior_ability_estimator = PosteriorAbilityEstimator(; ncomp)
     raw_next_item = next_item_aliases[criteria](ability_estimator, posterior_ability_estimator, integrator, optimizer)
-    next_item = FixedFirstItemNextItemRule(start_item, raw_next_item)
+    next_item = FixedFirstItem(start_item, raw_next_item)
     CatRules(;
         next_item,
         ability_estimator,
-        termination_condition = RunForeverTerminationCondition(),
+        termination_condition = RunForever(),
     )
 end
 

src/Stateful.jl

@@ -14,7 +14,7 @@ using ..Responses: BareResponses, Response, Responses
 using ..NextItemRules: compute_criteria, best_item
 using ..Sim: CatLoop, Sim, item_label
 
-export StatefulCat, StatefulCatConfig
+export StatefulCat, StatefulCatRules
 public next_item, ranked_items, item_criteria
 public add_response!, rollback!, reset!, get_responses, get_ability
 
@@ -190,26 +190,28 @@ $(TYPEDSIGNATURES)
 This is a the `StatefulCat` implementation in terms of `CatRules`.
 It is also the de-facto standard for the behavior of the interface.
 """
-struct StatefulCatConfig{TrackedResponsesT <: TrackedResponses} <: StatefulCat
+struct StatefulCatRules{TrackedResponsesT <: TrackedResponses} <: StatefulCat
     rules::CatRules
     tracked_responses::Ref{TrackedResponsesT}
 end
 
-function StatefulCatConfig(rules::CatRules, item_bank::AbstractItemBank)
+function StatefulCatRules(rules::CatRules, item_bank::AbstractItemBank)
     bare_responses = BareResponses(ResponseType(item_bank))
     tracked_responses = TrackedResponses(
         bare_responses,
         item_bank,
         rules.ability_tracker
     )
-    return StatefulCatConfig(rules, Ref(tracked_responses))
+    return StatefulCatRules(rules, Ref(tracked_responses))
 end
 
-function next_item(config::StatefulCatConfig)
+StatefulCat(rules::CatRules, item_bank::AbstractItemBank) = StatefulCatRules(rules, item_bank)
+
+function next_item(config::StatefulCatRules)
     return best_item(config.rules.next_item, config.tracked_responses[])
 end
 
-function ranked_items(config::StatefulCatConfig)
+function ranked_items(config::StatefulCatRules)
     criteria = compute_criteria(
         config.rules.next_item, config.tracked_responses[])
     if criteria === nothing
@@ -218,27 +220,27 @@ function ranked_items(config::StatefulCatConfig)
     return sortperm(criteria)
 end
 
-function item_criteria(config::StatefulCatConfig)
+function item_criteria(config::StatefulCatRules)
     return compute_criteria(
         config.rules.next_item, config.tracked_responses[])
 end
 
-function add_response!(config::StatefulCatConfig, index, response)
+function add_response!(config::StatefulCatRules, index, response)
     tracked_responses = config.tracked_responses[]
     Responses.add_response!(
         tracked_responses, Response(
             ResponseType(tracked_responses.item_bank), index, response))
 end
 
-function rollback!(config::StatefulCatConfig)
+function rollback!(config::StatefulCatRules)
     Responses.pop_response!(config.tracked_responses[])
 end
 
-function reset!(config::StatefulCatConfig)
+function reset!(config::StatefulCatRules)
     empty!(config.tracked_responses[])
 end
 
-function set_item_bank!(config::StatefulCatConfig, item_bank)
+function set_item_bank!(config::StatefulCatRules, item_bank)
     bare_responses = BareResponses(ResponseType(item_bank))
     config.tracked_responses[] = TrackedResponses(
         bare_responses,
@@ -247,23 +249,23 @@ function set_item_bank!(config::StatefulCatConfig, item_bank)
     )
 end
 
-function get_responses(config::StatefulCatConfig)
+function get_responses(config::StatefulCatRules)
     return config.tracked_responses[].responses
 end
 
-function get_ability(config::StatefulCatConfig)
+function get_ability(config::StatefulCatRules)
     return (config.rules.ability_estimator(config.tracked_responses[]), nothing)
 end
 
-function likelihood(config::StatefulCatConfig, ability)
+function likelihood(config::StatefulCatRules, ability)
     pdf(distribution_estimator(config.rules.ability_estimator), config.tracked_responses[], ability)
 end
 
-function item_bank_size(config::StatefulCatConfig)
+function item_bank_size(config::StatefulCatRules)
     return length(config.tracked_responses[].item_bank)
 end
 
-function item_response_functions(config::StatefulCatConfig, index, ability)
+function item_response_functions(config::StatefulCatRules, index, ability)
     item_bank = config.tracked_responses[].item_bank
     item_response = ItemResponse(item_bank, index)
     return resp_vec(item_response, ability)

src/TerminationConditions.jl

@@ -9,8 +9,8 @@ using FittedItemBanks
 import Base: show
 
 export TerminationCondition,
-       LengthTerminationCondition, SimpleFunctionTerminationCondition
-export RunForeverTerminationCondition
+       FixedLength, SimpleFunctionTerminationCondition
+export RunForever
 
 """
 $(TYPEDEF)
@@ -25,21 +25,18 @@ end
 $(TYPEDEF)
 $(TYPEDFIELDS)
 """
-struct LengthTerminationCondition{} <: TerminationCondition
+struct FixedLength{} <: TerminationCondition
     num_items::Int64
 end
-function (condition::LengthTerminationCondition)(responses::TrackedResponses,
+function (condition::FixedLength)(responses::TrackedResponses,
         items::AbstractItemBank)
     length(responses) >= condition.num_items
 end
 
-function show(io::IO, ::MIME"text/plain", condition::LengthTerminationCondition)
+function show(io::IO, ::MIME"text/plain", condition::FixedLength)
     println(io, "Terminate test after administering $(condition.num_items) items")
 end
 
-# Alias for old name
-const FixedItemsTerminationCondition = LengthTerminationCondition
-
 struct SimpleFunctionTerminationCondition{F} <: TerminationCondition
     func::F
 end
@@ -48,8 +45,8 @@ function (condition::SimpleFunctionTerminationCondition)(responses::TrackedRespo
     condition.func(responses, items)
 end
 
-struct RunForeverTerminationCondition <: TerminationCondition end
-function (condition::RunForeverTerminationCondition)(::TrackedResponses, ::AbstractItemBank)
+struct RunForever <: TerminationCondition end
+function (condition::RunForever)(::TrackedResponses, ::AbstractItemBank)
     return false
 end