Exemplo n.º 1
0
void setBit(int j) {
   seg* segNum =  whichseg(j);
   int rownum = whichint(j);
   int posinrow = whichbit(j);
   
   seg *p = segNum;
   unsigned int flag = 1;
   flag = flag << posinrow;
   p->bits[rownum] = p->bits[rownum] | flag;
}
Exemplo n.º 2
0
int testBitIs0( int j ) {

   seg* segNum =  whichseg(j);
   int rownum = whichint(j);
   int posinrow = whichbit(j);

 
   int a = 0;
   seg *p = segNum;
   unsigned int flag = 1;
   flag = flag << posinrow;
   int r = p->bits[rownum] & flag; 

   if ( r == 0 )
      return 1;        
   else
      return 0;
}
Exemplo n.º 3
0
int   testbit (int n, seg* head){ 

	 int q = (n-3)/2;

	 seg* thisseg = whichseg(q, head);

	 int thisint = whichint(q);

	 int thisbit = whichbit(q);

	if(thisseg->bits[thisint] & 1 << thisbit)

		return 1;

	else

		return 0;

		}
Exemplo n.º 4
0
void  setbit (int n, seg* head){

	int q = (n-3)/2;

	seg* thisseg = whichseg(q, head);

	int thisint = whichint(q);

	int thisbit = whichbit(q);

	

	thisseg->bits[thisint] |= 1 << thisbit;

	

	

	} 
