CDynamicArray<index_t>* CBaggingMachine::get_oob_indices(const SGVector<index_t>& in_bag)
{
SGVector<bool> out_of_bag(m_features->get_num_vectors());
out_of_bag.set_const(true);
// mark the ones that are in_bag
index_t oob_count = m_features->get_num_vectors();
for (index_t i = 0; i < in_bag.vlen; i++)
{
if (out_of_bag[in_bag[i]])
{
out_of_bag[in_bag[i]] = false;
oob_count--;
}
}
CDynamicArray<index_t>* oob = new CDynamicArray<index_t>();
// store the indicies of vectors that are out of the bag
for (index_t i = 0; i < out_of_bag.vlen; i++)
{
if (out_of_bag[i])
{
oob->push_back(i);
m_all_oob_idx[i] = true;
}
}
return oob;
}
//Unknown word recognition
//pWordSegResult:word Segmentation result;graphOptimum: The optimized segmentation graph
//graphSeg: The original segmentation graph
bool CUnknowWord::Recognition(PWORD_RESULT pWordSegResult, CDynamicArray &graphOptimum,CSegGraph &graphSeg,CDictionary &dictCore)
{
int nStartPos=0,j=0,nAtomStart,nAtomEnd,nPOSOriginal;
ELEMENT_TYPE dValue;
m_roleTag.POSTagging(pWordSegResult,dictCore,m_dict);
//Tag the segmentation with unknown recognition roles according the core dictionary and unknown recognition dictionary
for(int i=0;i<m_roleTag.m_nUnknownIndex;i++)
{
while((unsigned int)j<graphSeg.m_nAtomCount&&nStartPos<m_roleTag.m_nUnknownWords[i][0])
{
nStartPos+=graphSeg.m_nAtomLength[j++];
}
nAtomStart=j;
while((unsigned int)j<graphSeg.m_nAtomCount&&nStartPos<m_roleTag.m_nUnknownWords[i][1])
{
nStartPos+=graphSeg.m_nAtomLength[j++];
}
nAtomEnd=j;
if(nAtomStart<nAtomEnd)
{
graphOptimum.GetElement(nAtomStart,nAtomEnd,&dValue,&nPOSOriginal);
if(dValue>m_roleTag.m_dWordsPossibility[i])//Set the element with less frequency
graphOptimum.SetElement(nAtomStart,nAtomEnd,m_roleTag.m_dWordsPossibility[i],m_nPOS,m_sUnknownFlags);
}
}
return true;
}
//CDynamicArray &aWord: the words array
//CDynamicArray &aWordBinaryNet:the net between words
//double dSmoothingPara: the parameter of data smoothing
//CDictionary &DictBinary: the binary dictionary
//CDictionary &DictCore: the Core dictionary
bool CSegment::BiGraphGenerate(CDynamicArray &aWord, CDynamicArray &aBinaryWordNet,double dSmoothingPara,CDictionary &DictBinary,CDictionary &DictCore)
{
PARRAY_CHAIN pTail,pCur,pNextWords;//Temp buffer
unsigned int nWordIndex=0,nTwoWordsFreq=0,nCurWordIndex,nNextWordIndex;
//nWordIndex: the index number of current word
double dCurFreqency,dValue,dTemp;
char sTwoWords[WORD_MAXLENGTH];
m_nWordCount=aWord.GetTail(&pTail);//Get tail element and return the words count
if(m_npWordPosMapTable)
{//free buffer
delete [] m_npWordPosMapTable;
m_npWordPosMapTable=0;
}
if(m_nWordCount>0)//Word count is greater than 0
{
m_npWordPosMapTable=new int[m_nWordCount];//Record the position of possible words
memset(m_npWordPosMapTable,0,m_nWordCount*sizeof(int));
}
pCur=aWord.GetHead();
while(pCur!=NULL)//Set the position map of words
{
m_npWordPosMapTable[nWordIndex++]=pCur->row*MAX_SENTENCE_LEN+pCur->col;
pCur=pCur->next;
}
pCur=aWord.GetHead();
while(pCur!=NULL)//
{
if(pCur->nPOS>=0)//It's not an unknown words
dCurFreqency=pCur->value;
else//Unknown words
dCurFreqency=DictCore.GetFrequency(pCur->sWord,2);
aWord.GetElement(pCur->col,-1,pCur,&pNextWords);//Get next words which begin with pCur->col
while(pNextWords&&pNextWords->row==pCur->col)//Next words
{
//Current words frequency
strcpy(sTwoWords,pCur->sWord);
strcat(sTwoWords,WORD_SEGMENTER);
strcat(sTwoWords,pNextWords->sWord);
nTwoWordsFreq=DictBinary.GetFrequency(sTwoWords,3);
//Two linked Words frequency
dTemp=(double)1/MAX_FREQUENCE;
//Smoothing
dValue=-log(dSmoothingPara*(1+dCurFreqency)/(MAX_FREQUENCE+80000)+(1-dSmoothingPara)*((1-dTemp)*nTwoWordsFreq/(1+dCurFreqency)+dTemp));
//-log{a*P(Ci-1)+(1-a)P(Ci|Ci-1)} Note 0<a<1
if(pCur->nPOS<0)//Unknown words: P(Wi|Ci);while known words:1
dValue+=pCur->value;
//Get the position index of current word in the position map table
nCurWordIndex=BinarySearch(pCur->row*MAX_SENTENCE_LEN+pCur->col,m_npWordPosMapTable,m_nWordCount);
nNextWordIndex=BinarySearch(pNextWords->row*MAX_SENTENCE_LEN+pNextWords->col,m_npWordPosMapTable,m_nWordCount);
aBinaryWordNet.SetElement(nCurWordIndex,nNextWordIndex,dValue,pCur->nPOS);
pNextWords=pNextWords->next;//Get next word
}
pCur=pCur->next;
}
return true;
}
Bool AppendString(CDynamicArray<char>& arLine, CDynamicArray<char>& arTempString, const String &str)
{
char *pchTemp;
Int32 lLen = str.GetCStringLen(STRINGENCODING_7BITHEX);
if (!arLine.Append('\"')) return false;
if (!arTempString.SetMinSizeNoCopy(3 + lLen)) return false;
pchTemp = arTempString.GetArray();
str.GetCString(pchTemp, lLen + 1, STRINGENCODING_7BITHEX);
if (!AppendString(arLine, pchTemp)) return false;
if (!arLine.Append('\"')) return false;
return true;
}
void BSPVertexContainer<Type, iDimensions>::CreateEdges(CDynamicArray<BSPEdge<Type, iDimensions> > &abed, ULONG ulEdgeTag)
{
// if there are no vertices, or the container is not line
if (bvc_aVertices.Count()==0 || IsPlannar()) {
// do not attempt to sort
return;
}
// initially, edge is inactive
BOOL bActive = FALSE;
BSPEdge<Type, iDimensions> *pbed = NULL;
// for all vertices in container
for (INDEX iVertex=0; iVertex<bvc_aVertices.Count(); iVertex++) {
BSPVertex<Type, iDimensions> &bvx = bvc_aVertices[iVertex]; // reference to this vertex
// if edge is inactive
if (!bActive) {
// create new edge
pbed = abed.New();
pbed->bed_ulEdgeTag = ulEdgeTag;
// set start vertex
pbed->bed_vVertex0 = bvx;
} else {
// set end vertex
pbed->bed_vVertex1 = bvx;
// trash edge pointer
IFDEBUG(pbed = NULL);
}
// toggle edge
bActive = !bActive;
}
}
Bool AppendString(CDynamicArray<char>& arLine, const char* pchLine)
{
while (*pchLine != '\0')
{
if (*pchLine == '\"')
{
if (!arLine.Append('\"') || !arLine.Append('\"'))
return false;
}
else
{
if (!arLine.Append(*pchLine))
return false;
}
pchLine++;
}
return true;
}
int CCia3dObj::ObjectCount(int objidbuff[], const int bufflen)
{
int i, j;
CDynamicArray<int> A;
for (i=0; i<CIA3D_SUBOBJ_LIMIT; i++){
CObject3D *p = m_pObjList[i];
if (p==NULL) continue;
int bsize= p->ObjectCount(objidbuff, bufflen);
for (j=0; j<bsize; j++)
A.AddWithNoDuplication(objidbuff[j]);
}
int asize = A.GetSize();
assert(asize>0 && asize<bufflen);
for (i=0; i<asize; i++)
objidbuff[i] = A[i];
return asize;
}
Bool ReadLine(BaseFile* pFile, CDynamicArray<char>& arLine)
{
if (pFile->GetPosition() >= pFile->GetLength())
return false;
char ch;
Bool bEmpty, bEOF = false;
// read line
do
{
arLine.ResetCounter();
while (!bEOF)
{
if (!pFile->TryReadBytes(&ch, 1))
{
if (!arLine.Append('\0')) return false;
bEOF = true;
}
else if (ch == '\r' || ch == '\n')
{
if (!arLine.Append('\0')) return false;
break;
}
else
{
if (!arLine.Append(ch)) return false;
}
}
bEmpty = (arLine.GetElementCount() == 0);
if (!bEmpty && arLine[0] == '\0')
bEmpty = true;
} while (bEmpty && !bEOF);
return true;
}
void InitStreams(void)
{
// obtain information about system
// !!! FIXME: Move this into an abstraction of some sort...
#ifdef PLATFORM_WIN32
SYSTEM_INFO siSystemInfo;
GetSystemInfo( &siSystemInfo);
// and remember page size
_ulPageSize = siSystemInfo.dwPageSize*16; // cca. 64kB on WinNT/Win95
#else
_ulPageSize = PAGESIZE;
#endif
// keep a copy of path for setting purposes
_fnmApp = _fnmApplicationPath;
// if no mod defined yet
if (_fnmMod=="") {
// check for 'default mod' file
LoadStringVar(CTString("DefaultMod.txt"), _fnmMod);
}
CPrintF(TRANSV("Current mod: %s\n"),
(_fnmMod=="") ? TRANS("<none>") :
(const char *) (CTString&)_fnmMod);
// if there is a mod active
if (_fnmMod!="") {
// load mod's include/exclude lists
CPrintF(TRANSV("Loading mod include/exclude lists...\n"));
BOOL bOK = FALSE;
bOK |= LoadFileList(_afnmBaseWriteInc , CTString("BaseWriteInclude.lst"));
bOK |= LoadFileList(_afnmBaseWriteExc , CTString("BaseWriteExclude.lst"));
bOK |= LoadFileList(_afnmBaseBrowseInc, CTString("BaseBrowseInclude.lst"));
bOK |= LoadFileList(_afnmBaseBrowseExc, CTString("BaseBrowseExclude.lst"));
// if none found
if (!bOK) {
// the mod is not valid
_fnmMod = CTString("");
CPrintF(TRANSV("Error: MOD not found!\n"));
// if mod is ok
} else {
// remember mod name (the parameter that is passed on cmdline)
_strModName = _fnmMod;
_strModName.DeleteChar(_strModName.Length()-1);
_strModName = CTFileName(_strModName).FileName();
}
}
// find eventual extension for the mod's dlls
_strModExt = "";
LoadStringVar(CTString("ModExt.txt"), _strModExt);
CPrintF(TRANSV("Loading group files...\n"));
CDynamicArray<CTString> *files = NULL;
// for each group file in base directory
files = _pFileSystem->FindFiles(_fnmApplicationPath, "*.gro");
int max = files->Count();
int i;
// for each .gro file in the directory
for (i = 0; i < max; i++) {
// add it to active set
UNZIPAddArchive( _fnmApplicationPath+((*files)[i]) );
}
delete files;
// if there is a mod active
if (_fnmMod!="") {
// for each group file in mod directory
files = _pFileSystem->FindFiles(_fnmApplicationPath+_fnmMod, "*.gro");
max = files->Count();
for (i = 0; i < max; i++) {
UNZIPAddArchive( _fnmApplicationPath + _fnmMod + ((*files)[i]) );
}
delete files;
}
// if there is a CD path
if (_fnmCDPath!="") {
// for each group file on the CD
files = _pFileSystem->FindFiles(_fnmCDPath, "*.gro");
max = files->Count();
for (i = 0; i < max; i++) {
UNZIPAddArchive( _fnmCDPath + ((*files)[i]) );
}
delete files;
// if there is a mod active
if (_fnmMod!="") {
// for each group file in mod directory
files = _pFileSystem->FindFiles(_fnmCDPath+_fnmMod, "*.gro");
max = files->Count();
for (i = 0; i < max; i++) {
UNZIPAddArchive( _fnmCDPath + _fnmMod + ((*files)[i]) );
}
delete files;
}
}
// try to
try {
// read the zip directories
UNZIPReadDirectoriesReverse_t();
// if failed
} catch( char *strError) {
// report warning
CPrintF( TRANS("There were group file errors:\n%s"), strError);
}
CPrintF("\n");
const char *dirsep = CFileSystem::GetDirSeparator();
LoadFileList(_afnmNoCRC, CTFILENAME("Data") + CTString(dirsep) + CTString("NoCRC.lst"));
_pShell->SetINDEX(CTString("sys")+"_iCPU"+"Misc", 1);
}
Bool ReadPreset(const Filename& fnPreset)
{
AutoAlloc <BaseFile> pFile;
if (!pFile)
return false;
Filename fnTemp;
PresetElement* pPreset;
String strName;
Int32 n;
CDynamicArray <char> arLine;
char* pszLine;
Bool bHeaderRead = false;
String str;
fnTemp = fnPreset.GetFile();
fnTemp.ClearSuffix();
strName = fnTemp.GetString();
bHeaderRead = false;
for (n = 0; n < g_Presets.GetElementCount(); n++)
{
if (g_Presets[n]->strName == strName)
break;
}
if (n != g_Presets.GetElementCount())
return false;
pPreset = g_Presets.GetNextObject();
if (!pPreset)
return false;
pPreset->strName = strName;
if (!pFile->Open(fnPreset))
return false;
while (ReadLine(pFile, arLine))
{
pszLine = arLine.GetArray();
if (!bHeaderRead)
{
if (strstr(pszLine, FILE_HEADER) == pszLine)
{
bHeaderRead = true;
continue;
}
}
if (!bHeaderRead)
break;
while (*pszLine != '\0')
{
if (strstr(pszLine, ORIG_PATH) == pszLine)
{
pszLine += strlen(ORIG_PATH);
ReadString(pszLine, pPreset->strOrigin);
}
if (strstr(pszLine, DEST_PATH) == pszLine)
{
pszLine += strlen(DEST_PATH);
ReadString(pszLine, pPreset->strDestination);
}
if (strstr(pszLine, CREATE_ZIP) == pszLine)
{
pszLine += strlen(CREATE_ZIP);
ReadBool(pszLine, pPreset->bCreateZipFile);
}
if (strstr(pszLine, CREATE_ZIP_COMPRESSION) == pszLine)
{
pszLine += strlen(CREATE_ZIP_COMPRESSION);
ReadInt32(pszLine, pPreset->lCreateZipCompressionLevel);
}
if (strstr(pszLine, CHECK_VERSION) == pszLine)
{
pszLine += strlen(CHECK_VERSION);
ReadBool(pszLine, pPreset->bCheckVersion);
}
if (strstr(pszLine, PARSE_SYMBOLS) == pszLine)
{
pszLine += strlen(PARSE_SYMBOLS);
ReadBool(pszLine, pPreset->bParseSymbols);
}
if (strstr(pszLine, WRITE_BUILD) == pszLine)
{
pszLine += strlen(WRITE_BUILD);
ReadBool(pszLine, pPreset->bWriteBuildInfo);
}
if (strstr(pszLine, REMOVE_SCC) == pszLine)
{
pszLine += strlen(REMOVE_SCC);
ReadBool(pszLine, pPreset->bRemoveSCC);
}
if (strstr(pszLine, BATCH) == pszLine)
{
pszLine += strlen(BATCH);
ReadBool(pszLine, pPreset->bBatch);
}
if (strstr(pszLine, PASSWORD) == pszLine)
{
pszLine += strlen(PASSWORD);
ReadString(pszLine, pPreset->strPassword);
pPreset->strPassword = DecryptPassword(pPreset->strPassword);
}
if (strstr(pszLine, FILTER_STRING) == pszLine)
{
pszLine += strlen(FILTER_STRING);
FilterElement* pFilter = pPreset->arFilters.GetNextObject();
if (!pFilter)
continue;
ReadString(pszLine, pFilter->str);
if (strstr(pszLine, FILTER_CONDITION) == pszLine)
{
pszLine += strlen(FILTER_CONDITION);
ReadString(pszLine, str);
if (str == W_FILTER_COND_FN_IS) pFilter->lCondition = FILTER_COND_FN_IS;
else if (str == W_FILTER_COND_FN_EXT) pFilter->lCondition = FILTER_COND_FN_EXT;
else if (str == W_FILTER_COND_PATH_CONTAINS) pFilter->lCondition = FILTER_COND_PATH_CONTAINS;
else if (str == W_FILTER_COND_PATH_IS) pFilter->lCondition = FILTER_COND_PATH_IS;
else if (str == W_FILTER_COND_DIRECTORY_IS) pFilter->lCondition = FILTER_COND_DIRECTORY_IS;
else DebugAssert(false);
}
if (strstr(pszLine, FILTER_ACTION) == pszLine)
{
pszLine += strlen(FILTER_ACTION);
ReadString(pszLine, str);
if (str == W_FILTER_ACTION_INCLUDE) pFilter->lAction = FILTER_ACTION_INCLUDE;
else if (str == W_FILTER_ACTION_EXCLUDE) pFilter->lAction = FILTER_ACTION_EXCLUDE;
else if (str == W_FILTER_ACTION_RENAME) pFilter->lAction = FILTER_ACTION_RENAME;
else if (str == W_FILTER_ACTION_COMPILE_INCL) pFilter->lAction = FILTER_ACTION_COMPILE_INCL;
else if (str == W_FILTER_ACTION_MOVE_TO) pFilter->lAction = FILTER_ACTION_MOVE_TO;
else if (str == W_FILTER_ACTION_FORCE_COPY) pFilter->lAction = FILTER_ACTION_FORCE_COPY;
else if (str == W_FILTER_ACTION_COMPILE_INCL_KILL) pFilter->lAction = FILTER_ACTION_COMPILE_INCL_KILL;
else DebugAssert(false);
}
if (strstr(pszLine, FILTER_RENAME) == pszLine)
{
DebugAssert(pFilter->lAction == FILTER_ACTION_RENAME);
pszLine += strlen(FILTER_RENAME);
ReadString(pszLine, pFilter->strRename);
}
else
DebugAssert(pFilter->lAction != FILTER_ACTION_RENAME);
if (strstr(pszLine, FILTER_FLAG) == pszLine)
{
pszLine += strlen(FILTER_FLAG);
ReadString(pszLine, str);
if (str == W_FILTER_FLAG_SET_XBIT) pFilter->bSetXBit = true;
else DebugAssert(false);
}
}
//if (pszLastPos != pszLine) always skip until the end of the line
break;
}
}
pFile->Close();
pPreset->ulCRC = GetPresetCrc(pPreset);
return true;
}
void WriteLine(CDynamicArray<char>& arLine, BaseFile* pFile)
{
pFile->WriteBytes(arLine.GetArray(), arLine.GetElementCount());
pFile->WriteBytes((void*)"\r\n", 2);
arLine.ResetCounter();
}