test_case(p2, greaterthan) {
bool a[8], b[8];
to_bits8(a, 11);
to_bits8(b, 24);
assert_false(greaterthan(a, b));
assert_true(greaterthan(b, a));
assert_false(greaterthan(a, a));
}
void setRegistryValue(bool registryNum[8], bool value[8]) {
try{
bool* output = new bool[8];
bool tmpCheck = 0;
bool* low = new bool[8];
bool* high = new bool[8];
if ( Eightto1bit(tmpCheck, lessthan(output, registryNum, low))) throw 10;
if ( Eightto1bit(tmpCheck, greaterthan(output, registryNum, high))) throw 10;
value[0] = registry[to_int8(registryNum)][0];
value[1] = registry[to_int8(registryNum)][1];
value[2] = registry[to_int8(registryNum)][2];
value[3] = registry[to_int8(registryNum)][3];
value[4] = registry[to_int8(registryNum)][4];
value[5] = registry[to_int8(registryNum)][5];
value[6] = registry[to_int8(registryNum)][6];
value[7] = registry[to_int8(registryNum)][7];
}
catch (int e) {
std::cout<<"Reg(";
printValueInDecimal(registryNum);
std::cout<<") = ";
printValue(registryNum);
std::cout<<'\n';
}
}
//*****(F-3)*****
largeInt addl(largeInt ia1,largeInt ia2) // ADDITION
{
largeInt iresult,ik1,ik2;
largeNum result,a1,a2;
if(equal_to_zero(ia1) && equal_to_zero(ia2))
{
iresult.sign=0;
iresult.len=1;
iresult.line[0]='0';
return(iresult);
}
else
{
if( (ia1.sign==0 && ia2.sign==1) || (ia1.sign==1 && ia2.sign==0) )
{
ik1=absl(ia1);
ik2=absl(ia2);
iresult=subl(ik1,ik2);
if(greaterthan(ik1,ik2)==1)
{
iresult.sign=ia1.sign;
}
else
{
iresult.sign=ia2.sign;
}
}
else if(ia1.sign==1 && ia2.sign==1)
{
IntToNum(ia1,&a1);
IntToNum(ia2,&a2);
result=add_pos(a1,a2);
NumToInt(result,&iresult);
iresult.sign=1;
}
else
{
IntToNum(ia1,&a1);
IntToNum(ia2,&a2);
result=add_pos(a1,a2);
NumToInt(result,&iresult);
}
if(equal_to_zero(iresult))
{
iresult.sign=0;
iresult.len=1;
iresult.line[0]='0';
}
return iresult;
}
}
//**********(G-5)*********************
int Isprime(largeInt li) // return 1 (if prime),else 0
{
largeInt temp,temp1,temp_f;
int i;
if(li.sign==1)
{
return 0;
}
else
{
fp=fopen("prime_tab.txt","r+");
if(fp==NULL)
{
printf("\nCannot open file\n");
return;
}
else
{
temp=freadI(fp);
while(feof(fp)==0)
{
temp_f=temp;
if(chk_equal(temp_f,li)==1)
{
return 1;
}
if(greaterthan(li,temp_f)==0)
{
return 0;
}
temp=freadI(fp);
}
temp1=add_primes(temp_f,li);// returns last prime no. which it added to the file prime_tab.txt
if(chk_equal(temp1,li)==1)
return 1;
else
return 0;
}
}
}
//**********(G-4)*********************
largeInt add_primes(largeInt min,largeInt max) //store all prime no.s ranging (>min && <=max) and return last prime no. added to the file
{
//largeNum nmin,nmax,ntemp,nptemp;
largeInt itemp,iptemp,irem,lprime,zero;
div_result temp_result;
fp=fopen("prime_tab.txt","r+");
zero.sign=0;
zero.len=1;
zero.line[0]='0';
lprime=zero;
iptemp=increment1(min);
printf("\n");
while(greaterthan(max,iptemp)==1)
{
rewind(fp);
itemp=freadI(fp);
while(!feof(fp))
{
temp_result=divl(iptemp,itemp);
if(Nequal_to_zero(temp_result.rem)==1)
{
break;
}
itemp=freadI(fp);
if(feof(fp)==1)
{
fwriteI(iptemp,fp);
lprime=iptemp;
}
}
iptemp=increment1(iptemp);
}
return(lprime);
}
std::pair<bool, ByteOffset> find_bed_range(FILE* qfile, TargetIter titer, TargetIter teof, Op op) {
extract_details::TargetBedType reference;
extract_details::QueryBedType last, current;
Bed::Overlapping overlap, lessthan, greaterthan; // any overlap
ByteOffset prev_pos = 0, cur_pos = 0, start_pos = 0, end_pos = 0;
extract_details::MType bounds;
cur_pos = std::ftell(qfile); // may not be start of file if, for ex., qfile has headers we skipped
std::fseek(qfile, 0, SEEK_END); // apparently dangerous on some platforms in binary mode -> padded nulls;
const ByteOffset at_end = std::ftell(qfile); // I'll assume msft is the problem until I know better
std::fseek(qfile, cur_pos, SEEK_SET);
prev_pos = cur_pos;
std::iterator_traits<FILE*>::difference_type count, step;
bool didWork = false, first = true, donequery = false;
while ( titer != teof ) {
extract_details::TargetBedType* const refelement = *titer++;
if ( donequery ) { // read through and delete items in [titer,teof) for posterity
delete refelement;
continue;
} else if ( !first && (greaterthan(&last, refelement) > 0) ) { // last lower_bound is still applicable
delete refelement;
continue;
}
// only use reference where you need to compare to starting base. Otherwise, use refelement.
reference = *refelement;
reference.end(reference.start()+1);
start_pos = std::ftell(qfile);
while ( true ) {
extract_details::MType::iterator miter = bounds.upper_bound(*refelement); // define end_pos
if ( miter == bounds.end() ) {
end_pos = at_end;
bounds.clear();
break;
} else {
// it's possible that miter->first and refelement overlap but are not picked up in
// bounds.upper_bound() search b/c bounds is ordered by the analog of "<", where
// start coord takes precedence. Consider when refelement is less than miter->first
// but refelement->end() > miter->first.start(). In such a case miter->first would
// not be a proper upper bound. Remove it and try again.
bounds.erase(bounds.begin(), miter);
end_pos = miter->second;
if ( extract_details::check_overlap(refelement, &miter->first) )
bounds.erase(miter);
else
break;
}
} // while
count = end_pos - start_pos; // how many bytes between positions
didWork = false;
while ( count > 0 ) {
std::fseek(qfile, start_pos, SEEK_SET);
step = count/2;
std::fseek(qfile, step, SEEK_CUR);
// find beginning of current line
while ( std::ftell(qfile) != start_pos ) {
if ( static_cast<char>(std::fgetc(qfile)) != '\n' ) {
std::fseek(qfile, -2, SEEK_CUR);
} else {
break;
}
} // while
// read in the line; incrementing to start of next QueryBedType element.
prev_pos = std::ftell(qfile);
current.readline(qfile);
cur_pos = std::ftell(qfile);
bounds.insert(std::make_pair(current, prev_pos));
// compare 'current' to starting base
if ( lessthan(¤t, &reference) < 0 ) {
count = (end_pos - cur_pos);
start_pos = cur_pos;
if ( 0 == count ) {
if ( end_pos != at_end ) {
prev_pos = cur_pos;
current.readline(qfile);
cur_pos = std::ftell(qfile);
bounds.insert(std::make_pair(current, prev_pos));
} else {
prev_pos = at_end;
}
}
} else {
count = (prev_pos - start_pos);
end_pos = prev_pos;
}
didWork = true;
} // while
// spit elements in range
if ( didWork ) {
while ( prev_pos != at_end && extract_details::check_overlap(¤t, refelement) ) {
op(¤t);
prev_pos = std::ftell(qfile);
if ( prev_pos != at_end )
current.readline(qfile);
} // while
}
if ( refelement )
delete refelement;
std::fseek(qfile, prev_pos, SEEK_SET); // because start_pos = std::ftell(qfile); on next go-around
if ( prev_pos == at_end )
donequery = true;
last = current;
first = false;
} // while
return std::make_pair(!first, prev_pos);
}
//*****(F-2)
largeInt subl(largeInt ia1, largeInt ia2) // For substracting any +ve/-ve numbers
{
int i,k,d;
largeNum result,a1,a2;
largeInt iresult;
if(equal_to_zero(ia1) && equal_to_zero(ia2))
{
iresult.sign=0;
iresult.len=1;
iresult.line[0]='0';
return(iresult);
}
else
{
IntToNum(ia1,&a1);
IntToNum(ia2,&a2);
if(a1.sign==1 && a2.sign==0)
{
result=add_pos(a1,a2);
result.sign=1;
NumToInt(result,&iresult);
return(iresult);
}
else if(a1.sign==0 && a2.sign==1)
{
result=add_pos(a1,a2);
result.sign=0;
NumToInt(result,&iresult);
return(iresult);
}
else
{
if(greaterthan(ia1,ia2)==1)
{
d=a1.len-a2.len;
shift(&a2,d);
k=a1.len-1;
for(i=k;i>=0;i--)
{
if(a1.line[i]<a2.line[i])
{
result.line[i]=(a1.line[i]+10)-a2.line[i];
a2.line[i-1]++;
}
else
{
result.line[i]=a1.line[i]-a2.line[i];
}
}
result.len=a1.len;
if(a1.sign==0&&a2.sign==0)
result.sign=0;
else
result.sign=1;
rem_all_zeros_from_left(&result);
NumToInt(result,&iresult);
if(equal_to_zero(iresult))
{
iresult.sign=0;
iresult.len=1;
iresult.line[0]='0';
}
return(iresult);
}
else
{
d=a2.len-a1.len;
shift(&a1,d);
k=a2.len-1;
for(i=k;i>=0;i--)
{
if(a2.line[i]<a1.line[i])
{
result.line[i]=(a2.line[i]+10)-a1.line[i];
a1.line[i-1]++;
}
else
{
result.line[i]=a2.line[i]-a1.line[i];
}
}
result.len=a2.len;
if(a1.sign==0&&a2.sign==0)
result.sign=1;
else
result.sign=0;
rem_all_zeros_from_left(&result);
NumToInt(result,&iresult);
if(equal_to_zero(iresult))
{
iresult.sign=0;
iresult.len=1;
iresult.line[0]='0';
}
return(iresult);
}
}
}
}
void Population::sortByScore()
{
sort(m_Pop.begin(),m_Pop.end(),greaterthan());
}
