C++ s2i函数代码示例

static void print_prob(
  double *a_p,					/* tuple->prob assoc. array */
  int n,					/* widest tuple */
  char *tuple,					/* call with "" */
  int tuplew,					/* tuple width; call with 0 */
  char *alpha 					/* alphabet */
) 
{
  int i;
  char *t = NULL; 				/* tuple */

  if (n==0) return;				/* everything is OK */

  Resize(t, tuplew+2, char);
  
  for(i=0; alpha[i]; i++) {			/* include last letter (X) */
    /* append letter to tuple */
    strcpy(t, tuple); t[tuplew] = alpha[i]; t[tuplew+1] = '\0';
    /* print tuple and probability */
    if (a_p[s2i(t)]) printf("%10s %8.4f\n", t, a_p[s2i(t)]);
    /* recur */
    print_prob(a_p, n-1, t, tuplew+1, alpha);
  } /* letter */
  myfree(t);

} /* print_prob */

int CAgramtab :: AreEqualPartOfSpeech (char *grm1, char* grm2) 
 {
   if ((grm1==0) && (grm2==0)) return 1;
   if ((grm1==0) && (grm2!=0)) return 0;
   if ((grm2==0) && (grm1!=0)) return 0;
   if (((unsigned char)grm1[0] == '?') || ((unsigned char)grm2[0] == '?')) return 0;
   return GetLine(s2i(grm1))->m_PartOfSpeech == GetLine(s2i(grm2))->m_PartOfSpeech;
 }

void parse(const string & s, int *id_from, int *id_msg, int *id_cmd)
{
	size_t index1 = s.find_first_not_of("-0123456789",0);

	*id_from = s2i(s.substr(0,index1));

	size_t index2 = s.find_first_not_of("-0123456789",index1+1);

	*id_msg = s2i(s.substr(index1+1,index2));

	*id_cmd = s2i(s.substr(index2+1));
}

void linear_pcm32_be_2ch(uint8_t *rawdata, samples_t samples, size_t size)
{
  samples_t src = samples;
  int32_t *dst = (int32_t *)rawdata;

  int r = set_rounding();
  while (size--)
  {
    dst[0] = int2be32(s2i(*src[0])); src[0]++;
    dst[1] = int2be32(s2i(*src[1])); src[1]++;
    dst += 2;
  }
  restore_rounding(r);
}

void linear_pcm24_be_3ch(uint8_t *rawdata, samples_t samples, size_t size)
{
  samples_t src = samples;
  int24_t *dst = (int24_t *)rawdata;

  int r = set_rounding();
  while (size--)
  {
    dst[0] = int2be24(s2i(*src[0])); src[0]++;
    dst[1] = int2be24(s2i(*src[1])); src[1]++;
    dst[2] = int2be24(s2i(*src[2])); src[2]++;
    dst += 3;
  }
  restore_rounding(r);
}

void linear_pcm16_4ch(uint8_t *rawdata, samples_t samples, size_t size)
{
  samples_t src = samples;
  int16_t *dst = (int16_t *)rawdata;

  int r = set_rounding();
  while (size--)
  {
    dst[0] = int2le16(s2i(*src[0])); src[0]++;
    dst[1] = int2le16(s2i(*src[1])); src[1]++;
    dst[2] = int2le16(s2i(*src[2])); src[2]++;
    dst[3] = int2le16(s2i(*src[3])); src[3]++;
    dst += 4;
  }
  restore_rounding(r);
}

/* ----------------------------------------------------------------------------
 * Reads the provided script variables, if any, and does stuff with them.
 */
void pikmin::read_script_vars(const string &vars) {
    mob::read_script_vars(vars);
    maturity = s2i(get_var_value(vars, "maturity", "2"));
    if(s2b(get_var_value(vars, "sprout", "0"))) {
        fsm.first_state_override = PIKMIN_STATE_SPROUT;
    }
}

extern double log_cum_back(
  char *seq,					/* the sequence */
  double *a_cp,					/* the conditional probs */
  int order,					/* the order of the model */
  double *logcumback				/* the result */ 
)
{
  int i;
  int len = strlen(seq);			/* length of sequence */

  /* compute probability for each position in string */
  int ipos;					// gets reset by ambig
  for (i=ipos=0, logcumback[0]=0; i<len; i++) {	/* position of "a" */
    int lp = MIN(ipos+1, order+1);		/* substring length */
    char *wa = &seq[i-lp+1];			/* next wa */
    char *wa_end = &seq[i+1];			/* position after wa */
    char save = *wa_end;			/* save character after wa */
    *wa_end = '\0';				/* make wa a string */
    int index = s2i(wa);			/* index into conditional probs */
    double log_pwa;				/* log Pr(a | w) */
    if (index < 0) {				// set prob to 1 and reset ipos
      log_pwa = 0;
      ipos = 0;
    } else { 
      log_pwa = log(a_cp[index]);		/* log Pr(a | w) */
      ipos++;
    }
    logcumback[i+1] = logcumback[i] + log_pwa;
    //printf("wa:: %s log_pwa %g\n", wa, log_pwa);
    *wa_end = save;				/* restore seq */
  }
  return(logcumback[i]);			/* total cumulative prob. */
} /* log_cum_back */

