Пример #1
0
Файл: 111.c Проект: pete/euler
static inline int64_t next_prime(int64_t i)
{
	int64_t j;
	for(j = p2i(i) + 1; j < SSZ; j++)
		if(!sieve[j])
			return i2p(j);
	return 0;
}
Пример #2
0
const void *toThd(int tid,int del,int *ser){
	const void *tidx;
	int ti;

	if( enbugTID64() ){
		return i2p(tid);
	}
	if( !lTHREADID() ){
		if( SIZEOF_tid_t <= sizeof(int) ){
			return i2p(tid);
		}
	}
	/*
	if( (tid & 0x8000) == 0 ){
		return (void*)tid;
	}
	ti = tid & ~0xFF00;
	*/
	ti = tid2ti(tid);
	if( 0 <= tid && ti < elnumof(tids) ){
		tidx = tids[ti].t_tidx;
		if( del ){
			if( tids[ti].t_Stid == *ser ){
				tids[ti].t_tidx = (void*)-1;
			}else{
				syslog_ERROR("##toThd unmatch ser: %d %d\n",
					*ser,tids[ti].t_Stid);
			}
			if( lTHREAD() || lTHREADID() ){
				porting_dbg("##tid del[%d] %d %llX/%X",
					ti,tids[ti].t_Stid,
					p2llu(tidx),tid);
				if( lTHREADID() ){
					dumpTids();
				}
			}
		}else{
			if( ser ){
				*ser = tids[ti].t_Stid;
			}
		}
		return tidx;
	}
	return i2p(tid);
}
Пример #3
0
int main()
{
	char s[100];
	void i2p(char[]);
	printf("Enter the Infix expression: ");
	scanf("%s",s);
	printf("nThe Postfix expression is: ");
	i2p(s);
	return 0;
}
/**
 * \fn encodeBlockSimple
 * \brief mono or stereo
 */
bool	AUDMEncoder_Lavcodec::encodeBlockSimple(int count, uint8_t *dest,int &encoded)
{
     encoded=0;
     AVPacket pkt; // out
     av_init_packet(&pkt);
     pkt.size=5000;
     pkt.data=dest;     
     
      if(!count)
      {
          return lastBlock(&pkt,encoded);
      }
     int gotPacket;
     int channel=wavheader.channels;
     _frame->channel_layout=CONTEXT->channel_layout;

     int nbBlocks=count/channel;
      _frame->nb_samples=nbBlocks;
      
      
      int er;
      if( CONTEXT->sample_fmt   ==  AV_SAMPLE_FMT_FLTP)
        {
                float *in=i2p(count);
                // reorder and de-interleave
                er=avcodec_fill_audio_frame(_frame, channel,
                              AV_SAMPLE_FMT_FLTP, (uint8_t *)in,
                               count*sizeof(float), 0);
        }else
        { // s16
              dither16(&(tmpbuffer[tmphead]),count,channel);
              er=avcodec_fill_audio_frame(_frame, channel,
                              AV_SAMPLE_FMT_S16, (uint8_t *)&(tmpbuffer[tmphead]),
                               count*sizeof(uint16_t), 0);
        }
     if(er<0)
     {
        printError("Fill audio",er);
        return false;
     }
     
     
    int  nbout = avcodec_encode_audio2(CONTEXT, &pkt,_frame,&gotPacket);
    if(nbout>=0 && gotPacket)
    {
        cprintf("Got %d bytes \n",pkt.size);
        encoded=pkt.size;
    }
    else
    {
        printError("Encoding",nbout);
        return false;
    }
    return true;
}
Пример #5
0
static array get_environment_key(array env)
{
    register unsigned int ix;

    array result = array_new(NULL, NULL);

    for (ix = 0; ix < env->sz; ix++) {
        atms_node node = (atms_node)env->arr[ix];
        array_append(result, i2p(node->index));
    }

    return result;
}
Пример #6
0
/**
 * Creates a new DPLL problem for use by the DPLL consistency checker
 * or the CNF to DNF converter. This function is used internally by
 * the solvers.
 *
 * @param clauses the input set of clauses;
 * @param variables the number of variables in the CNF.
 * @returns the newly created DPLL problem.
 */
