自学教程：C++ DIV函数代码示例

/* constants that do not change during successive pe calculations */void prepareSfbPe(PE_CHANNEL_DATA *peChanData,                  const float *sfbEnergy,                  const float *sfbThreshold,                  const float *sfbFormFactor,                  const int     *sfbOffset,                  const int     sfbCnt,                  const int     sfbPerGroup,                  const int     maxSfbPerGroup){   int sfbGrp,sfb;   int sfbWidth;   float avgFormFactor;   COUNT_sub_start("prepareSfbPe");   LOOP(1);   for(sfbGrp = 0;sfbGrp < sfbCnt;sfbGrp+=sfbPerGroup){    PTR_INIT(6); /* pointers for sfbEnergy[],                                 sfbThreshold[],                                 sfbOffset[],                                 sfbFormFactor[],                                 peChanData->sfbNLines[],                                 peChanData->sfbLdEnergy[]                 */    LOOP(1);    for (sfb=0; sfb<maxSfbPerGroup; sfb++) {      ADD(1); BRANCH(1);      if (sfbEnergy[sfbGrp+sfb] > sfbThreshold[sfbGrp+sfb]) {         ADD(1);         sfbWidth = sfbOffset[sfbGrp+sfb+1] - sfbOffset[sfbGrp+sfb];         /* estimate number of active lines */         DIV(1); TRANS(1);         avgFormFactor = (float) pow(sfbEnergy[sfbGrp+sfb]/(float)sfbWidth, 0.25f);         DIV(1); STORE(1);         peChanData->sfbNLines[sfbGrp+sfb] =         sfbFormFactor[sfbGrp+sfb]/avgFormFactor;          /* ld(sfbEn) */         TRANS(1); MULT(1); STORE(1);         peChanData->sfbLdEnergy[sfbGrp+sfb] = (float) (log(sfbEnergy[sfbGrp+sfb]) * LOG2_1);      }      else {         MOVE(2);         peChanData->sfbNLines[sfbGrp+sfb] = 0.0f;         peChanData->sfbLdEnergy[sfbGrp+sfb] = 0.0f;      }    }   }   COUNT_sub_end();}

