/** * Tries to create a cargo subsidy with a town as source. * @return True iff the subsidy was created. */ bool FindSubsidyTownCargoRoute() { if (!Subsidy::CanAllocateItem()) return false; SourceType src_type = ST_TOWN; /* Select a random town. */ const Town *src_town = Town::GetRandom(); uint32 town_cargo_produced = src_town->cargo_produced; /* Passenger subsidies are not handled here. */ ClrBit(town_cargo_produced, CT_PASSENGERS); /* No cargo produced at all? */ if (town_cargo_produced == 0) return false; /* Choose a random cargo that is produced in the town. */ uint8 cargo_number = RandomRange(CountBits(town_cargo_produced)); CargoID cid; FOR_EACH_SET_CARGO_ID(cid, town_cargo_produced) { if (cargo_number == 0) break; cargo_number--; } /* Avoid using invalid NewGRF cargoes. */ if (!CargoSpec::Get(cid)->IsValid()) return false; /* Quit if the percentage transported is large enough. */ if (src_town->GetPercentTransported(cid) > SUBSIDY_MAX_PCT_TRANSPORTED) return false; SourceID src = src_town->index; return FindSubsidyCargoDestination(cid, src_type, src); }
/** Retrieve a list of bit offsets The \p bit_offsets vector is first cleared. \param[out] bit_offsets A list of bit offsets, in ascending order */ void OBBitVec::ToVecInt(std::vector<int> & bit_offsets) const { bit_offsets.clear(); bit_offsets.reserve(CountBits()); for (int i = NextBit(-1);i != -1;i = NextBit(i)) bit_offsets.push_back(i); }
void ReceiveBasePortalVis( uint64 iWorkUnit, MessageBuffer *pBuf, int iWorker ) { portal_t * p = &portals[iWorkUnit]; if ( p->portalflood != 0 || p->portalfront != 0 || p->portalvis != 0) { Msg("Duplicate portal %llu\n", iWorkUnit); } if ( pBuf->getLen() - pBuf->getOffset() != portalbytes*2 ) Error( "Invalid packet in ReceiveBasePortalVis." ); // // allocate memory for bitwise vis solutions for this portal // p->portalfront = (byte*)malloc (portalbytes); pBuf->read( p->portalfront, portalbytes ); p->portalflood = (byte*)malloc (portalbytes); pBuf->read( p->portalflood, portalbytes ); p->portalvis = (byte*)malloc (portalbytes); memset (p->portalvis, 0, portalbytes); p->nummightsee = CountBits( p->portalflood, g_numportals*2 ); }
/* ============== LeafVectorFromPortalVector ============== */ int LeafVectorFromPortalVector(byte * portalbits, byte * leafbits) { int i, j, leafnum; vportal_t *p; int c_leafs; for(i = 0; i < numportals * 2; i++) { if(portalbits[i >> 3] & (1 << (i & 7))) { p = portals + i; leafbits[p->leaf >> 3] |= (1 << (p->leaf & 7)); } } for(j = 0; j < portalclusters; j++) { leafnum = j; while(leafs[leafnum].merged >= 0) leafnum = leafs[leafnum].merged; //if the merged leaf is visible then the original leaf is visible if(leafbits[leafnum >> 3] & (1 << (leafnum & 7))) { leafbits[j >> 3] |= (1 << (j & 7)); } } c_leafs = CountBits(leafbits, portalclusters); return c_leafs; }
int main(){ printf("Enter the value for n : "); int n, count; scanf("%d", &n); count = CountBits(n); printf("Bit Count: %d", count); return 0; }
int GetClassLevel(struct char_data *ch, int iClass) { if (IS_SET(ch->player.iClass, iClass)) { return(GET_LEVEL(ch, CountBits(iClass)-1)); } return(0); }
/* static */ bool ScriptGoal::Question(uint16 uniqueid, ScriptCompany::CompanyID company, Text *question, QuestionType type, int buttons) { CCountedPtr<Text> counter(question); EnforcePrecondition(false, ScriptObject::GetCompany() == OWNER_DEITY); EnforcePrecondition(false, question != NULL); const char *text = question->GetEncodedText(); EnforcePreconditionEncodedText(false, text); EnforcePrecondition(false, company == ScriptCompany::COMPANY_INVALID || ScriptCompany::ResolveCompanyID(company) != ScriptCompany::COMPANY_INVALID); EnforcePrecondition(false, CountBits(buttons) >= 1 && CountBits(buttons) <= 3); EnforcePrecondition(false, buttons < (1 << ::GOAL_QUESTION_BUTTON_COUNT)); EnforcePrecondition(false, type < ::GOAL_QUESTION_TYPE_COUNT); uint8 c = company; if (company == ScriptCompany::COMPANY_INVALID) c = INVALID_COMPANY; return ScriptObject::DoCommand(0, uniqueid | (c << 16) | (type << 24), buttons, CMD_GOAL_QUESTION, text); }
int main(){ int num=9; printf("\nNo of set bits : %d",CountBits(num)); return 0; }
bool CWAVFile::ProcessWAVEFORMATEX() { if (!m_fmtdata || m_fmtsize < sizeof(WAVEFORMATEX)) { return false; } WAVEFORMATEX* wfe = (WAVEFORMATEX*)m_fmtdata; if (wfe->wFormatTag == WAVE_FORMAT_EXTENSIBLE && m_fmtsize >= sizeof(WAVEFORMATEXTENSIBLE)) { WAVEFORMATEXTENSIBLE* wfex = (WAVEFORMATEXTENSIBLE*)m_fmtdata; m_subtype = wfex->SubFormat; if (CountBits(wfex->dwChannelMask) != wfex->Format.nChannels) { // fix incorrect dwChannelMask wfex->dwChannelMask = GetDefChannelMask(wfex->Format.nChannels); } } else { m_subtype = FOURCCMap(wfe->wFormatTag); } if (wfe->wFormatTag == WAVE_FORMAT_PCM && (wfe->nChannels > 2 || wfe->wBitsPerSample != 8 && wfe->wBitsPerSample != 16) || wfe->wFormatTag == WAVE_FORMAT_IEEE_FLOAT && wfe->nChannels > 2) { // convert incorrect WAVEFORMATEX to WAVEFORMATEXTENSIBLE WAVEFORMATEXTENSIBLE* wfex = DNew WAVEFORMATEXTENSIBLE; wfex->Format.wFormatTag = WAVE_FORMAT_EXTENSIBLE; wfex->Format.nChannels = wfe->nChannels; wfex->Format.nSamplesPerSec = wfe->nSamplesPerSec; wfex->Format.wBitsPerSample = (wfe->wBitsPerSample + 7) & ~7; wfex->Format.nBlockAlign = wfex->Format.nChannels * wfex->Format.wBitsPerSample / 8; wfex->Format.nAvgBytesPerSec = wfex->Format.nSamplesPerSec * wfex->Format.nBlockAlign; wfex->Format.cbSize = 22; wfex->Samples.wValidBitsPerSample = wfe->wBitsPerSample; wfex->dwChannelMask = GetDefChannelMask(wfe->nChannels); wfex->SubFormat = m_subtype; delete[] m_fmtdata; m_fmtdata = (BYTE*)wfex; m_fmtsize = sizeof(WAVEFORMATEXTENSIBLE); wfe = (WAVEFORMATEX*)m_fmtdata; } m_samplerate = wfe->nSamplesPerSec; m_bitdepth = wfe->wBitsPerSample; m_channels = wfe->nChannels; if (wfe->wFormatTag == WAVE_FORMAT_EXTENSIBLE && m_fmtsize >= sizeof(WAVEFORMATEXTENSIBLE)) { m_layout = ((WAVEFORMATEXTENSIBLE*)m_fmtdata)->dwChannelMask; } else { m_layout = GetDefChannelMask(wfe->nChannels); } m_nAvgBytesPerSec = wfe->nAvgBytesPerSec; m_nBlockAlign = wfe->nBlockAlign; m_blocksize = max(m_nBlockAlign, m_nAvgBytesPerSec / 16); // 62.5 ms m_blocksize -= m_blocksize % m_nBlockAlign; return true; }
int CTreeHandler::CheckMode( int srcmode ) { // import か exportは必ず、どちらか1個だけセット int chkmask; int chkcnt; chkmask = TMODE_IMPORT | TMODE_EXPORT; chkcnt = CountBits( srcmode & chkmask ); if( chkcnt != 1 ) return 1; // once または level_once または mult は必ず、どちらか1個だけセット chkmask = TMODE_ONCE | TMODE_LEVEL_ONCE | TMODE_MULT; chkcnt = CountBits( srcmode & chkmask ); if( chkcnt != 1 ) return 1; return 0; // 0 が正常なの おほほほほ }
/** * Ask a goal related question * @param tile unused. * @param flags type of operation * @param p1 various bitstuffed elements * - p1 = (bit 0 - 15) - Unique ID to use for this question. * - p1 = (bit 16 - 23) - Company for which this question is. * @param p2 Buttons of the question. * @param text Text of the question. * @return the cost of this operation or an error */ CommandCost CmdGoalQuestion(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text) { uint16 uniqueid = (GoalType)GB(p1, 0, 16); CompanyID company = (CompanyID)GB(p1, 16, 8); byte type = GB(p1, 24, 8); if (_current_company != OWNER_DEITY) return CMD_ERROR; if (StrEmpty(text)) return CMD_ERROR; if (company != INVALID_COMPANY && !Company::IsValidID(company)) return CMD_ERROR; if (CountBits(p2) < 1 || CountBits(p2) > 3) return CMD_ERROR; if (p2 >= (1 << GOAL_QUESTION_BUTTON_COUNT)) return CMD_ERROR; if (type >= GOAL_QUESTION_TYPE_COUNT) return CMD_ERROR; if (flags & DC_EXEC) { if ((company != INVALID_COMPANY && company == _local_company) || (company == INVALID_COMPANY && Company::IsValidID(_local_company))) ShowGoalQuestion(uniqueid, type, p2, text); } return CommandCost(); }
//================================================================================================= bool Quest_Orcs::HandleLocationEvent(LocationEventHandler::Event event) { if(event == LocationEventHandler::CLEARED && prog == Progress::Started) { levels_cleared |= (1 << L.dungeon_level); if(CountBits(levels_cleared) == dungeon_levels) SetProgress(Progress::ClearedLocation); } return false; }
/** * Ask a goal related question * @param tile unused. * @param flags type of operation * @param p1 various bitstuffed elements * - p1 = (bit 0 - 15) - Unique ID to use for this question. * - p1 = (bit 16 - 23) - Company or client for which this question is. * - p1 = (bit 24 - 25) - Question type. * - p1 = (bit 31) - Question target: 0 - company, 1 - client. * @param p2 Buttons of the question. * @param text Text of the question. * @return the cost of this operation or an error */ CommandCost CmdGoalQuestion(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text) { uint16 uniqueid = (GoalType)GB(p1, 0, 16); CompanyID company = (CompanyID)GB(p1, 16, 8); #ifdef ENABLE_NETWORK ClientIndex client = (ClientIndex)GB(p1, 16, 8); #endif byte type = GB(p1, 24, 2); bool is_client = HasBit(p1, 31); if (_current_company != OWNER_DEITY) return CMD_ERROR; if (StrEmpty(text)) return CMD_ERROR; if (is_client) { #ifdef ENABLE_NETWORK if (!NetworkClientInfo::IsValidID(client)) return CMD_ERROR; #else return CMD_ERROR; #endif } else { if (company != INVALID_COMPANY && !Company::IsValidID(company)) return CMD_ERROR; } if (CountBits(p2) < 1 || CountBits(p2) > 3) return CMD_ERROR; if (p2 >= (1 << GOAL_QUESTION_BUTTON_COUNT)) return CMD_ERROR; if (type >= GOAL_QUESTION_TYPE_COUNT) return CMD_ERROR; if (flags & DC_EXEC) { if (is_client) { #ifdef ENABLE_NETWORK if (NetworkClientInfo::Get(client)->client_id != _network_own_client_id) return CommandCost(); #endif } else { if (company == INVALID_COMPANY && !Company::IsValidID(_local_company)) return CommandCost(); if (company != INVALID_COMPANY && company != _local_company) return CommandCost(); } ShowGoalQuestion(uniqueid, type, p2, text); } return CommandCost(); }
uint_32 emitInfo( FILE *fp ) { uint_32 total; uint u; fprintf( fp,"\nstatic const struct abbrev_info {\n" " abbrev_code valid_mask;\n" " uint_16 bit_index;\n" " uint_8 data_offset;\n" " uint_8 data_len;\n" " uint_16 tag;\n" "} abbrevInfo[] = {\n" ); total = 1; u = 0; for(;;) { fprintf( fp, "/*%-32s*/{ 0x%08lx, 0x%04x, 0x%02x, 0x%02x, 0x%02x }", abbrevInfo[u].name, (unsigned long)abbrevInfo[u].valid_mask, (unsigned)total, (unsigned)abbrevExtra[u].data_offset, (unsigned)abbrevExtra[u].data_len, abbrevInfo[u].tag ); if( abbrevExtra[u].data_offset > 0xff ) { /* just change the uint_8 data_offset in the above structure */ fprintf( stderr, "data_offset too large, must increase size of data_offset field\n" ); exit( 1 ); } if( abbrevExtra[u].data_len > 0xff ) { /* just change the uint_8 data_len in the above structure */ fprintf( stderr, "data_len too large, must increase size of data_len field\n" ); exit( 1 ); } if( abbrevInfo[u].tag > 0xffff ) { /* just change the uint_16 tag in the above structure */ fprintf( stderr, "Tag too large, must increase size of tag field\n" ); exit( 1 ); } total += 1 << CountBits( abbrevInfo[u].valid_mask & ~AB_ALWAYS ); ++u; if( u == AB_MAX ) break; if( total > 0xffff ) { /* just change the uint_16 bit_index in the above structure */ fprintf( stderr, "Index too large, must increase size of index field\n" ); exit( 1 ); } fprintf( fp, ",\n" ); } fprintf( fp, "\n};\n" ); return( total ); }
/* * @brief */ static size_t LeafVectorFromPortalVector(byte *portalbits, byte *leafbits) { uint32_t i; memset(leafbits, 0, map_vis.leaf_bytes); for (i = 0; i < map_vis.num_portals * 2; i++) { if (portalbits[i >> 3] & (1 << (i & 7))) { const portal_t *p = map_vis.portals + i; leafbits[p->leaf >> 3] |= (1 << (p->leaf & 7)); } } return CountBits(leafbits, map_vis.portal_clusters); }
/** * private method used to see if a hopping between state a and b is * possible and with which sign. Only for 1D Hubbard. * @param ket the ket to use * @returns matrix element of the hopping term between the ket and the bra. You still * have to multiply this with the hopping strength J */ double MomHamiltonian::hopping(myint ket) const { double result = 0; while(ket) { // select rightmost one myint hop = ket & (~ket + 1); // set it to zero in ket ket ^= hop; result += -2* cos(2.0*M_PI/L * CountBits(hop-1)); } return result; }
/* ============== LeafVectorFromPortalVector ============== */ int LeafVectorFromPortalVector( byte *portalbits, byte *leafbits ){ int i; portal_t *p; int c_leafs; memset( leafbits, 0, leafbytes ); for ( i = 0 ; i < numportals * 2 ; i++ ) { if ( portalbits[i >> 3] & ( 1 << ( i & 7 ) ) ) { p = portals + i; leafbits[p->leaf >> 3] |= ( 1 << ( p->leaf & 7 ) ); } } c_leafs = CountBits( leafbits, portalclusters ); return c_leafs; }
/* ============== LeafVectorFromPortalVector ============== */ int LeafVectorFromPortalVector (byte *portalbits, byte *leafbits) { int i; portal_t *p; int c_leafs; memset (leafbits, 0, leafbytes); for (i=0 ; i<g_numportals*2 ; i++) { if ( CheckBit( portalbits, i ) ) { p = portals+i; SetBit( leafbits, p->leaf ); } } c_leafs = CountBits (leafbits, portalclusters); return c_leafs; }
static char *PrintConstant(char *s, uint32 n, uint flags) { char *q; char buf[40]; if (flags & PF_EA && (q = get_name(BADADDR, n, charbuf, sizeof(charbuf))) != NULL) { // check if we don't need to write the type explicitly if (flags & PF_TYPEMASK && DontNeedExplicitType( GetTypeOf(n),(flags & PF_TYPEMASK) - 1, !!(flags & PF_EA_STORE))) { flags &= ~PF_TYPEMASK; } } else { q = buf; if (flags & PF_NEGCONST) { uint32 tmp_n = (~n) & _typemask_size_masks[flags & PF_TYPEMASK]; if (CountBits(tmp_n) <= 2) { *q++ = '~'; n = tmp_n; } } if (n < 10) { sprintf(q, "%d", n); } else { sprintf(q, "0x%X", n); } q = buf; } if (flags & PF_EA && flags & PF_TYPEMASK) { s = strcpy_e(s, TypeNames[(flags & PF_TYPEMASK) - 1]); } s = strcpy_e(s, q); if (flags & PF_EA && flags & PF_TYPEMASK ) { s = strcpy_e(s, ">"); } return s; }
void GhostManager::createGhost(SimNetObject *obj) { AssertWarn(refFreeList, "scoping over 1024 ghosts!"); if (!refFreeList) return; GhostInfo *giptr = refFreeList; refFreeList = refFreeList->nextRef; giptr->flags = GhostInfo::NotYetGhosted | GhostInfo::InScope; if(obj->netFlags.test(SimNetObject::ScopeAlways)) giptr->flags |= GhostInfo::ScopeAlways; giptr->obj = obj; giptr->updateMask = 0xFFFFFFFF; giptr->updateChain = NULL; giptr->updateSkipCount = 0; giptr->prevRef = NULL; giptr->nextRef = ghostList; if(ghostList) ghostList->prevRef = giptr; ghostList = giptr; GhostRef gr; gr.ghostManager = this; gr.ghostInfo = giptr; obj->ghosts.push_back(gr); int giSize = CountBits(giptr->ghostIndex); if(giSize > sendIdSize) sendIdSize = giSize; }
//----------------------------------------- // // Run BasePortalVis across all available processing nodes // Then collect and redistribute the results. // void RunMPIBasePortalVis() { int i; Msg( "\n\nportalbytes: %d\nNum Work Units: %d\nTotal data size: %d\n", portalbytes, g_numportals*2, portalbytes*g_numportals*2 ); Msg("%-20s ", "BasePortalVis:"); if ( g_bMPIMaster ) StartPacifier(""); VMPI_SetCurrentStage( "RunMPIBasePortalVis" ); // Note: we're aiming for about 1500 portals in a map, so about 3000 work units. g_CPUTime.Init(); double elapsed = DistributeWork( g_numportals * 2, // # work units VMPI_DISTRIBUTEWORK_PACKETID, // packet ID ProcessBasePortalVis, // Worker function to process work units ReceiveBasePortalVis // Master function to receive work results ); if ( g_bMPIMaster ) { EndPacifier( false ); Msg( " (%d)\n", (int)elapsed ); } // // Distribute the results to all the workers. // if ( g_bMPIMaster ) { if ( !fastvis ) { VMPI_SetCurrentStage( "SendPortalResults" ); // Store all the portal results in a temp file and multicast that to the workers. CUtlVector<char> allPortalData; allPortalData.SetSize( g_numportals * 2 * portalbytes * 2 ); char *pOut = allPortalData.Base(); for ( i=0; i < g_numportals * 2; i++) { portal_t *p = &portals[i]; memcpy( pOut, p->portalfront, portalbytes ); pOut += portalbytes; memcpy( pOut, p->portalflood, portalbytes ); pOut += portalbytes; } const char *pVirtualFilename = "--portal-results--"; VMPI_FileSystem_CreateVirtualFile( pVirtualFilename, allPortalData.Base(), allPortalData.Count() ); char cPacketID[2] = { VMPI_VVIS_PACKET_ID, VMPI_BASEPORTALVIS_RESULTS }; VMPI_Send2Chunks( cPacketID, sizeof( cPacketID ), pVirtualFilename, strlen( pVirtualFilename ) + 1, VMPI_PERSISTENT ); } } else { VMPI_SetCurrentStage( "RecvPortalResults" ); // Wait until we've received the filename from the master. while ( g_BasePortalVisResultsFilename.Count() == 0 ) { VMPI_DispatchNextMessage(); } // Open FileHandle_t fp = g_pFileSystem->Open( g_BasePortalVisResultsFilename.Base(), "rb", VMPI_VIRTUAL_FILES_PATH_ID ); if ( !fp ) Error( "Can't open '%s' to read portal info.", g_BasePortalVisResultsFilename.Base() ); for ( i=0; i < g_numportals * 2; i++) { portal_t *p = &portals[i]; p->portalfront = (byte*)malloc (portalbytes); g_pFileSystem->Read( p->portalfront, portalbytes, fp ); p->portalflood = (byte*)malloc (portalbytes); g_pFileSystem->Read( p->portalflood, portalbytes, fp ); p->portalvis = (byte*)malloc (portalbytes); memset (p->portalvis, 0, portalbytes); p->nummightsee = CountBits (p->portalflood, g_numportals*2); } g_pFileSystem->Close( fp ); } if ( !g_bMPIMaster ) { if ( g_iVMPIVerboseLevel >= 1 ) Msg( "\n%% worker CPU utilization during BasePortalVis: %.1f\n", (g_CPUTime.GetSeconds() * 100.0f / elapsed) / numthreads ); } }
static uint32 RailTypeGetRandomBits(const ResolverObject *object) { TileIndex tile = object->u.routes.tile; uint tmp = CountBits(tile + (TileX(tile) + TileY(tile)) * TILE_SIZE); return GB(tmp, 0, 2); }
dword C_dir::GetNumDrives(){ return CountBits(GetDriveMask()); }
dword C_dir::GetNumDrives(){ return CountBits(win::GetLogicalDrives()); }
static void DoCountBits( a_bit_set set ) /**************************************/ { bitCount += CountBits( set ); }
void SssBang( tPink* me) { tTaus88DataPtr tausData = me->tausData; unsigned short c = me->counter++; // We rely on the increment wrapping // every 2^16 iterations (16-bit integer // representation). unsigned long* curDie = me->dice; unsigned long sum = me->sum; int i; if (c == 0) { // First time through... or wrap around! i = kArraySize; sum = 0; do { sum += *curDie++ = Taus88(tausData) & kDiceBits; } while (--i > 0); } else { unsigned long bitCount = CountBits(c); unsigned bit = 0x01; if (bitCount == 1) { // Just update one die while ((bit & c) == 0) { bit += bit; // Marginally faster than bit <<= 1 curDie += 1; } sum -= *curDie; sum += *curDie = Taus88(tausData) & kDiceBits; } else if (bitCount < kArraySize / 2) { // Still faster to calculate differences i = kArraySize; do { if (bit & c) { sum -= *curDie; sum += *curDie = Taus88(tausData) & kDiceBits; } bit += bit; // Marginally faster than bit <<= 1 curDie += 1; } while (--i > 0); } else { // Faster just to update and recalculate sum from scratch i = kArraySize; sum = 0; do { if (bit & c) *curDie = Taus88(tausData) & kDiceBits; sum += *curDie++; bit += bit; } while (--i > 0); } } me->sum = sum; if (me->nn != 0) { // Adjust output value for NN factor sum &= me->nnMask; sum += me->nnOffset; } outlet_float(me->coreObject.o_outlet, ULong2Unit_ZO(sum)); }
int* SssPerform( int* iParams) { enum { paramFuncAddress = 0, paramMe, paramVectorSize, paramOut, paramNextLink }; long vecCounter; tSampleVector outNoise; tPink* me = (tPink*) iParams[paramMe]; unsigned long* firstDie; unsigned long sum, mask, offset; unsigned short counter; // Must be 16-bit value to match "dice" array if (me->coreObject.z_disabled) goto exit; // Copy parameters into registers vecCounter = (long) iParams[paramVectorSize]; outNoise = (tSampleVector) iParams[paramOut]; sum = me->sum; firstDie = me->dice; mask = me->mask; offset = me->offset; counter = me->counter; // Do our stuff do { unsigned long* curDie = firstDie; int bitCount = CountBits(counter); unsigned bit = 0x01; switch (bitCount) { case 0: InitDice(me); sum = me->sum; break; case 1: // Just update one die while ((bit & counter) == 0) { bit *= 2; // Let compiler choose fastest way to do this curDie += 1; } sum -= *curDie; sum += *curDie = Taus88(NULL) / kArraySize; break; default: if (bitCount < kArraySize / 2) { // Still faster to calculate differences int i = kArraySize; do { if (bit & counter) { sum -= *curDie; sum += *curDie = Taus88(NULL) / kArraySize; } bit *= 2; curDie += 1; } while (--i > 0); } else { // Faster just to update and recalculate sum from scratch int i = kArraySize; sum = 0; do { if (bit & counter) *curDie = Taus88(NULL) / kArraySize; sum += *curDie++; bit *= 2; } while (--i > 0); } break; } *outNoise++ = ULong2Signal((sum & mask) + offset); counter++; } while (--vecCounter > 0); me->sum = sum; me->counter = counter; exit: return iParams + paramNextLink; }
static int CheckExtend(struct Position *p) { int kp = p->kingSq[p->turn]; BitBoard att; att = p->atkFr[kp] & p->mask[OPP(p->turn)][0]; if (CountBits(att) > 1) { /* * double check, the king has to move * count no. of flight squares, if only one, extend deeper * */ BitBoard ff; int i; int cnt = 0; DblExt++; ff = KingEPM[kp] & ~p->mask[p->turn][0]; att &= p->slidingPieces; while (att) { i=FindSetBit(att); ClrBit(att, i); ff &= ~Ray[i][kp]; } while (ff) { i=FindSetBit(ff); ClrBit(ff, i); if (!(p->atkFr[i] & p->mask[OPP(p->turn)][0])) cnt++; if (cnt > 1) return ExtendDoubleCheck; } } else { BitBoard ff; BitBoard def; BitBoard tmp; int atp = FindSetBit(att); int cnt = 0; int i; int nd = 0; /* discovered check */ if (atp != M_TO((p->actLog-1)->gl_Move)) { DiscExt++; nd = ExtendDiscoveredCheck; } ff = KingEPM[kp] & ~p->mask[p->turn][0]; i = FindSetBit(att); if (Sliding[TYPE(p->piece[i])]) ff &= ~Ray[i][kp]; /* check for king flight squares */ while (ff) { i=FindSetBit(ff); ClrBit(ff, i); if (!(p->atkFr[i] & p->mask[OPP(p->turn)][0])) cnt++; if (cnt > 1) return nd; } /* Find all non-pinned defenders */ def = p->mask[p->turn][0] & ~p->mask[p->turn][King]; tmp = (p->mask[OPP(p->turn)][Bishop] | p->mask[OPP(p->turn)][Queen]) & BishopEPM[kp]; while (tmp) { BitBoard tmp2; i=FindSetBit(tmp); ClrBit(tmp, i); tmp2= InterPath[i][kp]; if (tmp2 && !(p->mask[OPP(p->turn)][0] & tmp2)) { tmp2 &= p->mask[p->turn][0]; if (CountBits(tmp2) == 1) { ClrBit(def, FindSetBit(tmp2)); } } } tmp = (p->mask[OPP(p->turn)][Rook] | p->mask[OPP(p->turn)][Queen]) & RookEPM[kp]; while (tmp) { BitBoard tmp2; i=FindSetBit(tmp); ClrBit(tmp, i); tmp2= InterPath[i][kp]; if (tmp2 && !(p->mask[OPP(p->turn)][0] & tmp2)) { tmp2 &= p->mask[p->turn][0]; if (CountBits(tmp2) == 1) { ClrBit(def, FindSetBit(tmp2)); } } } /* All non-pinned defenders are in 'def' */ tmp = p->atkFr[atp] & def; cnt += CountBits(tmp); if (cnt > 1) return nd; /* if possible, try an interposition */ if (Sliding[TYPE(p->piece[atp])]) { tmp = InterPath[atp][kp]; while (tmp) { BitBoard tmp2; i=FindSetBit(tmp); ClrBit(tmp, i); if ((tmp2 = p->atkFr[i] & def)) { cnt+=CountBits(tmp2); } if (p->turn == White && (i-8) > 0 && TstBit(p->mask[White][Pawn], i-8) && TstBit(def, i-8)) cnt++; if (p->turn == Black && (i+8) < 64 && TstBit(p->mask[Black][Pawn], i+8) && TstBit(def, i+8)) cnt++; if (cnt > 1) return nd; } } } /* If we get here, we have only one legal move. */ SingExt++; return ExtendSingularReply; }
/* virtual */ uint32 RailTypeScopeResolver::GetRandomBits() const { uint tmp = CountBits(this->tile + (TileX(this->tile) + TileY(this->tile)) * TILE_SIZE); return GB(tmp, 0, 2); }
/** * Returns the number of valuators set in the given mask. */ int valuator_mask_num_valuators(const ValuatorMask *mask) { return CountBits(mask->mask, min(mask->last_bit + 1, MAX_VALUATORS)); }