static A jtcants(J jt,A a,A w,A z){A a1,q,y;B*b,*c;I*u,wr,zr;P*wp,*zp; RZ(a&&w&&z); RZ(a=grade1(a)); wr=AR(w); wp=PAV(w); a1=SPA(wp,a); zr=AR(z); zp=PAV(z); ASSERT(wr==zr,EVNONCE); RZ(b=bfi(wr,a1,1)); GA(q,B01,wr,1,0); c=BAV(q); u=AV(a); DO(wr, c[i]=b[u[i]];);
/* Make a copy of r, appending l to the end */ regexp regexp_append(regexp r, letter let) { regexp result = regexp_calloc(); result->length = r->length + 1; result->expr = regexp_alloc_str(result->length + 1); strncpy((char *)result->expr, (char *)r->expr, r->length); result->expr[result->length-1] = let; result->expr[result->length] = 0; /* Copy the necessary letters bit vector */ memcpy(result->necessary, r->necessary, sizeof(unsigned char) * 32); /* Set the bit at let's position */ bfi(result->necessary, let + 1, 1, 1); return result; }
int32_t decodePixelMeasurement(unsigned char* data, int sub, int x, int y) { // 298496 = 512 * 424 * 11 / 8 = number of bytes per sub image uint16_t *ptr = reinterpret_cast<uint16_t *>(data + 298496 * sub); int i = y < 212 ? y + 212 : 423 - y; ptr += 352*i; /** r1.yz = r2.xxyx < l(0, 1, 0, 0) // ilt r1.y = r1.z | r1.y // or */ bool r1y = x < 1 || y < 0; /* r1.zw = l(0, 0, 510, 423) < r2.xxxy // ilt r1.z = r1.w | r1.z // or */ bool r1z = 510 < x || 423 < y; /* r1.y = r1.z | r1.y // or */ r1y = r1y || r1z; /* r1.y = r1.y & l(0x1fffffff) // and */ int r1yi = r1y ? 0xffffffff : 0x0; r1yi &= 0x1fffffff; /* bfi r1.z, l(2), l(7), r2.x, l(0) ushr r1.w, r2.x, l(2) r1.z = r1.w + r1.z // iadd */ int r1zi = bfi(2, 7, x, 0); int r1wi = x >> 2; r1zi = r1wi + r1zi; /* imul null, r1.z, r1.z, l(11) ushr r1.w, r1.z, l(4) r1.y = r1.w + r1.y // iadd r1.w = r1.y + l(1) // iadd r1.z = r1.z & l(15) // and r4.w = -r1.z + l(16) // iadd */ r1zi = (r1zi * 11L) & 0xffffffff; r1wi = r1zi >> 4; r1yi = r1yi + r1wi; r1zi = r1zi & 15; int r4wi = -r1zi + 16; if(r1yi > 352) { return lut11to16[0]; } int i1 = ptr[r1yi]; int i2 = ptr[r1yi + 1]; i1 = i1 >> r1zi; i2 = i2 << r4wi; return lut11to16[((i1 | i2) & 2047)]; }
void NesSyncCompiler::mClock(int ppuCycles) { /* Here the compiler will generate following function: syncData.baseCycleCounter += baseCycles; u64 cpuCyclesNow = syncData.baseCycleCounter / nesEmu.clockDividerForCpu(); syncData.cpuCycleCounter += additionalCpuCycles; int newCpuCycles = cpuCyclesNow - syncData.cpuCycleCounter; if (newCpuCycles > 0) { syncData.cpuCycleCounter += newCpuCycles; return newCpuCycles; } return 0; If return value != 0 it will return to the cpu emulation also. */ int baseCycles = ppuCycles * nesEmu.clockDividerForPpu(); Q_ASSERT(baseCycles >= 0); __ Ldrd(r0, r1, MemOperand(m_dataBase, offsetof(NesSyncData,baseCycleCounter))); __ add(r0, r0, Operand(baseCycles), SetCC); __ adc(r1, r1, Operand(0)); __ Strd(r0, r1, MemOperand(m_dataBase, offsetof(NesSyncData,baseCycleCounter))); if (nesEmu.clockDividerForCpu() == 12 #if !defined(CAN_USE_ARMV7_INSTRUCTIONS) || nesEmu.clockDividerForCpu() == 16 #endif ) { __ mov(r2, Operand(nesEmu.clockDividerForCpu())); __ mov(r3, Operand(0)); u8 *uldiv = reinterpret_cast<u8 *>(&__aeabi_uldivmod); __ mov(ip, Operand(reinterpret_cast<u32>(uldiv))); __ blx(ip); #if defined(CAN_USE_ARMV7_INSTRUCTIONS) } else if (nesEmu.clockDividerForCpu() == 16) { __ bfi(r0, r1, 0, 4); __ mov(r0, Operand(r0, ROR, 4)); __ mov(r1, Operand(r1, LSR, 4)); #endif } else { UNREACHABLE(); } __ Ldrd(r2, r3, MemOperand(m_dataBase, offsetof(NesSyncData,cpuCycleCounter))); __ add(r2, r2, m_additionalCpuCycles, SetCC); __ adc(r3, r3, Operand(0)); __ Strd(r2, r3, MemOperand(m_dataBase, offsetof(NesSyncData,cpuCycleCounter))); // clear additionalCpuCycles here because mClock can be executed multiple // times in single synchronization step __ mov(m_additionalCpuCycles, Operand(0)); __ sub(r0, r0, r2); __ cmp(r0, Operand(0)); __ mov(r0, Operand(0), LeaveCC, le); Label holdCpu; __ b(&holdCpu, le); __ add(r2, r2, r0, SetCC); __ adc(r3, r3, Operand(0)); __ Strd(r2, r3, MemOperand(m_dataBase, offsetof(NesSyncData,cpuCycleCounter))); mLeaveToCpu(); __ bind(&holdCpu); }
int main() { unsigned long i, f1, f2, f3, f4, f5; unsigned int BYTES_PER_LONG; /* 16 bytes unsigned char array plus 7 bytes pad(3 needed for 32 bit systems and 7 needed for 64 bit systems)*/ unsigned char c[16+7]; for (i=0 ; i<16+7 ; i++) { c[i] = 0x00; } f1 = f2 = f3 = f4 = f5 = 0; bfi(c, 1, 1, 1); bfi(c, 5, 2, 3); bfi(c, 17, 4, 15); bfi(c, 97, 32, 0xffffffff); bfi(c, 49, 8, 0xee); bfi(c, 8, 8, 0xff); fprintf(stderr, "Tests on 32 and 64 bit systems.\n"); fprintf(stderr, "c(should be) = 8d fe f0 00 00 00 ee 00 00 00 00 00 ff ff ff ff\n"); fprintf(stderr, " c = %02x %02x %02x %02x %02x %02x %02x %02x ", c[0], c[1], c[2], c[3], c[4], c[5], c[6], c[7]); fprintf(stderr, "%02x %02x %02x %02x %02x %02x %02x %02x\n", c[8], c[9], c[10], c[11], c[12], c[13], c[14], c[15]); f1 = bfx(c, 1, 1); f2 = bfx(c, 5, 2); f3 = bfx(c, 17, 4); f4 = bfx(c, 113, 16); f5 = bfx(c, 49, 8); fprintf(stderr, "f1(should be 1) = %ld\n" "f2(should be 3) = %ld\n" "f3(should be 15) = %ld\n" "f4(should be 65535) = %ld\n" "f5(should be 238) = %ld\n", f1, f2, f3, f4, f5); BYTES_PER_LONG = sizeof(unsigned long); if (BYTES_PER_LONG == 8) { unsigned long ff, ee; fprintf(stderr, "\n\nTests on 64 bit systems.\n"); for (i=0 ; i<16+7 ; i++) { c[i] = 0x00; } for (i=0 ; i<BYTES_PER_LONG ; i++) { ((unsigned char *)&ff)[i] = 0xff; ((unsigned char *)&ee)[i] = 0xee; } bfi(c, 1, 64, ff); bfi(c, 65, 64, ee); fprintf(stderr, "c(should be) = ff ff ff ff ff ff ff ff ee ee ee ee ee ee ee ee\n"); fprintf(stderr, " c = %02x %02x %02x %02x %02x %02x %02x %02x ", c[0], c[1], c[2], c[3], c[4], c[5], c[6], c[7]); fprintf(stderr, "%02x %02x %02x %02x %02x %02x %02x %02x\n", c[8], c[9], c[10], c[11], c[12], c[13], c[14], c[15]); f1 = bfx(c, 1, 64); f2 = bfx(c, 65, 64); f3 = bfx(c, 33, 64); fprintf(stderr, "f1(should be ffffffffffffffff) = %016lx\n" "f2(should be eeeeeeeeeeeeeeee) = %016lx\n" "f3(should be ffffffffeeeeeeee) = %016lx\n", f1, f2, f3); } exit(0); }
int main(int, char *[]) { /*{ CORE::Polynomial<CORE::BigFloat> p("-2+20t-50t^2+1t^50", 't'); for (int i=0; i< p.getDegree()+1; ++i){ assert(p.getCoeffi(i).isExact()); } CORE::Sturm<CORE::BigFloat> s(p, true); std::cout << p << std::endl; std::cout << s.numberOfRoots() << std::endl; }*/ #ifdef CGAL_USE_CORE { CORE::BigFloat c[3]; c[0]= CORE::BigFloat(1.0); c[1]= CORE::BigFloat(3.0); c[2]= CORE::BigFloat(-4.0); CORE::Polynomial<CORE::BigFloat> bf(2, c); CORE::BFInterval bfi(CORE::BigFloat(-.5), CORE::BigFloat(-.2)); std::cout << bf << std::endl; CORE::Expr e(bf, bfi); std::cout << e << std::endl; } if (1) { /*CORE::Polynomial<CORE::BigFloat> p("-2+20t-50t^2+1t^50", 't'); CORE::Sturm<CORE::BigFloat> s(p, true); std::cout << p << std::endl; std::cout << s.numberOfRoots() << std::endl;*/ CORE::BigRat c[17]; c[0]= CORE::BigRat("86966370606641/4503599627370496"); c[1]= CORE::BigRat("9813373613357677/18014398509481984"); c[2]= CORE::BigRat("3924498795192991/18014398509481984"); c[3]= CORE::BigRat("-156857429476936177/576460752303423488"); c[4]= CORE::BigRat("28036759770576529/72057594037927936"); c[5]= CORE::BigRat("-3478688861042611/9007199254740992"); c[6]= CORE::BigRat("4395898718207/35184372088832"); c[7]= CORE::BigRat("-4078546949307093/9007199254740992"); c[8]= CORE::BigRat("4063208312463087/9007199254740992"); c[9]= CORE::BigRat("-1076999133570829/4503599627370496"); c[10]= CORE::BigRat("-21830467801783653/72057594037927936"); c[11]= CORE::BigRat("813684203309077/4503599627370496"); c[12]= CORE::BigRat("19160047808947179/36028797018963968"); c[13]= CORE::BigRat("-22915804375471/140737488355328"); c[14]= CORE::BigRat("9001478429603223/36028797018963968"); c[15]= CORE::BigRat("77422038291455461/144115188075855872"); c[16]= CORE::BigRat("-3556900689495543/72057594037927936"); CORE::Polynomial<CORE::BigRat> p( 16, c); std::cout << p << std::endl; CORE::Sturm<CORE::BigRat> s(p); std::cout << "done" << std::endl; } { CORE::BigFloat cs[9]; cs[0]=CORE::BigFloat(-2295485086.0); cs[1]=CORE::BigFloat(2072822157.0); cs[2]=CORE::BigFloat(116461914.2); cs[3]=CORE::BigFloat(-116175036.500); cs[4]=CORE::BigFloat(-10063149.8700); cs[5]=CORE::BigFloat(-196007.034400); cs[6]=CORE::BigFloat(3460.88600000); cs[7]=CORE::BigFloat(136.910039600); cs[8]=CORE::BigFloat(1.0); for (unsigned int i=0; i< 9; ++i) { assert(cs[i].isExact()); } CORE::Polynomial<CORE::BigFloat> p(8, cs); //std::cout << p << std::endl; CORE::Polynomial<CORE::BigFloat> temp(p); //std::cout << temp << std::endl; CORE::Polynomial<CORE::BigFloat> pp=p; pp.differentiate(); //std::cout << pp << std::endl; CORE::Polynomial<CORE::BigFloat> pg = gcd(p, temp.differentiate()); CORE::BigFloat c; CORE::Polynomial<CORE::BigFloat> prem=p; CORE::Polynomial<CORE::BigFloat> pquo= prem.pseudoRemainder(pp, c); std::cout << "p: " << p << std::endl; std::cout << "pp: " << pp << std::endl; std::cout << "prem: " << prem << std::endl; std::cout << "c: " << c << std::endl; std::cout << "quo: " << pquo << std::endl; //std::cout << R << std::endl; /*CGAL::POLYNOMIAL::internal::CORE_polynomial cp(p); CGAL::POLYNOMIAL::internal::CORE_polynomial cpp(pp); CGAL::POLYNOMIAL::internal::CORE_polynomial cpg(pg); CGAL::POLYNOMIAL::internal::CORE_polynomial cprem(prem); CGAL::POLYNOMIAL::internal::CORE_polynomial cpquo(pquo); std::cout << "P: " << cp << std::endl; std::cout << "P': " << cpp<< std::endl; std::cout << "gcd: " << cpg<< std::endl; std::cout << "Rem: " << cprem << std::endl; std::cout << "Quo: " << cpquo << std::endl; std::cout << "C: " << c << std::endl;*/ } #endif return 0; }