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;
}