dpll_problem dpll_new_problem(tv_clause_list clauses,
                              const unsigned int variables_count)
{
    register unsigned int ix;

    const_int_list pos;
    const_int_list neg;

    dpll_problem problem = (dpll_problem)malloc(sizeof(struct str_dpll_problem));
    if (NULL == problem) {
        return problem;
    }

    problem->variables_count = variables_count;
    if (option_simplify_clauses) {
        problem->clauses = simplify_clauses(clauses);
    } else {
        problem->clauses = clauses;
    }
    problem->assigned_variables = 0;
    problem->current_variable = (unsigned int)-1;
    problem->consistent = 1;
    problem->branch_points = 0;
    problem->satisfied_clauses = 0;
    problem->randomized = 0;

    problem->empty_clause = new_tv_clause(new_int_list(), new_int_list());

    problem->assignment_history = (unsigned int *)malloc(sizeof(unsigned int) * variables_count);

    memset(problem->assignment_history, 0, sizeof(unsigned int) * variables_count);

    problem->satisfied = (unsigned int *)malloc(sizeof(unsigned int) * clauses->sz);
    problem->labelled = (unsigned int *)malloc(sizeof(unsigned int) * clauses->sz);

    memset(problem->satisfied, 0, sizeof(unsigned int) * clauses->sz);
    memset(problem->labelled, 0, sizeof(unsigned int) * clauses->sz);

    problem->unit_variables_pos = queue_new(NULL, NULL);
    problem->unit_variables_neg = queue_new(NULL, NULL);

    problem->unit_variables_pos_map = (unsigned char *)malloc(sizeof(unsigned char) * variables_count);
    problem->unit_variables_neg_map = (unsigned char *)malloc(sizeof(unsigned char) * variables_count);

    memset(problem->unit_variables_pos_map, 0, sizeof(unsigned char) * variables_count);
    memset(problem->unit_variables_neg_map, 0, sizeof(unsigned char) * variables_count);

    problem->variables = (dpll_variable *)malloc(sizeof(dpll_variable) * variables_count);
    for (ix = 0; ix < variables_count; ix++) {
        problem->variables[ix] = new_dpll_variable();
    }

    for (ix = 0; ix < problem->clauses->sz; ix++) {
        initialize_clause(problem, ix);

        pos = clauses->arr[ix]->pos;
        neg = clauses->arr[ix]->neg;
        if (pos->sz == 0 && neg->sz == 0) {
/* Problem is UNSAT due to an empty clause. */
            problem->consistent = 0;
        }
        if (pos->sz == 1 && neg->sz == 0) {
            int var = pos->arr[0];
            if (problem->variables[var]->pos_filter_clause != NULL) {
/* Problem is UNSAT due to arc inconsistency. */
                problem->consistent = 0;
            }
            if (problem->variables[var]->neg_filter_clause == NULL) {
                problem->variables[var]->neg_filter_clause = clauses->arr[ix];

                queue_push(problem->unit_variables_pos, i2p(var));
                problem->unit_variables_pos_map[var] = 1;
            }
        }
        if (neg->sz == 1 && pos->sz == 0) {
            int var = neg->arr[0];
            if (problem->variables[var]->neg_filter_clause != NULL) {
/* Problem is UNSAT due to arc inconsistency. */
                problem->consistent = 0;
            }
            if (problem->variables[var]->pos_filter_clause == NULL) {
                problem->variables[var]->pos_filter_clause = clauses->arr[ix];

                queue_push(problem->unit_variables_neg, i2p(var));
                problem->unit_variables_neg_map[var] = 1;
            }
        }
    }

    return problem;
}