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

int main (){    srandom ((unsigned) time (NULL));    zmq::context_t context(1);    zmq::socket_t server(context, ZMQ_REP);    server.bind("tcp://*:5555");    int cycles = 0;    while (1) {        std::string request = s_recv (server);        cycles++;        // Simulate various problems, after a few cycles        if (cycles > 3 && within (3) == 0) {            printf ("I: simulating a crash/n");            break;        }        else        if (cycles > 3 && within (3) == 0) {            printf ("I: simulating CPU overload/n");            sleep (5);        }        printf ("I: normal request (%s)/n", request.c_str());        sleep (1); // Do some heavy work        s_send (server, request);    }    return 0;}

    // TODO: shortcut number of comparisons    Interval::IntervalComparison Interval::compare(const Interval& other) const {        //        // Intersect cases        //        // TODO: rewrite this to be member functions so semantics are clearer.        if (intersects(*this, other)) {            if (exact(*this, other)) {                return INTERVAL_EQUALS;            }            if (within(*this, other)) {                return INTERVAL_WITHIN;            }            if (within(other, *this)) {                return INTERVAL_CONTAINS;            }            if (precedes(*this, other)) {                return INTERVAL_OVERLAPS_BEFORE;            }            return INTERVAL_OVERLAPS_AFTER;        }        //        // Non-intersect cases        //        if (precedes(*this, other)) {            if (0 == end.woCompare(other.start, false)) {                return INTERVAL_PRECEDES_COULD_UNION;            }            return INTERVAL_PRECEDES;        }        return INTERVAL_SUCCEEDS;    }

    // TODO: shortcut number of comparisons    Interval::IntervalComparison Interval::compare(const Interval& other) const {        //        // Intersect cases        //        if (intersects(*this, other)) {            if (exact(*this, other)) {                return INTERVAL_EQUALS;            }            if (within(*this, other)) {                return INTERVAL_WITHIN;            }            if (within(other, *this)) {                return INTERVAL_CONTAINS;            }            if (precedes(*this, other)) {                    return INTERVAL_OVERLAPS_BEFORE;            }            return INTERVAL_OVERLAPS_AFTER;        }        //        // Non-intersect cases        //        if (precedes(*this, other)) {            return INTERVAL_PRECEDES;        }        return INTERVAL_SUCCEDS;    }

void AmplitudeWidget::mousePressEvent(QMouseEvent *e){  View *view = gdata->view;  int timeX = toInt(view->viewOffset() / view->zoomX());  //int pixelAtCurrentNoiseThresholdY = toInt(gdata->noiseThresholdDB() / gdata->dBFloor() / range() * double(height()));  int pixelAtCurrentNoiseThresholdY;  dragMode = DragNone;    //Check if user clicked on center bar, to drag it  if(within(4, e->x(), timeX)) {    dragMode = DragTimeBar;    mouseX = e->x();    return;  }  //Check if user clicked on a threshold bar  for(int j=0; j<2; j++) {    pixelAtCurrentNoiseThresholdY = height() - 1 - toInt((getCurrentThreshold(j) - offsetInv()) / range() * double(height()));    if(within(4, e->y(), pixelAtCurrentNoiseThresholdY)) {      dragMode = DragNoiseThreshold;      thresholdIndex = j; //remember which thresholdIndex the user clicked      mouseY = e->y();      return;    }  }  //Otherwise user has clicked on background  {    mouseX = e->x();    mouseY = e->y();    dragMode = DragBackground;    downTime = view->currentTime();    downOffset = offset();  }}

int main () {    //  Prepare our context and publisher    zmq::context_t context (1);    zmq::socket_t publisher (context, ZMQ_PUB);    publisher.bind("tcp://*:5556");//    publisher.bind("ipc://weather.ipc");    //  Initialize random number generator    srandom ((unsigned) time (NULL));    while (1) {        int zipcode, temperature, relhumidity;        //  Get values that will fool the boss        zipcode     = within (100000);        temperature = within (215) - 80;        relhumidity = within (50) + 10;        //  Send message to all subscribers        zmq::message_t message(20);        snprintf ((char *) message.data(), 20 ,        	"%05d %d %d", zipcode, temperature, relhumidity);        publisher.send(message);    }    return 0;}

double distance(struct position a, struct  position b,                const region_map_t* regs) {    // find a region that fits a.    bool a_in_reg = false;    bool b_in_reg = false;    int r;    for (r=0; r<SIZE(*regs); ++r) {        if (within(a, GET(*regs,r))) {            a_in_reg = true;        }        if (within(b, GET(*regs,r))) {            b_in_reg = true;        }        if (within(a, GET(*regs,r)) && within(b, GET(*regs,r))) {            return rawDistance(a,b);        }    }    /*  if (!a_in_reg) {        iprintf ("%7d WARNING(a): (%4.1f, %4.1f, %4.1f) is not in any region./n", warn_count,        a.x, a.y, a.z);        warn_count++;        }        if (!b_in_reg) {        iprintf ("%7d WARNING(b): (%4.1f, %4.1f, %4.1f) is not in any region./n", warn_count,        b.x, b.y, b.z);        warn_count++;        }    */    return INFINITY;}

//  Set simple random printable identity on socket//static voids_set_id (zmq::socket_t & socket){    char identity [10];    sprintf (identity, "%04X-%04X", within (0x10000), within (0x10000));    socket.setsockopt(ZMQ_IDENTITY, identity, strlen (identity));}

int main (){    srand ((unsigned) time (NULL));    zmq::context_t context(1);    zmq::socket_t server(context, ZMQ_REP);    server.bind("tcp://*:5555");    int cycles = 0;    while (1) {        std::string request = s_recv (server);        cycles++;        // Simulate various problems, after a few cycles        if (cycles > 3 && within (3) == 0) {            std::cout << "I: simulating a crash" << std::endl;            break;        }        else        if (cycles > 3 && within (3) == 0) {            std::cout << "I: simulating CPU overload" << std::endl;            s_sleep (2000);        }        std::cout << "I: normal request (" << request << ")" << std::endl;        s_sleep (1000); // Do some heavy work        s_send (server, request);    }    return 0;}

//  Set simple random printable identity on socket//inline std::strings_set_id (zmq::socket_t & socket){    std::stringstream ss;    ss << std::hex << std::uppercase       << std::setw(4) << std::setfill('0') << within (0x10000) << "-"       << std::setw(4) << std::setfill('0') << within (0x10000);    socket.setsockopt(ZMQ_IDENTITY, ss.str().c_str(), ss.str().length());    return ss.str();}

// return true if the current cell (i, j) is used by the current stage of calibrationbool TouchTracker::Calibrator::isWithinCalibrateArea(int i, int j){	if(mCollectingNormalizeMap)	{		return(within(i, 1, mWidth - 1) && within(j, 0, mHeight));	}	else	{		return(within(i, 2, mWidth - 2) && within(j, 0, mHeight));	}}

// Returns a pointer to the header of a relative virtual addressstatic PIMAGE_SECTION_HEADER RvaToHdr(LPVOID base, DWORD rva, PIMAGE_NT_HEADERS nt, LPVOID end){  PIMAGE_SECTION_HEADER sect = IMAGE_FIRST_SECTION(nt);  unsigned i;  for ( i=0; (i < nt->FileHeader.NumberOfSections) && within(base,sect,end); i++, sect++ ) {    if ( (rva>=sect->VirtualAddress) && (rva<(sect->VirtualAddress+sect->Misc.VirtualSize))) {      return within(base,sect,end)?sect:NULL;    }  }  return NULL;}

static void edu_check_range(uint32_t addr, uint32_t size1, uint32_t start,                uint32_t size2){    uint32_t end1 = addr + size1;    uint32_t end2 = start + size2;    if (within(addr, start, end2) &&            end1 > addr && within(end1, start, end2)) {        return;    }    hw_error("EDU: DMA range 0x%.8x-0x%.8x out of bounds (0x%.8x-0x%.8x)!",            addr, end1 - 1, start, end2 - 1);}

 /* --- Produce the vector end points produced by the overlap        of two other vectors --- */static void subVector(int *v1, int *v2,                        int t1, int t2, int o1, int o2){    *v1 = *v2 = -1;    if (within(o1, t1, t2))    {        *v1 = o1;        if (within(o2, t1, t2))            *v2 = o2;        else            *v2 = t2;    }    else if (within(o2, t1, t2))    {        *v2 = o2;        if (within(o1, t1, t2))            *v1 = o1;        else            *v1 = t1;    }    else if (within(t1, o1, o2))    {        *v1 = t1;        if (within(t2, o1, o2))            *v2 = t2;        else            *v2 = o2;    }    else if (within(t2, o1, o2))    {        *v2 = t2;        if (within(t1, o1, o2))            *v1 = t1;        else            *v1 = o1;    }}

void Terrain_SelectAreaPoints( void ) {	brush_t			*pb;	terrainMesh_t	*p;	int				x;	int				y;	vec3_t			vec;	g_qeglobals.d_numterrapoints = 0;	g_nPatchClickedView = -1;	for( pb = selected_brushes.next; pb != &selected_brushes; pb = pb->next ) {		if ( pb->terrainBrush ) {			p = pb->pTerrain;			for( x = 0; x < p->width; x++ ) {				for( y = 0; y < p->height; y++ ) {					Terrain_CalcVertPos( p, x, y, vec );					if ( within( vec, g_qeglobals.d_vAreaTL, g_qeglobals.d_vAreaBR ) ) {						if ( g_qeglobals.d_numterrapoints < MAX_TERRA_POINTS ) {							g_qeglobals.d_terrapoints[ g_qeglobals.d_numterrapoints++ ] = &p->heightmap[ x + y * p->width ];						}					}				}			}		}	}}

static int gcov_module_notifier(struct notifier_block *nb, unsigned long event,				void *data){	struct module *mod = data;	struct gcov_info *info;	struct gcov_info *prev;	if (event != MODULE_STATE_GOING)		return NOTIFY_OK;	mutex_lock(&gcov_lock);	prev = NULL;	/*                                                    */	for (info = gcov_info_head; info; info = info->next) {		if (within(info, mod->module_core, mod->core_size)) {			if (prev)				prev->next = info->next;			else				gcov_info_head = info->next;			if (gcov_events_enabled)				gcov_event(GCOV_REMOVE, info);		} else			prev = info;	}	mutex_unlock(&gcov_lock);	return NOTIFY_OK;}

    static inline    void discard_clusters(Turns& turns, Clusters const& clusters,            Geometry0 const& geometry0, Geometry1 const& geometry1)    {        for (typename Clusters::const_iterator cit = clusters.begin();             cit != clusters.end(); ++cit)        {            signed_size_type cluster_id = cit->first;            // If there are only self-turns in the cluster, the cluster should            // be located within the other geometry, for intersection            if (is_self_cluster(cluster_id, turns, clusters))            {                cluster_info const& cinfo = cit->second;                if (! within(turns[*cinfo.turn_indices.begin()], geometry0, geometry1))                {                    // Discard all turns in cluster                    for (std::set<signed_size_type>::const_iterator sit = cinfo.turn_indices.begin();                         sit != cinfo.turn_indices.end(); ++sit)                    {                        turns[*sit].discarded = true;                    }                }            }        }    }

static void *worker_thread (void *arg) {    zmq::context_t * context = (zmq::context_t *)arg;    zmq::socket_t worker (*context, ZMQ_REQ);        //  We use a string identity for ease here    s_set_id (worker);    worker.connect("ipc://routing.ipc");    int total = 0;    while (1) {        //  Tell the router we're ready for work        s_send (worker, "ready");        //  Get workload from router, until finished        std::string workload = s_recv (worker);        int finished = (workload.compare("END") == 0);                if (finished) {            std::cout << "Processed: " << total << " tasks" << std::endl;            break;        }        total++;        //  Do some random work        s_sleep(within (100) + 1);    }    return (NULL);}

static void *worker_thread (void *context) {    void *worker = zmq_socket (context, ZMQ_REQ);    //  We use a string identity for ease here    s_set_id (worker);    zmq_connect (worker, "ipc://routing.ipc");    int total = 0;    while (1) {        //  Tell the router we're ready for work        s_send (worker, "ready");        //  Get workload from router, until finished        char *workload = s_recv (worker);        int finished = (strcmp (workload, "END") == 0);        free (workload);        if (finished) {            printf ("Processed: %d tasks/n", total);            break;        }        total++;        //  Do some random work        struct timespec t;        t.tv_sec = 0;        t.tv_nsec = within (100000000) + 1;        nanosleep (&t, NULL);    }    return (NULL);}

OcTree *OcTree::findParent(sceneobj_t *sc) {	OcTree *p=NULL;	int i=4, max=8;		if(sc->userdata)		return (OcTree*)sc->userdata;		if(within(sc)) {		p = this;		if(children[0]) { //we are garaunteed all 8						if(sc->pos[AXIS_UP] < pos[AXIS_UP]) {				i=0;max=OCTREE_MAX_CHILDREN/2;			}							for(;i<max;i++) {				OcTree *q = children[i]->findParent(sc);				if(q) {					p = q;					break;				}			}		}	}		sc->userdata = p;	return p;}

    bool inside(vec3f pos, float fudge)    {        mat3f rot;        //if(ctr == nullptr)        {            btTransform trans;            rigid_body->getMotionState()->getWorldTransform(trans);            btVector3 bpos = trans.getOrigin();            btQuaternion bq = trans.getRotation();            quaternion q = {{bq.x(), bq.y(), bq.z(), bq.w()}};            rot = q.get_rotation_matrix();            vec3f v = {bpos.x(), bpos.y(), bpos.z()};            vec3f rel = pos - v;            return within(b, rot.transp() * rel, fudge);        }        /*rot = ctr->rot_quat.get_rotation_matrix();        vec3f my_pos = xyz_to_vec(ctr->pos);        return within(b, rot.transp() * (pos - my_pos));*/    }

void SuBlock::persist()	{	if (persisted)		return;	if (frame->fn != fn)		except_err("orphaned block!");	// won't need to copy locals if another block persist has already done so	if (within(tls().proc->stack, frame->local))		{		// save locals on heap - only done once per call/frame		Value* old_locals = frame->local;		int n = frame->fn->nlocals * sizeof (Value);		frame->local = (Value*) memcpy(new char[n], frame->local, n);		// update any other active frames pointing to the same locals		// i.e. nested blocks within one parent frame		for (Frame* f = tls().proc->fp; f > tls().proc->frames; --f)			if (f->local == old_locals)				f->local = frame->local;		}	// save frame on heap	frame = (Frame*) memcpy(new Frame, frame, sizeof (Frame));	persisted = true;	}

void TRexGame::AccelerateGame(double delta_v){	double accelerated = game_speed_ + delta_v;	if (within(accelerated, kGameMinSpeed, kGameMaxSpeed))	{		game_speed_ = accelerated;	}}

void main(int argc, string argv[]){  initparam(argv, defv);  if (within(getdparam("val"), getparam("range"), getdparam("fuzz")))    printf("within returns TRUE/n");  else    printf("within returns FALSE/n");}

void nemo_main(){    stream instr, outstr;    string times, ctypei, ctypeo;    real   tsnap;    int i, nbody, bits, mode;    Body *btab = NULL, *bp;    proc transform, trans2;    times = getparam("times");    ctypei = getparam("ctypei");    ctypeo = getparam("ctypeo");    if (streq(ctypei,"cart") && streq(ctypeo,"sph"))        transform = cartesian_spherical;    else if (streq(ctypei,"sph") && streq(ctypeo,"cart"))        transform = spherical_cartesian;    else if (streq(ctypei,"cart") && streq(ctypeo,"cyl"))        transform = cartesian_cylindrical;    else if (streq(ctypei,"cyl") && streq(ctypeo,"cart"))        transform = cylindrical_cartesian;    else        error("Unimplemented ctype i/o : %s -> %s",ctypei,ctypeo);    dprintf(0,"converting from %s to %s/n",ctypei,ctypeo);        instr = stropen(getparam("in"), "r");       outstr = stropen(getparam("out"), "w");    get_history(instr);    put_history(outstr);		    for (;;) {    	get_history(instr);		/* skip over stuff we can forget */        if (!get_tag_ok(instr, SnapShotTag))		break;			/* done with work in loop */        get_snap(instr, &btab, &nbody, &tsnap, &bits);        if ((bits & MassBit) == 0 && (bits & PhaseSpaceBit) == 0) {	    continue;       /* just skip it's probably a diagnostics */        }        if ((bits & TimeBit) == 0)	    tsnap = 0.0;        else if (!streq(times,"all") && !within(tsnap, times, TIMEFUZZ))            continue;        dprintf (1,"Transforming snapshot at time= %f bits=0x%x/n",tsnap,bits);#if 0        Qmass  = MassBit & bits;               Qphase = PhaseSpaceBit & bits;        Qacc   = AccelerationBit & bits;        Qaux   = AuxBit & bits;        Qkey   = KeyBit & bits;#endif        for (bp = btab; bp < btab+nbody; bp++) {            (transform)(Pos(bp),Vel(bp),Acc(bp));        }        put_snap(outstr, &btab, &nbody, &tsnap, &bits);    }}

u16 I2cSoft::waitAck() {	_sda.init(GPIO_Mode_IN_FLOATING);	_scl.set(Bit_SET);	vu16 t;	within(_FLAG_TIMEOUT, _sda.getInput() == Bit_SET);	_scl.set(Bit_RESET);	return t;}

void MLPluginProcessor::setStateFromMIDIProgram (const int idx){	if(within(idx, 0, kMLPluginMIDIPrograms))	{		if(mMIDIProgramFiles[idx].exists())		{			loadStateFromFile(mMIDIProgramFiles[idx]);		}	}}

void testing_$RAND_expand(bool verbose){	if (verbose) {		fprintf( stdout, "/n----- testing_$RAND_expand ----/n/n");	}	// regressions	REQUIRE( within(expand("$RANDOM_INTEGER(-30,30,1)"), -30, 30) );	REQUIRE( within(expand("$RANDOM_INTEGER(2,2,1)"), 2, 2) );	REQUIRE( within(expand("$RANDOM_INTEGER(-10,0,2)"), -10, 0) );	REQUIRE( within(expand("$RANDOM_INTEGER(-1000,-99,3)"), -1000, -99) );	REQUIRE( within(expand("$RANDOM_INTEGER(3,9,3)"), 3, 9) );	REQUIRE( within(expand("$RANDOM_INTEGER(0,9,3)"), 0, 9) );	REQUIRE( within(expand("$RANDOM_CHOICE(1,2,2,1)"), 1, 2) );	REQUIRE( within(expand("$RANDOM_CHOICE(aa,bb,cc)"), "aa", "cc") );	REQUIRE( within(expand("$RANDOM_CHOICE(List6c)"), "aa", "ff") );	REQUIRE( within(expand_as("MASTER", "$RANDOM_CHOICE(List6c)"), "JMK", "ZKM") );	REQUIRE( expand("$RANDOM_CHOICE(1)") == "1" );	REQUIRE( expand("$RANDOM_CHOICE(aa bb cc)") == "aa bb cc" );}

int main(int argc, char *argv[]){    int opt;    printf("multiply 1 by 2 a number of times/n");    for(opt=0; opt<=1; ++opt)    {        printf(" (optimize:%d) result=%d/n", opt, multiply(opt, 24));    }    printf("check if abstract value N within threshold T/n");    for(opt=0; opt<=1; ++opt)    {        printf(" (optimize:%d) result=%d/n", opt, within(opt, -3, 3));        printf(" (optimize:%d) result=%d/n", opt, within(opt, 3, 3));        printf(" (optimize:%d) result=%d/n", opt, within(opt, -4, 3));        printf(" (optimize:%d) result=%d/n", opt, within(opt, 4, 3));    }    return 0;}

    static inline    void apply(Turns& turns, Clusters const& clusters,            Geometry0 const& geometry0, Geometry1 const& geometry1)    {        discard_clusters(turns, clusters, geometry0, geometry1);        typedef typename boost::range_value<Turns>::type turn_type;        for (typename boost::range_iterator<Turns>::type                it = boost::begin(turns);             it != boost::end(turns);             ++it)        {            turn_type& turn = *it;            if (turn.discarded || ! is_self_turn<overlay_intersection>(turn))            {                continue;            }            segment_identifier const& id0 = turn.operations[0].seg_id;            segment_identifier const& id1 = turn.operations[1].seg_id;            if (id0.multi_index != id1.multi_index                    || (id0.ring_index == -1 && id1.ring_index == -1)                    || (id0.ring_index >= 0 && id1.ring_index >= 0))            {                // Not an ii ring (int/ext) on same ring                continue;            }            if (turn.is_clustered() && turn.has_colocated_both)            {                // Don't delete a self-ii-turn colocated with another ii-turn                // (for example #case_recursive_boxes_70)                // But for some cases (#case_58_iet) they should be deleted,                // there are many self-turns there and also blocked turns there                if (! any_blocked(turn.cluster_id, turns, clusters))                {                    continue;                }            }            // It is a ii self-turn            // Check if it is within the other geometry            // If not, it can be ignored            if (! within(turn, geometry0, geometry1))            {                // It is not within another geometry, discard the turn                turn.discarded = true;            }        }    }