static void add_x_tuples(
  double *a_p,					/* tuple->prob assoc. array */
  char *ntuple,					/* non-X-containing tuple */
  int ntuplew, 					/* ntuple width */
  int ntuplei, 					/* ntuple index */
  char *xtuple,					/* X-containing tuple */
  int xtuplew, 					/* xtuple width */
  int xcnt					/* count of X's in xtuple */
)
{
  if (xtuplew == ntuplew) {			/* add prob. of non-X-tuple */
    int xtuplei;
    xtuple[xtuplew] = '\0';			/* end tuple */
    xtuplei = s2i(xtuple);
    if (a_p[xtuplei] == -1) a_p[xtuplei] = 0;	/* first time for x-tuple */
    a_p[xtuplei] += a_p[ntuplei];
  } else {					/* continue building x-tuple */
    xtuple[xtuplew] = 'X';			/* add X to xtuple */
    add_x_tuples(a_p, ntuple, ntuplew, ntuplei, xtuple, xtuplew+1, xcnt+1);
    if (xcnt || xtuplew < ntuplew-1) {		/* OK to add non-X to xtuple */
      xtuple[xtuplew] = ntuple[xtuplew];	/* add X to xtuple */
      add_x_tuples(a_p, ntuple, ntuplew, ntuplei, xtuple, xtuplew+1, xcnt);
    }
  }
} /* add_x_tuples */

bool CAgramtab :: FindGrammems (const char* gram_codes, QWORD grammems) const
{
  for (size_t l=0; l<strlen(gram_codes); l+=2)
		if ( (GetLine(s2i(gram_codes+l))->m_Grammems & grammems) == grammems)
			return true;

  return false;	
};

//changes GramCodes1pair according to satisfied GramCodes1 
//(if gramcode number N is good(bad) in GramCodes1 it must be good(bad) in GramCodes1pair)
string CAgramtab::GleicheAncode1 (GrammemCompare CompareFunc, string GramCodes1, string GramCodes2, string& GramCodes1pair) const
{
	string Result;
	string pair;
	const char* gram_codes1 = GramCodes1.c_str();
	const char* gram_codes2 = GramCodes2.c_str();
	if (!gram_codes1) return "";
	if (!gram_codes2) return "";
	if (!strcmp(gram_codes1, "??")) return gram_codes2;
	if (!strcmp(gram_codes2, "??")) return gram_codes2;
	size_t len1 = strlen(gram_codes1);
	size_t len2 = strlen(gram_codes2);
	bool has_pair = GramCodes1pair.length() == len1;
	for (size_t l=0; l<len1; l+=2)
		if(CompareFunc)
		{
			const CAgramtabLine* l1 = GetLine(s2i(gram_codes1+l));
			for (size_t m=0; m<len2; m+=2)	
			{
				const CAgramtabLine* l2 = GetLine(s2i(gram_codes2+m));
				if ( CompareFunc  (l1, l2) )  
				{
					//printf ("%s[%i]=%c\n",gram_codes1,l,gram_codes1[l]);
					Result.append(gram_codes1+l,2);
					if(has_pair) pair.append(GramCodes1pair.substr(l,2));
					//Result += gram_codes1[l+1];
					break;
				};
			};
		}
		else
		{
			for (size_t m=0; m<len2; m+=2)	
			{
				if ( s2i(gram_codes1+l) == s2i(gram_codes2+m) )  
				{
					Result.append(gram_codes1+l,2);
					if(has_pair) pair.append(GramCodes1pair.substr(l,2));
					break;
				};
			};
		};
	if(has_pair) GramCodes1pair = pair;
 	return Result;
};

bool CAgramtab :: Read (const char * FileName) 
{
	if (FileName ==  NULL) return true;

	for (size_t i=0; i<GetMaxGrmCount(); i++) 
		GetLine(i) = 0;


	FILE* fp = fopen (FileName,"r");

	assert (fp);

	if( !fp)
		return false;


	char buff[300];
	size_t LineNo = 0;;
	while (fgets (buff,300,fp))
	{
		LineNo++;
		char * s = buff;
		for (; isspace ( (unsigned char) *s); s++);
		if (!*s) continue;
		if (!strncmp (s,"//",2)) continue;

		CAgramtabLine* pAgramtabLine = new CAgramtabLine(LineNo);

		// a double can  occur
		if (GetLine(s2i(s))) delete GetLine(s2i(s));

		GetLine(s2i(s)) = pAgramtabLine;
		bool bResult = ProcessAgramtabLine(*this, buff,s2i(s));
	}

	fclose (fp);

	m_bInited = true;
	return true;
};

unsigned int
MBVersion::publicVersion() {
	if (!m_talkedToMama)
		phoneHome();

	unsigned int version=0;

	CString val = m_pairs.getVal("version");
	if (val.GetLength())
		version = s2i(val);

	return version;
}

BYTE CAgramtab::GetPartOfSpeech(const char* gram_code) const
{
	if (gram_code == 0) return UnknownPartOfSpeech;
    if (*gram_code == 0) return UnknownPartOfSpeech;
	if (*gram_code == '?') return UnknownPartOfSpeech; 

	const CAgramtabLine* L =  GetLine(s2i(gram_code));

	if (L == NULL)
		return UnknownPartOfSpeech;

	return L->m_PartOfSpeech;
}

void linear_pcm16_be_1ch(uint8_t *rawdata, samples_t samples, size_t size)
{
  samples_t src = samples;
  int16_t *dst = (int16_t *)rawdata;

  int r = set_rounding();
  while (size--)
  {
    dst[0] = int2be16(s2i(*src[0])); src[0]++;
    dst += 1;
  }
  restore_rounding(r);
}