Exemplo n.º 5
0
void goldbach(int n){
// finds the seg, int and bit for 3 and k-3 and passes them to methods that increment up and down in 2 different methods
int numCount = 0;
int k = 3;
int ktwo = n-3;
int goldCount = 0;
int targetNum1 = 0;
int targetNum2 = 0;
///////seg int and bit for 3
seg* segNum2 = whichseg(k);
int kintone = whichint(k);
int bit1 = whichbit(k);
///////seg in and bit for k-3
seg* segNum3 = whichseg(ktwo);
int kinttwo = whichint(ktwo);
int bit2 = whichbit(ktwo);

while (k <= n/2){
		
	if(checkLower(segNum2, kintone, bit1) && checkHigher(segNum3, kinttwo, bit2) == 1){
		goldCount += 1;
		targetNum1 = k;
		targetNum2 = ktwo;
		}

	//printf("%d %d\n", k, ktwo);

	//////////////////////////////////LOWER END LOGIC
	if(bit1 != 31){
		bit1 +=1;}
		
	else{
	bit1 = 0;
	kintone += 1;}

	if(kintone > 255 && segNum2->next !=NULL){
	kintone = 0;
	segNum2 = segNum2->next;}
	/////////////////////////////////////////////////
	//////////////////////////////////UPPER END LOGIC
	if(bit2 != 0){
		bit2 -=1;}

	else{
	bit2 = 31;
	kinttwo -= 1;}	
	
   	if( kinttwo < 0 && segNum3->prev != NULL){
	kinttwo = 255;
	segNum3 = segNum3->prev;
	}	
	/////////////////////////////////////////////////


	k += 2;
	ktwo -=2;

}
printf("\nThe last Goldbach decomposition is: %d + %d \n",  targetNum1, targetNum2 );
printf("The amount of decompositions is: %d \n", goldCount);	
	

}
Exemplo n.º 6
0
void main(int argc, char *argv[]) {

	seg *head,*pt;
	int	 i;
	int howmany, upto;

	//goldbach sample from class only worked if arg was sent in with the ./goldbach
	if (argc == 2) sscanf(argv[1],"%d",&howmany);
		else return;
	upto = howmany;
	howmany = ((howmany/2) +BITSPERSEG -1)/BITSPERSEG;

	head = (  seg * ) malloc(sizeof(seg));
	pt=head;
	
	//link the segments created
	for (i=1;i<howmany;i++) {
		pt->next = (  seg *) malloc(sizeof (seg)); 
		pt->next->prev = pt;
		pt=pt->next;	
	}
	//printf("Done allocating %d nodes\n",i);
	int j;
	pt=head;
	//clear int's at a time for each segment
	for (i=1;i<=howmany;i++) {
		for(j=0;j<255;j++) {
		pt->bits[j] = 0;
		}
	pt=pt->next;
	//printf("Done clearing node %d \n",i);
	}

	//find the primes
printf("Calculating odd primes up to %d...\n",upto);
	//sqrt() wasnt working so used i^2
	
	for(i = 3 ; (i*i)<=upto ; i+=2) {
		seg* myPT = whichseg(i,head);
		int myInt = whichint(i);
		int myBit = whichbit(i);
	//after or'ing with the bit pos set to one, if its unchanged that means the number was turned on 
		if((myPT->bits[myInt]|(1<<myBit)) == myPT->bits[myInt]) {
			//the number isnt prime
			continue;
		} else {
			//we have a prime so remove its multiples!!!
			int j;
			for( j = i+i; j<=upto; j+=i) {
				if((j%2)!=0) {
					seg* nonprimePT = whichseg(j,head);
					int nonprimeInt = whichint(j);
					int nonprimeBit = whichbit(j);	
					nonprimePT->bits[nonprimeInt] = nonprimePT->bits[nonprimeInt]|(1<<nonprimeBit);	
				}
			}
		}
	}

	//count the primes
	int countPrimes =0;
	pt=head;
	int finalInt = whichint(upto);
	int finalBit = whichbit(upto);
	int segment =1;
	int num = 3;
	for(segment=1; segment<=howmany; segment++) {
		for(i = 0 ; i<=255 ; i++) {
			for(j = 0 ; j<32;j++) {
				if (((pt->bits[i]|(1<<j))) == pt->bits[i]) {
					//printf(" number not prime: %d: data:i- %d and j- %d \n", num,i,j);
					num+=2;
					continue;
				} else {
					if(num>upto) {
					//done counting
					break;
					} else {
					//found a prime!
					countPrimes++;
					}
				}
				num+=2;
			}
		}
	pt= pt->next;
	}
	printf("The number of odd primes less than or equal to %d is:  %d \n",upto,countPrimes);
	
//now from prime numbers calc the possible pair sums
	printf("Enter Even Numbers >5 for Goldbach Tests\n");
	int even;
	scanf("%d",&even);
	int lasteven = 0;
	while(even) {
		int sumCounter = 0;
		int lasti = 0;
		//when a non-int was entered, my program would freakout.
		if(even == lasteven) {break;}
		//end on EOF
		if(even == EOF) { break;}
		//must be even number and greater than 5 and less than that to which i calc primes for
		if(even >= 6 & even <= upto & even%2==0)	{
			int lowerNum = 3;
			seg* lowerPT = whichseg(lowerNum,head);
			int lowerInt = whichint(lowerNum);
			int lowerBit = whichbit(lowerNum);
			
			int higherNum = even-3;
			seg* higherPT = whichseg(higherNum,head);
			int higherInt = whichint(higherNum);
			int higherBit = whichbit(higherNum);
			//while statement
			while(lowerNum <= higherNum) {
			if((lowerPT->bits[lowerInt]|(1<<lowerBit)) == lowerPT->bits[lowerInt]) {
					//lower is not prime
						//rise lowerbit/ lower higherbit
						if(lowerBit==31) {
							lowerBit=0;
							lowerInt++;
							if(lowerInt==256) {
								lowerInt =0;
								lowerPT=lowerPT->next;
							}
							lowerNum+=2;
						} else {
							lowerBit++;
							lowerNum+=2;
						}
						if(higherBit==0) {
							higherBit=31;
							higherInt--;
							if(higherInt==-1) {
								higherInt =255;
								higherPT=higherPT->prev;
							}
							higherNum-=2;
						} else {
							higherNum-=2;
							higherBit--;
						}
						/////// end of bit manipulation
					continue;
				} else {
					if((higherPT->bits[higherInt]|(1<<higherBit)) == higherPT->bits[higherInt]) {
					//higher is not prime
						//rise lowerbit/ lower higherbit
						if(lowerBit==31) {
							lowerBit=0;
							lowerInt++;
							if(lowerInt==256) {
								lowerInt =0;
								lowerPT=lowerPT->next;
							}
							lowerNum+=2;
						} else {
							lowerBit++;
							lowerNum+=2;
						}
						if(higherBit==0) {
							higherBit=31;
							higherInt--;
							if(higherInt==-1) {
								higherInt =255;
								higherPT=higherPT->prev;
							}
							higherNum-=2;
						} else {
							higherNum-=2;
							higherBit--;
						}
						/////// end of bit manipulation
					continue;
					} else {
						sumCounter++;
						lasti = lowerNum;
						//printf("solution %d: lowerNum- %d, higherNum %d \n",sumCounter,lowerNum, higherNum);
						//rise lowerbit /lower higherbit
						if(lowerBit==31) {
							lowerBit=0;
							lowerInt++;
							if(lowerInt==256) {
								lowerInt =0;
								lowerPT=lowerPT->next;
							}
							lowerNum+=2;
						} else {
							lowerBit++;
							lowerNum+=2;
						}
						if(higherBit==0) {
							higherBit=31;
							higherInt--;
							if(higherInt==-1) {
								higherInt =255;
								higherPT=higherPT->prev;
							}
							higherNum-=2;
						} else {
							higherNum-=2;
							higherBit--;
						}
						/////// end of bit manipulation
					}
				}
			
			} //end while
		//calc the middle term using the value
		printf("Largest %d = %d + %d out of %d solutions \n", even ,lasti, even-lasti,sumCounter);
		}
		lasteven = even;
		scanf("%d",&even);
	} // outer while
}
Exemplo n.º 7
0
static void NpcSpellAttack(P_CHAR pc_attacker, P_CHAR pc_defender, unsigned int currenttime, int los)
{
	if (pc_attacker->spatimer<=currenttime)
	{
		int spattacks = numbitsset( pc_attacker->spattack );

		if (!pc_defender->dead && chardist(pc_attacker, pc_defender) < SrvParams->attack_distance() && spattacks > 0 )
		{
			if (los)
			{																	
				int spattackbit=rand()%(spattacks) + 1;
				switch(whichbit(pc_attacker->spattack, spattackbit))
				{
				case 1:
					if (pc_attacker->mn>=4)
					{
						npcaction(pc_attacker, 6);
						Magic->MagicArrow(pc_attacker, pc_defender);
					}
					break; 
				case 2:
					if (pc_attacker->mn>=6)
					{
						npcaction(pc_attacker, 6);
						Magic->HarmSpell(pc_attacker, pc_defender);
					}
					break; //lb
				case 3:
					if (pc_attacker->mn>=4)
					{
						npcaction(pc_attacker, 6);
						Magic->ClumsySpell(pc_attacker, pc_defender);										
					}
					break; //LB
				case 4:
					if (pc_attacker->mn>=4)
					{
						npcaction(pc_attacker, 6);
						Magic->FeebleMindSpell(pc_attacker, pc_defender);
					}
					break; //LB
				case 5:
					if (pc_attacker->mn>=4)
					{
						npcaction(pc_attacker, 6);
						Magic->WeakenSpell(pc_attacker, pc_defender);
					}
					break; //LB
				case 6:
					if (pc_attacker->mn>=9)
					{
						npcaction(pc_attacker, 6);
						Magic->FireballSpell(pc_attacker, pc_defender);
					}
					break; //LB
				case 7:
					if (pc_attacker->mn>=11)
					{
						npcaction(pc_attacker, 6);
						Magic->CurseSpell(pc_attacker, pc_defender);
					}
					break; //LB
				case 8:
					if (pc_attacker->mn>=11)
					{
						npcaction(pc_attacker, 6);
						Magic->LightningSpell(pc_attacker, pc_defender);
					}
					break; //lb
				case 9:
					if (pc_attacker->mn>=14)
					{
						npcaction(pc_attacker, 6);
						Magic->ParalyzeSpell(pc_attacker, pc_defender);
					}
					break; //lb
				case 10:
					if (pc_attacker->mn>=14)
					{
						npcaction(pc_attacker, 6);
						Magic->MindBlastSpell(pc_attacker, pc_defender);
					}
					break;
				case 11:
					if (pc_attacker->mn>=20)
					{
						npcaction(pc_attacker, 6);
						Magic->EnergyBoltSpell(pc_attacker, pc_defender);
					}
					break;
				case 12:
					if (pc_attacker->mn>=20)
					{
						npcaction(pc_attacker, 6);
						Magic->ExplosionSpell(pc_attacker, pc_defender);
					}
					break;
				case 13:
					if (pc_attacker->mn>=40)
					{
						npcaction(pc_attacker, 6);
						Magic->FlameStrikeSpell(pc_attacker, pc_defender);
					}
					break;
				case 14:
					npcaction(pc_attacker, 6);
					Magic->PFireballTarget(pc_attacker, pc_defender, 10);
					break;
				case 15:
					npcaction(pc_attacker, 6);
					Magic->PFireballTarget(pc_attacker, pc_defender, 20);
					break;
				case 16:
					npcaction(pc_attacker, 6);
					Magic->PFireballTarget(pc_attacker, pc_defender, 40);
					break;
				}
			}			
		}
		pc_attacker->spatimer=currenttime+(pc_attacker->spadelay*MY_CLOCKS_PER_SEC); //LB bugkilling
	}
}