开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多国语言处理 > 查看源码
Dictionary.cpp
资源名称：Codes and Application.rar　[点击查看]
上传用户：yxl0916
上传日期：2007-05-25
资源大小：2245k
文件大小：33k
源码类别：

多国语言处理

开发平台：

Visual C++

Dictionary.cpp：源码内容
  1. //////////////////////////////////////////////////////////////////////
  2. //ICTCLAS简介：计算所汉语词法分析系统ICTCLAS(Institute of Computing Technology, Chinese Lexical Analysis System)，
  3. //             功能有：中文分词；词性标注；未登录词识别。
  4. //             分词正确率高达97.58%(973专家评测结果)，
  5. //             未登录词识别召回率均高于90%，其中中国人名的识别召回率接近98%;
  6. //             处理速度为31.5Kbytes/s。
  7. //著作权：  Copyright?2002-2005中科院计算所 职务著作权人：张华平 刘群
  8. //遵循协议：自然语言处理开放资源许可证1.0
  9. //Email: zhanghp@software.ict.ac.cn
  10. //Homepage:www.nlp.org.cn;mtgroup.ict.ac.cn
  11. /****************************************************************************
  12.  *
  13.  * Copyright (c) 2000, 2001 
  14.  *     Machine Group
  15.  *     Software Research Lab.
  16.  *     Institute of Computing Tech.
  17.  *     Chinese Academy of Sciences
  18.  *     All rights reserved.
  19.  *
  20.  * This file is the confidential and proprietary property of 
  21.  * Institute of Computing Tech. and the posession or use of this file requires 
  22.  * a written license from the author.
  23.  * Filename: Dictionary.cpp
  24.  * Abstract:
  25.  *           implementation of the CDictionary class.
  26.  * Author:   Kevin Zhang 
  27.  *          (zhanghp@software.ict.ac.cn)
  28.  * Date:     2002-1-8
  29.  *
  30.  * Notes:
  31.  *                
  32.  ****************************************************************************/
  33. #include "stdafx.h"
  34. #include "Dictionary.h"
  35. #include "Utility.h"
  36. #include <string.h>
  37. #include <stdlib.h>
  38. #include <malloc.h>
  39. #include <stdio.h>
  40. //////////////////////////////////////////////////////////////////////
  41. // Construction/Destruction
  42. //////////////////////////////////////////////////////////////////////
  44. CDictionary::CDictionary()
  45. {
  46.   //initilization
  47.   memset(m_IndexTable,0,sizeof(m_IndexTable));
  48.   m_pModifyTable=NULL;
  49. }
  51. CDictionary::~CDictionary()
  52. {
  53. for(int i=0;i<CC_NUM;i++)
  54. {//delete the memory of word item array in the dictionary
  55. for(int j=0;j<m_IndexTable[i].nCount;j++)
  56. delete m_IndexTable[i].pWordItemHead[j].sWord;
  57. delete [] m_IndexTable[i].pWordItemHead;
  58. }
  59.     DelModified();
  60. }
  61. /*********************************************************************
  62.  *
  63.  *  Func Name  : Load
  64.  *
  65.  *  Description: Load the dictionary from the file .dct
  66.  *              
  67.  *
  68.  *  Parameters : sFilename: the file name
  69.  *
  70.  *  Returns    : success or fail
  71.  *  Author     : Kevin Zhang  
  72.  *  History    : 
  73.  *              1.create 2002-1-9
  74.  *********************************************************************/
  75. bool CDictionary::Load(char *sFilename,bool bReset)
  76. {
  77.    FILE *fp;
  78.    int i,j,nBuffer[3];
  79.    if((fp=fopen(sFilename,"rb"))==NULL)
  80.    return false;//fail while opening the file
  81.    
  82.    //Release the memory for new files
  83.    for( i=0;i<CC_NUM;i++)
  84. {//delete the memory of word item array in the dictionary
  85. for( j=0;j<m_IndexTable[i].nCount;j++)
  86. delete m_IndexTable[i].pWordItemHead[j].sWord;
  87. delete [] m_IndexTable[i].pWordItemHead;
  88. }
  89.     DelModified();
  90.    for(i=0;i<CC_NUM;i++)
  91.    {
  92.    fread(&(m_IndexTable[i].nCount),sizeof(int),1,fp);
  93.        if(m_IndexTable[i].nCount>0)
  94.      m_IndexTable[i].pWordItemHead=new WORD_ITEM[m_IndexTable[i].nCount];
  95.    else 
  96.    {
  97.    m_IndexTable[i].pWordItemHead=0;
  98.    continue;
  99.    }
  100.        j=0;
  101.    while(j<m_IndexTable[i].nCount)
  102.    {
  103.          fread(nBuffer,sizeof(int),3,fp);
  104.          m_IndexTable[i].pWordItemHead[j].sWord=new char[nBuffer[1]+1];
  105.     if(nBuffer[1])//String length is more than 0
  106.  {
  107.  fread(m_IndexTable[i].pWordItemHead[j].sWord,sizeof(char),nBuffer[1],fp);
  108.  }
  109.  m_IndexTable[i].pWordItemHead[j].sWord[nBuffer[1]]=0;
  110.         if(bReset)//Reset the frequency
  111.           m_IndexTable[i].pWordItemHead[j].nFrequency=0;
  112.  else
  113.               m_IndexTable[i].pWordItemHead[j].nFrequency=nBuffer[0];
  114.  m_IndexTable[i].pWordItemHead[j].nWordLen=nBuffer[1];
  115.  m_IndexTable[i].pWordItemHead[j].nHandle=nBuffer[2];
  116.    j+=1;//Get next item in the original table.
  117.    }
  118.    }
  119.    fclose(fp);
  120.    return true;
  121. }
  122. /*********************************************************************
  123.  *
  124.  *  Func Name  : Save
  125.  *
  126.  *  Description: Save the dictionary as the file .dct
  127.  *              
  128.  *
  129.  *  Parameters : sFilename: the file name
  130.  *
  131.  *  Returns    : success or fail
  132.  *  Author     : Kevin Zhang  
  133.  *  History    : 
  134.  *              1.create 2002-1-9
  135.  *********************************************************************/
  137. bool CDictionary::Save(char *sFilename)
  138. {
  139.    FILE *fp;
  140.    int i,j,nCount,nBuffer[3];
  141.    PWORD_CHAIN pCur;
  142.    if((fp=fopen(sFilename,"wb"))==NULL)
  143.    return false;//fail while opening the file
  144.    for(i=0;i<CC_NUM;i++)
  145.    {
  146.    pCur=NULL;
  147.    if(m_pModifyTable)
  148.    {//Modification made
  149.    nCount=m_IndexTable[i].nCount+m_pModifyTable[i].nCount-m_pModifyTable[i].nDelete;
  150.    fwrite(&nCount,sizeof(int),1,fp);
  151.    pCur=m_pModifyTable[i].pWordItemHead;
  152.    j=0;
  153.    while(pCur!=NULL&&j<m_IndexTable[i].nCount)
  154.    {//Output to the file after comparision
  155.    if(strcmp(pCur->data.sWord,m_IndexTable[i].pWordItemHead[j].sWord)<0||(strcmp(pCur->data.sWord,m_IndexTable[i].pWordItemHead[j].sWord)==0&&pCur->data.nHandle<m_IndexTable[i].pWordItemHead[j].nHandle))
  156.    {//Output the modified data to the file
  157.  nBuffer[0]=pCur->data.nFrequency;
  158.          nBuffer[1]=pCur->data.nWordLen;
  159.      nBuffer[2]=pCur->data.nHandle;
  160.                  fwrite(nBuffer,sizeof(int),3,fp);
  161.  if(nBuffer[1])//String length is more than 0
  162.           fwrite(pCur->data.sWord,sizeof(char),nBuffer[1],fp);
  163.                  pCur=pCur->next;//Get next item in the modify table.
  164.    }
  165.    else if(m_IndexTable[i].pWordItemHead[j].nFrequency==-1)
  166.    {//The item has been removed,so skip it
  167.    j+=1;
  168.    }
  169.    else if(strcmp(pCur->data.sWord,m_IndexTable[i].pWordItemHead[j].sWord)>0||(strcmp(pCur->data.sWord,m_IndexTable[i].pWordItemHead[j].sWord)==0&&pCur->data.nHandle>m_IndexTable[i].pWordItemHead[j].nHandle))
  170.    {//Output the index table data to the file
  171.  nBuffer[0]=m_IndexTable[i].pWordItemHead[j].nFrequency;
  172.  nBuffer[1]=m_IndexTable[i].pWordItemHead[j].nWordLen;
  173.  nBuffer[2]=m_IndexTable[i].pWordItemHead[j].nHandle;
  174.  fwrite(nBuffer,sizeof(int),3,fp);
  175.  if(nBuffer[1])//String length is more than 0
  176.    fwrite(m_IndexTable[i].pWordItemHead[j].sWord,sizeof(char),nBuffer[1],fp);
  177.  j+=1;//Get next item in the original table.
  178.    }
  179.    }
  180.    if(j<m_IndexTable[i].nCount)
  181.    {
  182.    while(j<m_IndexTable[i].nCount)
  183.    {
  184.    if(m_IndexTable[i].pWordItemHead[j].nFrequency!=-1)
  185.    {//Has been deleted
  186.  nBuffer[0]=m_IndexTable[i].pWordItemHead[j].nFrequency;
  187.  nBuffer[1]=m_IndexTable[i].pWordItemHead[j].nWordLen;
  188.  nBuffer[2]=m_IndexTable[i].pWordItemHead[j].nHandle;
  189.  fwrite(nBuffer,sizeof(int),3,fp);
  190.  if(nBuffer[1])//String length is more than 0
  191.    fwrite(m_IndexTable[i].pWordItemHead[j].sWord,sizeof(char),nBuffer[1],fp);
  192.    }
  193.    j+=1;//Get next item in the original table.
  194.    }
  195.    }
  196.    else////No Modification
  197.    while(pCur!=NULL)//Add the rest data to the file.
  198.    {
  199.  nBuffer[0]=pCur->data.nFrequency;
  200.          nBuffer[1]=pCur->data.nWordLen;
  201.      nBuffer[2]=pCur->data.nHandle;
  202.                  fwrite(nBuffer,sizeof(int),3,fp);
  203.  if(nBuffer[1])//String length is more than 0
  204.    fwrite(pCur->data.sWord,sizeof(char),nBuffer[1],fp);
  205.                  pCur=pCur->next;//Get next item in the modify table.
  206.    }
  207.    }
  208.    else
  209.    {
  210.    fwrite(&m_IndexTable[i].nCount,sizeof(int),1,fp);
  211.    //write to the file
  212.            j=0;  
  213.    while(j<m_IndexTable[i].nCount)
  214.    {
  215.  nBuffer[0]=m_IndexTable[i].pWordItemHead[j].nFrequency;
  216.      nBuffer[1]=m_IndexTable[i].pWordItemHead[j].nWordLen;
  217.  nBuffer[2]=m_IndexTable[i].pWordItemHead[j].nHandle;
  218.              fwrite(nBuffer,sizeof(int),3,fp);
  219.  if(nBuffer[1])//String length is more than 0
  220.    fwrite(m_IndexTable[i].pWordItemHead[j].sWord,sizeof(char),nBuffer[1],fp);
  221.    j+=1;//Get next item in the original table.
  222.    }
  223.    }
  224.    }
  225.    fclose(fp);
  226.    return true;
  227. }
  228. /*********************************************************************
  229.  *
  230.  *  Func Name  : AddItem
  231.  *
  232.  *  Description: Add a word item to the dictionary
  233.  *              
  234.  *
  235.  *  Parameters : sWord: the word
  236.  *               nHandle:the handle number
  237.  *               nFrequency: the frequency
  238.  *  Returns    : success or fail
  239.  *  Author     : Kevin Zhang  
  240.  *  History    : 
  241.  *              1.create 2002-1-9
  242.  *********************************************************************/
  244. bool CDictionary::AddItem(char *sWord, int nHandle,int nFrequency)
  245. {
  247.    char sWordAdd[WORD_MAXLENGTH-2];
  248.    int nPos,nFoundPos;
  249.    PWORD_CHAIN pRet,pTemp,pNext;
  250.    int i=0;
  251.    if(!PreProcessing(sWord, &nPos,sWordAdd,true))
  252.    return false;
  253.    if(FindInOriginalTable(nPos,sWordAdd,nHandle,&nFoundPos))
  254.    {//The word exists in the original table, so add the frequency
  255.     //Operation in the index table and its items 
  256.        if(m_IndexTable[nPos].pWordItemHead[nFoundPos].nFrequency==-1)
  257.    {//The word item has been removed
  258.       m_IndexTable[nPos].pWordItemHead[nFoundPos].nFrequency=nFrequency;
  259.         if(!m_pModifyTable)//Not prepare the buffer
  260.   {
  261.    m_pModifyTable=new MODIFY_TABLE[CC_NUM];
  262.    memset(m_pModifyTable,0,CC_NUM*sizeof(MODIFY_TABLE));
  263.   }
  264.   m_pModifyTable[nPos].nDelete-=1;
  265.    }
  266.    else
  267.   m_IndexTable[nPos].pWordItemHead[nFoundPos].nFrequency+=nFrequency;
  268.    return true;
  269.    }
  271.    //The items not exists in the index table.
  272.    //As following, we have to find the item whether exists in the modify data region
  273.    //If exists, change the frequency .or else add a item
  274.    if(!m_pModifyTable)//Not prepare the buffer
  275.    {
  276.    m_pModifyTable=new MODIFY_TABLE[CC_NUM];
  277.    memset(m_pModifyTable,0,CC_NUM*sizeof(MODIFY_TABLE));
  278.    }
  279.    if(FindInModifyTable(nPos,sWordAdd,nHandle,&pRet))
  280.    {
  281.    if(pRet!=NULL)
  282.    pRet=pRet->next;
  283.    else
  284.    pRet=m_pModifyTable[nPos].pWordItemHead;
  285.    pRet->data.nFrequency+=nFrequency;
  286.    return true;
  287.    }
  288.    //find the proper position to add the word to the modify data table and link
  289.    pTemp=new WORD_CHAIN;//Allocate the word chain node
  290.    if(pTemp==NULL)//Allocate memory failure
  291.    return false;
  292.    memset(pTemp,0,sizeof(WORD_CHAIN));//init it with 0
  293.    pTemp->data.nHandle=nHandle;//store the handle 
  294.    pTemp->data.nWordLen=strlen(sWordAdd);
  295.    pTemp->data.sWord=new char[1+pTemp->data.nWordLen];
  296.    strcpy(pTemp->data.sWord,sWordAdd);
  297.    pTemp->data.nFrequency=nFrequency;
  298.    pTemp->next=NULL;   
  299.    if(pRet!=NULL)
  300.    {
  301.    pNext=pRet->next;//Get the next item before the current item
  302.    pRet->next=pTemp;//link the node to the chain
  303.    }
  304.    else
  305.    {
  306.    pNext=m_pModifyTable[nPos].pWordItemHead;
  307.    m_pModifyTable[nPos].pWordItemHead=pTemp;//Set the pAdd as the head node
  308.    }
  309.    pTemp->next=pNext;//Very important!!!! or else it will lose some node
  310.    //Modify in 2001-10-29
  311.    m_pModifyTable[nPos].nCount++;//the number increase by one
  312.    return true;
  313. }
  314. bool CDictionary::DelItem(char *sWord,int nHandle)
  315. {
  316.    char sWordDel[WORD_MAXLENGTH-2];
  317.    int nPos,nFoundPos,nTemp;
  318.    PWORD_CHAIN pPre,pTemp,pCur;
  319.    if(!PreProcessing(sWord, &nPos,sWordDel))
  320.    return false;
  321.    if(FindInOriginalTable(nPos,sWordDel,nHandle,&nFoundPos))
  322.    {
  323.        if(!m_pModifyTable)//Not prepare the buffer
  324.    {
  325.    m_pModifyTable=new MODIFY_TABLE[CC_NUM];
  326.    memset(m_pModifyTable,0,CC_NUM*sizeof(MODIFY_TABLE));
  327.    }
  328.        m_IndexTable[nPos].pWordItemHead[nFoundPos].nFrequency=-1;
  329.    m_pModifyTable[nPos].nDelete+=1;
  330.    if(nHandle==-1)//Remove all items which word is sWordDel,ignoring the handle
  331.    {
  332. /*    nTemp=nFoundPos-1;//Check its previous position
  333.    while(nTemp>0&&strcmp(m_IndexTable[nPos].pWordItemHead[nFoundPos].sWord,sWordDel)==0)
  334.    {
  335. m_IndexTable[nPos].pWordItemHead[nTemp].nFrequency=-1;
  336. m_pModifyTable[nPos].nDelete+=1;
  337. nTemp-=1;
  338.    }
  339. */    nTemp=nFoundPos+1;//Check its previous position
  340.    while(nTemp<m_IndexTable[nPos].nCount&&strcmp(m_IndexTable[nPos].pWordItemHead[nFoundPos].sWord,sWordDel)==0)
  341.    {
  342. m_IndexTable[nPos].pWordItemHead[nTemp].nFrequency=-1;
  343. m_pModifyTable[nPos].nDelete+=1;
  344. nTemp+=1;
  345.    }
  346.    }
  347.    return true;
  348.    }
  349.    //Operation in the modify table and its items 
  350.    if(FindInModifyTable(nPos,sWordDel,nHandle,&pPre))
  351.    {
  352.      pCur=m_pModifyTable[nPos].pWordItemHead;
  353.      if(pPre!=NULL)
  354.  pCur=pPre->next;
  355.          while(pCur!=NULL && _stricmp(pCur->data.sWord,sWordDel)==0&&(pCur->data.nHandle==nHandle||nHandle<0))
  356.  {
  357.  pTemp=pCur;
  358.       if(pPre!=NULL)//pCur is the first item
  359.  pPre->next=pCur->next;
  360.  else
  361.  m_pModifyTable[nPos].pWordItemHead=pCur->next;
  362.  pCur=pCur->next;
  363.  delete pTemp->data.sWord;//Delete the word
  364.  delete pTemp;
  365.  }
  366.    return true;
  367.    }
  368.    return false;
  369. }
  370. bool CDictionary::DelModified()
  371. {
  372.   PWORD_CHAIN pTemp,pCur;
  373.   if(!m_pModifyTable)
  374.   return true;
  375.   for(int i=0;i<CC_NUM;i++)
  376.   {
  377.       pCur=m_pModifyTable[i].pWordItemHead;
  378.   while(pCur!=NULL)
  379.   {
  380.   pTemp=pCur;
  381.   pCur=pCur->next;
  382.   delete pTemp->data.sWord;
  383.   delete pTemp;
  384.   }
  385.   }
  386.   delete [] m_pModifyTable;
  387.   m_pModifyTable=NULL;
  388.   return true;
  389. }
  390. bool CDictionary::IsExist(char *sWord,  int nHandle)
  391. {
  392.    char sWordFind[WORD_MAXLENGTH-2];
  393.    int nPos;
  394.    if(!PreProcessing(sWord, &nPos,sWordFind))
  395.    return false;
  396.    return(FindInOriginalTable(nPos,sWordFind,nHandle)||FindInModifyTable(nPos,sWordFind,nHandle));
  397. }
  398. bool CDictionary::GetHandle(char *sWord,int *pnCount,int *pnHandle,int *pnFrequency)
  399. {
  400.    char sWordGet[WORD_MAXLENGTH-2];
  401.    int nPos,nFoundPos,nTemp;
  402.    PWORD_CHAIN pPre,pCur;
  403.    *pnCount=0;
  404.    if(!PreProcessing(sWord, &nPos,sWordGet))
  405.    return false;
  406.    if(FindInOriginalTable(nPos,sWordGet,-1,&nFoundPos))
  407.    {
  408.        pnHandle[*pnCount]=m_IndexTable[nPos].pWordItemHead[nFoundPos].nHandle;
  409.    pnFrequency[*pnCount]=m_IndexTable[nPos].pWordItemHead[nFoundPos].nFrequency;
  410.    *pnCount+=1;
  411. /*    nTemp=nFoundPos-1;//Check its previous position
  412.    while(nTemp>0&&strcmp(m_IndexTable[nPos].pWordItemHead[nTemp].sWord,sWordGet)==0)
  413.    {
  414.    pnHandle[*pnCount]=m_IndexTable[nPos].pWordItemHead[nTemp].nHandle;
  415.    pnFrequency[*pnCount]=m_IndexTable[nPos].pWordItemHead[nTemp].nFrequency;
  416.    *pnCount+=1;
  417.        nTemp-=1;
  418.    }
  419. */    nTemp=nFoundPos+1;//Check its previous position
  420.    while(nTemp<m_IndexTable[nPos].nCount&&strcmp(m_IndexTable[nPos].pWordItemHead[nTemp].sWord,sWordGet)==0)
  421.    {
  422.    pnHandle[*pnCount]=m_IndexTable[nPos].pWordItemHead[nTemp].nHandle;
  423.    pnFrequency[*pnCount]=m_IndexTable[nPos].pWordItemHead[nTemp].nFrequency;
  424.    *pnCount+=1;
  425.    nTemp+=1;
  426.    }
  427.    return true;
  428.    }
  429.    //Operation in the index table and its items 
  430.    if(FindInModifyTable(nPos,sWordGet,-1,&pPre))
  431.    {
  432.      pCur=m_pModifyTable[nPos].pWordItemHead;
  433.      if(pPre!=NULL)
  434.  pCur=pPre->next;
  435.          while(pCur!=NULL && _stricmp(pCur->data.sWord,sWordGet)==0)
  436.  {
  437.  pnHandle[*pnCount]=pCur->data.nHandle;
  438.  pnFrequency[*pnCount]=pCur->data.nFrequency;
  439.  *pnCount+=1;
  440.    pCur=pCur->next;
  441.  }
  442.    return true;
  443.    }
  444.    return false;
  445. }
  446. /*********************************************************************
  447.  *
  448.  *  Func Name  : FindInOriginalTable
  449.  *
  450.  *  Description: judge the word and handle exist in the inner table and its items
  451.  *              
  452.  *
  453.  *  Parameters : nInnerCode: the inner code of the first CHines char
  454.  *               sWord: the word
  455.  *               nHandle:the handle number
  456.  *               *nPosRet:the position which node is matched
  457.  *
  458.  *  Returns    : success or fail
  459.  *  Author     : Kevin Zhang  
  460.  *  History    : 
  461.  *              1.create 2002-1-9
  462.  *********************************************************************/
  464. bool CDictionary::FindInOriginalTable(int nInnerCode,char *sWord,int nHandle,int *nPosRet)
  465. {
  466.     PWORD_ITEM pItems=m_IndexTable[nInnerCode].pWordItemHead;
  467. int nStart=0,nEnd=m_IndexTable[nInnerCode].nCount-1,nMid=(nStart+nEnd)/2,nCount=0,nCmpValue;
  468. while(nStart<=nEnd)//Binary search
  469. {
  470.        nCmpValue=strcmp(pItems[nMid].sWord,sWord);
  471.        if(nCmpValue==0&&(pItems[nMid].nHandle==nHandle||nHandle==-1))
  472.    {
  473.    if(nPosRet)
  474.    {
  475.    if(nHandle==-1)//Not very strict match
  476.    {//Add in 2002-1-28
  477.    nMid-=1;
  478.    while(nMid>=0&&strcmp(pItems[nMid].sWord,sWord)==0)
  479.    //Get the first item which match the current word
  480.    nMid--;
  481.                    if(nMid<0||strcmp(pItems[nMid].sWord,sWord)!=0)
  482.    nMid++;
  483.    }
  484.    *nPosRet=nMid;
  485.                return true;   
  486.    }
  487.         if(nPosRet)
  488. *nPosRet=nMid;
  489. return true;//find it
  490.    }
  491.    else if(nCmpValue<0||(nCmpValue==0&&pItems[nMid].nHandle<nHandle&&nHandle!=-1))
  492.    {
  493.    nStart=nMid+1;
  494.    }
  495.    else if(nCmpValue>0||(nCmpValue==0&&pItems[nMid].nHandle>nHandle&&nHandle!=-1))
  496.        {
  497.    nEnd=nMid-1;
  498.    }
  499.    nMid=(nStart+nEnd)/2;
  500. }
  501.     if(nPosRet)
  502. {
  503. //Get the previous position
  504. *nPosRet=nMid-1;
  505. }
  506. return false;
  507. }
  509. /*********************************************************************
  510.  *
  511.  *  Func Name  : FindInModifyTable
  512.  *
  513.  *  Description: judge the word and handle exist in the modified table and its items
  514.  *              
  515.  *
  516.  *  Parameters : nInnerCode: the inner code of the first CHines char
  517.  *               sWord: the word
  518.  *               nHandle:the handle number
  519.  *               *pFindRet: the node found
  520.  *
  521.  *  Returns    : success or fail
  522.  *  Author     : Kevin Zhang  
  523.  *  History    : 
  524.  *              1.create 2002-1-9
  525.  *********************************************************************/
  526. bool CDictionary::FindInModifyTable(int nInnerCode,char *sWord,int nHandle,PWORD_CHAIN *pFindRet)
  527. {
  528.    PWORD_CHAIN pCur,pPre;
  529.    if(m_pModifyTable==NULL)//empty
  530.    return false;
  531.    pCur=m_pModifyTable[nInnerCode].pWordItemHead;
  532.    pPre=NULL;
  533.    while(pCur!=NULL&&(_stricmp(pCur->data.sWord,sWord)<0||(_stricmp(pCur->data.sWord,sWord)==0&&pCur->data.nHandle<nHandle)))
  534.    //sort the link chain as alphabet
  535.    {
  536.        pPre=pCur;
  537.    pCur=pCur->next;
  538.    }
  539.    if(pFindRet)
  540.      *pFindRet=pPre;
  541.    if(pCur!=NULL && _stricmp(pCur->data.sWord,sWord)==0&&(pCur->data.nHandle==nHandle||nHandle<0))
  542.    {//The node exists, delete the node and return 
  543.    return true;
  544.    }
  545.    return false;
  546. }
  547. /*********************************************************************
  548.  *
  549.  *  Func Name  : GetWordType
  550.  *
  551.  *  Description: Get the type of word
  552.  *              
  553.  *
  554.  *  Parameters : sWord: the word
  556.  *  Returns    : the type
  557.  *  Author     : Kevin Zhang  
  558.  *  History    : 
  559.  *              1.create 2002-1-9
  560.  *********************************************************************/
  561. int CDictionary::GetWordType(char *sWord)
  562. {
  563.    int nType=charType((unsigned char *)sWord),nLen=strlen(sWord);
  564.    if(nLen>0&&nType==CT_CHINESE&&IsAllChinese((unsigned char *)sWord))
  565.    return WT_CHINESE;//Chinese word
  566.    else if(nLen>0&&nType==CT_DELIMITER)
  567.        return WT_DELIMITER;//Delimiter
  568.    else
  569.    return WT_OTHER;//other invalid
  570. }
  571. /*********************************************************************
  572.  *
  573.  *  Func Name  : PreProcessing
  574.  *
  575.  *  Description: Get the type of word
  576.  *              
  577.  *
  578.  *  Parameters : sWord: the word
  580.  *  Returns    : the type
  581.  *  Author     : Kevin Zhang  
  582.  *  History    : 
  583.  *              1.create 2002-1-9
  584.  *********************************************************************/
  585. bool CDictionary::PreProcessing(char *sWord, int *nId, char *sWordRet,bool bAdd)
  586. {
  587.    //Position for the delimeters
  588.    int nType=charType((unsigned char *)sWord),nLen=strlen(sWord);
  589.    int nEnd=nLen-1,nBegin=0;
  590.    if(nLen==0)
  591.    return false;
  592.    while(nEnd>=0&&sWord[nEnd]==' ')
  593. nEnd-=1;
  594.    while(nBegin<=nEnd&&sWord[nBegin]==' ')
  595. nBegin+=1;
  596.    if(nBegin>nEnd)
  597.    return false;
  598.    if(nEnd!=nLen-1||nBegin!=0)
  599.    {
  600.    strncpy(sWord,sWord+nBegin,nEnd-nBegin+1);
  601.    sWord[nEnd-nBegin+1]=0;
  602.    }
  603. /*
  604.    if((bAdd||strlen(sWord)>4)&&IsAllChineseNum(sWord))
  605.    {  //Only convert the Chinese Num to 3755 while 
  606.       //Get the inner code of the first Chinese Char
  607.        strcpy(sWord,"五十八");
  608.    }
  609. */   
  610.    if(nType==CT_CHINESE)//&&IsAllChinese((unsigned char *)sWord)
  611.    {//Chinese word
  612.    *nId=CC_ID(sWord[0],sWord[1]);
  613.    //Get the inner code of the first Chinese Char
  614. strcpy(sWordRet,&sWord[2]);//store the word,not store the first Chinese Char
  615. return true;
  616.    }
  617. /* if(nType==CT_NUM&&IsAllNum((unsigned char *)sWord))
  618.    {
  619.    *nId=3756;
  620.        //Get the inner code of the first Chinese Char
  621.        sWordRet[0]=0;//store the word,not store the first Chinese Char
  622.    return true;
  623.    }
  624. */ if(nType==CT_DELIMITER)
  625.    {//Delimiter
  626.    *nId=3755;
  627.        //Get the inner code of the first Chinese Char
  628.        strcpy(sWordRet,sWord);//store the word,not store the first Chinese Char
  629.    return true;
  630.    }
  631. /*
  632.    if(nType==CT_LETTER&&IsAllLetter((unsigned char *)sWord))
  633.    {
  634.    *nId=3757;
  635.        //Get the inner code of the first Chinese Char
  636.        sWordRet[0]=0;//store the word,not store the first Chinese Char
  637.    return true;
  638.    }
  639.    if(nType==CT_SINGLE&&IsAllSingleByte((unsigned char *)sWord))
  640.    {
  641.    *nId=3758;
  642.        //Get the inner code of the first Chinese Char
  643.        sWordRet[0]=0;//store the word,not store the first Chinese Char
  644.    return true;
  645.    }
  646.    if(nType==CT_INDEX&&IsAllIndex((unsigned char *)sWord))
  647.    {
  648.    *nId=3759;
  649.        //Get the inner code of the first Chinese Char
  650.        sWordRet[0]=0;//store the word,not store the first Chinese Char
  651.    return true;
  652.    }
  653. */
  654.    return false;//other invalid
  655. }
  656. /*********************************************************************
  657.  *
  658.  *  Func Name  : MergePOS
  659.  *
  660.  *  Description: Merge all the POS into nHandle,
  661.  *              just get the word in the dictionary and set its Handle as nHandle
  662.  *              
  663.  *
  664.  *  Parameters : nHandle: the only handle which will be attached to the word
  666.  *  Returns    : the type
  667.  *  Author     : Kevin Zhang  
  668.  *  History    : 
  669.  *              1.create 2002-1-21
  670.  *********************************************************************/
  671. bool CDictionary::MergePOS(int nHandle)
  672. {
  673.     int i,j,nCompare;
  674. char sWordPrev[WORD_MAXLENGTH];
  675. PWORD_CHAIN pPre,pCur,pTemp;
  676.     if(!m_pModifyTable)//Not prepare the buffer
  677.     {
  678.    m_pModifyTable=new MODIFY_TABLE[CC_NUM];
  679.    memset(m_pModifyTable,0,CC_NUM*sizeof(MODIFY_TABLE));
  680.     }
  681. for( i=0;i<CC_NUM;i++)//Operation in the index table
  682. {//delete the memory of word item array in the dictionary
  683. sWordPrev[0]=0;//Set empty
  684. for(j=0;j<m_IndexTable[i].nCount;j++)
  685. {
  686. nCompare=_stricmp(sWordPrev,m_IndexTable[i].pWordItemHead[j].sWord);
  687.             if((j==0||nCompare<0)&&m_IndexTable[i].pWordItemHead[j].nFrequency!=-1)
  688. {//Need to modify its handle
  689.     m_IndexTable[i].pWordItemHead[j].nHandle=nHandle;//Change its handle
  690. strcpy(sWordPrev,m_IndexTable[i].pWordItemHead[j].sWord);//Refresh previous Word
  691. }
  692. else if(nCompare==0&&m_IndexTable[i].pWordItemHead[j].nFrequency!=-1)
  693. {//Need to delete when not delete and same as previous word
  694. m_IndexTable[i].pWordItemHead[j].nFrequency=-1;//Set delete flag
  695. m_pModifyTable[i].nDelete+=1;//Add the number of being deleted
  696. }
  697. }
  698. }
  699. for( i=0;i<CC_NUM;i++)//Operation in the modify table
  700. {
  701.  pPre=NULL;
  702.      pCur=m_pModifyTable[i].pWordItemHead;
  703.  sWordPrev[0]=0;//Set empty
  704.          while(pCur!=NULL)
  705.  {
  706.  if(_stricmp(pCur->data.sWord,sWordPrev)>0)
  707.  {//The new word
  708. pCur->data.nHandle=nHandle;//Chang its handle
  709. strcpy(sWordPrev,pCur->data.sWord);//Set new previous word
  710. pPre=pCur;//New previous pointer
  711. pCur=pCur->next;
  712.  }
  713.  else
  714.  {//The same word as previous,delete it.
  715.  pTemp=pCur;
  716.       if(pPre!=NULL)//pCur is the first item
  717.  pPre->next=pCur->next;
  718.  else
  719.  m_pModifyTable[i].pWordItemHead=pCur->next;
  720.  pCur=pCur->next;
  721.    delete pTemp->data.sWord;//Delete the word
  722.  delete pTemp;//Delete the item
  723.  }
  724.  }
  725.    }
  726. return true;
  727. }
  728. /*********************************************************************
  729.  *
  730.  *  Func Name  : GetMaxMatch
  731.  *
  732.  *  Description: Get the max match to the word
  733.  *              
  734.  *
  735.  *  Parameters : nHandle: the only handle which will be attached to the word
  737.  *  Returns    : success or fail
  738.  *  Author     : Kevin Zhang  
  739.  *  History    : 
  740.  *              1.create 2002-1-21
  741.  *********************************************************************/
  742. bool CDictionary::GetMaxMatch(char *sWord, char *sWordRet,int *npHandleRet)
  743. {
  744.    char sWordGet[WORD_MAXLENGTH-2],sFirstChar[3];
  745.    int nPos,nFoundPos,nTemp;
  746.    PWORD_CHAIN pCur;
  747.    *npHandleRet=-1;
  748.    if(!PreProcessing(sWord, &nPos,sWordGet))
  749.    return false;
  750.    sWordRet[0]=0;
  751.    strncpy(sFirstChar,sWord,strlen(sWord)-strlen(sWordGet));//Get the first char
  752.    sFirstChar[strlen(sWord)-strlen(sWordGet)]=0;//Set the end flag
  753.    FindInOriginalTable(nPos,sWordGet,-1,&nFoundPos);
  754.    nTemp=nFoundPos;//Check its previous position
  755.    if(nFoundPos==-1)
  756. nTemp=0;
  757.    while(nTemp<m_IndexTable[nPos].nCount&&CC_Find(m_IndexTable[nPos].pWordItemHead[nTemp].sWord,sWordGet)!=m_IndexTable[nPos].pWordItemHead[nTemp].sWord)
  758.    {//Get the next
  759.    nTemp+=1;
  760.    }
  761.    if(nTemp<m_IndexTable[nPos].nCount&&CC_Find(m_IndexTable[nPos].pWordItemHead[nTemp].sWord,sWordGet)==m_IndexTable[nPos].pWordItemHead[nTemp].sWord)
  762.    {
  763.    strcpy(sWordRet,sFirstChar);
  764.    strcat(sWordRet,m_IndexTable[nPos].pWordItemHead[nTemp].sWord);
  765.    *npHandleRet=m_IndexTable[nPos].pWordItemHead[nTemp].nHandle;
  766.    return true;
  767.    }//Cannot get the item and retrieve the modified data if exists
  768.     //Operation in the index table and its items 
  769.    if(m_pModifyTable&&m_pModifyTable[nPos].pWordItemHead)//Exists 
  770.    pCur=m_pModifyTable[nPos].pWordItemHead;
  771.    else
  772.    pCur=NULL;
  773.    while(pCur!=NULL&&strcmp(pCur->data.sWord,sWordGet)<=0&&CC_Find(pCur->data.sWord,sWordGet)!=pCur->data.sWord)//
  774.    {
  775.    pCur=pCur->next;
  776.    }
  777.    if(pCur!=NULL&&CC_Find(pCur->data.sWord,sWordGet)!=pCur->data.sWord)
  778.    {//Get it
  779.    strcpy(sWordRet,sFirstChar);
  780.    strcat(sWordRet,pCur->data.sWord);
  781.    *npHandleRet=pCur->data.nHandle;
  782.    return true;
  783.    }
  784.    return false;
  785. }
  786. /*********************************************************************
  787.  *
  788.  *  Func Name  : GetPOSValue
  789.  *
  790.  *  Description: Get the POS value according the POS string
  791.  *              
  792.  *
  793.  *  Parameters : 
  795.  *  Returns    : the value
  796.  *  Author     : Kevin Zhang  
  797.  *  History    : 
  798.  *              1.create 2002-1-29
  799.  *********************************************************************/
  800. int CDictionary::GetPOSValue(char *sPOS)
  801. {
  802. int nPOS;
  803. char *sPlusPos,sTemp[4];
  804. if(strlen(sPOS)<3)
  805. {
  806. nPOS=sPOS[0]*256+sPOS[1];
  807. }
  808. else
  809. {
  810. sPlusPos=strchr(sPOS,'+');
  811. strncpy(sTemp,sPOS,sPlusPos-sPOS);
  812. sTemp[sPlusPos-sPOS]=0;
  813.         nPOS=100*GetPOSValue(sTemp);
  814. strncpy(sTemp,sPlusPos+1,4);
  815.         nPOS+=atoi(sTemp);
  816. }
  817. return nPOS;
  818. }
  819. /*********************************************************************
  820.  *
  821.  *  Func Name  : GetPOSString
  822.  *
  823.  *  Description: Get the POS string according the POS value
  824.  *              
  825.  *
  826.  *  Parameters : 
  828.  *  Returns    : success or fail
  829.  *  Author     : Kevin Zhang  
  830.  *  History    : 
  831.  *              1.create 2002-1-29
  832.  *********************************************************************/
  833. bool CDictionary::GetPOSString(int nPOS, char *sPOSRet)
  834. {
  835.     if(nPOS>'a'*25600) 
  836. {
  837. if((nPOS/100)%256!=0)
  838.   sprintf(sPOSRet,"%c%c+%d",nPOS/25600,(nPOS/100)%256,nPOS%100);
  839. else
  840. sprintf(sPOSRet,"%c+%d",nPOS/25600,nPOS%100);
  841. }
  842. else
  843. {
  844.   if(nPOS>256)
  845. sprintf(sPOSRet,"%c%c",nPOS/256,nPOS%256);
  846.   else
  847. sprintf(sPOSRet,"%c",nPOS%256);
  848. }
  849. return true;
  850. }
  852. int CDictionary::GetFrequency(char *sWord, int nHandle)
  853. {
  854.    char sWordFind[WORD_MAXLENGTH-2];
  855.    int nPos,nIndex;
  856.    PWORD_CHAIN pFound;
  857.    if(!PreProcessing(sWord, &nPos,sWordFind))
  858.    return 0;
  859.    if(FindInOriginalTable(nPos,sWordFind,nHandle,&nIndex))
  860.    {
  861. return m_IndexTable[nPos].pWordItemHead[nIndex].nFrequency;
  862.    }
  863.    if(FindInModifyTable(nPos,sWordFind,nHandle,&pFound))
  864.    {
  865.    return pFound->data.nFrequency;
  866.    }
  867.    return 0;
  868. }
  870. bool CDictionary::Output(char *sFilename)
  871. {
  872.    FILE *fp;
  873.    int i,j;
  874.    PWORD_CHAIN pCur;
  875.    char sPrevWord[WORD_MAXLENGTH]="", sCurWord[WORD_MAXLENGTH],sPOS[10];
  876.    if((fp=fopen(sFilename,"wb"))==NULL)
  877.    return false;//fail while opening the file
  878.    if(m_pModifyTable)
  879.    {//Modification made, not to output when modify table exists.
  880.    return false;
  881.    }   
  882.    for(i=0;i<CC_NUM;i++)
  883.    {
  884.    pCur=NULL;
  885.        j=0;  
  886.    while(j<m_IndexTable[i].nCount)
  887.    {
  888.  GetPOSString(m_IndexTable[i].pWordItemHead[j].nHandle,sPOS);
  889.  //Get the POS string
  890.  sprintf(sCurWord,"%c%c%s",CC_CHAR1(i),CC_CHAR2(i),m_IndexTable[i].pWordItemHead[j].sWord);
  891.          if(strcmp(sPrevWord,sCurWord)!=0)
  892.  fprintf(fp,"n%s %s",sCurWord,sPOS);
  893.  else
  894.  fprintf(fp," %s",sPOS);
  895.  strcpy(sPrevWord,sCurWord);
  896.    j+=1;//Get next item in the original table.
  897.    }
  898.    }
  899.    fclose(fp);
  900.    return true;
  901. }
  902. bool CDictionary::OutputChars(char *sFilename)
  903. {
  904.    FILE *fp;
  905.    int i,j;
  906.    char sPrevWord[WORD_MAXLENGTH]="", sCurWord[WORD_MAXLENGTH];
  907.    if((fp=fopen(sFilename,"wb"))==NULL)
  908.    return false;//fail while opening the file
  909.    if(m_pModifyTable)
  910.    {//Modification made, not to output when modify table exists.
  911.    return false;
  912.    }   
  913.    for(i=0;i<CC_NUM;i++)
  914.    {
  915.        j=0;  
  916.    while(j<m_IndexTable[i].nCount)
  917.    {
  918.  sprintf(sCurWord,"%c%c%s",CC_CHAR1(i),CC_CHAR2(i),m_IndexTable[i].pWordItemHead[j].sWord);
  919.          if(strcmp(sPrevWord,sCurWord)!=0&&m_IndexTable[i].pWordItemHead[j].nFrequency>50)//
  920.  fprintf(fp,"%s",sCurWord);
  921.  strcpy(sPrevWord,sCurWord);
  922.    j+=1;//Get next item in the original table.
  923.    }
  924.    }
  925.    fclose(fp);
  926.    return true;
  928. }
  930. bool CDictionary::Merge(CDictionary dict2, int nRatio)
  931. //Merge dict2 into current dictionary and the frequency ratio from dict2 and current dict is nRatio
  932. {
  933.    int i,j,k,nCmpValue;
  934.    char sWord[WORD_MAXLENGTH];
  935.    if(m_pModifyTable||dict2.m_pModifyTable)
  936.    {//Modification made, not to output when modify table exists.
  937.    return false;
  938.    }   
  939.    for(i=0;i<CC_NUM;i++)
  940.    {
  941.        j=0; 
  942.    k=0; 
  943.    while(j<m_IndexTable[i].nCount&&k<dict2.m_IndexTable[i].nCount)
  944.    {
  945.  nCmpValue=strcmp(m_IndexTable[i].pWordItemHead[j].sWord,dict2.m_IndexTable[i].pWordItemHead[k].sWord);
  946.  if(nCmpValue==0)//Same Words and determine the different handle
  947.  {
  948.  if(m_IndexTable[i].pWordItemHead[j].nHandle<dict2.m_IndexTable[i].pWordItemHead[k].nHandle)
  949. nCmpValue=-1;
  950.  else if(m_IndexTable[i].pWordItemHead[j].nHandle>dict2.m_IndexTable[i].pWordItemHead[k].nHandle)
  951. nCmpValue=1;
  952.  }
  954.  if(nCmpValue==0)
  955.  {
  956.  m_IndexTable[i].pWordItemHead[j].nFrequency=(nRatio*m_IndexTable[i].pWordItemHead[j].nFrequency+dict2.m_IndexTable[i].pWordItemHead[k].nFrequency)/(nRatio+1);
  957.  j+=1;
  958.  k+=1;
  959.  }
  960.  else if(nCmpValue<0)//Get next word in the current dictionary
  961.  {
  962.  m_IndexTable[i].pWordItemHead[j].nFrequency=(nRatio*m_IndexTable[i].pWordItemHead[j].nFrequency)/(nRatio+1);
  963.  j+=1;
  964.  }
  965.  else//Get next word in the second dictionary
  966.  {
  967.   if(dict2.m_IndexTable[i].pWordItemHead[k].nFrequency>(nRatio+1)/10)
  968.   {
  969.   sprintf(sWord,"%c%c%s",CC_CHAR1(i),CC_CHAR2(i),dict2.m_IndexTable[i].pWordItemHead[k].sWord);
  970.   AddItem(sWord,dict2.m_IndexTable[i].pWordItemHead[k].nHandle,dict2.m_IndexTable[i].pWordItemHead[k].nFrequency/(nRatio+1));
  971.   }
  972.  k+=1;
  973.  }
  974.    }
  975.    while(j<m_IndexTable[i].nCount)//words in current dictionary are left
  976.    {
  977.  m_IndexTable[i].pWordItemHead[j].nFrequency=(nRatio*m_IndexTable[i].pWordItemHead[j].nFrequency)/(nRatio+1);
  978.  j+=1;
  979.    }
  980.    while(k<dict2.m_IndexTable[i].nCount)//words in Dict2 are left
  981.    {
  982. if(dict2.m_IndexTable[i].pWordItemHead[k].nFrequency>(nRatio+1)/10)
  983. {
  984.  sprintf(sWord,"%c%c%s",CC_CHAR1(i),CC_CHAR2(i),dict2.m_IndexTable[i].pWordItemHead[k].sWord);
  985.  AddItem(sWord,dict2.m_IndexTable[i].pWordItemHead[k].nHandle,dict2.m_IndexTable[i].pWordItemHead[k].nFrequency/(nRatio+1));
  986. }
  987.         k+=1;
  988.    }
  989.    }
  990.    return true;
  991. }
  992. //Delete word item which 
  993. //(1)frequency is 0 
  994. //(2)word is same as following but the POS value is parent set of the following
  995. //for example "江泽民/n/0" will deleted, because "江泽民/nr/0" is more detail and correct
  996. bool CDictionary::Optimum()
  997. {
  998.    int nPrevPOS,i,j,nPrevFreq;
  999.    char sPrevWord[WORD_MAXLENGTH],sCurWord[WORD_MAXLENGTH];
  1000.    for(i=0;i<CC_NUM;i++)
  1001.    {
  1002.        j=0;  
  1003.    sPrevWord[0]=0;
  1004.    nPrevPOS=0;
  1005.    nPrevFreq=-1;
  1006.    while(j<m_IndexTable[i].nCount)
  1007.    {
  1008.  sprintf(sCurWord,"%c%c%s",CC_CHAR1(i),CC_CHAR2(i),m_IndexTable[i].pWordItemHead[j].sWord);
  1009.          if(nPrevPOS==30720||nPrevPOS==26368||nPrevPOS==29031||(strcmp(sPrevWord,sCurWord)==0&&nPrevFreq==0&&m_IndexTable[i].pWordItemHead[j].nHandle/256*256==nPrevPOS))
  1010.  {//Delete Previous word item
  1011.   //Delete word with POS 'x','g' 'qg'
  1012. DelItem(sPrevWord,nPrevPOS);
  1013.  }
  1014.  strcpy(sPrevWord,sCurWord);
  1015.  nPrevPOS=m_IndexTable[i].pWordItemHead[j].nHandle;
  1016.  nPrevFreq=m_IndexTable[i].pWordItemHead[j].nFrequency;
  1017.    j+=1;//Get next item in the original table.
  1018.    }
  1019.    }
  1020.    return true;
  1021. }