void Bezier::recalc(QPointF p)
{
// http://www.flong.com/texts/code/shapers_bez/
// http://www.lemoda.net/maths/bezier-length/index.html,
// arbitrary but reasonable t-values for interior control points
double t0 = 0.3;
double t1 = 0.7;
if (m_drag_cp0) {
double x = (p.x() - m_endpoint0.x() * B0(t0) - m_cp1.x() * B2(t0) - m_endpoint1.x() * B3(t0)) / B1(t0);
double y = (p.y() - m_endpoint0.y() * B0(t0) - m_cp1.y() * B2(t0) - m_endpoint1.y() * B3(t0)) / B1(t0);
m_cp0 = QPointF(x, y);
}
else {
double x = (p.x() - m_endpoint0.x() * B0(t1) - m_cp0.x() * B1(t1) - m_endpoint1.x() * B3(t1)) / B2(t1);
double y = (p.y() - m_endpoint0.y() * B0(t1) - m_cp0.y() * B1(t1) - m_endpoint1.y() * B3(t1)) / B2(t1);
m_cp1 = QPointF(x, y);
}
/*
DebugDialog::debug(QString("ix:%1 p0x:%2,p0y:%3 p1x:%4,p1y:%5 px:%6,py:%7")
.arg(m_drag_cp0)
.arg(m_endpoint0.x())
.arg(m_endpoint0.y())
.arg(m_endpoint1.x())
.arg(m_endpoint1.y())
.arg(p.x())
.arg(p.y())
);
*/
m_isEmpty = false;
}
mat ls_solve_od(const mat &A, const mat &B)
{
int m=A.rows(), n=A.cols(), N=B.cols(), j;
double beta;
mat A2(A), B2(B), B3(n,N), submat, submat2;
vec tmp(n), v;
// it_assert1(m >= n, "The system is under-determined!");
//it_assert1(m == B.rows(), "The number of rows in A must equal the number of rows in B!");
// Perform a Householder QR factorization
for (j=0; j<n; j++) {
house(rvectorize(A2(j, m-1, j, j)), v, beta);
v *= sqrt(beta);
// submat.ref(A2, j,m-1, j,n-1);
submat = A2(j,m-1,j,n-1);
sub_v_vT_m(submat, v);
// submat.ref(B2, j,m-1, 0,N-1);
submat = B2(j,m-1,0,N-1);
sub_v_vT_m(submat, v);
}
// submat.ref(A2, 0,n-1,0,n-1);
// submat2.ref(B2, 0,n-1,0,N-1);
submat = A2(0,n-1,0,n-1);
submat2 = B2(0,n-1,0,N-1);
for (j=0; j<N; j++) {
backward_substitution(submat, submat2.get_col(j), tmp);
B3.set_col(j, tmp);
}
return B3;
}
static int reallyroutespline (Pedge_t *edges, int edgen,
Ppoint_t *inps, int inpn, Ppoint_t ev0, Ppoint_t ev1) {
Ppoint_t p1, p2, cp1, cp2, p;
Pvector_t v1, v2, splitv, splitv1, splitv2;
double maxd, d, t;
int maxi, i, spliti;
static tna_t *tnas;
static int tnan;
if (tnan < inpn) {
if (!tnas) {
if (!(tnas = (tna_t *)malloc (sizeof (tna_t) * inpn)))
return -1;
} else {
if (!(tnas = (tna_t *)realloc (tnas, sizeof (tna_t) * inpn)))
return -1;
}
tnan = inpn;
}
tnas[0].t = 0;
for (i = 1; i < inpn; i++)
tnas[i].t = tnas[i - 1].t + dist (inps[i], inps[i - 1]);
for (i = 1; i < inpn; i++)
tnas[i].t /= tnas[inpn - 1].t;
for (i = 0; i < inpn; i++) {
tnas[i].a[0] = scale (ev0, B1 (tnas[i].t));
tnas[i].a[1] = scale (ev1, B2 (tnas[i].t));
}
if (mkspline (inps, inpn, tnas, ev0, ev1, &p1, &v1, &p2, &v2) == -1)
return -1;
if (splinefits (edges, edgen, p1, v1, p2, v2, (inpn == 2 ? 1 : 0)))
return 0;
cp1 = add (p1, scale (v1, 1 / 3.0));
cp2 = sub (p2, scale (v2, 1 / 3.0));
for (maxd = -1, maxi = -1, i = 1; i < inpn - 1; i++) {
t = tnas[i].t;
p.x = B0 (t) * p1.x + B1 (t) * cp1.x +
B2 (t) * cp2.x + B3 (t) * p2.x;
p.y = B0 (t) * p1.y + B1 (t) * cp1.y +
B2 (t) * cp2.y + B3 (t) * p2.y;
if ((d = dist (p, inps[i])) > maxd)
maxd = d, maxi = i;
}
spliti = maxi;
splitv1 = normv (sub (inps[spliti], inps[spliti - 1]));
splitv2 = normv (sub (inps[spliti + 1], inps[spliti]));
splitv = normv (add (splitv1, splitv2));
reallyroutespline (edges, edgen, inps, spliti + 1, ev0, splitv);
reallyroutespline (edges, edgen, &inps[spliti], inpn - spliti, splitv, ev1);
return 0;
}
// Shortest cubic spline through 4 on-curve points(chord approximation)
void Bezier::FitSpline(Vec3 p[])
{
// use chord length for shortest(best) cubic spline approximation
float c3 = (p[1] - p[0]).Magnitude();
float c2 = (p[2] - p[1]).Magnitude();
float c1 = (p[3] - p[2]).Magnitude();
// cases where p[1] is close to p[2] might lead to instabilities(need some heuristic)
if (50 * c2 < c1 + c3)
{
p[1] = p[0] + (p[1] - p[0]) * 0.98;
p[2] = p[3] + (p[2] - p[3]) * 0.98;
c3 = c3 * 0.98;
c2 = (p[2] - p[1]).Magnitude();
c1 = c1 * 0.98;
}
float t1 = c1 / (c1 + c2 + c3);
float t2 = (c1 + c2) / (c1 + c2 + c3);
// Solve M * x = y
float m00 = B1(t1);
float m01 = B2(t1);
float m10 = B1(t2);
float m11 = B2(t2);
float detM = m00 * m11 - m01 * m10;
if (fabs(detM) > 1E-3)
{
// y = p - p0 * B0(t) - p3 * B3(t)
Vec3 y1 = p[1] - p[0] * B0(t1) - p[3] * B3(t1);
Vec3 y2 = p[2] - p[0] * B0(t2) - p[3] * B3(t2);
// Minv
float s = 1 / detM;
float n00 = s * m11;
float n01 = -s * m01;
float n10 = -s * m10;
float n11 = s * m00;
// x = Minv * y
Vec3 x1 = y1 * n00 + y2 * n01;
Vec3 x2 = y1 * n10 + y2 * n11;
p[1] = x1;
p[2] = x2;
}
}
int read_toc(unsigned char *buf, int *buflen, int mode)
{
int result;
int len,i,o;
result=scsi_request("read_toc",buf,buflen,10,0,SCSIR_READ,
READTOC,0,0,0,0,0,
0,
B2(*buflen),
0);
if (result || !mode) return result;
len=V2(&buf[0]);
printf("\nTracks: %d \t (first=%02d last=%02d)\n",
(buf[3]-buf[2])+1,buf[2],buf[3]);
for (i=0;i<((len-2)/8)-1;i++) {
o=4+i*8; /* offset to track descriptor */
printf("Track %02d: %s (adr/ctrl=%02xh) begin=%06d end=%06d "
"length<=%06d\n",
i+1,(buf[o+1]&DATA_TRACK?"data ":"audio"),buf[o+1],V4(&buf[o+4]),
V4(&buf[o+4+8]),V4(&buf[o+4+8])-V4(&buf[o+4]) );
}
return result;
}
void rubikStep(char *step)
{
u8 m=0;
for(m=0;step[m]!=0;m++)
{
switch(step[m])
{
case 7:allright90();break;
case 11:F1();break;
case 12:F2();break;
case 13:F3();break;
case 21:B1();break;
case 22:B2();break;
case 23:B3();break;
case 31:R1();break;
case 32:R2();break;
case 33:R3();break;
case 41:L1();break;
case 42:L2();break;
case 43:L3();break;
case 51:U1();break;
case 52:U2();break;
case 53:U3();break;
case 61:D1();break;
case 62:D2();break;
case 63:D3();break;
default:break;
}
}
}
void f(void) {
int b1 = B1();
if (b1) {
int b2 = B2();
if (b2) {
B3();
} else {
B4();
}
}
B5();
while (B6()) {
B12();
int b14;
do {
B13();
b14 = B14();
} while(b14);
B15();
}
int b7 = B7();
if (b7 || B8()) {
B9();
}
B10();
B11();
}
int mode_sense10(unsigned char *buf, int *buflen)
{
int len = *buflen;
if (len >65000) len=65000;
return scsi_request("mode_sense(10)",buf,buflen,10,0,SCSIR_READ,
MODESENSE10,0,0x01,0,0,0,0,B2(len),0);
}
inline CPLSafeInt<unsigned> operator*( const CPLSafeInt<unsigned>& A,
const CPLSafeInt<unsigned>& B )
{
#ifdef BUILTIN_OVERFLOW_CHECK_AVAILABLE
unsigned res;
if( __builtin_umul_overflow(A.v(), B.v(), &res) )
throw CPLSafeIntOverflow();
return CPLSM(res);
#elif defined(_MSC_VER)
msl::utilities::SafeInt<unsigned, CPLMSVCSafeIntException> A2(A.v());
msl::utilities::SafeInt<unsigned, CPLMSVCSafeIntException> B2(B.v());
return CPLSM(static_cast<unsigned>(A2 * B2));
#elif defined(CPL_HAS_GINT64)
const unsigned a = A.v();
const unsigned b = B.v();
const GUInt64 res = static_cast<GUInt64>(a) * b;
if( res > std::numeric_limits<unsigned>::max() )
{
throw CPLSafeIntOverflow();
}
return CPLSM(static_cast<unsigned>(res));
#else
const unsigned a = A.v();
const unsigned b = B.v();
if( b > 0 && a > std::numeric_limits<unsigned>::max() / b )
throw CPLSafeIntOverflow();
return CPLSM(a*b);
#endif
}
void inter_cone(t_caster *caster, t_object *cone)
{
double a;
double b;
double c;
double delt;
init_temp_pos(caster, cone);
a = A2(caster->temp_vec.x, caster->temp_vec.y, caster->temp_vec.z,
cone->data.angle);
b = B2(caster->temp_vec.x, caster->temp_pos.x, caster->temp_vec.y,
caster->temp_pos.y, caster->temp_vec.z, caster->temp_pos.z,
cone->data.angle);
c = C2(caster->temp_pos.x, caster->temp_pos.y, caster->temp_pos.z,
cone->data.angle);
delt = (pow(b, 2.0) - 4.0 * (a * c));
if (delt >= 0.0)
{
cone->dist = get_nearest((-b - sqrt(delt)) / (2.0 * a),
(-b + sqrt(delt)) / (2.0 * a));
if (cone->dist > 0.0 && cone->dist < caster->intersection.dist)
{
caster->intersection.brightness = cone->brightness;
init_intersection(caster, cone);
rotate_caster(caster, cone);
}
}
}
inline CPLSafeInt<int> operator*( const CPLSafeInt<int>& A,
const CPLSafeInt<int>& B )
{
#ifdef BUILTIN_OVERFLOW_CHECK_AVAILABLE
int res;
if( __builtin_smul_overflow(A.v(), B.v(), &res) )
throw CPLSafeIntOverflow();
return CPLSM(res);
#elif defined(_MSC_VER)
msl::utilities::SafeInt<int, CPLMSVCSafeIntException> A2(A.v());
msl::utilities::SafeInt<int, CPLMSVCSafeIntException> B2(B.v());
return CPLSM(static_cast<int>(A2 * B2));
#elif defined(CPL_HAS_GINT64)
const int a = A.v();
const int b = B.v();
const GInt64 res = static_cast<GInt64>(a) * b;
if( res < std::numeric_limits<int>::min() ||
res > std::numeric_limits<int>::max() )
{
throw CPLSafeIntOverflow();
}
return CPLSM(static_cast<int>(res));
#else
return SafeMulSigned(A,B);
#endif
}
static int
rvec_priv_inst( int dummy_rvec, ulong inst )
{
int op, op_ext, b1, b2, b3;
/* unhandled privileged instruction in supervisor mode */
/* IMPORTANT: The GPRs are not available here! */
op = OPCODE_PRIM( inst );
op_ext = OPCODE_EXT( inst );
b1 = B1( inst ); /* bit 6-10 */
b2 = B2( inst ); /* bit 11-15 */
b3 = B3( inst ); /* bit 16-20 */
switch( OPCODE(op,op_ext) ) {
case OPCODE( 31, 370 ): /* tlbia (opt.) */
/* not implemented on the 601,603,604,G3 (G4?) */
break;
case OPCODE( 31, 470 ): /* dcbi rA,rB -- rA=b2 rB=b3 */
printm("dcbi treated as nop\n");
mregs->nip += 4;
return 0;
default:
printm("Unknown privileged instruction, opcode %lX\n", inst);
stop_emulation();
break;
}
mac_exception( 0x700, MOL_BIT(13) );
return 0;
}
bool PGCicrcleTaskPt::CrossPoint(const ProjPt& prev, const ProjPt& next, ProjPt& optimized) {
ProjPt A = prev - m_Center;
ProjPt B = next - m_Center;
ProjPt A2(A.m_X * A.m_X, A.m_Y * A.m_Y);
ProjPt B2(B.m_X * B.m_X, B.m_Y * B.m_Y);
double R2 = (m_Radius * m_Radius);
bool PrevOutside = (A2.m_X + A2.m_Y) > R2;
bool NextOutside = (B2.m_X + B2.m_Y) > R2;
if (!PrevOutside && !NextOutside) {
return false; // no cross point
}
ProjPt AB = B - A;
double a = (AB.m_X * AB.m_X) + (AB.m_Y * AB.m_Y);
double b = 2 * ((AB.m_X * A.m_X) + (AB.m_Y * A.m_Y));
double c = A2.m_X + A2.m_Y - R2;
double bb4ac = (b * b) -(4 * a * c);
if (bb4ac < 0.0) {
return false;
}
bool bCrossPoint = false;
double k = 0.0;
if (bb4ac == 0.0) {
LKASSERT(a);
// one point
k = -b / (2 * a);
bCrossPoint = true;
}
if (bb4ac > 0.0) {
// Two point,
if ((PrevOutside && m_bExit) || (!PrevOutside && NextOutside)) {
LKASSERT(a);
k = (-b + sqrt(bb4ac)) / (2 * a); // ouput : prev ouside && Exit TP || prev inside && next outside
bCrossPoint = true;
} else {
LKASSERT(a);
k = (-b - sqrt(bb4ac)) / (2 * a); // input : prev outside && Enter TP
bCrossPoint = true;
}
}
if (bCrossPoint) {
ProjPt O = prev + ((next - prev) * k);
if (dot_product((next - prev), O - prev) > 0.0 &&
dot_product((prev - next), O - next) > 0.0) {
optimized = O;
return true;
}
}
// no point
return false;
}
Matrix genA0(Matrix &A,vector<long>&JROW,vector<long>&JCOL)
{
long M = A.size();
Matrix B(M), B2(M);
forMatrix(A,i,j) B[JROW[i]-1][j] = A[i][j];
forMatrix(B,i,j) B2[i][JCOL[j]-1] = B[i][j];
return B2;
}
int main()
{
Rat a1(-1,2);
Rat a2(2,9);
Rat b2(3,2);
Rat c1(-1,9);
DoubleInterval A11(a2,b2);
DoubleInterval A12(a1,0);
DoubleInterval A21(-1,c1);
DoubleInterval A22(a2,b2);
DoubleMatrix A(2,2);
A(0,0) = A11;
A(0,1) = A12;
A(1,0) = A21;
A(1,1) = A22;
DoubleInterval B1(1,3);
DoubleInterval B2(3,4);
DoubleVector b(2, (DoubleInterval)0);
b[0] = B1;
b[1] = B2;
std::cout << A << std::endl;
std::cout << b << std::endl;
DoubleVector x(2, (DoubleInterval)0);
x = A * b;
std::cout << x << std::endl;
//Need to sort this out
DoubleInterval test(-1,2);
DoubleInterval testb(5,100);
DoubleInterval ans;
ans = testb/test;
std::cout << ans << std::endl;
DoubleInterval k00(0,2);
DoubleInterval k01(1,3);
DoubleInterval k10(3,5);
DoubleInterval k11(5,7);
std::cout << "INVERSE IS " << std::endl;
std::cout << boost::numeric::Doubleinterval_lib::multiplicative_inverse(k11) << std::endl;
std::cout << boost::numeric::norm(k11) << std::endl;
std::cout << k00 * k11 << std::endl;
std::cout << k01 * k10 << std::endl;
std::cout << (k00 * k11) - (k01 * k10) << std::endl;
return 0;
}
uint8 IRsense(void){
uint8 tmp;
DIRIN(TRISD,BIT2);
Nop();Nop();Nop();Nop();
tmp=PORTD;
DIROUT(TRISC,BIT2);
switch(irsta){
case 1:
psta=0;
B2(LATC)=0;
if(irsense==1) {oncnt=0;irsta=2;}
// else {irsta=1;}
break;
case 2:
oncnt++;
if(oncnt>t1000) {irsta=3;}
if(irsense==0) {irsta=1;}
break;
case 3:
psta=1;
B2(LATC)=1;
if(irsense==0) {irsta=4;offcnt=0;}
break;
case 4:
offcnt++;
if(offcnt>t1000) {irsta=1;}
if(irsense==1) {irsta=3;}
break;
default: irsta=1; break;
}
return irsta;
}
int read_10(int lba, int len, unsigned char *buf, int *buflen)
{
return scsi_request("read_10",buf,buflen,10,0,SCSIR_READ,
READ10, 0,
B4(lba),
0,
B2(len),
0);
}
int main()
{
vector<float> A2(N*N);
vector<float> B2(N*N);
cout << "t4:" << endl;
prob2_2_v2(A2, B2);
cout << "-------" << endl;
return 0;
}
void CreateDoubleWayInteraction::paintEvent(QPaintEvent* /* anEvent */, QPainter& thePainter)
{
if (R1 && (!R1->layer() || R1->isDeleted())) { // The roads were begon and then undoed. Restarting....
HaveFirst = false;
view()->setInteracting(false);
R1 = R2 = NULL;
}
qreal rB = view()->pixelPerM()*DockData.RoadDistance->text().toDouble()/2;
if (!HaveFirst)
{
thePainter.setPen(QColor(0,0,0));
thePainter.drawEllipse(int(LastCursor.x()-rB),int(LastCursor.y()-rB),int(rB*2),int(rB*2));
}
else
{
Coord PreviousPoint;
if (R1 && R1->size())
PreviousPoint = PreviousPoints[R1->size()-1];
else
PreviousPoint = FirstPoint;
if (distance(COORD_TO_XY(PreviousPoint), LastCursor) > 1)
{
qreal rA = FirstDistance * view()->pixelPerM()/2;
LineF FA1(COORD_TO_XY(PreviousPoint),LastCursor);
LineF FA2(FA1);
LineF FB1(FA1);
LineF FB2(FA1);
FA1.slide(-rA);
FA2.slide(rA);
FB1.slide(-rB);
FB2.slide(rB);
QPointF A1(FA1.project(COORD_TO_XY(PreviousPoint)));
QPointF A2(FA2.project(COORD_TO_XY(PreviousPoint)));
QPointF B1(FB1.project(LastCursor));
QPointF B2(FB2.project(LastCursor));
QBrush SomeBrush(QColor(0xff,0x77,0x11,128));
QPen TP(SomeBrush,view()->pixelPerM()*4);
if (DockData.DriveRight->isChecked())
{
::draw(thePainter,TP,Feature::OneWay, B1,A1,rB/4,view()->projection());
::draw(thePainter,TP,Feature::OneWay, A2,B2,rB/4,view()->projection());
}
else
{
::draw(thePainter,TP,Feature::OneWay, A1,B1,rB/4,view()->projection());
::draw(thePainter,TP,Feature::OneWay, B2,A2,rB/4,view()->projection());
}
}
}
}
void
CAST5decrypt(const PGPUInt8 *in, PGPUInt8 *out, const PGPUInt32 *xkey)
{
PGPUInt32 l, r, t;
r = (PGPUInt32) in[0]<<24 | (PGPUInt32) in[1]<<16 |
(PGPUInt32) in[2]<<8 | in[3];
l = (PGPUInt32) in[4]<<24 | (PGPUInt32) in[5]<<16 |
(PGPUInt32) in[6]<<8 | in[7];
t = F1(l, xkey, 15); r ^= G1(t);
t = F3(r, xkey, 14); l ^= G3(t);
t = F2(l, xkey, 13); r ^= G2(t);
t = F1(r, xkey, 12); l ^= G1(t);
// Start here if only doing 12 rounds
t = F3(l, xkey, 11); r ^= G3(t);
t = F2(r, xkey, 10); l ^= G2(t);
t = F1(l, xkey, 9); r ^= G1(t);
t = F3(r, xkey, 8); l ^= G3(t);
t = F2(l, xkey, 7); r ^= G2(t);
t = F1(r, xkey, 6); l ^= G1(t);
t = F3(l, xkey, 5); r ^= G3(t);
t = F2(r, xkey, 4); l ^= G2(t);
t = F1(l, xkey, 3); r ^= G1(t);
t = F3(r, xkey, 2); l ^= G3(t);
t = F2(l, xkey, 1); r ^= G2(t);
t = F1(r, xkey, 0); l ^= G1(t);
out[0] = (PGPUInt8) B0(l);
out[1] = (PGPUInt8) B1(l);
out[2] = (PGPUInt8) B2(l);
out[3] = (PGPUInt8) B3(l);
out[4] = (PGPUInt8) B0(r);
out[5] = (PGPUInt8) B1(r);
out[6] = (PGPUInt8) B2(r);
out[7] = (PGPUInt8) B3(r);
}
/*
* Encrypt the 8 bytes at *in into the 8 bytes at *out using the expanded
* key schedule from *xkey.
*/
static void
CAST5encrypt(PGPByte const *in, PGPByte *out, PGPUInt32 const *xkey)
{
PGPUInt32 l, r, t;
l = (PGPUInt32)
in[0]<<24 | (PGPUInt32)in[1]<<16 | (PGPUInt32)in[2]<<8 | in[3];
r = (PGPUInt32)
in[4]<<24 | (PGPUInt32)in[5]<<16 | (PGPUInt32)in[6]<<8 | in[7];
t = F1(r, xkey, 0); l ^= G1(t);
t = F2(l, xkey, 1); r ^= G2(t);
t = F3(r, xkey, 2); l ^= G3(t);
t = F1(l, xkey, 3); r ^= G1(t);
t = F2(r, xkey, 4); l ^= G2(t);
t = F3(l, xkey, 5); r ^= G3(t);
t = F1(r, xkey, 6); l ^= G1(t);
t = F2(l, xkey, 7); r ^= G2(t);
t = F3(r, xkey, 8); l ^= G3(t);
t = F1(l, xkey, 9); r ^= G1(t);
t = F2(r, xkey, 10); l ^= G2(t);
t = F3(l, xkey, 11); r ^= G3(t);
/* Stop here if only doing 12 rounds */
t = F1(r, xkey, 12); l ^= G1(t);
t = F2(l, xkey, 13); r ^= G2(t);
t = F3(r, xkey, 14); l ^= G3(t);
t = F1(l, xkey, 15); r ^= G1(t);
out[0] = B0(r);
out[1] = B1(r);
out[2] = B2(r);
out[3] = B3(r);
out[4] = B0(l);
out[5] = B1(l);
out[6] = B2(l);
out[7] = B3(l);
}
inline CPLSafeInt<GInt64> operator*( const CPLSafeInt<GInt64>& A,
const CPLSafeInt<GInt64>& B )
{
#if defined(BUILTIN_OVERFLOW_CHECK_AVAILABLE) && defined(__x86_64__)
GInt64 res;
if( __builtin_smulll_overflow(A.v(), B.v(), &res) )
throw CPLSafeIntOverflow();
return CPLSM(res);
#elif defined(_MSC_VER)
msl::utilities::SafeInt<GInt64, CPLMSVCSafeIntException> A2(A.v());
msl::utilities::SafeInt<GInt64, CPLMSVCSafeIntException> B2(B.v());
return CPLSM(static_cast<GInt64>(A2 * B2));
#else
return SafeMulSigned(A,B);
#endif
}
COMPLEX Pade_approximant::operator()(COMPLEX e) const
{
COMPLEX A1(0);
COMPLEX A2 = a(0);
COMPLEX B1(1.0), B2(1.0);
int N = a.size();
for(int i=0; i<=N-2; ++i){
COMPLEX Anew = A2 + (e - z_in(i))*a(i+1)*A1;
COMPLEX Bnew = B2 + (e - z_in(i))*a(i+1)*B1;
A1 = A2; A2 = Anew;
B1 = B2; B2 = Bnew;
}
return A2/B2;
}
void huddraw_info_nav(int r) {
char text[256];
fg_color = B0(COLOR_BLACK);
bg_color = B3(COLOR_SAND_YELLOW);
draw_rect(0,r,128,35,1);
fg_color = B2(COLOR_SAND_YELLOW);
draw_rect(35,r+2,12,14,0);
draw_rect(76,r+2,12,14,0);
// coordinates
fg_color = B3(COLOR_REDSTONE_RED);
bg_color = COLOR_TRANSPARENT;
int32_t x = (int32_t)floor(gs.own.x);
int32_t z = (int32_t)floor(gs.own.z);
int32_t x_= (gs.world==&gs.nether) ? x*8 : x/8;
int32_t z_= (gs.world==&gs.nether) ? z*8 : z/8;
char * n_= (gs.world==&gs.nether) ? "Overworld" : "Nether";
draw_text(3, r+ 3, "X");
draw_text(3, r+10, "Z");
draw_text(3, r+19, "Y");
draw_text(3, r+26, "DIR");
sprintf(text, "%9d", x); draw_text(11,r+3,text);
sprintf(text, "%9d", x_); draw_text(53,r+3,text);
sprintf(text, "%9d", z); draw_text(11,r+10,text);
sprintf(text, "%9d", z_); draw_text(53,r+10,text);
sprintf(text, "%9d", (int32_t)floor(gs.own.y)); draw_text(11,r+19,text);
char * dir = "UNKNOWN";
switch(player_direction()) {
case DIR_NORTH : dir = "NORTH"; break;
case DIR_SOUTH : dir = "SOUTH"; break;
case DIR_EAST : dir = "EAST"; break;
case DIR_WEST : dir = "WEST"; break;
}
sprintf(text, "%9s", dir); draw_text(11,r+26,text);
int pos = (42-(strlen(n_)*4-1))/2+49;
draw_text(pos, r+26, n_);
// compass
huddraw_compass(108,r+17,B0(COLOR_BLACK), B3(COLOR_REDSTONE_RED));
}
void huddraw_info_health(int r) {
char text[256];
fg_color = B0(COLOR_BLACK);
bg_color = B3(COLOR_GRASS_GREEN);
draw_rect(0,r,128,12,1);
bg_color = COLOR_TRANSPARENT;
fg_color = B3(COLOR_REDSTONE_RED);
draw_blit(fonts, FONTS_ICON_HEART, 8, 8, 2, r+2);
fg_color = B0(COLOR_BLACK);
sprintf(text, "%.1f", gs.own.health);
draw_text(12, r+3, text);
fg_color = B2(COLOR_ORANGE);
draw_blit(fonts, FONTS_ICON_FOOD, 8, 8, 33, r+2);
fg_color = B0(COLOR_BLACK);
sprintf(text, "%d (%.1f)", gs.own.food, gs.own.saturation);
draw_text(43, r+3, text);
}
inline CPLSafeInt<unsigned> operator-( const CPLSafeInt<unsigned>& A,
const CPLSafeInt<unsigned>& B )
{
#ifdef BUILTIN_OVERFLOW_CHECK_AVAILABLE
unsigned res;
if( __builtin_usub_overflow(A.v(), B.v(), &res) )
throw CPLSafeIntOverflow();
return CPLSM(res);
#elif defined(_MSC_VER)
msl::utilities::SafeInt<unsigned, CPLMSVCSafeIntException> A2(A.v());
msl::utilities::SafeInt<unsigned, CPLMSVCSafeIntException> B2(B.v());
return CPLSM(static_cast<unsigned>(A2 - B2));
#else
const unsigned a = A.v();
const unsigned b = B.v();
if( a < b )
throw CPLSafeIntOverflow();
return CPLSM(a-b);
#endif
}
Coord findIntersection(LineSegment& one, LineSegment& two, double extrapolatePercentage)
{
// extrapolate both lines out by making new segments that are larger
one.normalize(); two.normalize(); // A < B
// line one
double ext1 = extrapolatePercentage*one.length();
Coord A1 (one.A.x-ext1, one.A.y-ext1*one.slope());
Coord B1 (one.B.x+ext1, one.B.y+ext1*one.slope());
LineSegment L1 (A1, B1);
// line one
double ext2 = extrapolatePercentage*two.length();
Coord A2 (two.A.x-ext2, two.A.y-ext2*two.slope());
Coord B2 (two.B.x+ext2, two.B.y+ext2*two.slope());
LineSegment L2 (A2, B2);
// lines are now ready for intersection check
return findIntersection(L1, L2, false);
}
static int _response(Socket_T socket, mysql_packet_t *pkt) {
memset(pkt, 0, sizeof *pkt);
if (socket_read(socket, pkt->buf, 4) < 4) {
socket_setError(socket, "Error receiving server response -- %s", STRERROR);
return FALSE;
}
pkt->len = B3(pkt->buf);
pkt->len = pkt->len > STRLEN ? STRLEN : pkt->len; // Adjust packet length for this buffer
pkt->seq = pkt->buf[3];
pkt->msg = pkt->buf + 4;
if (socket_read(socket, pkt->msg, pkt->len) != pkt->len) {
socket_setError(socket, "Error receiving server response -- %s", STRERROR);
return FALSE;
}
if (*pkt->msg == MYSQL_ERROR) {
unsigned short code = B2(pkt->msg + 1);
unsigned char *err = pkt->msg + 9;
socket_setError(socket, "Server returned error code %d -- %s", code, err);
return FALSE;
}
return TRUE;
}
void TableCompiler::genCharIndexFn() {
llvm::Type *T[] = { B.getInt8Ty() };
llvm::FunctionType *FT = llvm::FunctionType::get(B.getInt32Ty(), T, false);
CharIndexFn = llvm::Function::Create(FT, llvm::Function::InternalLinkage,
"getcharindex", M);
llvm::BasicBlock *Entry = llvm::BasicBlock::Create(*C, "entry", CharIndexFn);
llvm::BasicBlock *Default =
llvm::BasicBlock::Create(*C, "default", CharIndexFn);
llvm::IRBuilder<> B(Default);
B.CreateRet(B.getInt32(-1));
B.SetInsertPoint(Entry);
llvm::SwitchInst *Switch =
B.CreateSwitch(CharIndexFn->arg_begin(), Default, UniqueChars.size());
std::vector<llvm::BasicBlock *> Rets;
Rets.reserve(UniqueChars.size());
unsigned Idx = 0;
for (auto I = UniqueChars.cbegin(); I != UniqueChars.cend(); ++I, ++Idx) {
llvm::BasicBlock *BB = llvm::BasicBlock::Create(*C, "", CharIndexFn);
Switch->addCase(B.getInt8(*I), BB);
llvm::IRBuilder<> B2(BB);
B2.CreateRet(B.getInt32(Idx));
}
}
void huddraw_info_inv_item(int id, float damage, int r) {
int col = 4+31*(id%4);
int row = r+2+10*(id/4);
int fcol = FONTS_ICON_EQ_C+8*(id%4);
int frow = FONTS_ICON_EQ_R+8*(id/4);
bg_color = COLOR_TRANSPARENT;
fg_color = (damage<0) ? B0(COLOR_CLAY_GRAY) : B3(COLOR_DIAMOND_BLUE);
draw_blit(fonts, fcol, frow, 8, 8, col, row);
fg_color = B2(COLOR_CLAY_GRAY);
draw_rect(col+10, row+1, 16, 6, 1);
if (damage >= 0) {
fg_color = B3(COLOR_LAPIS_BLUE);
if (damage < 1.0) fg_color = B3(COLOR_EMERALD_GREEN);
if (damage < 0.5) fg_color = B3(COLOR_GOLD_YELLOW);
if (damage < 0.25) fg_color = B3(COLOR_ORANGE);
if (damage < 0.1) fg_color = B3(COLOR_REDSTONE_RED);
draw_rect(col+10, row+1, 16*damage, 6, 0);
}
}
