| Modifier and Type | Method and Description |
|---|---|
double |
ParametricFunction.ParametricStateFunction.evaluate(State s)
Sets the input of this function to the given
State and returns
the value of it. |
double |
ParametricFunction.ParametricStateActionFunction.evaluate(State s,
Action a)
|
FunctionGradient |
DifferentiableStateValue.gradient(State s)
Returns the gradient of this function
|
FunctionGradient |
DifferentiableStateActionValue.gradient(State s,
Action a)
Returns the gradient of this function.
|
| Modifier and Type | Field and Description |
|---|---|
protected State |
DenseStateActionLinearVFA.lastState |
protected State |
DenseLinearVFA.lastState |
| Modifier and Type | Method and Description |
|---|---|
double |
DenseLinearVFA.evaluate(State s) |
double |
DenseStateActionLinearVFA.evaluate(State s,
Action a) |
double |
DenseLinearVFA.evaluate(State s,
Action a) |
double[] |
SparseToDenseFeatures.features(State s) |
double[] |
PFFeatures.features(State s) |
double[] |
NumericVariableFeatures.features(State s) |
double[] |
NormalizedVariableFeatures.features(State s) |
double[] |
DenseStateFeatures.features(State s)
Returns a feature vector represented as a double array for a given input state.
|
double[] |
ConcatenatedObjectFeatures.features(State s) |
double[] |
DenseStateActionFeatures.features(State s,
Action a)
Returns a feature vector represented as a double array for a given input state-action pair.
|
double[] |
DenseCrossProductFeatures.features(State s,
Action a) |
FunctionGradient |
DenseLinearVFA.gradient(State s) |
FunctionGradient |
DenseStateActionLinearVFA.gradient(State s,
Action a) |
FunctionGradient |
DenseLinearVFA.gradient(State s,
Action a) |
| Modifier and Type | Method and Description |
|---|---|
double[] |
FourierBasis.features(State s) |
double |
FourierBasisLearningRateWrapper.peekAtLearningRate(State s,
Action ga) |
double |
FourierBasisLearningRateWrapper.pollLearningRate(int agentTime,
State s,
Action ga) |
| Modifier and Type | Method and Description |
|---|---|
double[] |
RBFFeatures.features(State s) |
| Modifier and Type | Method and Description |
|---|---|
static List<RBF> |
GaussianRBF.generateGaussianRBFsForStates(List<State> states,
DenseStateFeatures fvGen,
DistanceMetric metric,
double epsilon)
Creates a
List of GaussianRBF units
for each State provided using the given DenseStateFeatures , metric, and epsilon value. |
static List<RBF> |
GaussianRBF.generateGaussianRBFsForStates(List<State> states,
DenseStateFeatures fvGen,
double epsilon)
Creates a
List of GaussianRBF units
for each State provided using the given DenseStateFeatures , and epsilon value
and using a default EuclideanDistance metric for all units. |
| Modifier and Type | Field and Description |
|---|---|
protected State |
LinearVFA.lastState |
| Modifier and Type | Method and Description |
|---|---|
double |
LinearVFA.evaluate(State s) |
double |
LinearVFA.evaluate(State s,
Action a) |
List<StateFeature> |
SparseStateFeatures.features(State s)
Returns non-zero state features for a given state.
|
List<StateFeature> |
SparseStateActionFeatures.features(State s,
Action a)
Returns non-zero state-action features for a given state and action.
|
List<StateFeature> |
SparseCrossProductFeatures.features(State s,
Action a) |
FunctionGradient |
LinearVFA.gradient(State s) |
FunctionGradient |
LinearVFA.gradient(State s,
Action a) |
| Modifier and Type | Method and Description |
|---|---|
List<StateFeature> |
TileCodingFeatures.features(State s) |
| Modifier and Type | Field and Description |
|---|---|
State |
SupervisedVFA.SupervisedVFAInstance.s
The state
|
| Constructor and Description |
|---|
SupervisedVFAInstance(State s,
double v)
Initializes
|
| Modifier and Type | Method and Description |
|---|---|
protected ExponentialDecayLR.StateWiseLearningRate |
ExponentialDecayLR.getStateWiseLearningRate(State s)
Returns the learning rate data structure for the given state.
|
protected SoftTimeInverseDecayLR.StateWiseTimeIndex |
SoftTimeInverseDecayLR.getStateWiseTimeIndex(State s)
Returns the learning rate data structure for the given state.
|
double |
SoftTimeInverseDecayLR.peekAtLearningRate(State s,
Action ga) |
double |
LearningRate.peekAtLearningRate(State s,
Action ga)
A method for looking at the current learning rate for a state-action pair without having it altered.
|
double |
ExponentialDecayLR.peekAtLearningRate(State s,
Action ga) |
double |
ConstantLR.peekAtLearningRate(State s,
Action ga) |
double |
SoftTimeInverseDecayLR.pollLearningRate(int agentTime,
State s,
Action ga) |
double |
LearningRate.pollLearningRate(int agentTime,
State s,
Action ga)
A method for returning the learning rate for a given state action pair and then decaying the learning rate as defined by this class.
|
double |
ExponentialDecayLR.pollLearningRate(int agentTime,
State s,
Action ga) |
double |
ConstantLR.pollLearningRate(int agentTime,
State s,
Action ga) |
| Modifier and Type | Method and Description |
|---|---|
Action |
RandomPolicy.action(State s) |
Action |
Policy.action(State s)
This method will return an action sampled by the policy for the given state.
|
Action |
GreedyQPolicy.action(State s) |
Action |
GreedyDeterministicQPolicy.action(State s) |
Action |
EpsilonGreedy.action(State s) |
Action |
CachedPolicy.action(State s) |
Action |
BoltzmannQPolicy.action(State s) |
double |
RandomPolicy.actionProb(State s,
Action a) |
double |
Policy.actionProb(State s,
Action a)
Returns the probability/probability density that the given action will be taken in the given state.
|
double |
GreedyQPolicy.actionProb(State s,
Action a) |
double |
GreedyDeterministicQPolicy.actionProb(State s,
Action a) |
double |
EpsilonGreedy.actionProb(State s,
Action a) |
double |
CachedPolicy.actionProb(State s,
Action a) |
double |
BoltzmannQPolicy.actionProb(State s,
Action a) |
static double |
PolicyUtils.actionProbFromEnum(EnumerablePolicy p,
State s,
Action a)
Returns the probability of the policy taking action a in state s by searching for the action
in the returned policy distribution from the provided
EnumerablePolicy . |
boolean |
RandomPolicy.definedFor(State s) |
boolean |
Policy.definedFor(State s)
Specifies whether this policy is defined for the input state.
|
boolean |
GreedyQPolicy.definedFor(State s) |
boolean |
GreedyDeterministicQPolicy.definedFor(State s) |
boolean |
EpsilonGreedy.definedFor(State s) |
boolean |
CachedPolicy.definedFor(State s) |
boolean |
BoltzmannQPolicy.definedFor(State s) |
static List<ActionProb> |
PolicyUtils.deterministicPolicyDistribution(Policy p,
State s)
A helper method for defining deterministic policies.
|
List<ActionProb> |
RandomPolicy.policyDistribution(State s) |
List<ActionProb> |
GreedyQPolicy.policyDistribution(State s) |
List<ActionProb> |
GreedyDeterministicQPolicy.policyDistribution(State s) |
List<ActionProb> |
EpsilonGreedy.policyDistribution(State s) |
List<ActionProb> |
EnumerablePolicy.policyDistribution(State s)
This method will return action probability distribution defined by the policy.
|
List<ActionProb> |
CachedPolicy.policyDistribution(State s) |
List<ActionProb> |
BoltzmannQPolicy.policyDistribution(State s) |
static Episode |
PolicyUtils.rollout(Policy p,
State s,
SampleModel model)
This method will return the an episode that results from following the given policy from state s.
|
static Episode |
PolicyUtils.rollout(Policy p,
State s,
SampleModel model,
int maxSteps)
This method will return the an episode that results from following the given policy from state s.
|
static Action |
PolicyUtils.sampleFromActionDistribution(EnumerablePolicy p,
State s)
This is a helper method for stochastic policies.
|
| Modifier and Type | Field and Description |
|---|---|
List<State> |
Episode.stateSequence
The sequence of states observed
|
| Modifier and Type | Method and Description |
|---|---|
State |
Episode.state(int t)
Returns the state observed at time step t.
|
| Modifier and Type | Method and Description |
|---|---|
void |
Episode.addState(State s)
Adds a state to the state sequence.
|
protected List<Action> |
MDPSolver.applicableActions(State s)
Returns all applicable actions in the provided state for all the actions that this MDP Solver can use.
|
void |
Episode.initializeInState(State initialState)
Initializes this object with the initial state in which the episode started.
|
HashableState |
MDPSolver.stateHash(State s)
A shorthand method for hashing a state.
|
void |
Episode.transition(Action usingAction,
State nextState,
double r)
Records a transition event where the agent applied the usingAction action in the last
state in this object's state sequence, transitioned to state nextState, and received reward r,.
|
| Constructor and Description |
|---|
Episode(State initialState)
Initializes a new EpisodeAnalysis object with the initial state in which the episode started.
|
| Modifier and Type | Field and Description |
|---|---|
protected Map<Integer,State> |
StateEnumerator.reverseEnumerate
The reverse enumeration id to state map
|
| Modifier and Type | Method and Description |
|---|---|
State |
StateEnumerator.getStateForEnumerationId(int id)
Returns the state associated with the given enumeration id.
|
| Modifier and Type | Method and Description |
|---|---|
static List<State> |
StateReachability.getPolicyReachableStates(SADomain domain,
EnumerablePolicy p,
State from,
HashableStateFactory usingHashFactory)
Finds the set of states that are reachable under a policy from a source state.
|
static List<State> |
StateReachability.getReachableStates(State from,
SADomain inDomain,
HashableStateFactory usingHashFactory)
Returns the list of
State objects that are reachable from a source state. |
| Modifier and Type | Method and Description |
|---|---|
void |
StateEnumerator.findReachableStatesAndEnumerate(State from)
Finds all states that are reachable from an input state and enumerates them
|
int |
StateEnumerator.getEnumeratedID(State s)
Get or create and get the enumeration id for a state
|
static Set<HashableState> |
StateReachability.getPolicyReachableHashedStates(SADomain domain,
EnumerablePolicy p,
State from,
HashableStateFactory usingHashFactory)
Finds the set of states (
HashableState ) that are reachable under a policy from a source state. |
static List<State> |
StateReachability.getPolicyReachableStates(SADomain domain,
EnumerablePolicy p,
State from,
HashableStateFactory usingHashFactory)
Finds the set of states that are reachable under a policy from a source state.
|
static Set<HashableState> |
StateReachability.getReachableHashedStates(State from,
SADomain inDomain,
HashableStateFactory usingHashFactory)
Returns the set of
State objects that are reachable from a source state. |
static List<State> |
StateReachability.getReachableStates(State from,
SADomain inDomain,
HashableStateFactory usingHashFactory)
Returns the list of
State objects that are reachable from a source state. |
protected void |
EpisodeSequenceVisualizer.updatePropTextArea(State s) |
| Modifier and Type | Method and Description |
|---|---|
List<State> |
OOStateGridder.gridState(MutableOOState s)
Generates a set of states spaced along along.
|
List<State> |
FlatStateGridder.gridState(MutableState s)
Grids the input state.
|
| Modifier and Type | Method and Description |
|---|---|
protected void |
FlatStateGridder.gridStateHelper(MutableState s,
List<Map.Entry<Object,VariableGridSpec>> gridDims,
int index,
List<State> createdStates) |
| Modifier and Type | Method and Description |
|---|---|
void |
PerformancePlotter.observeEnvironmentActionInitiation(State o,
Action action) |
| Modifier and Type | Field and Description |
|---|---|
protected List<State> |
ValueFunctionVisualizerGUI.statesToVisualize |
protected Collection<State> |
ValueFunctionRenderLayer.statesToVisualize
The states to visualize
|
protected Collection<State> |
PolicyRenderLayer.statesToVisualize
The states to visualize
|
| Modifier and Type | Method and Description |
|---|---|
Collection<State> |
ValueFunctionRenderLayer.getStatesToVisualize()
Returns the states that will be visualized
|
Collection<State> |
PolicyRenderLayer.getStatesToVisualize()
Returns the states that will be visualized
|
| Modifier and Type | Method and Description |
|---|---|
void |
StatePolicyPainter.paintStatePolicy(Graphics2D g2,
State s,
Policy policy,
float cWidth,
float cHeight)
Paints a representation of the given policy for a specific state to a 2D graphics context.
|
abstract void |
StateValuePainter.paintStateValue(Graphics2D g2,
State s,
double value,
float cWidth,
float cHeight)
Paints the representation of a value function for a specific state.
|
| Modifier and Type | Method and Description |
|---|---|
static ValueFunctionVisualizerGUI |
ValueFunctionVisualizerGUI.createGridWorldBasedValueFunctionVisualizerGUI(List<State> states,
ValueFunction valueFunction,
Policy p,
Object xVar,
Object yVar,
VariableDomain xRange,
VariableDomain yRange,
double xWidth,
double yWidth,
String northActionName,
String southActionName,
String eastActionName,
String westActionName)
A method for creating common 2D arrow glyped value function and policy visualization.
|
void |
ValueFunctionRenderLayer.setStatesToVisualize(Collection<State> stateValuesToVisualize)
Sets the states to visualize
|
void |
PolicyRenderLayer.setStatesToVisualize(Collection<State> stateValuesToVisualize)
Sets the states to visualize
|
| Constructor and Description |
|---|
PolicyRenderLayer(Collection<State> states,
StatePolicyPainter spp,
Policy policy) |
ValueFunctionRenderLayer(Collection<State> states,
StateValuePainter svp,
ValueFunction valueFunction)
Initializes the visualizer.
|
ValueFunctionVisualizerGUI(List<State> states,
StateValuePainter svp,
ValueFunction valueFunction)
Initializes the visualizer GUI.
|
| Modifier and Type | Method and Description |
|---|---|
void |
PolicyGlyphPainter2D.paintStatePolicy(Graphics2D g2,
State s,
Policy policy,
float cWidth,
float cHeight) |
void |
StateValuePainter2D.paintStateValue(Graphics2D g2,
State s,
double value,
float cWidth,
float cHeight) |
| Modifier and Type | Class and Description |
|---|---|
class |
RLGlueState
A
State for RLGLue Observation objects. |
| Modifier and Type | Field and Description |
|---|---|
protected State |
RLGlueAgent.curState
The current state of the environment
|
State |
RLGlueAgent.StateReference.val |
| Modifier and Type | Method and Description |
|---|---|
State |
RLGlueState.copy() |
State |
RLGlueAgent.currentObservation() |
static State |
RLGlueDomain.stateFromObservation(org.rlcommunity.rlglue.codec.types.Observation obsv)
Creates a BURLAP
State from a RLGlue Observation . |
| Modifier and Type | Method and Description |
|---|---|
List<Action> |
RLGlueDomain.RLGlueActionType.allApplicableActions(State s) |
| Modifier and Type | Method and Description |
|---|---|
double |
RewardValueProjection.qValue(State s,
Action a) |
List<QValue> |
RewardValueProjection.qValues(State s) |
EnvironmentOutcome |
CustomRewardModel.sample(State s,
Action a) |
boolean |
RewardValueProjection.CustomRewardNoTermModel.terminal(State s) |
boolean |
CustomRewardModel.terminal(State s) |
List<TransitionProb> |
CustomRewardModel.transitions(State s,
Action a) |
double |
RewardValueProjection.value(State s) |
| Modifier and Type | Method and Description |
|---|---|
static State |
ApprenticeshipLearning.getInitialState(List<Episode> episodes)
Returns the initial state of a randomly chosen episode analysis
|
| Modifier and Type | Method and Description |
|---|---|
Action |
ApprenticeshipLearning.StationaryRandomDistributionPolicy.action(State s) |
double |
ApprenticeshipLearning.StationaryRandomDistributionPolicy.actionProb(State s,
Action a) |
boolean |
ApprenticeshipLearning.StationaryRandomDistributionPolicy.definedFor(State s) |
List<ActionProb> |
ApprenticeshipLearning.StationaryRandomDistributionPolicy.policyDistribution(State s) |
| Modifier and Type | Method and Description |
|---|---|
FunctionGradient |
MLIRL.logPolicyGrad(State s,
Action ga)
Computes and returns the gradient of the Boltzmann policy for the given state and action.
|
| Modifier and Type | Method and Description |
|---|---|
FunctionGradient |
LinearStateDifferentiableRF.gradient(State s,
Action a,
State sprime) |
FunctionGradient |
LinearStateActionDifferentiableRF.gradient(State s,
Action a,
State sprime) |
double |
LinearStateDifferentiableRF.reward(State s,
Action a,
State sprime) |
double |
LinearStateActionDifferentiableRF.reward(State s,
Action a,
State sprime) |
| Modifier and Type | Method and Description |
|---|---|
void |
DifferentiableVI.addStateToStateSpace(State s)
Adds the given state to the state space over which VI iterates.
|
protected FunctionGradient |
DifferentiableDP.computeQGradient(State s,
Action ga)
|
protected DifferentiableSparseSampling.DiffStateNode |
DifferentiableSparseSampling.getStateNode(State s,
int height)
Either returns, or creates, indexes, and returns, the state node for the given state at the given height in the tree
|
boolean |
DifferentiableVI.performReachabilityFrom(State si)
This method will find all reachable states that will be used by the
DifferentiableVI.runVI() method and will cache all the transition dynamics. |
BoltzmannQPolicy |
DifferentiableVI.planFromState(State initialState)
Plans from the input state and returns a
BoltzmannQPolicy following the
Boltzmann parameter used for value Botlzmann value backups in this planner. |
BoltzmannQPolicy |
DifferentiableSparseSampling.planFromState(State initialState)
Plans from the input state and returns a
BoltzmannQPolicy following the
Boltzmann parameter used for value Botlzmann value backups in this planner. |
FunctionGradient |
DifferentiableSparseSampling.qGradient(State s,
Action a) |
FunctionGradient |
DifferentiableDP.qGradient(State s,
Action a) |
double |
DifferentiableSparseSampling.qValue(State s,
Action a) |
List<QValue> |
DifferentiableSparseSampling.qValues(State s) |
double |
DifferentiableSparseSampling.value(State s) |
FunctionGradient |
DifferentiableDP.valueGradient(State s) |
| Modifier and Type | Method and Description |
|---|---|
void |
DifferentiableVI.addStatesToStateSpace(Collection<State> states)
Adds a
Collection of states over which VI will iterate. |
| Modifier and Type | Method and Description |
|---|---|
FunctionGradient |
LinearDiffRFVInit.gradient(State s,
Action a,
State sp) |
FunctionGradient |
DiffVFRF.gradient(State s,
Action a,
State sprime) |
double |
LinearDiffRFVInit.reward(State s,
Action a,
State sprime) |
double |
DiffVFRF.reward(State s,
Action a,
State sprime) |
double |
VanillaDiffVinit.value(State s) |
double |
LinearStateDiffVF.value(State s) |
double |
LinearDiffRFVInit.value(State s) |
FunctionGradient |
VanillaDiffVinit.valueGradient(State s) |
FunctionGradient |
LinearStateDiffVF.valueGradient(State s) |
FunctionGradient |
LinearDiffRFVInit.valueGradient(State s) |
| Modifier and Type | Field and Description |
|---|---|
State |
QGradientTuple.s
The state
|
| Modifier and Type | Method and Description |
|---|---|
static FunctionGradient |
BoltzmannPolicyGradient.computeBoltzmannPolicyGradient(State s,
Action a,
DifferentiableQFunction planner,
double beta)
Computes the gradient of a Boltzmann policy using the given differentiable valueFunction.
|
FunctionGradient |
DifferentiableRF.gradient(State s,
Action a,
State sprime) |
FunctionGradient |
DifferentiableQFunction.qGradient(State s,
Action a)
Returns the Q-value gradient (
QGradientTuple ) for the given state and action. |
FunctionGradient |
DifferentiableValueFunction.valueGradient(State s)
Returns the gradient of this value function
|
| Constructor and Description |
|---|
QGradientTuple(State s,
Action a,
FunctionGradient gradient)
Initializes.
|
| Modifier and Type | Method and Description |
|---|---|
void |
ActorCritic.planFromState(State initialState) |
void |
Critic.startEpisode(State s)
This method is called whenever a new learning episode begins
|
void |
Actor.startEpisode(State s)
This method is called whenever a new learning episode begins
|
| Modifier and Type | Method and Description |
|---|---|
Action |
BoltzmannActor.action(State s) |
double |
BoltzmannActor.actionProb(State s,
Action a) |
boolean |
BoltzmannActor.definedFor(State s) |
List<ActionProb> |
BoltzmannActor.policyDistribution(State s) |
void |
BoltzmannActor.startEpisode(State s) |
| Modifier and Type | Method and Description |
|---|---|
void |
TimeIndexedTDLambda.startEpisode(State s) |
void |
TDLambda.startEpisode(State s) |
double |
TDLambda.value(State s) |
| Modifier and Type | Field and Description |
|---|---|
State |
SARSData.SARS.s
The previou state
|
State |
SARSData.SARS.sp
The next state
|
| Modifier and Type | Method and Description |
|---|---|
void |
SARSData.add(State s,
Action a,
double r,
State sp)
Adds a
SARSData.SARS tuple with the given component. |
abstract SARSData |
SARSCollector.collectDataFrom(State s,
SampleModel model,
int maxSteps,
SARSData intoDataset)
Collects data from an initial state until either a terminal state is reached or until the maximum number of steps is taken.
|
SARSData |
SARSCollector.UniformRandomSARSCollector.collectDataFrom(State s,
SampleModel model,
int maxSteps,
SARSData intoDataset) |
GreedyQPolicy |
LSPI.planFromState(State initialState)
Plans from the input state and then returns a
GreedyQPolicy that greedily
selects the action with the highest Q-value and breaks ties uniformly randomly. |
double |
LSPI.qValue(State s,
Action a) |
List<QValue> |
LSPI.qValues(State s) |
double |
LSPI.value(State s) |
| Constructor and Description |
|---|
SARS(State s,
Action a,
double r,
State sp)
Initializes.
|
| Modifier and Type | Method and Description |
|---|---|
void |
ModelLearningPlanner.initializePlannerIn(State s)
This is method is expected to be called at the beginning of any new learning episode.
|
void |
ModelLearningPlanner.modelChanged(State changedState)
Tells the valueFunction that the model has changed and that it will need to replan accordingly
|
static boolean |
KWIKModel.Helper.stateTransitionsModeled(KWIKModel model,
List<ActionType> actionTypes,
State s) |
boolean |
KWIKModel.transitionIsModeled(State s,
Action a)
Indicates whether this model "knows" how the transition dynamics from the given input state and action work.
|
static List<Action> |
KWIKModel.Helper.unmodeledActions(KWIKModel model,
List<ActionType> actionTypes,
State s) |
| Modifier and Type | Method and Description |
|---|---|
double |
ARTDP.qValue(State s,
Action a) |
List<QValue> |
ARTDP.qValues(State s) |
double |
ARTDP.value(State s) |
| Modifier and Type | Field and Description |
|---|---|
protected State |
VIModelLearningPlanner.initialState
The last initial state of an episode
|
| Modifier and Type | Method and Description |
|---|---|
void |
VIModelLearningPlanner.initializePlannerIn(State s) |
void |
VIModelLearningPlanner.modelChanged(State changedState) |
| Modifier and Type | Method and Description |
|---|---|
EnvironmentOutcome |
TabularModel.sample(State s,
Action a) |
boolean |
TabularModel.terminal(State s) |
boolean |
TabularModel.transitionIsModeled(State s,
Action ga) |
List<TransitionProb> |
TabularModel.transitions(State s,
Action a) |
| Modifier and Type | Method and Description |
|---|---|
Action |
UnmodeledFavoredPolicy.action(State s) |
double |
UnmodeledFavoredPolicy.actionProb(State s,
Action a) |
boolean |
UnmodeledFavoredPolicy.definedFor(State s) |
List<ActionProb> |
UnmodeledFavoredPolicy.policyDistribution(State s) |
double |
PotentialShapedRMax.RMaxPotential.potentialValue(State s) |
EnvironmentOutcome |
RMaxModel.sample(State s,
Action a) |
boolean |
RMaxModel.terminal(State s) |
boolean |
RMaxModel.transitionIsModeled(State s,
Action a) |
List<TransitionProb> |
RMaxModel.transitions(State s,
Action a) |
| Modifier and Type | Method and Description |
|---|---|
GreedyQPolicy |
QLearning.planFromState(State initialState)
Plans from the input state and then returns a
GreedyQPolicy that greedily
selects the action with the highest Q-value and breaks ties uniformly randomly. |
double |
QLearning.qValue(State s,
Action a) |
List<QValue> |
QLearning.qValues(State s) |
double |
QLearning.value(State s) |
| Modifier and Type | Method and Description |
|---|---|
QValue |
ApproximateQLearning.getStaleQ(State s,
Action a)
Returns the state Q-function estimate for the state-action pair
|
List<QValue> |
ApproximateQLearning.getStaleQs(State s)
Returns all Q-value estimates from the current state Q-function
|
GreedyQPolicy |
GradientDescentSarsaLam.planFromState(State initialState)
Plans from the input state and then returns a
GreedyQPolicy that greedily
selects the action with the highest Q-value and breaks ties uniformly randomly. |
double |
GradientDescentSarsaLam.qValue(State s,
Action a) |
double |
ApproximateQLearning.qValue(State s,
Action a) |
List<QValue> |
GradientDescentSarsaLam.qValues(State s) |
List<QValue> |
ApproximateQLearning.qValues(State s) |
double |
ApproximateQLearning.staleValue(State s)
The stale state value function estimate (max state Q-value)
|
double |
GradientDescentSarsaLam.value(State s) |
double |
ApproximateQLearning.value(State s) |
| Modifier and Type | Method and Description |
|---|---|
List<Action> |
OptionType.allApplicableActions(State s) |
boolean |
SubgoalOption.inInitiationSet(State s) |
boolean |
Option.inInitiationSet(State s)
Returns true if the input state is in the initiation set of the
Option |
boolean |
MacroAction.inInitiationSet(State s) |
Action |
SubgoalOption.policy(State s,
Episode history) |
Action |
Option.policy(State s,
Episode history) |
Action |
MacroAction.policy(State s,
Episode history) |
List<ActionProb> |
SubgoalOption.policyDistribution(State s,
Episode history) |
List<ActionProb> |
Option.policyDistribution(State s,
Episode history) |
List<ActionProb> |
MacroAction.policyDistribution(State s,
Episode history) |
double |
SubgoalOption.probabilityOfTermination(State s,
Episode history) |
double |
Option.probabilityOfTermination(State s,
Episode history) |
double |
MacroAction.probabilityOfTermination(State s,
Episode history) |
| Constructor and Description |
|---|
EnvironmentOptionOutcome(State s,
Action a,
State sp,
double r,
boolean terminated,
double discountFactor,
Episode episode)
Initializes.
|
| Modifier and Type | Field and Description |
|---|---|
State |
BFSMarkovOptionModel.OptionScanNode.s
the state this search node wraps
|
| Modifier and Type | Method and Description |
|---|---|
protected double |
BFSNonMarkovOptionModel.computeTransitions(State s,
Option o,
HashedAggregator<HashableState> possibleTerminations,
double[] expectedReturn) |
protected double |
BFSMarkovOptionModel.computeTransitions(State s,
Option o,
HashedAggregator<HashableState> possibleTerminations,
double[] expectedReturn) |
EnvironmentOutcome |
BFSMarkovOptionModel.sample(State s,
Action a) |
boolean |
BFSMarkovOptionModel.terminal(State s) |
List<TransitionProb> |
BFSMarkovOptionModel.transitions(State s,
Action a) |
| Constructor and Description |
|---|
NonMarkovOptionScanNode(BFSNonMarkovOptionModel.NonMarkovOptionScanNode src,
State s,
double transProb,
double discountedR,
Action a) |
NonMarkovOptionScanNode(State s) |
OptionScanNode(BFSMarkovOptionModel.OptionScanNode src,
State s,
double transProb,
double discountedR)
Initializes.
|
OptionScanNode(State s) |
| Modifier and Type | Method and Description |
|---|---|
Policy |
Planner.planFromState(State initialState)
|
| Modifier and Type | Method and Description |
|---|---|
Action |
SDPlannerPolicy.action(State s) |
Action |
DDPlannerPolicy.action(State s) |
double |
SDPlannerPolicy.actionProb(State s,
Action a) |
double |
DDPlannerPolicy.actionProb(State s,
Action a) |
boolean |
SDPlannerPolicy.definedFor(State s) |
boolean |
DDPlannerPolicy.definedFor(State s) |
boolean |
DeterministicPlanner.hasCachedPlanForState(State s)
Returns whether the valueFunction has a plan solution from the provided state.
|
List<ActionProb> |
SDPlannerPolicy.policyDistribution(State s) |
List<ActionProb> |
DDPlannerPolicy.policyDistribution(State s) |
Action |
DeterministicPlanner.querySelectedActionForState(State s)
Returns the action suggested by the internal plan for the given state.
|
| Modifier and Type | Method and Description |
|---|---|
static void |
MultiStatePrePlanner.runPlannerForAllInitStates(Planner planner,
Collection<State> initialStates)
Runs a planning algorithm from multiple initial states to ensure that an adequate plan/policy exist for of the states.
|
| Modifier and Type | Method and Description |
|---|---|
double |
NullHeuristic.h(State s) |
double |
Heuristic.h(State s)
Returns the estimated amount of reward that will be received when following the optimal policy from the given state.
|
SDPlannerPolicy |
BestFirst.planFromState(State initialState)
Plans and returns a
SDPlannerPolicy . |
| Modifier and Type | Method and Description |
|---|---|
SDPlannerPolicy |
IDAStar.planFromState(State initialState)
Plans and returns a
SDPlannerPolicy . |
SDPlannerPolicy |
DynamicWeightedAStar.planFromState(State initialState)
Plans and returns a
SDPlannerPolicy . |
| Modifier and Type | Method and Description |
|---|---|
SDPlannerPolicy |
BFS.planFromState(State initialState)
Plans and returns a
SDPlannerPolicy . |
| Modifier and Type | Method and Description |
|---|---|
SDPlannerPolicy |
LimitedMemoryDFS.planFromState(State initialState)
Plans and returns a
SDPlannerPolicy . |
SDPlannerPolicy |
DFS.planFromState(State initialState)
Plans and returns a
SDPlannerPolicy . |
| Modifier and Type | Method and Description |
|---|---|
List<State> |
DynamicProgramming.getAllStates()
This method will return all states that are stored in this planners value function.
|
| Modifier and Type | Method and Description |
|---|---|
protected double |
DynamicProgramming.computeQ(State s,
Action ga)
Computes the Q-value This computation
*is* compatible with
Option objects. |
protected double |
DynamicProgramming.getDefaultValue(State s)
Returns the default V-value to use for the state
|
boolean |
DynamicProgramming.hasComputedValueFor(State s)
Returns whether a value for the given state has been computed previously.
|
double |
DynamicProgramming.performBellmanUpdateOn(State s)
Performs a Bellman value function update on the provided state.
|
double |
DynamicProgramming.performFixedPolicyBellmanUpdateOn(State s,
EnumerablePolicy p)
Performs a fixed-policy Bellman value function update (i.e., policy evaluation) on the provided state.
|
double |
DynamicProgramming.qValue(State s,
Action a) |
List<QValue> |
DynamicProgramming.qValues(State s) |
double |
DynamicProgramming.value(State s)
Returns the value function evaluation of the given state.
|
| Modifier and Type | Method and Description |
|---|---|
Action |
UCTTreeWalkPolicy.action(State s) |
double |
UCTTreeWalkPolicy.actionProb(State s,
Action a) |
boolean |
UCTTreeWalkPolicy.definedFor(State s) |
GreedyQPolicy |
UCT.planFromState(State initialState)
Plans from the input state and then returns a
GreedyQPolicy that greedily
selects the action with the highest Q-value and breaks ties uniformly randomly. |
List<ActionProb> |
UCTTreeWalkPolicy.policyDistribution(State s) |
double |
UCT.qValue(State s,
Action a) |
List<QValue> |
UCT.qValues(State s) |
double |
UCT.value(State s) |
| Modifier and Type | Method and Description |
|---|---|
void |
PolicyEvaluation.evaluatePolicy(EnumerablePolicy policy,
State s)
Computes the value function for the given policy after finding all reachable states from seed state s
|
boolean |
PolicyIteration.performReachabilityFrom(State si)
This method will find all reachable states that will be used when computing the value function.
|
boolean |
PolicyEvaluation.performReachabilityFrom(State si)
This method will find all reachable states that will be used when computing the value function.
|
GreedyQPolicy |
PolicyIteration.planFromState(State initialState)
Plans from the input state and then returns a
GreedyQPolicy that greedily
selects the action with the highest Q-value and breaks ties uniformly randomly. |
| Modifier and Type | Method and Description |
|---|---|
protected void |
RTDP.batchRTDP(State initialState)
Performs Bellman updates only after a rollout is complete and in reverse order
|
protected BoundedRTDP.StateSelectionAndExpectedGap |
BoundedRTDP.getNextState(State s,
Action a)
Selects a next state for expansion when action a is applied in state s.
|
protected BoundedRTDP.StateSelectionAndExpectedGap |
BoundedRTDP.getNextStateByMaxMargin(State s,
Action a)
Selects a next state for expansion when action a is applied in state s according to the next possible state that has the largest lower and upper bound margin.
|
protected BoundedRTDP.StateSelectionAndExpectedGap |
BoundedRTDP.getNextStateBySampling(State s,
Action a)
Selects a next state for expansion when action a is applied in state s by randomly sampling from the transition dynamics weighted by the margin of the lower and
upper bound value functions.
|
protected QValue |
BoundedRTDP.maxQ(State s)
Returns the maximum Q-value entry for the given state with ties broken randomly.
|
protected void |
RTDP.normalRTDP(State initialState)
Runs normal RTDP in which bellman updates are performed after each action selection.
|
GreedyQPolicy |
RTDP.planFromState(State initialState)
Plans from the input state and then returns a
GreedyQPolicy that greedily
selects the action with the highest Q-value and breaks ties uniformly randomly. |
GreedyQPolicy |
BoundedRTDP.planFromState(State initialState)
Plans from the input state and then returns a
GreedyQPolicy that greedily
selects the action with the highest Q-value and breaks ties uniformly randomly. |
double |
BoundedRTDP.runRollout(State s)
Runs a planning rollout from the provided state.
|
| Modifier and Type | Method and Description |
|---|---|
protected SparseSampling.StateNode |
SparseSampling.getStateNode(State s,
int height)
Either returns, or creates, indexes, and returns, the state node for the given state at the given height in the tree
|
GreedyQPolicy |
SparseSampling.planFromState(State initialState)
Plans from the input state and then returns a
GreedyQPolicy that greedily
selects the action with the highest Q-value and breaks ties uniformly randomly. |
double |
SparseSampling.qValue(State s,
Action a) |
List<QValue> |
SparseSampling.qValues(State s) |
double |
SparseSampling.value(State s) |
| Modifier and Type | Method and Description |
|---|---|
boolean |
ValueIteration.performReachabilityFrom(State si)
This method will find all reachable states that will be used by the
ValueIteration.runVI() method and will cache all the transition dynamics. |
boolean |
PrioritizedSweeping.performReachabilityFrom(State si) |
GreedyQPolicy |
ValueIteration.planFromState(State initialState)
Plans from the input state and then returns a
GreedyQPolicy that greedily
selects the action with the highest Q-value and breaks ties uniformly randomly. |
| Modifier and Type | Field and Description |
|---|---|
protected List<State> |
FittedVI.samples
The set of samples on which to perform value iteration.
|
| Modifier and Type | Method and Description |
|---|---|
List<State> |
FittedVI.getSamples()
Returns the state samples to which the value function will be fit.
|
| Modifier and Type | Method and Description |
|---|---|
GreedyQPolicy |
FittedVI.planFromState(State initialState)
Plans from the input state and then returns a
GreedyQPolicy that greedily
selects the action with the highest Q-value and breaks ties uniformly randomly. |
double |
FittedVI.qValue(State s,
Action a) |
double |
FittedVI.VFAVInit.qValue(State s,
Action a) |
List<QValue> |
FittedVI.qValues(State s) |
double |
FittedVI.value(State s) |
double |
FittedVI.VFAVInit.value(State s) |
| Modifier and Type | Method and Description |
|---|---|
void |
FittedVI.setSamples(List<State> samples)
Sets the state samples to which the value function will be fit.
|
| Constructor and Description |
|---|
FittedVI(SADomain domain,
double gamma,
SupervisedVFA valueFunctionTrainer,
List<State> samples,
int transitionSamples,
double maxDelta,
int maxIterations)
Initializes.
|
| Modifier and Type | Method and Description |
|---|---|
Policy |
QMDP.planFromState(State initialState) |
double |
QMDP.qValue(State s,
Action a) |
List<QValue> |
QMDP.qValues(State s) |
double |
QMDP.value(State s) |
| Modifier and Type | Method and Description |
|---|---|
Policy |
BeliefSparseSampling.planFromState(State initialState) |
double |
BeliefSparseSampling.qValue(State s,
Action a) |
List<QValue> |
BeliefSparseSampling.qValues(State s) |
double |
BeliefSparseSampling.value(State s) |
| Modifier and Type | Method and Description |
|---|---|
abstract double |
ShapedRewardFunction.additiveReward(State s,
Action a,
State sprime)
Returns the reward value to add to the base objective reward function.
|
double |
ShapedRewardFunction.reward(State s,
Action a,
State sprime) |
| Modifier and Type | Method and Description |
|---|---|
double |
PotentialShapedRF.additiveReward(State s,
Action a,
State sprime) |
double |
PotentialFunction.potentialValue(State s)
Returns the reward potential from the given state.
|
| Modifier and Type | Field and Description |
|---|---|
protected State |
JointPolicy.lastSyncedState
The last state in which synchronized actions were queried.
|
| Modifier and Type | Field and Description |
|---|---|
List<State> |
GameEpisode.states
The sequence of states
|
| Modifier and Type | Method and Description |
|---|---|
State |
GameEpisode.state(int t)
Returns the state stored at time step t where t=0 refers to the initial state
|
| Modifier and Type | Method and Description |
|---|---|
List<State> |
GameEpisode.getStates()
Returns the state sequence list object
|
| Modifier and Type | Method and Description |
|---|---|
Action |
PolicyFromJointPolicy.action(State s) |
double |
PolicyFromJointPolicy.actionProb(State s,
Action a) |
boolean |
PolicyFromJointPolicy.definedFor(State s) |
Action |
JointPolicy.getAgentSynchronizedActionSelection(int agentNum,
State s)
This method returns the action for a single agent by a synchronized sampling of this joint policy,
which enables multiple agents to query this policy object and act according to the same selected joint
actions from it.
|
List<JointAction> |
JointPolicy.getAllJointActions(State s)
Returns all possible joint actions that can be taken in state s for the set of agents defined to be used in this joint policy.
|
void |
GameEpisode.initializeInState(State initialState)
Clears out any already recorded states, joint actions, and rewards, and sets the initial state of the game.
|
List<ActionProb> |
PolicyFromJointPolicy.policyDistribution(State s) |
void |
GameEpisode.transition(JointAction jointAction,
State nextState,
double[] jointReward)
Records a transition from the last recorded state in this object using the specififed joint action to the specified next state and with the specified joint reward
being received as a result.
|
| Constructor and Description |
|---|
GameEpisode(State initialState)
Initializes with an initial state of the game.
|
| Modifier and Type | Method and Description |
|---|---|
Action |
SetStrategySGAgent.action(State s) |
Action |
RandomSGAgent.action(State s) |
void |
SetStrategySGAgent.observeOutcome(State s,
JointAction jointAction,
double[] jointReward,
State sprime,
boolean isTerminal) |
void |
RandomSGAgent.observeOutcome(State s,
JointAction jointAction,
double[] jointReward,
State sprime,
boolean isTerminal) |
| Modifier and Type | Field and Description |
|---|---|
protected State |
LearningAgentToSGAgentInterface.currentState
The current state of the world
|
protected State |
LearningAgentToSGAgentInterface.StateReference.val |
| Modifier and Type | Method and Description |
|---|---|
State |
LearningAgentToSGAgentInterface.currentObservation() |
| Modifier and Type | Method and Description |
|---|---|
Action |
LearningAgentToSGAgentInterface.action(State s) |
void |
LearningAgentToSGAgentInterface.observeOutcome(State s,
JointAction jointAction,
double[] jointReward,
State sprime,
boolean isTerminal) |
| Modifier and Type | Method and Description |
|---|---|
Action |
MultiAgentDPPlanningAgent.action(State s) |
void |
MultiAgentDPPlanningAgent.observeOutcome(State s,
JointAction jointAction,
double[] jointReward,
State sprime,
boolean isTerminal) |
| Modifier and Type | Method and Description |
|---|---|
Action |
MultiAgentQLearning.action(State s) |
void |
MultiAgentQLearning.observeOutcome(State s,
JointAction jointAction,
double[] jointReward,
State sprime,
boolean isTerminal) |
| Modifier and Type | Field and Description |
|---|---|
protected Map<HashableState,State> |
SGNaiveQLAgent.stateRepresentations
A map from hashed states to the internal state representation for the states stored in the q-table.
|
| Modifier and Type | Method and Description |
|---|---|
Action |
SGNaiveQLAgent.action(State s) |
protected double |
SGNaiveQLAgent.getMaxQValue(State s)
Returns maximum numeric Q-value for a given state
|
void |
SGNaiveQLAgent.observeOutcome(State s,
JointAction jointAction,
double[] jointReward,
State sprime,
boolean isTerminal) |
double |
SGNaiveQLAgent.qValue(State s,
Action a) |
List<QValue> |
SGNaiveQLAgent.qValues(State s) |
protected HashableState |
SGNaiveQLAgent.stateHash(State s)
First abstracts state s, and then returns the
HashableState object for the abstracted state. |
protected QValue |
SGNaiveQLAgent.storedQ(State s,
Action a) |
double |
SGNaiveQLAgent.value(State s) |
| Modifier and Type | Class and Description |
|---|---|
class |
HistoryState |
| Modifier and Type | Field and Description |
|---|---|
protected State |
HistoryState.curState |
| Modifier and Type | Method and Description |
|---|---|
State |
HistoryState.copy() |
| Modifier and Type | Method and Description |
|---|---|
Action |
SGQWActionHistory.action(State s) |
HistoryState |
HistoryState.incrementWithChange(State newState,
JointAction lastAction) |
void |
SGQWActionHistory.observeOutcome(State s,
JointAction jointAction,
double[] jointReward,
State sprime,
boolean isTerminal) |
| Constructor and Description |
|---|
HistoryState(State curState,
int historySize) |
HistoryState(State curState,
JointAction[] history,
int sIndex) |
| Modifier and Type | Method and Description |
|---|---|
Action |
TitForTat.action(State s) |
Action |
GrimTrigger.action(State s) |
void |
TitForTat.observeOutcome(State s,
JointAction jointAction,
double[] jointReward,
State sprime,
boolean isTerminal) |
void |
GrimTrigger.observeOutcome(State s,
JointAction jointAction,
double[] jointReward,
State sprime,
boolean isTerminal) |
| Modifier and Type | Method and Description |
|---|---|
Action |
EquilibriumPlayingSGAgent.action(State s) |
protected EquilibriumPlayingSGAgent.BimatrixTuple |
EquilibriumPlayingSGAgent.constructBimatrix(State s,
List<Action> myActions)
Constructs a bimatrix game from the possible joint rewards of the given state.
|
void |
EquilibriumPlayingSGAgent.observeOutcome(State s,
JointAction jointAction,
double[] jointReward,
State sprime,
boolean isTerminal) |
| Modifier and Type | Method and Description |
|---|---|
void |
MultiAgentPerformancePlotter.gameEnding(State s) |
void |
MultiAgentPerformancePlotter.gameStarting(State s) |
void |
MultiAgentPerformancePlotter.observe(State s,
JointAction ja,
double[] reward,
State sp) |
| Modifier and Type | Field and Description |
|---|---|
State |
JAQValue.s |
| Modifier and Type | Method and Description |
|---|---|
double |
MADynamicProgramming.backupAllValueFunctions(State s)
Backups the state value function for all agent's value functions in state s.
|
protected Map<JointAction,JAQValue> |
QSourceForSingleAgent.HashBackedQSource.getJAMap(State s)
Returns the Map from joint actions to q-values for a given state.
|
JAQValue |
QSourceForSingleAgent.getQValueFor(State s,
JointAction ja)
Returns a Q-value (represented with a
JAQValue object) stored for the given state and joint action. |
JAQValue |
QSourceForSingleAgent.HashBackedQSource.getQValueFor(State s,
JointAction ja) |
JAQValue |
MADynamicProgramming.BackupBasedQSource.getQValueFor(State s,
JointAction ja) |
double |
SGBackupOperator.performBackup(State s,
int forAgent,
List<SGAgentType> agentDefinitions,
AgentQSourceMap qSourceMap) |
abstract void |
MADynamicProgramming.planFromState(State s)
Calling this method causes planning to be performed from State s.
|
| Constructor and Description |
|---|
JAQValue(State s,
JointAction ja,
double q) |
JointActionTransitions(State s,
JointAction ja)
Generates the transition information for the given state and joint aciton
|
| Modifier and Type | Method and Description |
|---|---|
double |
MinMaxQ.performBackup(State s,
int forAgent,
List<SGAgentType> agentDefinitions,
AgentQSourceMap qSourceMap) |
double |
MaxQ.performBackup(State s,
int forAgent,
List<SGAgentType> agentDefinitions,
AgentQSourceMap qSourceMap) |
double |
CorrelatedQ.performBackup(State s,
int forAgent,
List<SGAgentType> agentDefinitions,
AgentQSourceMap qSourceMap) |
double |
CoCoQ.performBackup(State s,
int forAgent,
List<SGAgentType> agentDefinitions,
AgentQSourceMap qSourceMap) |
| Modifier and Type | Method and Description |
|---|---|
boolean |
MAValueIteration.performStateReachabilityFrom(State s)
Finds and stores all states that are reachable from input state s.
|
void |
MAValueIteration.planFromState(State s) |
| Modifier and Type | Method and Description |
|---|---|
Action |
EMinMaxPolicy.action(State s) |
Action |
EGreedyMaxWellfare.action(State s) |
Action |
EGreedyJointPolicy.action(State s) |
Action |
ECorrelatedQJointPolicy.action(State s) |
double |
EMinMaxPolicy.actionProb(State s,
Action a) |
double |
EGreedyMaxWellfare.actionProb(State s,
Action a) |
double |
EGreedyJointPolicy.actionProb(State s,
Action a) |
double |
ECorrelatedQJointPolicy.actionProb(State s,
Action a) |
boolean |
EMinMaxPolicy.definedFor(State s) |
boolean |
EGreedyMaxWellfare.definedFor(State s) |
boolean |
EGreedyJointPolicy.definedFor(State s) |
boolean |
ECorrelatedQJointPolicy.definedFor(State s) |
List<ActionProb> |
EMinMaxPolicy.policyDistribution(State s) |
List<ActionProb> |
EGreedyMaxWellfare.policyDistribution(State s) |
List<ActionProb> |
EGreedyJointPolicy.policyDistribution(State s) |
List<ActionProb> |
ECorrelatedQJointPolicy.policyDistribution(State s) |
| Modifier and Type | Field and Description |
|---|---|
State |
QValue.s
The state with which this Q-value is associated.
|
| Modifier and Type | Method and Description |
|---|---|
static double |
QProvider.Helper.maxQ(QProvider qSource,
State s)
Returns the optimal state value function for a state given a
QProvider . |
static double |
QProvider.Helper.policyValue(QProvider qSource,
State s,
EnumerablePolicy p)
Returns the state value under a given policy for a state and
QProvider . |
double |
QFunction.qValue(State s,
Action a)
Returns the
QValue for the given state-action pair. |
double |
ConstantValueFunction.qValue(State s,
Action a) |
List<QValue> |
QProvider.qValues(State s)
|
double |
ValueFunction.value(State s)
Returns the value function evaluation of the given state.
|
double |
ConstantValueFunction.value(State s) |
| Constructor and Description |
|---|
QValue(State s,
Action a,
double q)
Creates a Q-value for the given state an action pair with the specified q-value
|
| Modifier and Type | Method and Description |
|---|---|
static State |
BlockDudeLevelConstructor.getLevel1(Domain domain)
Returns the initial
State of the first level. |
static State |
BlockDudeLevelConstructor.getLevel2(Domain domain)
Returns the initial
State of the second level. |
static State |
BlockDudeLevelConstructor.getLevel3(Domain domain)
Returns the initial
State of the third level. |
State |
BlockDudeModel.sample(State s,
Action a) |
| Modifier and Type | Method and Description |
|---|---|
boolean |
BlockDudeTF.isTerminal(State s) |
State |
BlockDudeModel.sample(State s,
Action a) |
List<StateTransitionProb> |
BlockDudeModel.stateTransitions(State s,
Action a) |
| Modifier and Type | Class and Description |
|---|---|
class |
BlockDudeAgent |
class |
BlockDudeCell |
class |
BlockDudeMap |
class |
BlockDudeState |
| Modifier and Type | Method and Description |
|---|---|
State |
BlockDudeState.copy() |
| Modifier and Type | Class and Description |
|---|---|
class |
BlocksWorldBlock |
class |
BlocksWorldState |
| Modifier and Type | Method and Description |
|---|---|
State |
BlocksWorldState.copy() |
static State |
BlocksWorld.getNewState(int nBlocks)
Creates a new state with nBlocks block objects in it.
|
State |
BWModel.sample(State s,
Action a) |
protected State |
BWModel.stack(BlocksWorldState s,
ObjectParameterizedAction a) |
protected State |
BWModel.unstack(BlocksWorldState s,
ObjectParameterizedAction a) |
| Modifier and Type | Method and Description |
|---|---|
boolean |
BlocksWorld.StackActionType.applicableInState(State st,
ObjectParameterizedAction groundedAction) |
boolean |
BlocksWorld.UnstackActionType.applicableInState(State st,
ObjectParameterizedAction groundedAction) |
State |
BWModel.sample(State s,
Action a) |
List<StateTransitionProb> |
BWModel.stateTransitions(State s,
Action a) |
| Modifier and Type | Method and Description |
|---|---|
boolean |
InvertedPendulum.InvertedPendulumTerminalFunction.isTerminal(State s) |
boolean |
CartPoleDomain.CartPoleTerminalFunction.isTerminal(State s) |
void |
CartPoleVisualizer.CartPolePainter.paint(Graphics2D g2,
State s,
float cWidth,
float cHeight) |
double |
InvertedPendulum.InvertedPendulumRewardFunction.reward(State s,
Action a,
State sprime) |
double |
CartPoleDomain.CartPoleRewardFunction.reward(State s,
Action a,
State sprime) |
| Modifier and Type | Method and Description |
|---|---|
State |
CPClassicModel.moveClassicModel(State s,
double dir)
Simulates the physics for one time step give the input state s, and the direction of force applied.
|
State |
CPCorrectModel.moveCorrectModel(State s,
double dir)
Simulates the physics for one time step give the input state s, and the direction of force applied.
|
State |
IPModel.sample(State s,
Action a) |
State |
CPCorrectModel.sample(State s,
Action a) |
State |
CPClassicModel.sample(State s,
Action a) |
protected State |
IPModel.updateState(State s,
double controlForce)
Updates the given state object given the control force.
|
| Modifier and Type | Method and Description |
|---|---|
State |
CPClassicModel.moveClassicModel(State s,
double dir)
Simulates the physics for one time step give the input state s, and the direction of force applied.
|
State |
CPCorrectModel.moveCorrectModel(State s,
double dir)
Simulates the physics for one time step give the input state s, and the direction of force applied.
|
State |
IPModel.sample(State s,
Action a) |
State |
CPCorrectModel.sample(State s,
Action a) |
State |
CPClassicModel.sample(State s,
Action a) |
List<StateTransitionProb> |
IPModel.stateTransitions(State s,
Action a) |
List<StateTransitionProb> |
CPCorrectModel.stateTransitions(State s,
Action a) |
List<StateTransitionProb> |
CPClassicModel.stateTransitions(State s,
Action a) |
protected State |
IPModel.updateState(State s,
double controlForce)
Updates the given state object given the control force.
|
| Modifier and Type | Class and Description |
|---|---|
class |
CartPoleFullState |
class |
CartPoleState |
class |
InvertedPendulumState |
| Modifier and Type | Method and Description |
|---|---|
State |
InvertedPendulumState.copy() |
State |
CartPoleState.copy() |
State |
CartPoleFullState.copy() |
| Modifier and Type | Method and Description |
|---|---|
State |
FrostbiteModel.sample(State s,
Action a) |
| Modifier and Type | Method and Description |
|---|---|
boolean |
FrostbiteTF.isTerminal(State s) |
double |
FrostbiteRF.reward(State s,
Action a,
State sprime) |
State |
FrostbiteModel.sample(State s,
Action a) |
List<StateTransitionProb> |
FrostbiteModel.stateTransitions(State s,
Action a) |
| Modifier and Type | Class and Description |
|---|---|
class |
FrostbiteAgent |
class |
FrostbiteIgloo |
class |
FrostbitePlatform |
class |
FrostbiteState |
| Modifier and Type | Method and Description |
|---|---|
State |
FrostbiteState.copy() |
| Modifier and Type | Class and Description |
|---|---|
class |
GraphStateNode |
| Modifier and Type | Method and Description |
|---|---|
State |
GraphStateNode.copy() |
State |
GraphDefinedDomain.GraphStateModel.sample(State s,
Action a) |
| Modifier and Type | Method and Description |
|---|---|
List<Action> |
GraphDefinedDomain.GraphActionType.allApplicableActions(State s) |
protected boolean |
GraphDefinedDomain.GraphActionType.applicableInState(State s) |
boolean |
GraphTF.isTerminal(State s) |
double |
GraphRF.reward(State s,
Action a,
State sprime) |
State |
GraphDefinedDomain.GraphStateModel.sample(State s,
Action a) |
List<StateTransitionProb> |
GraphDefinedDomain.GraphStateModel.stateTransitions(State s,
Action a) |
| Modifier and Type | Method and Description |
|---|---|
protected State |
GridWorldDomain.GridWorldModel.move(State s,
int xd,
int yd)
Attempts to move the agent into the given position, taking into account walls and blocks
|
State |
GridWorldDomain.GridWorldModel.sample(State s,
Action a) |
| Modifier and Type | Method and Description |
|---|---|
boolean |
GridWorldTerminalFunction.isTerminal(State s) |
protected State |
GridWorldDomain.GridWorldModel.move(State s,
int xd,
int yd)
Attempts to move the agent into the given position, taking into account walls and blocks
|
void |
GridWorldVisualizer.MapPainter.paint(Graphics2D g2,
State s,
float cWidth,
float cHeight) |
double |
GridWorldRewardFunction.reward(State s,
Action a,
State sprime) |
State |
GridWorldDomain.GridWorldModel.sample(State s,
Action a) |
List<StateTransitionProb> |
GridWorldDomain.GridWorldModel.stateTransitions(State s,
Action a) |
| Modifier and Type | Method and Description |
|---|---|
static ValueFunctionVisualizerGUI |
GridWorldDomain.getGridWorldValueFunctionVisualization(List<State> states,
int maxX,
int maxY,
ValueFunction valueFunction,
Policy p)
Creates and returns a
ValueFunctionVisualizerGUI
object for a grid world. |
| Modifier and Type | Class and Description |
|---|---|
class |
GridAgent
Object instance for the agent in a
GridWorldDomain . |
class |
GridLocation
ObjectInstance for locations in a
GridWorldDomain . |
class |
GridWorldState |
| Modifier and Type | Method and Description |
|---|---|
State |
GridWorldState.copy() |
| Modifier and Type | Method and Description |
|---|---|
State |
LunarLanderModel.sample(State s,
Action a) |
| Modifier and Type | Method and Description |
|---|---|
List<Action> |
LunarLanderDomain.ThrustType.allApplicableActions(State s) |
boolean |
LunarLanderTF.isTerminal(State s) |
double |
LunarLanderRF.reward(State s,
Action a,
State sprime) |
State |
LunarLanderModel.sample(State s,
Action a) |
List<StateTransitionProb> |
LunarLanderModel.stateTransitions(State s,
Action a) |
| Modifier and Type | Class and Description |
|---|---|
class |
LLAgent |
class |
LLBlock |
static class |
LLBlock.LLObstacle |
static class |
LLBlock.LLPad |
class |
LLState |
| Modifier and Type | Method and Description |
|---|---|
State |
LLState.copy() |
| Modifier and Type | Class and Description |
|---|---|
class |
MCState |
| Modifier and Type | Method and Description |
|---|---|
State |
MCState.copy() |
State |
MCRandomStateGenerator.generateState() |
State |
MountainCar.MCModel.move(State s,
int dir)
Changes the agents position in the provided state using car engine acceleration in the specified direction.
|
State |
MountainCar.MCModel.sample(State s,
Action a) |
| Modifier and Type | Method and Description |
|---|---|
boolean |
MountainCar.ClassicMCTF.isTerminal(State s) |
State |
MountainCar.MCModel.move(State s,
int dir)
Changes the agents position in the provided state using car engine acceleration in the specified direction.
|
void |
MountainCarVisualizer.AgentPainter.paint(Graphics2D g2,
State s,
float cWidth,
float cHeight) |
void |
MountainCarVisualizer.HillPainter.paint(Graphics2D g2,
State s,
float cWidth,
float cHeight) |
State |
MountainCar.MCModel.sample(State s,
Action a) |
List<StateTransitionProb> |
MountainCar.MCModel.stateTransitions(State s,
Action a) |
| Modifier and Type | Class and Description |
|---|---|
class |
TigerObservation |
class |
TigerState |
| Modifier and Type | Method and Description |
|---|---|
protected State |
TigerObservations.observationLeft()
Returns the observation of hearing the tiger behind the left door
|
protected State |
TigerObservations.observationNothing()
Returns the observation of hearing nothing; occurs when the do nothing action is selected
|
protected State |
TigerObservations.observationReset()
Returns the observation of approaching a new pair of doors
|
protected State |
TigerObservations.observationRight()
Returns the observation of hearing the tiger behind the right door
|
State |
TigerObservations.sample(State state,
Action action) |
| Modifier and Type | Method and Description |
|---|---|
List<State> |
TigerObservations.allObservations() |
| Modifier and Type | Method and Description |
|---|---|
List<ObservationProbability> |
TigerObservations.probabilities(State state,
Action action) |
double |
TigerObservations.probability(State observation,
State state,
Action action) |
State |
TigerObservations.sample(State state,
Action action) |
EnvironmentOutcome |
TigerModel.sample(State s,
Action a) |
boolean |
TigerModel.terminal(State s) |
List<TransitionProb> |
TigerModel.transitions(State s,
Action a) |
| Modifier and Type | Field and Description |
|---|---|
protected State |
RLGlueEnvironment.curState
The current state of the environment
|
| Modifier and Type | Method and Description |
|---|---|
protected org.rlcommunity.rlglue.codec.types.Observation |
RLGlueEnvironment.convertIntoObservation(State s)
Takes a OO-MDP state and converts it into an RLGlue observation
|
| Modifier and Type | Method and Description |
|---|---|
static State |
GridGame.getCorrdinationGameInitialState()
Returns the initial state for a classic coordination game, where the agent's personal goals are on opposite sides.
|
static State |
GridGame.getFriendFoeInitialState()
Returns the initial state for Friend Foe game.
|
static State |
GridGame.getIncredibleInitialState()
Returns the initial state for the Incredible game (a game in which player 0 can give an incredible threat).
|
static State |
GridGame.getPrisonersDilemmaInitialState()
Returns the initial state for a classic prisoner's dilemma formulated in a Grid Game.
|
static State |
GridGame.getSimpleGameInitialState()
Returns the initial state for a simple game in which both players can win without interfering with one another.
|
static State |
GridGame.getTurkeyInitialState() |
State |
GridGameStandardMechanics.sample(State s,
JointAction ja) |
| Modifier and Type | Method and Description |
|---|---|
boolean |
GridGame.GGTerminalFunction.isTerminal(State s) |
double[] |
GridGame.GGJointRewardFunction.reward(State s,
JointAction ja,
State sp) |
State |
GridGameStandardMechanics.sample(State s,
JointAction ja) |
List<StateTransitionProb> |
GridGameStandardMechanics.stateTransitions(State s,
JointAction ja) |
| Modifier and Type | Class and Description |
|---|---|
class |
GGAgent |
class |
GGGoal |
class |
GGWall |
static class |
GGWall.GGHorizontalWall |
static class |
GGWall.GGVerticalWall |
| Modifier and Type | Method and Description |
|---|---|
State |
GGGoal.copy() |
State |
GGAgent.copy() |
| Modifier and Type | Class and Description |
|---|---|
class |
NFGameState |
| Modifier and Type | Method and Description |
|---|---|
State |
NFGameState.copy() |
State |
NFGameState.generateState() |
| Modifier and Type | Method and Description |
|---|---|
double[] |
SingleStageNormalFormGame.SingleStageNormalFormJointRewardFunction.reward(State s,
JointAction ja,
State sp) |
| Modifier and Type | Method and Description |
|---|---|
State |
StateGenerator.generateState()
Returns a new state object.
|
State |
StateMapping.mapState(State s) |
| Modifier and Type | Method and Description |
|---|---|
State |
StateMapping.mapState(State s) |
| Modifier and Type | Field and Description |
|---|---|
protected State |
ConstantStateGenerator.src |
| Modifier and Type | Method and Description |
|---|---|
State |
RandomStartStateGenerator.generateState() |
State |
ConstantStateGenerator.generateState() |
State |
ShallowIdentityStateMapping.mapState(State s) |
State |
IdentityStateMapping.mapState(State s) |
| Modifier and Type | Method and Description |
|---|---|
boolean |
SinglePFTF.isTerminal(State s) |
boolean |
NullTermination.isTerminal(State s) |
boolean |
GoalConditionTF.isTerminal(State s) |
State |
ShallowIdentityStateMapping.mapState(State s) |
State |
IdentityStateMapping.mapState(State s) |
| Constructor and Description |
|---|
ConstantStateGenerator(State src)
This class takes a source state as input as returns copies of it for every call of generateState().
|
RandomStartStateGenerator(SADomain domain,
State seedState)
Will discover the reachable states from which to randomly select.
|
RandomStartStateGenerator(SADomain domain,
State seedState,
HashableStateFactory hashFactory)
Will discover reachable states from which to randomly select.
|
| Modifier and Type | Method and Description |
|---|---|
boolean |
TFGoalCondition.satisfies(State s) |
boolean |
StateConditionTest.satisfies(State s) |
boolean |
SinglePFSCT.satisfies(State s) |
void |
StateConditionTestIterable.setStateContext(State s) |
| Modifier and Type | Field and Description |
|---|---|
State |
StateTransitionProb.s |
| Modifier and Type | Method and Description |
|---|---|
boolean |
TerminalFunction.isTerminal(State s) |
| Constructor and Description |
|---|
StateTransitionProb(State s,
double p) |
| Modifier and Type | Method and Description |
|---|---|
List<Action> |
UniversalActionType.allApplicableActions(State s) |
List<Action> |
ActionType.allApplicableActions(State s)
Returns all possible actions of this type that can be applied in the provided
State . |
static List<Action> |
ActionUtils.allApplicableActionsForTypes(List<ActionType> actionTypes,
State s)
Returns all
Action s that are applicable in the given State for all ActionType objects in the provided list. |
| Modifier and Type | Interface and Description |
|---|---|
interface |
MutableOOState
A
MutableState extension OOState . |
interface |
ObjectInstance
|
interface |
OOState
This interface
provides common methods for working with states that are represented with the
the OO-MDP paradigm in which states are a collection of objects.
|
| Modifier and Type | Class and Description |
|---|---|
class |
DeepOOState
An alternative implementation of
GenericOOState in which the DeepOOState.copy() operations performs a deep copy
(DeepCopyState ) of all ObjectInstance objects, thereby allows safe modification of any of its
ObjectInstance objects without using the GenericOOState.touch(String) method. |
class |
GenericOOState
A generic implementation of a
OOState . |
| Modifier and Type | Interface and Description |
|---|---|
interface |
MutableState
A
State interface extension for mutable states whose values can be directly modified. |
| Modifier and Type | Class and Description |
|---|---|
class |
NullState
A null state that contains no information.
|
| Modifier and Type | Method and Description |
|---|---|
State |
State.copy()
Returns a copy of this state suitable for creating state transitions.
|
State |
NullState.copy() |
| Modifier and Type | Method and Description |
|---|---|
static String |
StateUtilities.stateToString(State s)
|
| Modifier and Type | Interface and Description |
|---|---|
interface |
StateDomain
An interface extension for when a
State can specify the numeric domain of one or more of its variables. |
| Modifier and Type | Method and Description |
|---|---|
void |
VisualActionObserver.observeEnvironmentActionInitiation(State o,
Action action) |
double |
UniformCostRF.reward(State s,
Action a,
State sprime) |
double |
SingleGoalPFRF.reward(State s,
Action a,
State sprime) |
double |
NullRewardFunction.reward(State s,
Action a,
State sprime) |
double |
GoalBasedRF.reward(State s,
Action a,
State sprime) |
| Modifier and Type | Field and Description |
|---|---|
protected State |
SimulatedEnvironment.curState
The current state of the environment
|
State |
EnvironmentOutcome.o
The previous environment observation (as a
State when the action was taken. |
State |
EnvironmentOutcome.op
The next environment observation (as a
State ) following the action's execution. |
| Modifier and Type | Method and Description |
|---|---|
State |
SimulatedEnvironment.currentObservation() |
State |
Environment.currentObservation()
Returns the current observation of the environment as a
State . |
| Modifier and Type | Method and Description |
|---|---|
void |
SimulatedEnvironment.setCurStateTo(State s) |
| Constructor and Description |
|---|
EnvironmentOutcome(State o,
Action a,
State op,
double r,
boolean terminated)
Initializes.
|
SimulatedEnvironment(SADomain domain,
State initialState) |
SimulatedEnvironment(SampleModel model,
State initialState) |
| Modifier and Type | Method and Description |
|---|---|
State |
EnvironmentServer.currentObservation() |
| Modifier and Type | Method and Description |
|---|---|
void |
EnvironmentObserver.observeEnvironmentActionInitiation(State o,
Action action)
This method is called when an
Environment receives an action to execute, but before the
Environment has completed execution. |
void |
StateSettableEnvironment.setCurStateTo(State s)
Sets the current state of the environment to the specified state.
|
void |
EnvironmentServer.StateSettableEnvironmentServer.setCurStateTo(State s) |
| Modifier and Type | Method and Description |
|---|---|
static List<TransitionProb> |
FullModel.Helper.deterministicTransition(SampleModel model,
State s,
Action a)
Method to easily implement the
FullModel.transitions(State, Action) method for deterministic domains. |
double |
RewardFunction.reward(State s,
Action a,
State sprime)
Returns the reward received when action a is executed in state s and the agent transitions to state sprime.
|
EnvironmentOutcome |
SampleModel.sample(State s,
Action a)
Samples a transition from the transition distribution and returns it.
|
EnvironmentOutcome |
FactoredModel.sample(State s,
Action a) |
EnvironmentOutcome |
DelegatedModel.sample(State s,
Action a) |
static EnvironmentOutcome |
FullModel.Helper.sampleByEnumeration(FullModel model,
State s,
Action a)
Method to implement the
SampleModel.sample(State, Action) method when the
FullModel.transitions(State, Action) method is implemented. |
boolean |
SampleModel.terminal(State s)
Indicates whether a state is a terminal state (i.e., no more action occurs and zero reward received from there on out)
|
boolean |
FactoredModel.terminal(State s) |
boolean |
DelegatedModel.terminal(State s) |
List<TransitionProb> |
FullModel.transitions(State s,
Action a)
|
List<TransitionProb> |
FactoredModel.transitions(State s,
Action a) |
List<TransitionProb> |
DelegatedModel.transitions(State s,
Action a) |
| Modifier and Type | Method and Description |
|---|---|
State |
SampleStateModel.sample(State s,
Action a)
Samples and returns a
State from a state transition function. |
static State |
FullStateModel.Helper.sampleByEnumeration(FullStateModel model,
State s,
Action a)
Method to implement the
SampleStateModel.sample(State, Action) method when the
FullStateModel.stateTransitions(State, Action) method is implemented. |
| Modifier and Type | Method and Description |
|---|---|
static List<StateTransitionProb> |
FullStateModel.Helper.deterministicTransition(SampleStateModel model,
State s,
Action a)
Method to easily implement the
FullStateModel.stateTransitions(State, Action) method for deterministic domains. |
State |
SampleStateModel.sample(State s,
Action a)
Samples and returns a
State from a state transition function. |
static State |
FullStateModel.Helper.sampleByEnumeration(FullStateModel model,
State s,
Action a)
Method to implement the
SampleStateModel.sample(State, Action) method when the
FullStateModel.stateTransitions(State, Action) method is implemented. |
List<StateTransitionProb> |
FullStateModel.stateTransitions(State s,
Action a)
|
| Modifier and Type | Method and Description |
|---|---|
List<Action> |
ObjectParameterizedActionType.allApplicableActions(State s) |
protected abstract boolean |
ObjectParameterizedActionType.applicableInState(State s,
ObjectParameterizedAction a)
Indicates whether the input action can be applied in the state
|
| Modifier and Type | Field and Description |
|---|---|
protected State |
SimulatedPOEnvironment.curObservation
The current observation from the POMDP environment
|
| Modifier and Type | Method and Description |
|---|---|
State |
SimulatedPOEnvironment.currentObservation() |
State |
SimulatedPOEnvironment.getCurrentHiddenState()
Returns the current hidden state of this
Environment . |
| Modifier and Type | Method and Description |
|---|---|
EnvironmentOutcome |
BeliefMDPGenerator.BeliefModel.sample(State s,
Action a) |
void |
SimulatedPOEnvironment.setCurObservationTo(State observation)
Overrides the current observation of this environment to the specified value
|
boolean |
BeliefMDPGenerator.BeliefModel.terminal(State s) |
List<TransitionProb> |
BeliefMDPGenerator.BeliefModel.transitions(State s,
Action a) |
| Constructor and Description |
|---|
SimulatedPOEnvironment(PODomain domain,
State initialHiddenState) |
| Modifier and Type | Interface and Description |
|---|---|
interface |
BeliefState
An interface for defining a belief state, which is a probability distribution over states.
|
interface |
DenseBeliefVector
An interface to be used in conjunction with
BeliefState instances
for belief states that can generate a dense belief vector representation. |
interface |
EnumerableBeliefState
An interface to be used by
BeliefState implementations that also can enumerate
the set of states that have probability mass. |
| Modifier and Type | Class and Description |
|---|---|
class |
TabularBeliefState
A class for storing a sparse tabular representation of the belief state.
|
| Modifier and Type | Field and Description |
|---|---|
State |
EnumerableBeliefState.StateBelief.s
The MDP state defined by a
State instance. |
| Modifier and Type | Method and Description |
|---|---|
State |
TabularBeliefState.copy() |
State |
TabularBeliefState.s() |
State |
TabularBeliefState.sample() |
State |
BeliefState.sample()
Samples an MDP state state from this belief distribution.
|
State |
TabularBeliefState.stateForId(int id)
Returns the corresponding MDP state for the provided unique identifier.
|
| Modifier and Type | Method and Description |
|---|---|
List<State> |
TabularBeliefState.getStateSpace()
Returns the set of underlying MDP states this belief vector spans.
|
| Modifier and Type | Method and Description |
|---|---|
double |
TabularBeliefState.belief(State s) |
double |
BeliefState.belief(State s)
Returns the probability density/mass for the input MDP state.
|
void |
TabularBeliefState.setBelief(State s,
double b)
Sets the probability mass (belief) associated with the underlying MDP state.
|
BeliefState |
TabularBeliefUpdate.update(BeliefState belief,
State observation,
Action a) |
BeliefState |
BeliefUpdate.update(BeliefState belief,
State observation,
Action a)
Computes a new belief distribution from a previous belief and given a new observation received after taking
a specific action.
|
| Constructor and Description |
|---|
StateBelief(State s,
double belief)
Initializes
|
| Modifier and Type | Field and Description |
|---|---|
State |
ObservationProbability.observation
The observation represented with a
State object. |
| Modifier and Type | Method and Description |
|---|---|
State |
ObservationFunction.sample(State state,
Action action)
Samples an observation given the true MDP state and action taken in the previous step that led to the MDP state.
|
static State |
ObservationUtilities.sampleByEnumeration(DiscreteObservationFunction of,
State state,
Action action)
A helper method for easily implementing the
ObservationFunction.sample(State, Action) method that
samples an observation by first getting all non-zero probability observations, as returned by the DiscreteObservationFunction.probabilities(State, Action)
method, and then sampling from the enumerated distribution. |
| Modifier and Type | Method and Description |
|---|---|
List<State> |
DiscreteObservationFunction.allObservations()
Returns a
List containing all possible observations. |
| Modifier and Type | Method and Description |
|---|---|
List<ObservationProbability> |
DiscreteObservationFunction.probabilities(State state,
Action action)
Returns the observation probability mass/density function for all observations that have non-zero mass/density conditioned on the true MDP state and previous action taken that led to the state.
|
static List<ObservationProbability> |
ObservationUtilities.probabilitiesByEnumeration(DiscreteObservationFunction of,
State state,
Action action)
A helper method for easily implementing the
DiscreteObservationFunction.probabilities(State, Action) method
that computes observation probability distribution by enumerating all possible observations (as defined by the DiscreteObservationFunction.allObservations() method)
and assigning their probability according to the ObservationFunction.probability(State, State, Action)
method. |
double |
ObservationFunction.probability(State observation,
State state,
Action action)
Returns the probability that an observation will be observed conditioned on the MDP state and previous action taken that led to the state.
|
State |
ObservationFunction.sample(State state,
Action action)
Samples an observation given the true MDP state and action taken in the previous step that led to the MDP state.
|
static State |
ObservationUtilities.sampleByEnumeration(DiscreteObservationFunction of,
State state,
Action action)
A helper method for easily implementing the
ObservationFunction.sample(State, Action) method that
samples an observation by first getting all non-zero probability observations, as returned by the DiscreteObservationFunction.probabilities(State, Action)
method, and then sampling from the enumerated distribution. |
| Constructor and Description |
|---|
ObservationProbability(State observation,
double p)
Initializes.
|
| Modifier and Type | Method and Description |
|---|---|
static List<JointAction> |
JointAction.getAllJointActions(State s,
List<SGAgent> agents) |
static List<JointAction> |
JointAction.getAllJointActionsFromTypes(State s,
List<SGAgentType> types) |
| Modifier and Type | Method and Description |
|---|---|
Action |
SGAgent.action(State s)
This method is called by the world when it needs the agent to choose an action
|
void |
SGAgent.observeOutcome(State s,
JointAction jointAction,
double[] jointReward,
State sprime,
boolean isTerminal)
This method is called by the world when every agent in the world has taken their action.
|
| Modifier and Type | Method and Description |
|---|---|
State |
StaticRepeatedGameModel.sample(State s,
JointAction ja) |
| Modifier and Type | Method and Description |
|---|---|
void |
VisualWorldObserver.gameEnding(State s) |
void |
VisualWorldObserver.gameStarting(State s) |
void |
VisualWorldObserver.observe(State s,
JointAction ja,
double[] reward,
State sp) |
double[] |
NullJointRewardFunction.reward(State s,
JointAction ja,
State sp) |
State |
StaticRepeatedGameModel.sample(State s,
JointAction ja) |
List<StateTransitionProb> |
StaticRepeatedGameModel.stateTransitions(State s,
JointAction ja) |
protected void |
VisualWorldObserver.updateAndWait(State s) |
| Modifier and Type | Method and Description |
|---|---|
State |
JointModel.sample(State s,
JointAction ja)
Samples the result of performing
JointAction ja in State s. |
| Modifier and Type | Method and Description |
|---|---|
static List<StateTransitionProb> |
FullJointModel.Helper.deterministicTransition(JointModel model,
State s,
JointAction ja)
A helper method for deterministic transition dynamics.
|
double[] |
JointRewardFunction.reward(State s,
JointAction ja,
State sp)
Returns the reward received by each agent specified in the joint action.
|
State |
JointModel.sample(State s,
JointAction ja)
Samples the result of performing
JointAction ja in State s. |
List<StateTransitionProb> |
FullJointModel.stateTransitions(State s,
JointAction ja)
Returns the transition probabilities for applying the provided
JointAction action in the given state. |
| Modifier and Type | Field and Description |
|---|---|
protected State |
World.currentState |
| Modifier and Type | Method and Description |
|---|---|
State |
World.getCurrentWorldState()
Returns the current world state
|
| Modifier and Type | Method and Description |
|---|---|
void |
WorldObserver.gameEnding(State s)
This method is called whenever a game in a world ends.
|
void |
WorldObserver.gameStarting(State s)
This method is called whenever a new game in a world is starting.
|
void |
WorldObserver.observe(State s,
JointAction ja,
double[] reward,
State sp)
This method is called whenever an interaction in the world occurs.
|
GameEpisode |
World.rolloutJointPolicyFromState(JointPolicy jp,
State s,
int maxStages)
Rollsout a joint policy from a given state until a terminate state is reached for a maximum number of stages.
|
GameEpisode |
World.runGame(int maxStages,
State s)
Runs a game starting in the input state until a terminal state is hit.
|
void |
World.setCurrentState(State s)
Sets the world state to the provided state if the a game is not currently running.
|
| Constructor and Description |
|---|
World(SGDomain domain,
JointRewardFunction jr,
TerminalFunction tf,
State initialState)
Initializes the world.
|
| Constructor and Description |
|---|
EnvironmentShell(SADomain domain,
State s)
Creates a shell for a
SimulatedEnvironment rooted at the input state using std in and std out. |
SGWorldShell(SGDomain domain,
State s)
Creates s SGWorldShell with a new world using the domain and using std in and std out.
|
| Modifier and Type | Method and Description |
|---|---|
void |
EpisodeRecordingCommands.observeEnvironmentActionInitiation(State o,
Action action) |
| Modifier and Type | Method and Description |
|---|---|
Action |
ManualAgentsCommands.ManualSGAgent.action(State s) |
void |
ManualAgentsCommands.ManualSGAgent.observeOutcome(State s,
JointAction jointAction,
double[] jointReward,
State sprime,
boolean isTerminal) |
| Modifier and Type | Method and Description |
|---|---|
void |
SGVisualExplorer.gameEnding(State s) |
void |
SGVisualExplorer.gameStarting(State s) |
void |
SGVisualExplorer.observe(State s,
JointAction ja,
double[] reward,
State sp) |
protected void |
VisualExplorer.updatePropTextArea(State s)
Updates the propositional function evaluation text display for the given state.
|
protected void |
SGVisualExplorer.updatePropTextArea(State s) |
void |
VisualExplorer.updateState(State s)
Updates the currently visualized state to the input state.
|
void |
SGVisualExplorer.updateState(State s)
Updates the currently visualized state to the input state.
|
| Constructor and Description |
|---|
SGVisualExplorer(SGDomain domain,
Visualizer painter,
State baseState)
Initializes the data members for the visual explorer.
|
SGVisualExplorer(SGDomain domain,
Visualizer painter,
State baseState,
int w,
int h)
Initializes the data members for the visual explorer.
|
VisualExplorer(SADomain domain,
Visualizer painter,
State baseState)
Initializes with a domain and initial state, automatically creating a
SimulatedEnvironment
as the environment with which to interact. |
| Modifier and Type | Field and Description |
|---|---|
protected State |
WrappedHashableState.s
The source
State to be hashed and evaluated by the WrappedHashableState.hashCode() and WrappedHashableState.equals(Object) method. |
| Modifier and Type | Method and Description |
|---|---|
State |
WrappedHashableState.getS()
Getter for Java Bean serialization purposes.
|
State |
WrappedHashableState.s() |
State |
HashableState.s()
Returns the underlying source state that is hashed.
|
| Modifier and Type | Method and Description |
|---|---|
HashableState |
ReflectiveHashableStateFactory.hashState(State s) |
HashableState |
HashableStateFactory.hashState(State s)
Turns
State s into a HashableState |
void |
WrappedHashableState.setS(State s)
Setter for Java Bean serialization purposes.
|
| Constructor and Description |
|---|
WrappedHashableState(State s) |
| Modifier and Type | Method and Description |
|---|---|
HashableState |
DiscretizingHashableStateFactory.hashState(State s) |
| Constructor and Description |
|---|
IDDiscHashableState(State s,
DiscConfig config) |
IIDiscHashableState(State s,
DiscConfig config) |
| Modifier and Type | Method and Description |
|---|---|
HashableState |
MaskedHashableStateFactory.hashState(State s) |
| Constructor and Description |
|---|
IDMaskedHashableState(State s,
MaskedConfig config) |
IIMaskedHashableState(State s,
MaskedConfig config) |
| Modifier and Type | Method and Description |
|---|---|
HashableState |
DiscretizingMaskedHashableStateFactory.hashState(State s) |
| Constructor and Description |
|---|
IDDiscMaskedHashableState(State s,
DiscMaskedConfig config) |
IIDiscMaskedHashableState(State s,
DiscMaskedConfig config) |
| Modifier and Type | Method and Description |
|---|---|
protected int |
IISimpleHashableState.computeFlatHashCode(State s) |
protected int |
IDSimpleHashableState.computeFlatHashCode(State s) |
protected int |
IISimpleHashableState.computeHashCode(State s)
Computes the hash code for the input state.
|
protected int |
IDSimpleHashableState.computeHashCode(State s)
Computes the hash code for the input state.
|
protected boolean |
IISimpleHashableState.flatStatesEqual(State s1,
State s2) |
protected boolean |
IDSimpleHashableState.flatStatesEqual(State s1,
State s2) |
HashableState |
SimpleHashableStateFactory.hashState(State s) |
protected boolean |
IISimpleHashableState.statesEqual(State s1,
State s2)
Returns true if the two input states are equal.
|
protected boolean |
IDSimpleHashableState.statesEqual(State s1,
State s2)
Returns true if the two input states are equal.
|
| Constructor and Description |
|---|
IDSimpleHashableState(State s) |
IISimpleHashableState(State s) |
| Modifier and Type | Field and Description |
|---|---|
protected State |
StateRenderLayer.curState
the current state to be painted next
|
protected State |
StateActionRenderLayer.renderState
The current
State to render |
| Modifier and Type | Method and Description |
|---|---|
State |
StateRenderLayer.getCurState() |
State |
StateActionRenderLayer.getRenderState()
Returns the
State that is/will be rendered |
| Modifier and Type | Method and Description |
|---|---|
void |
StatePainter.paint(Graphics2D g2,
State s,
float cWidth,
float cHeight)
Paints general state information not to graphics context g2
|
void |
OOStatePainter.paint(Graphics2D g2,
State s,
float cWidth,
float cHeight) |
abstract void |
StateActionRenderLayer.renderStateAction(Graphics2D g2,
State s,
Action a,
float width,
float height)
Method to be implemented by subclasses that will render the input state-action to the given graphics context.
|
void |
StateActionRenderLayer.updateRenderedStateAction(State s,
Action a)
|
void |
Visualizer.updateState(State s)
Updates the state that needs to be painted and repaints.
|
void |
StateRenderLayer.updateState(State s)
Updates the state that needs to be painted
|
void |
Visualizer.updateStateAction(State s,
Action a)
Updates the state and action for the
StateRenderLayer and StateActionRenderLayer ; then repaints. |
Copyright © 2019. All rights reserved.


Girl Develop It ♥s Colorado!
Girl Develop It is a nonprofit organization that exists to provide affordable and judgment-free opportunities for women interested in learning web and software development. Through in-person classes and community support, Girl Develop It helps women of diverse backgrounds achieve their technology goals and build confidence in their careers and their every day lives.
Our Vision
Our vision is to create a network of empowered women who feel confident in their abilities to code and build beautiful web and mobile applications. By teaching women around the world from diverse backgrounds to learn software development, we can help women improve their careers and confidence in their everyday lives.
Our Values
We are committed to making sure women of all races, education levels, income and upbringing can build confidence in their skill set to develop web and mobile applications.
Our goal is to provide powerful hands-on programs to women seeking professional help in software development and create basic to advanced web and mobile applications.
The Leaders
With chapters in 58+ cities across the country we have over 150 leaders changing lives through providing opportunities to their communities.
GDI Summit 2016
GDI Summit 2017
GDI Summit 2017
A timeline of GDI
- 2010: The first Girl Develop It chapter was founded in New York City!
- One class. It started with one class, Introduction to HTML/CSS.
- 24 hours How long it took for that very first class to sell out.
- 2013: The Boulder chapter is started!
- 2014: We expand to Denver, allowing us to offer more opportunities to the community!
- 2018: We celebrate 5 years in Colorado serving 2,500+ people!


Agriculture in Spain
The first useful agricultural area in the EU-15,With 25 million hectares covering 50% of its territory, Spain has, before France, the largest UAA in the EU. to 15 (21%). In particular, it has 18 million hectares of cultivated land (including 4.3 million irrigated hectares) and 7 million hectares of meadows and pastures. Although the position of farming has declined, it remains a significant part of Spain’s national economy and landscape. Spain has more than 29 million acres (11.7 million hectares) under permanent crops, the largest such area in Europe. About 6 percent of Spain’s workers are employed in agriculture, and they produce about 3 percent of the county’s GDP. The fourth final agricultural production in the EU: Production in the agricultural industry in 2004 stood at 39 billion euros (+ 60.3% compared to 1990), or 3.4% of Spanish GDP. The country contributes to 12% of the Community's Final Agricultural Production and is thus placed in 4th place within the countries of the European Union. The sectoral distribution of agricultural production shows a predominance of crop production which constitutes 58.7% of production against 41.3% for livestock, this proportion changing little. Spain is the second beneficiary country of the CAP with 6.34 billion euros in EAGGF-Guarantee revenue in the agricultural sector in 2004.
Fruits & Vegetables
Widespread irrigation has enabled Spain to grow almost all known varieties of fruit and vegetables. However, tradition still plays a part in what is grown in each region. A never- ending, flavorful and healthy supply.
Vegetables
Spain’s plentiful vegetable and fruit crops traditionally supplied a wealth of products needing preservation so that they could be consumed year-round. With the invention of canning and sterilization systems in the 19th century, small-scale, family-run businesses developed, forming the backbone of what were to become large vegetable processing companies. These have now existed for decades and are mostly located in the areas where the products are grown. The leaders in this sector are the regions of Murcia and Valencia, followed by the Ebro valley or, more specifically, Navarre and La Rioja. The latter have a longstanding tradition in the production of vegetable preserves, especially asparagus, peppers and artichokes. Other regions growing and canning vegetables are Extremadura, Aragón, the two Castiles, Andalusia and Catalonia. Many tomato preserves are also produced all over Spain. Some of the most famous Spanish vegetable preserves are the PDO Pimiento del Piquillo de Lodosa peppers from Navarre. Although virtually inedible when fresh, after roasting, hand peeling and canning, they become an outstanding delicacy with a silky texture and complex flavor – sweet, fragrant and just slightly hot. Another well-known variety of pepper used for roasting and canning are those from Nájera (La Rioja), which are the basis for PGI Pimiento Riojano. Others are the roasted Bierzo peppers from PGI Pimiento Asado del Bierzo in León. Another prized vegetable for canning is asparagus, and particularly those from La Rioja, Aragón and PGI Espárrago de Navarra in Navarre. Other stalk vegetables like cardoon and borage are also canned in this part of Spain. Canned artichokes are considered a delicacy, and particularly those from Tudela in Navarre which have PGI Alcachofa de Tudela status.
Fruit
Spain’s privileged location in the Mediterranean basin allows it to produce almost ten million tons of fruit annually. Approximately five to ten per cent of this is processed, mainly as preserves, making Spain one of Europe’s main producers and exporters of canned fruit. Production mostly takes place in the region of Murcia, with peaches (the star product), mandarins, apricots and pears being the most important. Some sub-tropical fruits such as mango and papaya are also produced in canned form. Spain’s plentiful vegetable and fruit crops, fish captures and meat elaboration methods traditionally supplied a wealth of products needing preservation so that they could be consumed year-round.
Growing animal productions
Meat production reached 5.37 million tonnes in 2004; this figure has been increasing in recent years. Pig production represents around 10% of final Spanish agricultural production. In 2004, Spain produced 15% of EU pigmeat, or 3.2 million tonnes. The herd is growing; it represented 25.4 million head in 2004, making it the second EU herd with 17% of the EU herd. Spain, which now has the most competitive pork sector in Europe, is also the leading consumer of pork in the EU (over 66 kg per person per year). The cattle herd was 6.7 million head in 2004, including 1.06 million dairy cows. The dairy herd is steadily declining. For its part, the suckler herd is progressing slowly, in particular due to restricted premium rights; fattening is gradually developing in the beef breed areas, the main areas of intensive fattening still in Catalonia. Beef production reached 716,000 tonnes in 2004 (2.3 million head), or 9% of EU production. Since November 22, 2000 (date of the announcement of the first case), the Spanish cattle herd is no longer free from BSE (137 cases in 2004). The Spanish milk quota was set at 6.12 million tonnes from April 1, 2001. There are around 34,000 farmers delivering milk (a marked decrease), the average quota per farm being 177,000 kg. Production is concentrated three-quarters in the Cantabrian cornice. 70% of farms benefit from a quota that does not reach the national average, while 2% of producers concentrate 20% of the quotas. A restructuring plan for the dairy sector was implemented in 2005 to encourage the expansion of farms whose size was too small and threatened profitability. With 253,000 tonnes in 2004, Spanish sheep and goat meat production represented 22% of Community production. In 2004, the sheep population was 23.5 million heads and the goat population 3.16 million heads. The slight decrease in livestock in 2004 (which had increased by 50% in 30 years) is explained by the reappearance of bluetongue in Andalusia in 2004. Poultry meat production reached 1.31 million tonnes (14% of EU production) and egg production 1.13 billion dozen (13% of EU production) in 2004 These two productions are growing. Total agri-food exports in 2004 were € 21.9 billion and imports were € 20.2 billion. The agro-food balance was positive for the ninth consecutive year at 1.7 billion euros, which allows Spain to reduce its overall deficit in foreign trade. The share of exports in Final Agricultural Production is around 56%. On the contrary, the trade balance of the non-food subsector was negative. The products contributing most significantly to this deficit are tobacco (cigars, cigarettes), wood, skins and cotton.
Area and Production
Spain is the EU’s second largest cotton growing Member State after Greece. Spain’s cotton production accounts for just above 20 percent of the EU-28 cotton output. Cotton production in Spain is concentrated in the Guadalquivir Valley, Andalucía, Spain’s southernmost region. The majority of the production is located in the Andalusian provinces of Seville and Cadiz, and to a lesser extent, Cordoba and Jaen. From an environmental, social and economic perspective, cotton is a critical crop in the areas where it is grown as viable crop alternatives are limited. Virtually all cotton in Spain is cultivated under irrigation. Spain’s cotton area is highly inelastic. It is grown under salty and warm conditions, and there are little alternative crops that can be profitable under these circumstances. However, slight area variations can occur, depending on water supplies, price relations, and competition from other crops. To a certain extent, available subsidies also play a role in planting decisions. The implementation of the EU cotton reform in 2006 resulted in a significant reduction in cotton planted area, which reached a record low in marketing year 2008/09. The amendments introduced by Regulation (EC) 637/2008 resulted in an area recovery until marketing year 2014/15 when cotton area hit its highest level in 9 years. The downwards revision of the reference amount for area payments resulted in a new drop in the cotton planted area, which has stabilized around 63,000 Ha. (For additional information, see Policy Section)
Terms&conditions
All information collected by Agri Library is encrypted to the standards required and used by all online services, such as online banking. We do not retain any financial related information. Agri Library has a strict privacy policy for the use of all information gathered by members.
AgriLibrary.com is a free online service that allows to find all needed information in real time. With the simple click of a mouse anyone can select usefull info at a time convenient to them.


{% load i18n %} {% include 'include/head.html' %}
Jucy is a customer support widget and dashboard by developers, for developers.
Because, as a tech team, you don't have to hire someone to communicate with your users - you just need the right tool.
{% blocktrans %} In just a few clicks, install a widget in your website or your mobile app. {% endblocktrans %}
{% blocktrans %} Start getting users' feedback, posted on GitHub. No need to change your habits! {% endblocktrans %}
{% blocktrans %} Accept or reject users' feedback on Jucy's friendly dashboard - or on GitHub! {% endblocktrans %}
{% blocktrans %} Gather feature requests and bug reports from your users. {% endblocktrans %}
{% blocktrans %} Your F.A.Q. on how to use your product, simplified. {% endblocktrans %}
{% blocktrans %} From encouragments to personal issues, let your users talk to you. {% endblocktrans %}
{% blocktrans %} In just a few clicks, get a preview of your very own Jucy dashboard for one of your GitHub repositories. {% endblocktrans %}


Good Eats - S02E01P1 - It's A Wonderful Cake - YouTube
Nov 1, 2010 .  Watch as . Recipe: Free Range Fruit Cake Recipes .
http://www.youtube.com/watch?v=3ijRhOYsFs4
Treatment for Herniated or Bulging Discs
Free Range Fruitcake Recipe : Alton Brown : Recipes : Food Network
Get this all-star, easy-to-follow Food Network Free Range Fruitcake recipe from Alton Brown.
http://www.foodnetwork.com/recipes/alton-brown/free-range-fruitcake-recipe/index.html
Drunken Fruit Cake | Eclectic Recipes
Dec 13, 2009 . This is the best fruitcake you will ever have. This recipe has been slightly adapted from the Alton Brown free range fruitcake recipe. Erase any .
http://eclecticrecipes.com/drunken-fruit-cake
alton brown fruitcake recipe Herniated or Bulging Discs
25 Gourmet Fruitcake Recipes - The very best fruitcakes for the ...
Dec 11, 2011 . Free Range Fruitcake This five-star recipe, from Food Network's Alton Brown, is packed full of goodies! Besides raisins, currants, candied .
http://www.examiner.com/article/25-gourmet-fruitcake-recipes-the-very-best-fruitcakes-for-the-holidays
Which Alton brown fruitcake recipe did they use on the iron chef ...
Which Alton brown fruitcake recipe did they use on the iron chef competition? Answer . I have a question for Alton Brown that has nothing to do with his shows.
http://wiki.answers.com/Q/Which_Alton_brown_fruitcake_recipe_did_they_use_on_the_iron_chef_competition
Official Impairment Listing for Spinal Disorders
Moist Xmas fruitcake recipe - Homesteading Today
Oct 19, 2012 . I made a recipe from Alton Brown called "Free Range Fruitcake" and I made it in December and opened one two weeks ago and it was very .
http://www.homesteadingtoday.com/country-homemaking/cooking/461587-moist-xmas-fruitcake-recipe.html
- the wharf express in tallahassee fl (narrowing of the spine)
Fruitcake Recipes in the Yahoo! Directory
Yahoo! reviewed these sites and found them related to .
http://dir.yahoo.com/Society_and_Culture/Food_and_Drink/Cooking/Recipes/Holidays_and_Occasions/Christmas/Christmas_Desserts/Fruitcake/ISO traditional/classic rich dark fruitcake recipe - Home Cooking ...
Nov 7, 2008 . I found that Alton Brown's fruitcake is very good and quite adaptable to personal preferences, and it is very close to my family recipe. Mine uses .
http://chowhound.chow.com/topics/570345
Make your holiday fruitcake now! - Slashfood
Nov 26, 2007 . Did you know that fruitcake is considered a holiday dessert to this day because of a law that was . I used Alton Brown's recipe this year. It looks .
http://www.slashfood.com/2007/11/26/make-your-holiday-fruitcake-now/
Free Range Fruitcake Recipe : Review : Alton Brown ... - Food Network
Prior posts have said it all: EXCELLENT. I love fruitcake, never thought I could make one. This makes me happy, happy, happy. I am making Holiday Baskets this .
http://www.foodnetwork.com/recipes/alton-brown/free-range-fruitcake-recipe/reviews/index.html
Medical-Vocational Allowance for Herniated Disc
dabblings and whimsey: In the left corner: Alton Brown's Fruitcake
Nov 17, 2010 . So let's get to his recipe and I'll show you what Lily and I did in the kitchen. Free Range Fruitcake. By, Alton Brown. Ingredients: 1 cup golden .
http://dabblingsandwhimsey.blogspot.com/2010/11/in-left-corner-alton-browns-fruitcake.html
Opening my mind to fruitcake - General Topics - Chowhound
Nov 7, 2012 . I like Alton Brown's fruitcake recipe as a good place to start. You need to use dried fruit instead of the purchased macerated fruit to get the .
http://chowhound.chow.com/topics/876681
Appealing a Denial of Benefits
Free Range Fruitcake Recipe : Review : Alton Brown ... - Food Network
Recipe courtesy Alton Brown. Rated: 5 stars out of 5Rate . Thanks Alton for giving me the inspiration and the best recipe for a fruitcake ever. A fan for life, thanks .
http://www.foodnetwork.com/recipes/alton-brown/free-range-fruitcake-recipe2/reviews/index.html


Ocean [ad52], ocean, in Crystal Sea
Last updated Turn #73
Ocean [ad52], ocean, in Crystal Sea
------------------------------------------------------------------------
12: Fast Sail [ht2u], ship, 3 hulls, 1 rowing port, 9 sails, arrived from
12: Ocean [ac52], owner:
12: Stewart [k0u], Pen, with 12 sailors
13: Fast Sail [ht2u], ship, 3 hulls, 1 rowing port, 9 sails, departed for
13: Ocean [ae52].
Routes leaving Ocean:
North, to Ocean [ac52], 6 days
East, to Ocean [ad53], 6 days
South, to Ocean [ae52], 6 days
West, to Ocean [ad51], 6 days