/**
* Write a textual representation of FeatureSet to File.
* This representation is an integer specifying the number of
* features in the set, followed by a newline, followed by
* text representations for each feature in the set.
* @param FeatureSet feature set to write to File
* @param str string to write Feature to
*/
void WriteFeatureSet(FEATURE_SET FeatureSet, STRING* str) {
if (FeatureSet) {
str->add_str_int("", FeatureSet->NumFeatures);
*str += "\n";
for (int i = 0; i < FeatureSet->NumFeatures; i++) {
WriteFeature(FeatureSet->Features[i], str);
}
}
} /* WriteFeatureSet */
/*---------------------------------------------------------------------------*/
void WriteFeatureSet(FILE *File, FEATURE_SET FeatureSet) {
/*
** Parameters:
** File open text file to write FeatureSet to
** FeatureSet feature set to write to File
** Globals: none
** Operation: Write a textual representation of FeatureSet to File.
** This representation is an integer specifying the number of
** features in the set, followed by a newline, followed by
** text representations for each feature in the set.
** Return: none
** Exceptions: none
** History: Wed May 23 10:06:03 1990, DSJ, Created.
*/
int i;
if (FeatureSet) {
fprintf (File, "%d\n", FeatureSet->NumFeatures);
for (i = 0; i < FeatureSet->NumFeatures; i++)
WriteFeature (File, FeatureSet->Features[i]);
}
} /* WriteFeatureSet */
void Oracle::Execute(const std::vector<Move>& steps, const std::string& feature_filename, const std::string& distribution_filename){
// write feature
WriteFeature(steps, feature_filename);
//return;
// call the tensorflow main body
PyObject* pFunc = PyObject_GetAttrString(pModule, "player");
if (!pFunc){
PyErr_Print();
std::cout << "Oracle::Execute() ERROR: get func failed!" << std::endl;
assert(0);
}
PyObject* pParam = Py_BuildValue("(ss)", feature_filename.c_str(), distribution_filename.c_str());
PyObject* pResult = PyEval_CallObject(pFunc, pParam);
if (!pResult){
PyErr_Print();
std::cout << "Oracle::Execute() ERROR: get result failed!" << std::endl;
assert(0);
}
// read the distribution
distribution.clear();
ReadDistribution(distribution_filename);
}
BOOL
CST202T_SATA::SetLookAhead(
)
{
BYTE bError = 0;
BYTE bStatus = 0;
// select device
SelectDevice();
// wait for device to acknowledge selection
WaitForDisc(WAIT_TYPE_NOT_BUSY, 100);
WaitForDisc(WAIT_TYPE_READY, 1000);
WaitOnBusy(TRUE);
// write command
WriteFeature(ATA_ENABLE_LOOKAHEAD);
WriteCommand(ATAPI_CMD_SET_FEATURES);
// wait for device to respond to command
WaitOnBusy(TRUE);
WaitForDisc(WAIT_TYPE_NOT_BUSY, 200);
// check response
bStatus = GetBaseStatus();
bError = GetError();
if ((bStatus & ATA_STATUS_ERROR) && (bError & ATA_ERROR_ABORTED)) {
DEBUGMSG(ZONE_ERROR, (_T(
"Atapi!CDisk::SetLookAhead> Failed to enable read look-ahead; status(%02X), error(%02X)\r\n"
), bStatus, bError));
ResetController(FALSE);
return FALSE;
}
return TRUE;
}
FLOAT32 Classify::ComputeNormMatch(CLASS_ID ClassId, FEATURE Feature,
BOOL8 DebugMatch) {
/*
** Parameters:
** ClassId id of class to match against
** Feature character normalization feature
** DebugMatch controls dump of debug info
** Globals:
** NormProtos character normalization prototypes
** Operation: This routine compares Features against each character
** normalization proto for ClassId and returns the match
** rating of the best match.
** Return: Best match rating for Feature against protos of ClassId.
** Exceptions: none
** History: Wed Dec 19 16:56:12 1990, DSJ, Created.
*/
LIST Protos;
FLOAT32 BestMatch;
FLOAT32 Match;
FLOAT32 Delta;
PROTOTYPE *Proto;
int ProtoId;
/* handle requests for classification as noise */
if (ClassId == NO_CLASS) {
/* kludge - clean up constants and make into control knobs later */
Match = (Feature->Params[CharNormLength] *
Feature->Params[CharNormLength] * 500.0 +
Feature->Params[CharNormRx] *
Feature->Params[CharNormRx] * 8000.0 +
Feature->Params[CharNormRy] *
Feature->Params[CharNormRy] * 8000.0);
return (1.0 - NormEvidenceOf (Match));
}
BestMatch = MAX_FLOAT32;
Protos = NormProtos->Protos[ClassId];
if (DebugMatch) {
cprintf ("\nFeature = ");
WriteFeature(stdout, Feature);
}
ProtoId = 0;
iterate(Protos) {
Proto = (PROTOTYPE *) first_node (Protos);
Delta = Feature->Params[CharNormY] - Proto->Mean[CharNormY];
Match = Delta * Delta * Proto->Weight.Elliptical[CharNormY];
Delta = Feature->Params[CharNormRx] - Proto->Mean[CharNormRx];
Match += Delta * Delta * Proto->Weight.Elliptical[CharNormRx];
if (Match < BestMatch)
BestMatch = Match;
if (DebugMatch) {
cprintf ("Proto %1d = ", ProtoId);
WriteNFloats (stdout, NormProtos->NumParams, Proto->Mean);
cprintf (" var = ");
WriteNFloats (stdout, NormProtos->NumParams,
Proto->Variance.Elliptical);
cprintf (" match = ");
PrintNormMatch (stdout, NormProtos->NumParams, Proto, Feature);
}
ProtoId++;
}
return (1.0 - NormEvidenceOf (BestMatch));
} /* ComputeNormMatch */