Example #1
0
double Par(int i, double t)
{
    double fr = (V(i+1)-F(i)) / (XI(i+1)-X(i))-(F(i)-V(i))/(X(i)-XI(i));

    double c1 = V(i);
    double c2 = (F(i) - V(i)) / (X(i)-XI(i)) - (X(i)-XI(i))/(XI(i+1)-XI(i))*fr;
    double c3 = 1.0/(XI(i+1)-XI(i))*fr;
    double d = t - XI(i);
    return c1 + c2 * d + c3 * d*d;
}
Example #2
0
void GetNodesAndValues(int n) // from formula
{
    max = 0;
    min = 0;

    for (int i = 1; i <= n; i++)
    {
	X(i) = a + (double(i)/double(n)) * (b-a);
	F(i) = f(X(i));
	if (max < F(i)) max = F(i);
	if (min > F(i)) min = F(i);
    }
    for (int i = 2; i <= n; i++) XI(i) = .5*(X(i-1)+X(i));
    XI(1) = a - (XI(2)-a);
    XI(n+1) = b + (b-XI(n));
}
Example #3
0
void DrawWindowContent()
{
    int w = nWWidth; int h = nWHeight;
    
    WSetColor (DARKGRAY);
    WFillRectangle (0, 0, w, h);
    WSetColor (BLACK);
    //axis
    WDrawLine(0, h/2, w, h/2);
    WDrawLine(w/2, 0, w/2, h);
    //arrows
    WDrawLine(w/2, 0, w/2-5,5);
    WDrawLine(w/2, 0, w/2+5,5);
    
    WDrawLine(w, h/2, w-5,h/2-5);
    WDrawLine(w, h/2, w-5,h/2+5);
    WSetColor(RED);
    WDrawString ("Q=quit, F1..F4 -- change scale, F5/F6 -- change node count", 10, 20);

    double diff = 0;
    for (int i = 1; i < N+1; i++)
    {
	int ss = int((XI(i)-a)/(b-a)*w);
	int se = int((XI(i+1)-a)/(b-a)*w);
	for (int j = ss; j <= se; j++)
	{
	    double t1 = (double(j)/double(w))*(b-a)+a;
	    double t2 = (double(j+1)/double(w))*(b-a)+a;
	    WSetColor (GREEN);
	    
	    WDrawLine(MX(t1), MY(Par(i, t1)), MX(t2), MY(Par(i, t2)));
	    WSetColor (BLUE);
	    WDrawLine(MX(t1), MY(f(t1)), MX(t2), MY(f(t2)));
	    if (diff < fabs(f(t1) - Par(i,t1))) diff = fabs(f(t1) - Par(i,t1));
	}
    }
    WSetColor(RED);
    for (int i = 1; i < N+1; i++) WDrawLine(MX(X(i)), h/2-3, MX(X(i)), h/2+3);

    char str[256];
    WSetColor(RED);
    sprintf(str, "Difference: %1.10lf", diff);
    WDrawString(str, 10, 40);
}
Example #4
0
static void mdlOutputs(SimStruct *S, int_T tid)
{
	double sp_original;
    double meas_scaled;
    double manip_original_in;
    double xi_in;
    int mode;
    double K;
    double Ti;
    double h;
    double LO_y;
    double HI_y;
    double LO_u;
    double HI_u;
    int action;
    int P_only;
    double rel_lo;
    double rel_hi;
    double hys;
    double hi_flag_in;

    double *manip_original;
    double *xi;
    double *hi_flag;
#ifdef DEBUG
	debug("mdlOutputs entered.\n");
#endif
	sp_original = SETPOINT(S);
	meas_scaled = INPUT(S);
	manip_original_in = MV(S);
	xi_in = XI(S);
	mode = MODE(S);
	K = GAIN(S);
	Ti = RESET(S);
	h = SAMPLING(S);
	LO_y = LOWMEAS(S);
	HI_y = HIGHMEAS(S);
	LO_u = LOWMV(S);
	HI_u = HIGHMV(S);
	action = PGAIN(S);
	P_only = PONLY(S);
	rel_lo = RELLO(S);
	rel_hi = RELHI(S);
	hys = HYS(S);
	hi_flag_in = HIFLAG(S);
	
	manip_original = &OUTPUT(S);
	xi = &XO(S);
	hi_flag = &FLAG(S);
	
	controller(manip_original, xi, hi_flag, sp_original, meas_scaled, manip_original_in, xi_in, mode, K, Ti, h, LO_y, HI_y, LO_u, HI_u, action, P_only, rel_lo, rel_hi, hys, hi_flag_in);

#ifdef DEBUG
	debug("mdlOutputs left.\n");
#endif
} /* mdlOutputs */
Example #5
0
scalar sasfit_ff_cyl_rwbrush_scc_core(scalar alpha, sasfit_param *param)
{
	scalar w;

	SASFIT_ASSERT_PTR(param);

	w	= sasfit_rwbrush_w(V[Q], V[RG]);

	return pow(w*XI(V[Q], V[R]+V[D]*V[RG], V[H]+2.0*V[D]*V[RG], alpha), 2.0) * sin(alpha);
}
Example #6
0
XI_EXPORT
void XI(main_paai)(int64_t** args) {
    XiQAppCtorReturn ret;
    XI(qapplication_t2o12QApplicationaaiaai)(&ret, args);

    // Create a QWidget "subclass", with custom paintEvent
    // vtable here and not in init function.
    mainWidget = (XiQWidget*)XI(_alloc_i)(XI(_size_QWidget));
    mainWidgetTable = XI(_vt_QWidget);

    // override the events
    mainWidgetTable.paintEvent = handlePaintEvent;
    mainWidget->vptr = &mainWidgetTable;

    // create the back buffer pixmap
    backBuffer = XI(qpixmap_o7QPixmapii)(DIM, DIM);

    // create animation timer.
    XiQTimer* timer = XI(qtimer_o6QTimer)();

    // make our listener.
    XiTimerListener* l = (XiTimerListener*)XI(_alloc_i)(XI(_size_TimerListener));
    listenerTable = XI(_vt_TimerListener);
    listenerTable.timeout = handleTimeout;
    l->vptr = &listenerTable;
    // and add it.
    timer->vtable()->addTimerListener(timer, l);

    // start the timer..
    timer->vtable()->setSingleShot(timer, false);
    timer->vtable()->setInterval(timer, 40);
    timer->vtable()->start(timer);

    mainWidget->setFixedSize(mainWidget, XI(qsize_o5QSizeii)(DIM, DIM));
    mainWidget->vtable()->show(mainWidget);
    ret.app->vtable()->exec(ret.app);
}
void DM_Z_Interaction::updateMatrix(const Vector3d &K, MatrixXcd &LN) const
{
  complex<double> XI(0.0, 1.0);
  complex<double> gamma_rs = neighbors.getGamma(K);

  LN(r, r) -= z_rs * tmp0;
  LN(r, s) -= z_rs * conj(gamma_rs) * (tmp1 - XI * tmp2 - XI * tmp3 - tmp4);
  LN(s, r) -= z_rs * gamma_rs * (-tmp1 + XI * tmp2 + XI * tmp3 - tmp4);
  LN(s, s) -= z_rs * tmp0;
  LN(r, s + M) -= z_rs * conj(gamma_rs) * (-tmp1 + XI * tmp2 - XI * tmp3 + tmp4);
  LN(s, r + M) -= z_rs * gamma_rs * (-tmp1 + XI * tmp2 - XI * tmp3 + tmp4);
  LN(r + M, s) -= z_rs * conj(gamma_rs) * (-tmp1 - XI * tmp2 + XI * tmp3 + tmp4);
  LN(s + M, r) -= z_rs * gamma_rs * (-tmp1 - XI * tmp2 + XI * tmp3 + tmp4);
  LN(r + M, r + M) -= z_rs * tmp0;
  LN(r + M, s + M) -= z_rs * conj(gamma_rs) * (-tmp1 + XI * tmp2 + XI * tmp3 - tmp4);
  LN(s + M, s + M) -= z_rs * tmp0;
  LN(s + M, r + M) -= z_rs * gamma_rs * (-tmp1 - XI * tmp2 - XI * tmp3 - tmp4);
}
void MagneticFieldInteraction::calcConstantValues(const Cell &cell)
{
  complex<double> XI(0.0, 1.0);
  // find location of r
  r = cell.getPosition(sl_r);
  M = cell.size();

  const Matrix3 &inv = cell[r].getInverseMatrix();

  LNrr = complex<double>(0.0, 0.0);

  for (int i = 0; i < 3; i++)
  {
    // cout << i << " " << j << " " << directions(i,j) << endl;
    if (abs(directions(i)) > 1.0e-10)
    {
      LNrr += 0.5 * value * directions(i) * inv(i, 2);
    }
  }
  // cout << LNrr << endl;
}
void MagneticFieldInteraction::calculateFirstOrderTerms(const Cell &cell, Eigen::VectorXcd &elements)
{
  complex<double> XI(0.0, 1.0);
  r = cell.getPosition(sl_r);
  M = cell.size();
  double S = cell[r].getMoment();
  const Matrix3 &inv = cell[r].getInverseMatrix();

  for (int i = 0; i < 3; i++)
  {
    // cout << i << " " << j << " " << directions(i,j) << endl;
    if (abs(directions(i)) > 1.0e-10)
    {
      double X = value * directions(i) * sqrt(S / 2.0);
      complex<double> nu = inv(i, 0) + XI * inv(i, 1);
      // cout << "nu= " << nu << endl;
      elements(r) -= X * conj(nu);
      elements(r + M) -= X * nu;
    }
  }
}
Example #10
0
static void handlePaintEvent(XiQWidget* __thisPtr, XiQPaintEvent* pe)
{
    // draw scene on backBuffer
    backBuffer->vtable()->fill(backBuffer, XI(qcolor_o6QColoriii)(255, 255, 192));
    XiQPainter* p = XI(qpainter_o8QPaintero12QPaintDevice)(backBuffer);
    p->vtable()->setHighQuality(p, true);

    XiQPen* pen = XI(qpen_o4QPeno6QColor)(XI(qcolor_o6QColoriii)(0, 0, 255));
    pen->vtable()->setWidth(pen, 5);
    p->vtable()->setPen(p, pen);
    p->vtable()->setBrush(p, XI(qbrush_o6QBrusho6QColor)(XI(qcolor_o6QColoriii)(255, 0, 0)));
    p->vtable()->drawEllipse(p, ballRect());
    p->vtable()->end(p);

    // paint the backbuffer
    XiQRect* dirty = pe->vtable()->rect(pe);
    XiQPainter* pw = XI(qpainter_o8QPaintero12QPaintDevice)(__thisPtr);
    pw->vtable()->drawPixmapPortion(pw, dirty->vtable()->topLeft(dirty),
                                    backBuffer, dirty);
    pw->vtable()->end(pw);
}
Example #11
0
static void analop_esil(RAnal *a, RAnalOp *op, ut64 addr, const ut8 *buf, const char *buf_asm) {
	r_strbuf_init (&op->esil);
	r_strbuf_set (&op->esil, "");

	switch (buf[0]) {

	// Irregulars sorted by lower nibble
	case 0x00: /* nop  */ emit(","); break;
	case 0x10: /* jbc  */
		k(BIT_R "&,?{,%2$d,1,<<,255,^,%1$d,&=[1],%3$hhd,3,+,pc,+=,}"); break;
	case 0x20: /* jb   */
		k(BIT_R "&,?{,%3$hhd,3,+,pc,+=,}"); break;
	case 0x30: /* jnb  */
		k(BIT_R "&,!,?{,%3$hhd,3,+,pc,+=,}"); break;
	case 0x40: /* jc   */ emitf("C,!,?{,%hhd,2,+,pc,+=,}", buf[1]); break;
	case 0x50: /* jnc  */ emitf("C,""?{,%hhd,2,+,pc,+=,}", buf[1]); break;
	case 0x60: /* jz   */ emitf("A,!,?{,%hhd,2,+,pc,+=,}", buf[1]); break;
	case 0x70: /* jnz  */ emitf("A,""?{,%hhd,2,+,pc,+=,}", buf[1]); break;
	case 0x80: /* sjmp */ j(ESX_L1 JMP("2")); break;
	case 0x90: /* mov  */ emitf("%d,dptr,=", (buf[1]<<8) + buf[2]); break;
	case 0xA0: /* orl  */ k(BIT_R "C,|="); break;
	case 0xB0: /* anl  */ k(BIT_R "C,&="); break;
	case 0xC0: /* push */ h(XR(IB1) PUSH1); break;
	case 0xD0: /* pop  */ h(POP1 XW(IB1)); break;
	case 0xE0: /* movx */ /* TODO */ break;
	case 0xF0: /* movx */ /* TODO */ break;

	case 0x11: case 0x31: case 0x51: case 0x71:
	case 0x91: case 0xB1: case 0xD1: case 0xF1:
		emit(CALL("2")); // fall through
	case 0x01: case 0x21: case 0x41: case 0x61:
	case 0x81: case 0xA1: case 0xC1: case 0xE1:
		emitf("0x%x,pc,=", (addr & 0xF800) | ((((unsigned short)buf[0])<<3) & 0x0700) | buf[1]); break;

	case 0x02: /* ljmp  */ emitf(          "%d,pc,=", (unsigned int)((buf[1]<<8)+buf[2])); break;
	case 0x12: /* lcall */ emitf(CALL("3")",%d,pc,=", (unsigned int)((buf[1]<<8)+buf[2])); break;
	case 0x22: /* ret   */ emitf(POP2 "pc,="); break;
	case 0x32: /* reti  */ /* TODO */ break;
	case 0x72: /* orl   */ /* TODO */ break;
	case 0x82: /* anl   */ /* TODO */ break;
	case 0x92: /* mov   */ /* TODO */ break;
	case 0xA2: /* mov   */ /* TODO */ break;
	case 0xB2: /* cpl   */ k("%2$d,1,<<,%1$d,^=[1]"); break;
	case 0xC2: /* clr   */ /* TODO */ break;

	case 0x03: /* rr   */ emit("1,A,0x101,*,>>,A,="); break;
	case 0x13: /* rrc  */ /* TODO */ break;
	case 0x23: /* rl   */ emit("7,A,0x101,*,>>,A,="); break;
	case 0x33: /* rlc  */ /* TODO */ break;
	case 0x73: /* jmp  */ emit("dptr,A,+,pc,="); break;
	case 0x83: /* movc */ emit("A,dptr,+,[1],A,="); break;
	case 0x93: /* movc */ emit("A,pc,+,[1],A,="); break;
	case 0xA3: /* inc  */ h(XI(IB1, "++")); break;
	case 0xB3: /* cpl  */ emit("1," XI(C, "^")); break;
	case 0xC3: /* clr  */ emit("0,C,="); break;

	// Regulars sorted by upper nibble
	OP_GROUP_UNARY_4(0x00, "++")
	OP_GROUP_UNARY_4(0x10, "--")
	OP_GROUP_INPLACE_LHS_4(0x20, A, "+")

	case 0x34:
		h (XR(L1)  "C,+," XI(A, "+")) break;
	case 0x35:
		h (XR(IB1) "C,+," XI(A, "+")) break;

	case 0x36: case 0x37:
		j (XR(R0I) "C,+," XI(A, "+")) break;

	case 0x38: case 0x39:
	case 0x3A: case 0x3B:
	case 0x3C: case 0x3D:
	case 0x3E: case 0x3F:
		h (XR(R0)  "C,+," XI(A, "+")) break;

	OP_GROUP_INPLACE_LHS_4(0x40, A, "|")
	OP_GROUP_INPLACE_LHS_4(0x50, A, "&")
	OP_GROUP_INPLACE_LHS_4(0x60, A, "^")

	case 0x74:
		h (XR(L1) XW(A)) break;
	case 0x75:
		h (XR(L2) XW(IB1)) break;

	case 0x76: case 0x77:
		j (XR(L1) XW(R0I)) break;

	case 0x78: case 0x79:
	case 0x7A: case 0x7B:
	case 0x7C: case 0x7D:
	case 0x7E: case 0x7F:
		h (XR(L1) XW(R0)) break;

	case 0x84:
		/* div */ emit("B,!,OV,=,0,A,B,A,/=,A,B,*,-,-,B,=,0,C,="); break;
	case 0x85:
		/* mov */ h(IRAM_BASE ",%2$d,+,[1]," IRAM_BASE ",%2$d,+,=[1]"); break;

	case 0x86: case 0x87:
		j (XR(R0I) XW(IB1)) break;

	case 0x88: case 0x89:
	case 0x8A: case 0x8B:
	case 0x8C: case 0x8D:
	case 0x8E: case 0x8F:
		h (XR(R0) XW(IB1)) break;

	OP_GROUP_INPLACE_LHS_4(0x90, A, ".")

	case 0xA4:
		/* mul */ emit("8,A,B,*,DUP,>>,DUP,!,!,OV,=,B,=,A,=,0,C,="); break;
	case 0xA5: /* ??? */ emit("0,TRAP"); break;
	case 0xA6: case 0xA7:
		j (XR(IB1) XW(R0I)) break;

	case 0xA8: case 0xA9:
	case 0xAA: case 0xAB:
	case 0xAC: case 0xAD:
	case 0xAE: case 0xAF:
		h (XR(IB1) XW(R0)) break;

	case 0xB4:
		h (XR(L1)  XR(A)   "!=,?{,%3$hhd,2,+pc,+=,}") break;
	case 0xB5:
		h (XR(IB1) XR(A)   "!=,?{,%3$hhd,2,+pc,+=,}") break;

	case 0xB6: case 0xB7:
		j (XR(L1)  XR(R0I) "!=,?{,%3$hhd,2,+pc,+=,}") break;

	case 0xB8: case 0xB9:
	case 0xBA: case 0xBB:
	case 0xBC: case 0xBD:
	case 0xBE: case 0xBF:
		h (XR(L1)  XR(R0)  "!=,?{,%3$hhd,2,+pc,+=,}") break;

	case 0xC4:
		/* swap */ emit("4,A,0x101,*,>>,A,="); break;
	case 0xC5:
		/* xch  */ /* TODO */ break;

	case 0xC6: case 0xC7:
		/* xch  */ /* TODO */ break;

	case 0xC8: case 0xC9:
	case 0xCA: case 0xCB:
	case 0xCC: case 0xCD:
	case 0xCE: case 0xCF:
		/* xch  */ h (XR(A) XR(R0) XW(A) ","  XW(R0)); break;

	case 0xD2:
		/* setb */ /* TODO */ break;
	case 0xD3:
		/* setb */ /* TODO */ break;
	case 0xD4:
		/* da   */ emit("A,--="); break;
	case 0xD5:
		/* djnz */ h(XI(R0I, "--") "," XR(R0I) CJMP(L2, "2")); break;
	case 0xD6:
		/* xchd */ /* TODO */ break;
	case 0xD7:
		/* xchd */ /* TODO */ break;

	case 0xD8: case 0xD9:
	case 0xDA: case 0xDB:
	case 0xDC: case 0xDD:
	case 0xDE: case 0xDF:
		/* djnz */ h(XI(R0, "--") "," XR(R0) CJMP(L1, "2")); break;

	case 0xE2: case 0xE3:
		/* movx */ j(XRAM_BASE "r%0$d,+,[1]," XW(A)); break;

	case 0xE4:
		/* clr  */ emit("0,A,="); break;
	case 0xE5:
		/* mov  */ h (XR(IB1) XW(A)) break;

	case 0xE6: case 0xE7:
		/* mov  */ j (XR(R0I) XW(A)) break;

	case 0xE8: case 0xE9:
	case 0xEA: case 0xEB:
	case 0xEC: case 0xED:
	case 0xEE: case 0xEF:
		/* mov  */ h (XR(R0)  XW(A)) break;

	case 0xF2: case 0xF3:
		/* movx */ j(XR(A) XRAM_BASE "r%0$d,+,=[1]");

	case 0xF4:
		/* cpl  */ h ("255" XI(A, "^")) break;
	case 0xF5:
		/* mov  */ h (XR(A) XW(IB1)) break;

	case 0xF6: case 0xF7:
		/* mov  */ j (XR(A) XW(R0I)) break;

	case 0xF8: case 0xF9:
	case 0xFA: case 0xFB:
	case 0xFC: case 0xFD:
	case 0xFE: case 0xFF:
		/* mov  */ h (XR(A) XW(R0)) break;

	default: break;
	}
}
Example #12
0
static void analop_esil(RAnal *a, RAnalOp *op, ut64 addr, const ut8 *buf) {
	r_strbuf_init (&op->esil);
	r_strbuf_set (&op->esil, "");

	switch (buf[0]) {
	// Irregulars sorted by lower nibble
	case 0x00: /* nop */
		emit (",");
		break;

	case 0x10: /* jbc bit, offset */
		k (BIT_R "?{," BIT_MASK XI(BIT, "&") JMP ",}");
		break;
	case 0x20: /* jb bit, offset */
		k (BIT_R CJMP);
		break;
	case 0x30: /* jnb bit, offset */
		k (BIT_R "!," CJMP);
		break;
	case 0x40: /* jc offset */
		h ("c,1,&," CJMP);
		break;
	case 0x50: /* jnc offset */
		h ("c,1,&,!," CJMP );
		break;
	case 0x60: /* jz offset */
		h ("a,0,==," CJMP);
		break;
	case 0x70: /* jnz offset */
		h ("a,0,==,!," CJMP);
		break;

	case 0x11: case 0x31: case 0x51: case 0x71:
	case 0x91: case 0xB1: case 0xD1: case 0xF1: /* acall addr11 */
	case 0x12: /* lcall addr16 */
		j (CALL);
		/* fall through */
	case 0x01: case 0x21: case 0x41: case 0x61:
	case 0x81: case 0xA1: case 0xC1: case 0xE1: /* ajmp addr11 */	
	case 0x02: /* ljmp addr16 */
	case 0x80: /* sjmp offset */
		j (JMP);
		break;

	case 0x22: /* ret */
	case 0x32: /* reti */
		emitf (POP2 "pc,=");
		break;

	case 0x03: /* rr a */
		emit ("1,a,0x101,*,>>,a,=," FLAG_P);
		break;
	case 0x04: /* inc a */
		h (XI(A, "++") FLAG_P);
		break;
	case 0x05: /* inc direct */
		h (XI(IB1, "++"));
		break;
	case 0x06: case 0x07: /* inc @Ri */
		j (XI(RI, "++"));
		break;
	case 0x08: case 0x09: case 0x0A: case 0x0B:
	case 0x0C: case 0x0D: case 0x0E: case 0x0F: /* dec @Rn */
		h (XI(RN, "++"));
		break;
	case 0x13: /* rrc a */
		emit ("7,c,<<,1,a,&,c,=,0x7f,1,a,>>,&,+,a,=," FLAG_P);
		break;
	case 0x14: /* dec a */
		h (XI(A, "--") FLAG_P);
		break;
	case 0x15: /* dec direct */
		h (XI(IB1, "--"));
		break;
	case 0x16: case 0x17: /* dec @Ri */
		j (XI(RI, "--"));
		break;
	case 0x18: case 0x19: case 0x1A: case 0x1B:
	case 0x1C: case 0x1D: case 0x1E: case 0x1F: /* dec @Rn */
		h (XI(RN, "--"));
		break;
	case 0x23: /* rl a */
		h ("7,a,0x101,*,>>,a,=," FLAG_P);
		break;
	TEMPLATE_ALU (0x20, "+", FLAG_C FLAG_AC FLAG_OV FLAG_P) /* 0x24..0x2f add a,.. */
	case 0x33: /* rlc a */
		h ("c,1,&,a,a,+=,$c7,c,=,a,+=," FLAG_P);
		break;
	TEMPLATE_ALU_C (0x30, "+", FLAG_C FLAG_AC FLAG_OV FLAG_P) /* 0x34..0x2f addc a,.. */
	case 0x42: /* orl direct, a */
		h (XR(A) XI(IB1, "|"));
		break;
	case 0x43: /* orl direct, imm */
		h (XR(L2) XI(IB1, "|"));
		break;
	TEMPLATE_ALU (0x40, "|", FLAG_P) /* 0x44..0x4f orl a,.. */
	case 0x52: /* anl direct, a */
		h (XR(A) XI(IB1, "&"));
		break;
	case 0x53: /* anl direct, imm */
		h (XR(L2) XI(IB1, "&"));
		break;
	TEMPLATE_ALU (0x50, "&", FLAG_P) /* 0x54..0x5f anl a,.. */
	case 0x62: /* xrl direct, a */
		h (XR(A) XI(IB1, "^"));
		break;
	case 0x63: /* xrl direct, imm */
		h (XR(L2) XI(IB1, "^"));
		break;
	TEMPLATE_ALU (0x60, "^", FLAG_P) /* 0x64..0x6f xrl a,.. */
	case 0x72: /* orl C, bit */
		k (BIT_R XI(C, "|"));
		break;
	case 0x73: /* jmp @a+dptr */
		emit ("dptr,a,+,pc,="); break;
	case 0x74: /* mov a, imm */
		h (XR(L1) XW(A) FLAG_P);
		break;
	case 0x75: /* mov direct, imm */
		h (XR(L2) XW(IB1));
		break;
	case 0x76: case 0x77: /* mov @Ri, imm */
		j (XR(L1) XW(RI));
		break;
	case 0x78: case 0x79: case 0x7A: case 0x7B:
	case 0x7C: case 0x7D: case 0x7E: case 0x7F: /* mov Rn, imm */
		h (XR(L1) XW(RN));
		break;
	case 0x82: /* anl C, bit */
		k (BIT_R XI(C, "&"));
		break;
	case 0x83: /* movc a, @a+pc */
		emit ("a,pc,--,+,[1]," XW(A) FLAG_P);
		break;
	case 0x84: /* div ab */
		emit ("b,!,OV,=,0,a,b,a,/=,a,b,*,-,-,b,=,0,c,=");
		break;
	case 0x85: /* mov direct, direct */
		h (XR(IB1) XW(IB2));
		break;
	case 0x86: case 0x87: /* mov direct, @Ri */
		j (XR(RI) XW(IB1));
		break;
	case 0x88: case 0x89: case 0x8A: case 0x8B:
	case 0x8C: case 0x8D: case 0x8E: case 0x8F: /* mov direct, Rn */
		h (XR(RN) XW(IB1));
		break;
	case 0x90: /* mov dptr, imm */
		h (XR(L16) XW(DP));
		break;
	case 0x92: /* mov bit, C */
		k (BIT_C BIT_MASK XR(BIT) "&,|," XW(BIT));
		break;
	case 0x93: /* movc a, @a+dptr */
		h ("a,dptr,+,[1]," XW(A) FLAG_P);
		break;
	TEMPLATE_ALU_C (0x90, "-", FLAG_B FLAG_AB FLAG_OB FLAG_P) /* 0x94..0x9f subb a,.. */
	case 0xA0: /* orl C, /bit */
		k (BIT_R "!," XI(C, "|"));
		break;
	case 0xA2: /* mov C, bit */
		k (BIT_R XW(C));
		break;
	case 0xA3: /* inc dptr */
		h (XI(DP, "++"));
		break;
	case 0xA4: /* mul ab */
		emit ("8,a,b,*,NUM,>>,NUM,!,!,ov,=,b,=,a,=,0,c,=");
		break;
	case 0xA5: /* "reserved" */
		emit ("0,trap");
		break;
	case 0xA6: case 0xA7: /* mov @Ri, direct */
		j (XR(IB1) XW(RI));
		break;
	case 0xA8: case 0xA9: case 0xAA: case 0xAB:
	case 0xAC: case 0xAD: case 0xAE: case 0xAF: /* mov Rn, direct */
		h (XR(IB1) XW(RN));
		break;
	case 0xB0: /* anl C, /bit */
		k (BIT_R "!," XI(C, "&"));
		break;
	case 0xB2: /* cpl bit */
		k (BIT_SET XI(BIT, "^"));
		break;
	case 0xB3: /* cpl C */
		h ("1," XI(C, "^"));
		break;
	case 0xB4: /* cjne a, imm, offset */
		h (XR(L1) XR(A) "-," CJMP);
		break;
	case 0xB5: /* cjne a, direct, offset */
		h (XR(IB1) XR(A) "-," CJMP);
		break;
	case 0xB6: case 0xB7: /* cjne @ri, imm, offset */
		j (XR(L1) XR(RI) "-," CJMP);
		break;
	case 0xB8: case 0xB9: case 0xBA: case 0xBB:
	case 0xBC: case 0xBD: case 0xBE: case 0xBF: /* cjne Rn, imm, offset */
		h (XR(L1) XR(RN) "-," CJMP);
		break;
	case 0xC0: /* push direct */
		h (XR(IB1) PUSH1);
		break;
	case 0xC2: /* clr bit */
		k (BIT_MASK XI(BIT, "&"));
		break;
	case 0xC3: /* clr C */
		h ("0," XW(C));
		break;
	case 0xC4: /* swap a */
		h ("0xff,4,a,0x101,*,>>,&," XW(A) FLAG_P);
		break;
	case 0xC5: /* xch a, direct */
		h (XR(A) "0,+," XR(IB1) XW(A) XW(IB1) FLAG_P);
		break;
	case 0xC6: case 0xC7: /* xch a, @Ri */ 
		j (XR(A) "0,+," XR(RI) XW(A) XW(RI) FLAG_P);
		break;
	case 0xC8: case 0xC9: case 0xCA: case 0xCB:
	case 0xCC: case 0xCD: case 0xCE: case 0xCF: /* xch a, Rn */
		h (XR(A) "0,+," XR(RN) XW(A) XW(RN) FLAG_P);
		break;
	case 0xD0: /* pop direct */
		h (POP1 XW(IB1));
		break;
	case 0xD2: /* setb bit */
		k (BIT_SET XI(BIT, "|"));
		break;
	case 0xD3: /* setb C */
		h ("1," XW(C));
		break;
	case 0xD4: /* da a */
		// BCD adjust after add:
		// if (lower nibble > 9) or (AC == 1) add 6
		// if (higher nibble > 9) or (C == 1) add 0x60
		// carry |= carry caused by this operation
		emit ("a,0x0f,&,9,<,ac,|,?{,6,a,+=,$c7,c,|=,},a,0xf0,&,0x90,<,c,|,?{,0x60,a,+=,$c7,c,|=,}," FLAG_P);
		break;
	case 0xD5: /* djnz direct, offset */
		h (XI(IB1, "--") XR(IB1) "0,==,!," CJMP);
		break;
	case 0xD6:
	case 0xD7: /* xchd a, @Ri*/
		j (XR(A) "0xf0,&," XR(RI) "0x0f,&,|," XR(RI) "0xf0,&," XR(A) "0x0f,&,|," XW(RI) XW(A) FLAG_P);
		break;
	case 0xD8: case 0xD9: case 0xDA: case 0xDB:
	case 0xDC: case 0xDD: case 0xDE: case 0xDF: /* djnz Rn, offset */
		h (XI(RN, "--") XR(RN) "0,==,!," CJMP);
		break;
	case 0xE0: /* movx a, @dptr */
		h (XR(DPX) XW(A) FLAG_P);
		break;
	case 0xE2: case 0xE3: /* movx a, @Ri */
		j (XR(R0X) XW(A) FLAG_P);
		break;
	case 0xE4: /* clr a */
		emit ("0," XW(A) FLAG_P);
		break;
	case 0xE5: /* mov a, direct */
		h (XR(IB1) XW(A) FLAG_P);
		break;
	case 0xE6: case 0xE7: /* mov a, @Ri */
		j (XR(RI) XW(A) FLAG_P);
		break;
	case 0xE8: case 0xE9: case 0xEA: case 0xEB:
	case 0xEC: case 0xED: case 0xEE: case 0xEF: /* mov a, Rn */
		h (XR(RN) XW(A) FLAG_P);
		break;
	case 0xF0: /* movx @dptr, a */
		h (XR(A) XW(DPX));
		break;
	case 0xF2: case 0xF3: /* movx @Ri, a */
		j (XR(A) XW(R0X));
		break;
	case 0xF4: /* cpl a */
		h ("255," XI(A, "^") FLAG_P);
		break;
	case 0xF5: /* mov direct, a */
		h (XR(A) XW(IB1));
		break;
	case 0xF6: case 0xF7: /* mov  @Ri, a */
		j (XR(A) XW(RI));
		break;
	case 0xF8: case 0xF9: case 0xFA: case 0xFB:
	case 0xFC: case 0xFD: case 0xFE: case 0xFF: /* mov Rn, a */
		h (XR(A) XW(RN));
		break;
	default:
		break;
	}
}
Example #13
0
static XiQRect* ballRect()
{
    return XI(qrect_o5QRectiiii)(x - R, y - R, R*2, R*2);
}
Example #14
0
void Interpolate(int n)
{
    delete x;
    delete fv;
    delete xi;
    delete v;
    delete aa;
    delete bb;
    x = new double[n];
    fv = new double[n];
    xi = new double[n+1];
    v = new double[n+1];
    aa = new double[(n+1)*(n+1)];
    bb = new double[n+1];
    
    GetNodesAndValues(n);
    
    for (int i = 1; i <= n+1; i++)
	for (int j = 1; j <= n+1; j++) A(i,j) = 0;
	
    for (int i = 2; i <= n; i++) //make system
    {
	A(i,i-1) = 1.0/(X(i-1)-XI(i-1)) - 1/(XI(i)-XI(i-1));
	A(i,i)   = 1.0/(XI(i)-X(i-1)) + 1.0/(XI(i)-XI(i-1)) + 1.0/(X(i)-XI(i)) + 1.0 /(XI(i+1)-XI(i));
	A(i,i+1) = 1.0/(XI(i+1)-X(i)) - 1.0/(XI(i+1)-XI(i));
	
	B(i) = F(i-1) * (1.0/(X(i-1)-XI(i-1)) + 1.0/(XI(i)-X(i-1)))+
		F(i) * (1.0/(X(i)-XI(i)) + 1.0/(XI(i+1)-X(i)));
    }
    
    // border conditions
    int i;
    i = 1;
    A(i,i) = 1.0/(X(i)-XI(i));
    A(i,i+1) = 1.0/(XI(i+1)-X(i));
    B(i) = F(i)*(1.0/(X(i)-XI(i))+ 1.0/(XI(i+1)-X(i)));

    i = n;
    A(i+1,i) = 1.0/(X(i)-XI(i));
    A(i+1,i+1) = 1.0/(XI(i+1)-X(i));
    B(i+1) = F(i)*(1.0/(X(i)-XI(i))+ 1.0/(XI(i+1)-X(i)));
    
//    PrintMatrix(aa,bb,n+1);
    
    
    SolveSystem(n+1,aa,bb,v);
}