C++ CState::getDiscreteState方法代码示例

void CFeatureOperatorAnd::getModifiedState(CStateCollection *stateCol, CState *featState)
{
	int featureOffset = 1;

	std::list<CStateModifier *>::iterator it = getStateModifiers()->begin();
	std::list<CState *>::iterator stateIt = states->begin();


	CState *stateBuf;

	for (unsigned int i = 0; i < getNumDiscreteStates();i ++)
	{
		featState->setDiscreteState(i, 0);
		featState->setContinuousState(i, 1.0);
	}

	int repetitions = getNumDiscreteStates();
	for (int j = 0; it != getStateModifiers()->end(); it ++, stateIt ++, j ++)
	{
		repetitions /= (*it)->getNumDiscreteStates();
		stateBuf = NULL;
		if (stateCol->isMember(*it))
		{
			stateBuf = stateCol->getState(*it);
		}
		else
		{
			stateBuf = *stateIt;
			(*it)->getModifiedState(stateCol, stateBuf);
		}
		
		if (stateBuf->getStateProperties()->isType(FEATURESTATE))
		{
			for (unsigned int i = 0; i < getNumDiscreteStates(); i++)
			{
				unsigned int singleStateFeatureNum = (i / repetitions) % stateBuf->getNumDiscreteStates();
				featState->setDiscreteState(i, featState->getDiscreteState(i) + featureOffset * stateBuf->getDiscreteState(singleStateFeatureNum));
				featState->setContinuousState(i, featState->getContinuousState(i) * stateBuf->getContinuousState(singleStateFeatureNum));
			}
		}
		else
		{
			for (unsigned int i = 0; i < getNumDiscreteStates(); i++)
			{
				featState->setDiscreteState(i, featState->getDiscreteState(i) + featureOffset * stateBuf->getDiscreteState(0));				
			}
		}

		featureOffset = featureOffset * (*it)->getDiscreteStateSize();
	}
	normalizeFeatures(featState);
}

void CEpisodeMatlabOutput::nextStep(CStateCollection *oldState, CAction *action, double reward,  CStateCollection *nextState)
{
	CActionData *actionData = action->getActionData();

	fprintf(stream, "%d %d ", nEpisodes, nSteps);
	CState *state = oldState->getState(properties);
	unsigned int i = 0;
	for (i = 0; i < properties->getNumContinuousStates(); i++)
	{
		fprintf(stream, "%lf ", state->getContinuousState(i));
	}
	for (i = 0; i < properties->getNumDiscreteStates(); i++)
	{
		fprintf(stream, "%d ", (int)state->getDiscreteState(i));
	}
	
	state = nextState->getState(properties);
	for (i = 0; i < properties->getNumContinuousStates(); i++)
	{
		fprintf(stream, "%lf ", state->getContinuousState(i));
	}
	for (i = 0; i < properties->getNumDiscreteStates(); i++)
	{
		fprintf(stream, "%d ", (int)state->getDiscreteState(i));
	}
	
	fprintf(stream,"%d ", actions->getIndex(action));
	if (actionData != NULL)
	{
		CContinuousActionData *contData = dynamic_cast<CContinuousActionData *>(actionData);
		for (int j = 0; j < contData->nrows(); j++)
		{
			fprintf(stream, "%lf ", contData->element(j));
		}
	}
	
	fprintf(stream, "%lf ", reward);
		
	fprintf(stream, "\n");
	
	nSteps++;
	
	fflush(stream);
}

void CStateVariablesChooser::getModifiedState(CStateCollection *originalStateCol, CState *modifiedState)
{
	CState *origState = originalStateCol->getState(originalState);
	for (unsigned int i = 0; i < getNumContinuousStates(); i ++)
	{
		modifiedState->setContinuousState(i, origState->getContinuousState(contStatesInd[i]));
	}
	for (unsigned int i = 0; i < getNumDiscreteStates(); i ++)
	{
		modifiedState->setDiscreteState(i, origState->getDiscreteState(discStatesInd[i]));
	}
}

void CFeatureStateRewardModel::nextStep(CStateCollection *, CAction *, double reward, CStateCollection *newStateCol)
{
	CState *newState = newStateCol->getState(discretizer);

	if (newState->getStateProperties()->isType(FEATURESTATE))
	{
		for (unsigned int i = 0; i < newState->getNumContinuousStates(); i++)
		{
			rewards[newState->getDiscreteState(i)] +=  reward * newState->getContinuousState(i);
			visits[newState->getDiscreteState(i)] += newState->getContinuousState(i);
		}
	}
	else
	{
		if (newState->getStateProperties()->isType(DISCRETESTATE))
		{
			rewards[newState->getDiscreteState(0)] +=  reward ;
			visits[newState->getDiscreteState(0)] += 1.0;
		}
	}
}

void CQAverageTDErrorLearner::receiveError(double error, CStateCollection *state, CAction *action, CActionData *)
{
	CState *featureState = state->getState(averageErrorFunction->getFeatureCalculator());
	
	for (unsigned int i = 0; i < featureState->getNumDiscreteStates(); i++)
	{
		int index = featureState->getDiscreteState(i);
		double featureFac = featureState->getContinuousState(i);
		double featureVal = averageErrorFunction->getValue(index, action);
				
		featureVal = featureVal * (updateRate  + (1 - featureFac) * (1 - updateRate)) + error * (1 - updateRate) * featureFac;
		averageErrorFunction->setValue(index, action, featureVal);
	}
}

void HashTableETraces::addETrace(CStateCollection *state, CAction *action, double factor, CActionData *data) 
{
//		_currentState = state;

    CState* currState = state->getState();
    int it = currState->getDiscreteState(0);

//    DebugPrint('e',"\n[+] Add e-trace to state : %d and action %d", it, dynamic_cast<MultiBoost::CAdaBoostAction*>(action)->getMode());

    _eTraces.push_back(factor);
    
    _eTraceStates.push_back( MDDAGState( currState ));
//        _eTraceStates->addStateCollection(state);
    
//        int actionIndex = dynamic_cast<MultiBoost::CAdaBoostAction*>(action)->getMode();
    _actions.push_back( action );
}