intxavs_cqm_init (xavs_t * h){  int def_quant8[64][64];  int def_dequant8[64][64];  int q, i, i_list;  int pos;  int deadzone[4] = { h->param.analyse.i_luma_deadzone[0],    h->param.analyse.i_luma_deadzone[1],    32 - 11, 32 - 21  };                            /*intra Y; inter Y; intra C; inter C */  int max_qp_err = -1;  //initial the dequant and quant table with q for 8x8   for (q = 0; q < 64; q++)  {    for (i = 0; i < 64; i++)    {      def_dequant8[q][i] = dequant8_table[q];      def_quant8[q][i] = quant8_scale[i];    }  }  //i_list =0 Intra Y ; i_list = 1 inter Y ; i_list =2 Intra C ; i_list =3 Inter C;  for (i_list = 0; i_list < 4; i_list++)  {    for (q = 0; q < 64; q++)    {      for (pos = 0; pos < 64; pos++)      {        int xx = pos % 8;        int yy = pos / 8;        int mf;        h->dequant8_mf[i_list][q][yy][xx] = DIV (def_dequant8[q][pos] * 16, h->pps->scaling_list[i_list][pos]);        h->quant8_mf[i_list][q][pos] = mf = DIV (def_quant8[q][pos] * 16, h->pps->scaling_list[i_list][pos]);        //here the deadzone is a value from 0~32 2~5          //deadzone 1/2, deadzone should be 0.5 * 1<<15  = (1<<5) * (1<<9)        //typical value intra  f=(1<<15)*10/31  inter  f=(1<<15)*10/62        if (i_list % 2 == 0)    /*intra */          h->quant8_bias[i_list][q][pos] = XAVS_MIN (deadzone[i_list] << 9, (1 << 15) * 10 / 31);        else                    /*inter */          h->quant8_bias[i_list][q][pos] = XAVS_MIN (deadzone[i_list] << 9, (1 << 15) * 10 / 62);      }    }  }  if (!h->mb.b_lossless && max_qp_err >= h->param.rc.i_qp_min)  {    xavs_log (h, XAVS_LOG_ERROR, "Quantization overflow./n");    xavs_log (h, XAVS_LOG_ERROR, "Your CQM is incompatible with QP < %d, but min QP is set to %d/n", max_qp_err + 1, h->param.rc.i_qp_min);    return -1;  }  return 0;}

static void  reducec(NUM_TYPE* l1,NUM_TYPE * l2){ NUM_TYPE    c, i1, i2;   i1 = ABS(*l1); i2 = ABS(*l2);   if (i2 > i1) { c = i1; i1 = i2; i2 = c; }   while (i2 != 0) { c = i2; i2 = REST(i1,i2); i1 = c; }   (*l1) = DIV(*l1,i1);   (*l2) = DIV(*l2,i1);}

ulong get_timer_raw(void){	ulong now = DIV(READ_TIMER);	if (now >= lastinc) {		/* normal mode */		timestamp += now - lastinc;	} else {		/* overflow ... */		timestamp += now + DIV(TIMER_LOAD_VAL) - lastinc;	}	lastinc = now;	return timestamp;}

    aravdebug(const char * userfile, int lineno, const char *PATH) {        dataPath = getenv("DLOG_OUTPUT_FOLDER") + std::string(PATH);        //llvm::errs()<<"Data path ::"<<dataPath;        datatempPath = dataPath + ".temp";//		tagPath = dataPath + ".tag";        std::string syscall = "rm -f " + dataPath;        int status = system(syscall.c_str());        if (status < 0)            std::cout << "DLOG Error: " << strerror(errno) << '/n';        OS.reset((new llvm::raw_fd_ostream(datatempPath.c_str(), ErrorInfo)));        llvm::errs() << ErrorInfo;        id = gid++;        //llvm::errs()<<"created DLOG with id "<<id<<"/n";        tagset.insert("SYSTEM");        (*OS) << DIV("SYSTEM")<< "Created Debugger " << GREEN(id)              << CALLINFO              << EDIV;        tagset.insert("CALLINFO");        (*OS).flush();    }

void tmr0_init(void){    // Select asynchronous timer 0 operation to use external 32.768 kHz crystal    BIT_SET_HI(ASSR,AS0);    // Reset time    TCNT0 = 0;    // Calculate and set period    OCR0 = (uint16)DIV(((F_RTC/8)*TMR0_PERIOD_MS),1000) - 1;    /* Start timer 0 with clock prescaler CLK/8 and CTC Mode ("Clear Timer on Compare")*/    /* Resolution is 244.14 us */    /* Maximum period is 62.5 ms */    TCCR0 = TMR0_TCCR0_VALUE;    // Wait for "update busy" flags to clear    while(ASSR&((1<<TCN0UB)|(1<<OCR0UB)|(1<<TCR0UB)))    {        ;    }    // Enable interrupt on compare match    BIT_SET_HI(TIMSK,OCIE0);}

static void calcPeCorrection(float *correctionFac,                             const float peAct,                             const float peLast,                              const int bitsLast) {  COUNT_sub_start("calcPeCorrection");  ADD(4); FUNC(1); FUNC(1); MULT(4); LOGIC(4); BRANCH(1);  if ((bitsLast > 0) && (peAct < (float)1.5f*peLast) && (peAct > (float)0.7f*peLast) &&      ((float)1.2f*bits2pe((float)bitsLast) > peLast) &&       ((float)0.65f*bits2pe((float)bitsLast) < peLast))  {    float newFac = peLast / bits2pe((float)bitsLast);    FUNC(1); DIV(1); /* counting previous operation */    /* dead zone */    ADD(1); BRANCH(1);    if (newFac < (float)1.0f) {      MULT(1); ADD(1); BRANCH(1); MOVE(1);      newFac = min((float)1.1f*newFac, (float)1.0f);      ADD(1); BRANCH(1); MOVE(1);      newFac = max(newFac, (float)0.85f);    }    else {      MULT(1); ADD(1); BRANCH(1); MOVE(1);      newFac = max((float)0.9f*newFac, (float)1.0f);      ADD(1); BRANCH(1); MOVE(1);      newFac = min(newFac, (float)1.15f);    }    ADD(4); LOGIC(3); BRANCH(1);    if (((newFac > (float)1.0f) && (*correctionFac < (float)1.0f)) ||        ((newFac < (float)1.0f) && (*correctionFac > (float)1.0f))) {      MOVE(1);      *correctionFac = (float)1.0f;    }    /* faster adaptation towards 1.0, slower in the other direction */    ADD(3); LOGIC(3); BRANCH(1); /* if() */ MULT(1); MAC(1); STORE(1);    if ((*correctionFac < (float)1.0f && newFac < *correctionFac) ||        (*correctionFac > (float)1.0f && newFac > *correctionFac))      *correctionFac = (float)0.85f * (*correctionFac) + (float)0.15f * newFac;    else      *correctionFac = (float)0.7f * (*correctionFac) + (float)0.3f * newFac;    ADD(2); BRANCH(2); MOVE(2);    *correctionFac = min(*correctionFac, (float)1.15f);    *correctionFac = max(*correctionFac, (float)0.85f);  }  else {    MOVE(1);    *correctionFac = (float)1.0f;  }  COUNT_sub_end();}

	void llvm_print(const char *userfile, int lineno, T &obj, const char* tag,			ADDON addon = ADDON())	{		std::string unformatted = llvm_to_str(obj);		std::string formatted = dlog_format_string_to_html(unformatted);		if (outputmode == DLOG_OUTPUT_BOTH || outputmode == DLOG_OUTPUT_FILE)		{			tag_handler(tag);			fdata << DIV(					tag) << BOLD("<br>Tag : ") << RED(tag) << NBSP << br << CALLINFO			<< BROWN(addon.getString()) << NBSP << NBSP			<< BOLD(" Data : <br>") << formatted << EDIV;		}		if (outputmode == DLOG_OUTPUT_BOTH || outputmode == DLOG_OUTPUT_STDOUT)		{			std::cout << "Tag : " << tag << "/t";			if (addon.getString().length() != 0)			std::cout << "/t Addon: " << addon.getString() << "/n";			std::cout << unformatted << "/n";		}		fdata.flush();	}

/*  The function creates the interpolated spectral data according to the   energy of the last good frame and the current (good) frame.*/void CConcealment_InterpolateBuffer (float       *spectrum,                                     float       *enPrev,                                     float       *enAct,                                     int          sfbCnt,                                     const short *pSfbOffset){  int    sfb, line = 0;  float  multiplier;  FLC_sub_start("CConcealment_InterpolateBuffer");  MOVE(1); /* counting previous operation */  PTR_INIT(3); /* enAct[]                  enPrev[]                  spectrum[]               */  LOOP(1);  for(sfb = 0; sfb < sfbCnt; sfb++) {    DIV(1); TRANS(1);    multiplier = (float) pow(enAct[sfb] / enPrev[sfb], 0.25f);    LOOP(1);    for(; line < pSfbOffset[sfb+1]; line++) {      MULT(1); STORE(1);      spectrum [line] = spectrum[line] * multiplier;    }  }  FLC_sub_end();}

static Value *binaryExprInterp(Node *node, void *parser){#ifndef NDEBUG	assert(node->type == NT_BINARY_EXPR);#endif	BinaryExpr *e = (BinaryExpr *)node;#ifdef LOG_INTERP	logInterpPrefix(parser);	rawlog("binaryExprInterp/n");	((Parser *)parser)->interpDepth++;#endif	assert(e->lhs && e->rhs);	Value *lhs = e->lhs->interp(e->lhs, parser);	Value *rhs = e->rhs->interp(e->rhs, parser);	switch (e->op) {	case TK_ADD: e->value = ADD(lhs, rhs, e->value); break; /* + */	case TK_SUB: e->value = SUB(lhs, rhs, e->value); break; /* - */	case TK_MUL: e->value = MUL(lhs, rhs, e->value); break; /* * */	case TK_DIV: e->value = DIV(lhs, rhs, e->value); break; /* / */	default:		assert(0);		break;	}#ifdef LOG_INTERP	logInterpPrefix(parser);	rawlog("%s/n", token2str(e->op));	((Parser *)parser)->interpDepth--;#endif	return e->value;}

/*!  /brief  Is SBR setting available.  /return a flag indicating success: yes (1) or no (0)****************************************************************************/unsigned intIsSbrSettingAvail (unsigned int bitrate,                   unsigned int numOutputChannels,                   unsigned int sampleRateInput,                   unsigned int *sampleRateCore                   ){  int idx = INVALID_TABLE_IDX;  COUNT_sub_start("IsSbrSettingAvail");  MOVE(1); /* counting previous operation */  ADD(1); BRANCH(1);  if (sampleRateInput < 32000)  {    COUNT_sub_end();    return 0;  }  DIV(1); STORE(1);  *sampleRateCore = sampleRateInput/2;  FUNC(3);  idx = getSbrTuningTableIndex(bitrate,numOutputChannels, *sampleRateCore);  ADD(1); BRANCH(1); /* counting post-operation */  COUNT_sub_end();  return (idx == INVALID_TABLE_IDX) ? 0 : 1;}

    void print_to_file(const char * userfile, int lineno, T obj, ADDON addon =                           ADDON()) {        tagset.insert("notag");        (*OS) << DIV("notag") << br << BLUE( obj) << NBSP << CALLINFO << NBSP              << BROWN(addon.getString()) << NBSP << EDIV;        (*OS).flush();    }

/** * Generates a sequence of nbits random bits */int srslte_binsource_cache_gen(srslte_binsource_t* q, int nbits) {  if (gen_seq_buff(q,DIV(nbits,32))) {    return -1;  }  q->seq_cache_nbits = nbits;  q->seq_cache_rp = 0;  return 0;}

/** * Stores in the bits buffer a sequence of nbits pseudo-random bits. * Overwrites the bits generated using srslte_binsource_cache_gen. */int srslte_binsource_generate(srslte_binsource_t* q, uint8_t *bits, int nbits) {  if (gen_seq_buff(q,DIV(nbits,32))) {    return -1;  }  int_2_bits(q->seq_buff,bits,nbits);  return 0;}

/** * Stores in the bits buffer a sequence of nbits pseudo-random bits. * Overwrites the bits generated using binsource_cache_gen. */int binsource_generate(binsource_t* q, char *bits, int nbits) {  if (gen_seq_buff(q,DIV(nbits,32))) {    return -1;  }  int_2_bits(q->seq_buff,bits,nbits);  return 0;}

int is_abs_walkable(Entity** entities, int x, int y) {    int walkable = is_walkable(entities[DIV(x)][DIV(y)]);    if(MOD(x) != 0 && MOD(y) != 0)        walkable = walkable && is_walkable(entities[DIV(x) + 1][DIV(y) + 1]);    if(MOD(x) != 0)        walkable = walkable && is_walkable(entities[DIV(x) + 1][DIV(y)]);    if(MOD(y) != 0)        walkable = walkable && is_walkable(entities[DIV(x)][DIV(y) + 1]);    return walkable;}

struct LongNumber DEGREE(struct LongNumber a, struct LongNumber b, struct LongNumber c){ 	struct LongNumber res;	if(a.size < c.size)		res.size = c.size + c.size;	else		res.size = a.size + a.size;	res = allocate(res, res.size);    res = zero(res, res.size); 	res.pointer[0] = 1;	struct LongNumber com;	com.size = 1;	com = allocate(com, com.size);	com.pointer[0] = 0;	struct LongNumber value;	value.size = res.size;	value = allocate(value, value.size);    value = zero(value, value.size);	memcpy(value.pointer, a.pointer, a.size * sizeof(unsigned int));	struct LongNumber pow = copy(b);	while((compare(pow,com)) > 0)	{		if((pow.pointer[0] & 1)==1)		{			res = MUL(res, value);			res = DIV(res, c, 2);		}		value = MUL(value, value);		value = DIV(value, c, 2);		pow = SmallDIV(pow, 2);	}	com = clear(com);	pow = clear(pow);	value = clear(value);	return res;}

    void print_to_default_file(const char * userfile, int lineno, S tag,                               unsigned int obj, ADDON addon = ADDON()) {        tagset.insert(tag);        (*OS) << DIV(tag) << BOLD("<br>Tag : ") << RED(tag) << NBSP << CALLINFO              << NBSP << BROWN(addon.getString()) << NBSP              << BOLD(" Data : <br>") << obj << EDIV;        (*OS).flush();    }

/*****************************************************************************    functionname: atan_approx    description:  Calculates atan , val >=0    returns:      approx of atan(val), error is less then 0.5 %    input:    output:*****************************************************************************/static float atan_approx(float val){  COUNT_sub_start("atan_approx");  ADD(1); BRANCH(1);  if(val < (float)1.0)  {    DIV(1); MULT(2); ADD(1); /* counting post-operations */    COUNT_sub_end();    return(val/((float)1.0f+(float)0.280872f*val*val));  }  else  {    DIV(1); MULT(1); ADD(2); /* counting post-operations */    COUNT_sub_end();    return((float)1.57079633f-val/((float)0.280872f +val*val));  }}

int main(void){	printf("ADDITION:/t %f + %f = %f/n", WERT1, WERT2, ADD(WERT1,WERT2));	printf("SUBTRAKTION:/t %f - %f = %f/n", WERT1, WERT2, SUB(WERT1,WERT2));	printf("MULTIPLIKATION:/t %f * %f = %f/n", WERT1, WERT2, MUL(WERT1,WERT2));	printf("DIVISION:/t %f / %f = %f/n", WERT1, WERT2, DIV(WERT1,WERT2));	return 0;}

int main(){ printf("%d",p); int num1, num2, mod; printf("/nEnter two integers/n"); scanf("%d%d",&num1,&num2); printf("/nThe result of division is %d/n", DIV(num1,num2)); mod = MOD(num1,num2); printf("/nThe result of modulus is %d/n", mod); }

int moduloExprCodegen(c_tree tree, int *registerNo, int topLevel,		int getAddress, const char *breakLabel, const char *continueLabel){	c_tree op2 = TREE_EXPR_OPERAND(tree,1);	c_tree op1 = TREE_EXPR_OPERAND(tree,0);	if (!topLevel)	{		int op1Register = c_codegen_recurse(op1,				registerNo, topLevel, getAddress, breakLabel, continueLabel);		if (TREE_CODE(op2) == TREE_INTEGER_CST)		{			int divReg = (*registerNo)++;			int mulReg = (*registerNo)++;			int resReg = (*registerNo)++;			int immiValue = INTEGER_CST(op2)->val;			DIVi(divReg, op1Register, immiValue, "modulo", NULL);			MULi(mulReg, divReg, immiValue, "modulo", NULL);			SUB(resReg, op1Register, mulReg, "modulo", NULL);			return resReg;		}		else		{			int op2Register = c_codegen_recurse(op2, registerNo, topLevel,					getAddress, breakLabel, continueLabel);			int divReg = (*registerNo)++;			int mulReg = (*registerNo)++;			int resReg = (*registerNo)++;			DIV(divReg, op1Register, op2Register, "modulo", NULL);			MUL(mulReg, divReg, op2Register, "modulo", NULL);			SUB(resReg, op1Register, mulReg, "modulo", NULL);			return resReg;		}	}	else	{		c_codegen_recurse(op1, registerNo, topLevel, getAddress, breakLabel,						continueLabel);		c_codegen_recurse(op2, registerNo, topLevel, getAddress, breakLabel,				continueLabel);		return *registerNo;	}}

static void test_div_basic(void){	TB_INFO("   Testing basic cases");	DEF_BIGINT(n, 2048);	DEF_BIGINT(d, 2048);	DEF_BIGINT(q, 2048);	DEF_BIGINT(r, 2048);	DEF_BIGINT(v, 2048);	SELF_VERIFY_DIV("8111_1110_0000_0001_12345678", "8000000012345678");	DIV("0", "1", "0");	DIV("1", "1", "1");	DIV("b7fb", "5", "24CB");	DIV("124378912734891273894712890347102358129034789120374",	    "1984086C15FA011154C86FA68", "B73D14EC7205D3311F6E78411D");	SELF_VERIFY_DIV("124378912734891273894712890347102358129034789120374",			"1984086C15FA011154C86FA68");	SELF_VERIFY_DIV("-124378912734891273894712890347102358129034789120374",			"1984086C15FA011154C86FA68");	SELF_VERIFY_DIV("124378912734891273894712890347102358129034789120374",			"-1984086C15FA011154C86FA68");	SELF_VERIFY_DIV("-124378912734891273894712890347102358129034789120374",			"-1984086C15FA011154C86FA68");	SELF_VERIFY_DIV("12345678", "10");	SELF_VERIFY_DIV("-12345678", "10");	SELF_VERIFY_DIV("12345678", "-10");	SELF_VERIFY_DIV("-12345678", "-10");	SELF_VERIFY_DIV("12345678901234567890123456789012345678901", "10");	SELF_VERIFY_DIV("1234567890123456789012345678901234567890", "10");	SELF_VERIFY_DIV("123456789012345678901234567890123456789", "10");	DEL_BIGINT(n);	DEL_BIGINT(d);	DEL_BIGINT(q);	DEL_BIGINT(r);	DEL_BIGINT(v);}

	Byte Processor::execInstruction() {#ifdef R_UM_OPT_ENABLE_LOGGING#ifdef R_UM_OPT_PRC_DEBUG		ic_ ++;#endif#endif		Word instr = (*mm_)(0, pc_ ++);		switch (decodeInstruction(instr)) {			case IC_CNDMOV:				return CNDMOV(decodeAreg(instr), decodeBreg(instr),						decodeCreg(instr));			case IC_ARRIDX:				return ARRIDX(decodeAreg(instr), decodeBreg(instr),						decodeCreg(instr));			case IC_ARRAMD:				return ARRAMD(decodeAreg(instr), decodeBreg(instr),						decodeCreg(instr));			case IC_ADD:				return ADD(decodeAreg(instr), decodeBreg(instr),						decodeCreg(instr));			case IC_MUL:				return MUL(decodeAreg(instr), decodeBreg(instr),						decodeCreg(instr));			case IC_DIV:				return DIV(decodeAreg(instr), decodeBreg(instr),						decodeCreg(instr));			case IC_NOTAND:				return NOTAND(decodeAreg(instr), decodeBreg(instr),						decodeCreg(instr));			case IC_HLT:				return HLT();			case IC_ALLOC:				return ALLOC(decodeBreg(instr), decodeCreg(instr));			case IC_ABAND:				return ABAND(decodeCreg(instr));			case IC_OUTP:				return OUTP(decodeCreg(instr));			case IC_INP:				return INP(decodeCreg(instr));			case IC_LDPRG:				return LDPRG(decodeBreg(instr), decodeCreg(instr));			case IC_ORTHO:				return ORTHO(decodeOreg(instr), decodeVal(instr));			default:				assert(false);				return HLT();		}	}

int main (void){	double *x, *f;	int i;	x = aCy (n, -1., 1. );	SV (n, x);	f = DIV (n);	for (i = 0; i < n; i++)		f[i] = fun (x[i]);	difdiv (n, x, f); /* generat el polinomi */	writeFile (n, 0.001, -1, 1, x, f);	return 0;}

int timer_init(void){	/* We are using timer34 in unchained 32-bit mode, full speed */	timer->tcr = 0x0;	timer->tgcr = 0x0;	timer->tgcr = 0x06;	timer->tim34 = 0x0;	timer->prd34 = DIV(TIMER_LOAD_VAL);	lastinc = 0;	timer->tcr = 0x80 << 16;	timestamp = 0;	return(0);}

intdynBitCount(const short          *quantSpectrum,            const unsigned short   *maxValueInSfb,            const signed short     *scalefac,            const int             blockType,            const int             sfbCnt,            const int             maxSfbPerGroup,            const int             sfbPerGroup,            const int            *sfbOffset,            SECTION_DATA         *sectionData){  int bitLookUp[MAX_SFB_LONG][CODE_BOOK_ESC_NDX + 1];  int mergeGainLookUp[MAX_SFB_LONG];  COUNT_sub_start("dynBitCount");  INDIRECT(3); MOVE(3);  sectionData->blockType      = blockType;  sectionData->sfbCnt         = sfbCnt;  sectionData->sfbPerGroup    = sfbPerGroup;  INDIRECT(1); DIV(1); STORE(1);  sectionData->noOfGroups     = sfbCnt / sfbPerGroup;  MOVE(1);  sectionData->maxSfbPerGroup = maxSfbPerGroup;  FUNC(7);  noiselessCounter(sectionData,                   mergeGainLookUp,                   bitLookUp,                   quantSpectrum,                   maxValueInSfb,                   sfbOffset,                   blockType);  FUNC(3);  scfCount(scalefac,           maxValueInSfb,           sectionData);  INDIRECT(3); ADD(2); /* counting post-operations */  COUNT_sub_end();  return (sectionData->huffmanBits +          sectionData->sideInfoBits +          sectionData->scalefacBits);}