예제 #1
0
ISTFLOAT GetDet(ISTFLOAT a[4][4], ISTSHORT n)
{
	ISTSHORT i, j, j1, j2;
	ISTFLOAT det = 0;
	ISTFLOAT mat[4][4] = {{0}};

	if (n == 2) { /* terminate recursion */
		det = _sub(_mul(a[0][0], a[1][1]), _mul(a[1][0], a[0][1]));
	} else {
		det = 0;
		for (j1 = 0; j1 < n; j1++) { /* do each column */
			for (i = 1; i < n; i++) { /* create minor */
				j2 = 0;
				for (j = 0; j < n; j++) {
					if (j == j1) {
						continue;
					}
					mat[i-1][j2] = a[i][j];
					j2++;
				}
			}
			/* sum (+/-)cofactor * minor */
			if ((j1 % 2) == 0) {
				det = _add(det, _mul(a[0][j1], GetDet(mat, n-1)));
			} else {
				det = _sub(det, _mul(a[0][j1], GetDet(mat, n-1)));
			}
		}
	}
	return det;
}
예제 #2
0
point
computeLyapunov (point p, point pe, struct attractor *a)
{
    point p2, dl, np;
    GLdouble dl2, df, rs;
    struct lyapu *lyapu = a->lyapunov;

    p2 = eval (pe, a->polynom);
    dl = _sub (p2, p);
    dl2 = _modulus (dl);

    if (dl2 == 0) {
        fprintf (stderr,
                 "Unable to compute Lyapunov exponent, trying to go on...\n");
        free (dl);
        free (p2);
        return pe;
    }

    df = dl2 / (LYAPU_DELTA * LYAPU_DELTA);
    rs = 1 / sqrt (df);

    lyapu->lsum += log (df);
    lyapu->n++;
    lyapu->ly = lyapu->lsum / lyapu->n / log (2);

    np = _sub (p, _scalar_mul (dl, rs));

    free (dl);
    free (p2);

    return np;
}
예제 #3
0
ISTVOID Get4Points(struct sphere_model *model)
{
	ISTFLOAT dv[IST_SPHERE_DATAMAX][3];
	ISTFLOAT cross[3] = {0};
	ISTFLOAT tmpv[3] = {0};
	ISTSHORT ndata = model->num;
	ISTSHORT i, j;
	ISTFLOAT dist, tmp;

	// Point 0
	for (j = 0; j < 3; ++j) {
		model->p4s[0][j] = model->data[0][j];
	}
	// Point 1
	dist = 0;
	for (i = 1; i < ndata; i++) {
		tmp = GetDistance(model->data[i], model->p4s[0]);
		if (_lt(dist, tmp)) {
			dist = tmp;
			for (j = 0; j < 3; j++) {
				model->p4s[1][j] = model->data[i][j];
			}
		}
	}
	// Point 2
	dist = 0;
	for (j = 0; j < 3; j++) {
		dv[0][j] = _sub(model->p4s[1][j], model->p4s[0][j]);
	}
	for (i = 1; i < ndata; i++) {
		for (j = 0; j < 3; j++) {
			dv[i][j] = _sub(model->data[i][j], model->p4s[0][j]);
		}
		tmpv[0] = _sub(_mul(dv[0][1], dv[i][2]), _mul(dv[0][2], dv[i][1]));
		tmpv[1] = _sub(_mul(dv[0][2], dv[i][0]), _mul(dv[0][0], dv[i][2]));
		tmpv[2] = _sub(_mul(dv[0][0], dv[i][1]), _mul(dv[0][1], dv[i][0]));
		tmp = _add3(_pow2(tmpv[0]), _pow2(tmpv[1]), _pow2(tmpv[2]));
		if (_lt(dist, tmp)) {
			dist = tmp;
			for (j = 0; j < 3; j++) {
				model->p4s[2][j] = model->data[i][j];
				cross[j] = tmpv[j];
			}
		}
	}
	// Point 3
	dist = 0;
	for (i = 1; i < ndata; i++) {
		tmp = _add3(_mul(dv[i][0], cross[0]), _mul(dv[i][1], cross[1]), _mul(dv[i][2], cross[2]));
		tmp = _abs(tmp);
		if (_lt(dist, tmp)) {
			dist = tmp;
			for (j = 0; j < 3; j++) {
				model->p4s[3][j] = model->data[i][j];
			}
		}
	}
	return;
}
예제 #4
0
		void _sub(TreeNode* root, int sum){
			if(root == NULL) return ;
			record_.push_back(root->val);
			if(root->left == NULL && root->right == NULL){
				if(root->val == sum){
					res_.push_back(record_);
				}
				record_.pop_back();
				return;
			}
			sum -= root->val;
			_sub(root->left, sum);
			_sub(root->right, sum);
			record_.pop_back();
		}
예제 #5
0
/* Remove the ids in SUB from those in UGIDS.  */
error_t
ugids_subtract (struct ugids *ugids, const struct ugids *sub)
{
  error_t err =
    _sub (&ugids->eff_uids, &ugids->eff_gids, &ugids->imp_eff_gids,
	  &sub->eff_uids, &sub->eff_gids, &sub->imp_eff_gids);

  if (! err)
    /* If this second call to _sub fails, ugids will be in an inconsistent
       state, but oh well.  */
    err = _sub (&ugids->avail_uids, &ugids->avail_gids, &ugids->imp_avail_gids,
		&sub->avail_uids, &sub->avail_gids, &sub->imp_avail_gids);

  return err;
}
예제 #6
0
int cgc_bn_div(bn_t *Q, bn_t *R, const bn_t *N, const bn_t *D)
{
    unsigned int i, len;
    cgc_bn_destroy(Q);
    cgc_bn_destroy(R);
    if (cgc_bn_init_bits(R, cgc_bn_length(D) + 1) != SUCCESS)
        return FAILURE;
    if (cgc_bn_length(N) > cgc_bn_length(D))
        len = cgc_bn_length(N) - cgc_bn_length(D);
    else
        len = 1;
    if (cgc_bn_init_bits(Q, len) != SUCCESS)
    {
        cgc_bn_destroy(R);
        return FAILURE;
    }

    for (i = cgc_bn_length(N); i-- > 0;)
    {
        _sll(R, 1);
        R->data[0] |= !!(N->data[i / 32] & (1 << (i % 32)));
        if (cgc_bn_cmp(R, D) >= 0)
        {
            _sub(R->data, D->data, D->length);
            Q->data[i / 32] |= 1 << (i % 32);
        }
    }

    return SUCCESS;
}
예제 #7
0
파일: executor.c 프로젝트: Rela-X/rlang
static
Value *
eval(const Ast *expr) {
	switch(expr->class) {
	case N_CALL:
		return call(expr);
	case N_ASSIGNMENT:
		return assignment(expr);
	case N_IDENTIFIER:
		return identifier(expr);
	case N_NEG:
		return _neg(expr);
	case N_NOT:
		return _not(expr);
	case N_EQ:
		return _eq(expr);
	case N_NEQ:
		return _neq(expr);
	case N_AND:
		return _and(expr);
	case N_IOR:
		return _ior(expr);
	case N_XOR:
		return _neq(expr); // alias
	case N_LT:
		return _lt(expr);
	case N_LE:
		return _le(expr);
	case N_GE:
		return _ge(expr);
	case N_GT:
		return _gt(expr);
	case N_ADD:
		return _add(expr);
	case N_SUB:
		return _sub(expr);
	case N_MUL:
		return _mul(expr);
	case N_DIV:
		return _div(expr);
	case N_POW:
		return _pow(expr);
	case N_MOD:
		return _mod(expr);
	case N_BOOLEAN:
		return _bool(expr);
	case N_INTEGER:
		return _int(expr);
	case N_FLOAT:
		return _float(expr);
	case N_STRING:
		return _string(expr);
	case N_SET:
		return _set(expr);
	case N_R:
		return _relation(expr);
	}
printf("EVALFAIL %d ", expr->class); pn(expr);
	assert(false && "should not be reached");
}
예제 #8
0
QJSValue THREEVector3::sub(QJSValue threeVector3) {
    THREEVector3 *vec = getAsTHREEVector3(threeVector3);
    if (!vec) {
        qDebug() << "THREEVector3::" << __FUNCTION__ << " parameter was not THREEVector3 was " << threeVector3.toQObject();
        return m_engine->newQObject(this);
    }

    return m_engine->newQObject(_sub(vec));
}
예제 #9
0
파일: instructions.c 프로젝트: cfdrake/cant
/*
 * Executes a given instruction, or errors out
 * ins - instruction to run
 */
void
execute (unsigned short int ins)
{
    /* seperate instruction into parts */
    short int a0 = (ins >> 12) % 16;
    short int a1 = (ins >> 8) % 16;
    short int a2 = (ins >> 4) % 16;
    short int a3 = (ins >> 0) % 16;

    /* Run associated instruction */
    switch(a0) {
    case 0x0:
        _add (a1, a2, a3);
        break;
    case 0x1:
        _sub (a1, a2, a3);
        break;
    case 0x2:
        _mul (a1, a2, a3);
        break;
    case 0x3:
        _div (a1, a2, a3);
        break;
    case 0x6:
        _beq (a1, a2, a3);
        break;
    case 0x7:
        _bgt (a1, a2, a3);
        break;
    case 0x8:
        _ld (a1, a2, a3);
        break;
    case 0x9:
        _st (a1, a2, a3);
        break;
    case 0xa:
        _lc (a1, a3);
        break;
    case 0xb:
        _jmp (a1, a3);
        break;
    case 0xc:
        _inc (a1, a3);
        break;
    case 0xf:
        _sys (a1, a3);
        break;
    default:
        printf ("Error: invalid opcode %#x.\n", a0);
        sys_dump (0x0);
        sys_halt (0x0);
    }
}
예제 #10
0
파일: .c 프로젝트: BackupTheBerlios/vsg-svn
/**
 * vsg_vector2@t@_dist:
 * @vec: a #VsgVector2@t@
 * @other: a #VsgVector2@t@
 *
 * Computes Euclidean norm of the substraction between @vec and @other.
 *
 * Returns: square of @vec-@other norm.
 */
@type@ vsg_vector2@t@_dist (const VsgVector2@t@ *vec,
                            const VsgVector2@t@ *other)
{
  VsgVector2@t@ tmp;

#ifdef VSG_CHECK_PARAMS
  g_return_val_if_fail (vec != NULL, 0.);
  g_return_val_if_fail (other != NULL, 0.);
#endif

  vsg_vector2@t@_sub (vec, other, &tmp);

  return vsg_vector2@t@_norm (&tmp);
}
예제 #11
0
ISTFLOAT GetDistance(CONST ISTFLOAT x[3], CONST ISTFLOAT y[3])
{
	ISTSHORT i;
	ISTFLOAT tmp, r = 0;

	for (i = 0; i < 3; ++i) {
		tmp = _sub(x[i], y[i]);
		r = _add(r, _pow2(tmp));
	}
	if (_le(r, 0)) {
		return 0;
	}
	return _sqrt(r);
}
예제 #12
0
파일: custom.cpp 프로젝트: SASfit/SASfit
c4_JoinPropViewer::c4_JoinPropViewer (c4_Sequence& seq_,
                    const c4_ViewProp& sub_, bool outer_)
  : _parent (&seq_),
    _sub (sub_), _subPos (_parent.FindProperty(sub_.GetId())), _subWidth (0)
{
  d4_assert(_subPos >= 0);

  for (int k = 0; k < _parent.NumProperties(); ++k)
  {
    if (k != _subPos)
      _template.AddProperty(_parent.NthProperty(k));
    else  // if there are no rows, then this join does very little anyway
        //! OOPS: if this is an unattached view, then the subviews can differ
      if (_parent.GetSize() > 0)
      {
        c4_View view = sub_ (_parent[0]);
        for (int l = 0; l < view.NumProperties(); ++l)
        {
          _template.AddProperty(view.NthProperty(l));
          ++_subWidth;
        }
      }
  }

  _base.SetSize(0, 5);
  _offset.SetSize(0, 5);

  for (int i = 0; i < _parent.GetSize(); ++i)
  {
    c4_View v = _sub (_parent[i]);

    int n = v.GetSize();
    if (n == 0 && outer_)
    {
      _base.Add(i);
      _offset.Add(~ (t4_i32) 0);  // special null entry for outer joins
    }
    else
      for (int j = 0; j < n; ++j)
      {
        _base.Add(i);
        _offset.Add(j);
      }
  }
}
예제 #13
0
int
isAttractorConverging (struct attractor *at)
{
    point p, pe, pnew = NULL;
    int i, result = 0;

    p = newPoint ();
    pe = newPoint ();
    for (i = 0; i < fset.dimension; i++)
        p[i] = pe[i] = 0.1;
    pe[0] += LYAPU_DELTA;
    at->lyapunov->lsum = at->lyapunov->ly = at->lyapunov->n = 0;

    for (i = 0; i < at->convergenceIterations; i++) {
        pnew = eval (p, at->polynom);

        if (_abs (pnew) > AT_INFINITY) {        /* Diverging - not an SA */
            free (p);
            break;
        }
        point ptmp = _sub (pnew, p);
        if (_abs (ptmp) < 1 / AT_INFINITY) {    /* Fixed point - not an SA */
            free (p);
            free (ptmp);
            break;
        }
        free (ptmp);
        ptmp = computeLyapunov (pnew, pe, at);
        free (pe);
        pe = ptmp;
        if (at->lyapunov->ly < 0.005 && i >= NUM_CONVERGENCE_POINTS) {  /* Limit cycle - not an SA */
            free (p);
            break;
        }
        free (p);
        p = pnew;
    }
    if (i == at->convergenceIterations)
        result = 1;
    free (pnew);
    free (pe);
    return result;
}
예제 #14
0
ISTBOOL GetParams(struct sphere_model *model, ISTFLOAT rad)
{
	ISTSHORT i, j;
	ISTFLOAT min[3] = {0};
	ISTFLOAT max[3] = {0};
	ISTFLOAT mean[3] = {0};
	ISTFLOAT var[3] = {0};
	ISTFLOAT tmpf;
	ISTFLOAT two = _float(2);

	for (j = 0; j < 3; j++) {
		min[j] = model->offsets[0][j];
		max[j] = model->offsets[0][j];
		for (i = 1; i < IST_SPHERE_OFFSET_NUM; i++) {
			if (_lt(model->offsets[i][j], min[j])) {
				min[j] = model->offsets[i][j];
			}
			if (_gt(model->offsets[i][j], max[j])) {
				max[j] = model->offsets[i][j];
			}
		}
		mean[j] = _div(_add(max[j], min[j]), two);
		var[j] = _sub(max[j], min[j]);
	}
	tmpf = _mul(rad, model->ratio);
	if (_ge(var[0], tmpf) || _ge(var[1], tmpf) || _ge(var[2], tmpf)) {
		goto EXIT;
	}
	for (j = 0; j < 3; ++j) {
		model->mean[j] = mean[j];
		model->var[j] = var[j];
	}
	model->rad = rad;
	return ISTTRUE;

EXIT:
	return ISTFALSE;
}
예제 #15
0
int main () {
	int i1 = 20, i2 = 4, i3;
	float f1 = 1.5,f2 = 0.3,f3;

	i3 = _add(i1, i2);
	printf("add(%d, %d)=%d\n", i1, i2, i3);
	i3 = _sub(i1, i2);
	printf("sub(%d, %d)=%d\n", i1, i2, i3);
	i3 = _mul(i1, i2);
	printf("mul(%d, %d)=%d\n", i1, i2, i3);
	i3 = _div(i1, i2);
	printf("div(%d, %d)=%d\n", i1, i2, i3);

	f3 = _fadd(f1, f2);
	printf("fadd(%f, %f)=%f\n", f1, f2, f3);
	f3 = _fsub(f1, f2);
	printf("fsub(%f, %f)=%f\n", f1, f2, f3);
	f3 = _fmul(f1, f2);
	printf("fmul(%f, %f)=%f\n", f1, f2, f3);
	f3 = _fdiv(f1, f2);
	printf("fdiv(%f, %f)=%f\n", f1, f2, f3);
    return 0;
}
예제 #16
0
파일: encode.cpp 프로젝트: Aman2302/mimic
//-----------------------------------------------------------------------------
//
// 命令コマンドを解釈してバイナリに変換
//
//-----------------------------------------------------------------------------
bool encode(char* instName, char* buffer, map<uint32_t, string>& labelNames, uint32_t currentLine, uint32_t& code, bool& useLabel)
{
	uint32_t rs = 0;
	uint32_t rt = 0;
	uint32_t rd = 0;
	uint32_t imm = 0;
	double d = 0;
	char label[MAX_LINE_SIZE];
	char dummy[MAX_LINE_SIZE];

	if (eq(instName, "add"))
	{
		int n = sscanf(buffer, formRRR, dummy, &rd, &rs, &rt);
		if (n == 4)
		{
			code = _add(rs, rt, rd);
			return true;
		}
	}
	if (eq(instName, "sub"))
	{
		int n = sscanf(buffer, formRRR, dummy, &rd, &rs, &rt);
		if (n == 4)
		{
			code = _sub(rs, rt, rd);
			return true;
		}
	}
	if (eq(instName, "mul"))
	{
		int n = sscanf(buffer, formRRR, dummy, &rd, &rs, &rt);
		if (n == 4)
		{
			code = _mul(rs, rt, rd);
			return true;
		}
	}
	if (eq(instName, "and"))
	{
		int n = sscanf(buffer, formRRR, dummy, &rd, &rs, &rt);
		if (n == 4)
		{
			code = _and(rs, rt, rd);
			return true;
		}
	}
	if (eq(instName, "or"))
	{
		int n = sscanf(buffer, formRRR, dummy, &rd, &rs, &rt);
		if (n == 4)
		{
			code = _or(rs, rt, rd);
			return true;
		}
	}
	if (eq(instName, "nor"))
	{
		int n = sscanf(buffer, formRRR, dummy, &rd, &rs, &rt);
		if (n == 4)
		{
			code = _nor(rs, rt, rd);
			return true;
		}
	}
	if (eq(instName, "xor"))
	{
		int n = sscanf(buffer, formRRR, dummy, &rd, &rs, &rt);
		if (n == 4)
		{
			code = _xor(rs, rt, rd);
			return true;
		}
	}
	if (eq(instName, "addi"))
	{
		int n = sscanf(buffer, formRRI, dummy, &rt, &rs, &imm);
		if (n == 4)
		{
			code = _addi(rs, rt, imm);
			return true;
		}
	}
	if (eq(instName, "subi"))
	{
		int n = sscanf(buffer, formRRI, dummy, &rt, &rs, &imm);
		if (n == 4)
		{
			code = _subi(rs, rt, imm);
			return true;
		}
	}
	if (eq(instName, "muli"))
	{
		int n = sscanf(buffer, formRRI, dummy, &rt, &rs, &imm);
		if (n == 4)
		{
			code = _muli(rs, rt, imm);
			return true;
		}
	}
	if (eq(instName, "slli"))
	{
		int n = sscanf(buffer, formRRI, dummy, &rt, &rs, &imm);
		if (n == 4)
		{
			code = _slli(rs, rt, imm);
			return true;
		}
	}
	if (eq(instName, "srai"))
	{
		int n = sscanf(buffer, formRRI, dummy, &rt, &rs, &imm);
		if (n == 4)
		{
			code = _srai(rs, rt, imm);
			return true;
		}
	}
	if (eq(instName, "andi"))
	{
		int n = sscanf(buffer, formRRI, dummy, &rt, &rs, &imm);
		if (n == 4)
		{
			code = _andi(rs, rt, imm);
			return true;
		}
	}
	if (eq(instName, "ori"))
	{
		int n = sscanf(buffer, formRRI, dummy, &rt, &rs, &imm);
		if (n == 4)
		{
			code = _ori(rs, rt, imm);
			return true;
		}
	}
	if (eq(instName, "nori"))
	{
		int n = sscanf(buffer, formRRI, dummy, &rt, &rs, &imm);
		if (n == 4)
		{
			code = _nori(rs, rt, imm);
			return true;
		}
	}
	if (eq(instName, "xori"))
	{
		int n = sscanf(buffer, formRRI, dummy, &rt, &rs, &imm);
		if (n == 4)
		{
			code = _xori(rs, rt, imm);
			return true;
		}
	}
	if (eq(instName, "fadd"))
	{
		int n = sscanf(buffer, formFFF, dummy, &rd, &rs, &rt);
		if (n == 4)
		{
			code = _fadd(rs, rt, rd);
			return true;
		}
	}
	if (eq(instName, "fsub"))
	{
		int n = sscanf(buffer, formFFF, dummy, &rd, &rs, &rt);
		if (n == 4)
		{
			code = _fsub(rs, rt, rd);
			return true;
		}
	}
	if (eq(instName, "fmul"))
	{
		int n = sscanf(buffer, formFFF, dummy, &rd, &rs, &rt);
		if (n == 4)
		{
			code = _fmul(rs, rt, rd);
			return true;
		}
	}
	if (eq(instName, "fmuln"))
	{
		int n = sscanf(buffer, formFFF, dummy, &rd, &rs, &rt);
		if (n == 4)
		{
			code = _fmuln(rs, rt, rd);
			return true;
		}
	}
	if (eq(instName, "finv"))
	{
		int n = sscanf(buffer, formFF, dummy, &rd, &rs);
		if (n == 3)
		{
			code = _finv(rs, rt, rd);
			return true;
		}
	}
	if (eq(instName, "fsqrt"))
	{
		int n = sscanf(buffer, formFF, dummy, &rd, &rs);
		if (n == 3)
		{
			code = _fsqrt(rs, rt, rd);
			return true;
		}
	}
	if (eq(instName, "fmov"))
	{
		int n = sscanf(buffer, formFF, dummy, &rd, &rs);
		if (n == 3)
		{
			code = _fmov(rs, rt, rd);
			return true;
		}
	}
	if (eq(instName, "fneg"))
	{
		int n = sscanf(buffer, formFF, dummy, &rd, &rs);
		if (n == 3)
		{
			code = _fneg(rs, rt, rd);
			return true;
		}
	}
	if (eq(instName, "imovf"))
	{
		int n = sscanf(buffer, formFR, dummy, &rt, &rs);
		if (n == 3)
		{
			code = _imovf(rs, rt, rd);
			return true;
		}
	}
	if (eq(instName, "fmovi"))
	{
		int n = sscanf(buffer, formRF, dummy, &rt, &rs);
		if (n == 3)
		{
			code = _fmovi(rs, rt, rd);
			return true;
		}
	}
	// to use ALU
	if (eq(instName, "mvlo"))
	{
		int n = sscanf(buffer, formRI, dummy, &rt, &imm);
		if (n == 3)
		{
			code = _mvlo(rt, rt, imm);
			return true;
		}
	}
	if (eq(instName, "mvhi"))
	{
		int n = sscanf(buffer, formRI, dummy, &rt, &imm);
		if (n == 3)
		{
			code = _mvhi(rt, rt, imm);
			return true;
		}
	}
	if (eq(instName, "fmvlo"))
	{
		int n = sscanf(buffer, formFI, dummy, &rt, &imm);
		if (n == 3)
		{
			code = _fmvlo(rt, rt, imm);
			return true;
		}
	}
	if (eq(instName, "fmvhi"))
	{
		int n = sscanf(buffer, formFI, dummy, &rt, &imm);
		if (n == 3)
		{
			code = _fmvhi(rt, rt, imm);
			return true;
		}
	}
	if (eq(instName, "j"))
	{
		int n = sscanf(buffer, formL, dummy, label);
		if (n == 2)
		{
			labelNames[currentLine] = string(label);
//			cerr << "assigned (" << currentLine << ", " << string(label) << ") in labelNames" << endl;
			useLabel = true;
			code = _j(0);
			return true;
		}
	}
	if (eq(instName, "beq"))
	{
		int n = sscanf(buffer, formRRL, dummy, &rs, &rt, label);
		if (n == 4)
		{
			labelNames[currentLine] = string(label);
//			cerr << "assigned (" << currentLine << ", " << string(label) << ") in labelNames" << endl;
			useLabel = true;
			code = _beq(rs, rt, imm);
			return true;
		}
	}
	if (eq(instName, "blt"))
	{
		int n = sscanf(buffer, formRRL, dummy, &rs, &rt, label);
		if (n == 4)
		{
			labelNames[currentLine] = string(label);
//			cerr << "assigned (" << currentLine << ", " << string(label) << ") in labelNames" << endl;
			useLabel = true;
			code = _blt(rs, rt, imm);
			return true;
		}
	}
	if (eq(instName, "ble"))
	{
		int n = sscanf(buffer, formRRL, dummy, &rs, &rt, label);
		if (n == 4)
		{
			labelNames[currentLine] = string(label);
//			cerr << "assigned (" << currentLine << ", " << string(label) << ") in labelNames" << endl;
			useLabel = true;
			code = _ble(rs, rt, imm);
			return true;
		}
	}
	if (eq(instName, "fbeq"))
	{
		int n = sscanf(buffer, formFFL, dummy, &rs, &rt, label);
		if (n == 4)
		{
			labelNames[currentLine] = string(label);
//			cerr << "assigned (" << currentLine << ", " << string(label) << ") in labelNames" << endl;
			useLabel = true;
			code = _fbeq(rs, rt, imm);
			return true;
		}
	}
	if (eq(instName, "fblt"))
	{
		int n = sscanf(buffer, formFFL, dummy, &rs, &rt, label);
		if (n == 4)
		{
			labelNames[currentLine] = string(label);
//			cerr << "assigned (" << currentLine << ", " << string(label) << ") in labelNames" << endl;
			useLabel = true;
			code = _fblt(rs, rt, imm);
			return true;
		}
	}
	if (eq(instName, "fble"))
	{
		int n = sscanf(buffer, formFFL, dummy, &rs, &rt, label);
		if (n == 4)
		{
			labelNames[currentLine] = string(label);
//			cerr << "assigned (" << currentLine << ", " << string(label) << ") in labelNames" << endl;
			useLabel = true;
			code = _fble(rs, rt, imm);
			return true;
		}
	}
	if (eq(instName, "jr"))
	{
		int n = sscanf(buffer, formR, dummy, &rs);
		if (n == 2)
		{
			code = _jr(rs, rt, rd);
			return true;
		}
	}
	if (eq(instName, "call"))
	{
		int n = sscanf(buffer, formL, dummy, label);
		if (n == 2)
		{
			labelNames[currentLine] = string(label);
//			cerr << "assigned (" << currentLine << ", " << string(label) << ") in labelNames" << endl;
			useLabel = true;
			code = _call(0);
			return true;
		}
	}
	if (eq(instName, "callr"))
	{
		int n = sscanf(buffer, formR, dummy, &rs);
		if (n == 2)
		{
			code = _callr(rs, rt, rd);
			return true;
		}
	}
	if (eq(instName, "return"))
	{
		int n = sscanf(buffer, form, dummy);
		if (n == 1)
		{
			code = _return(rs, rt, rd);
			return true;
		}
	}
	if (eq(instName, "ldr"))
	{
		int n = sscanf(buffer, formRRR, dummy, &rd, &rs, &rt);
		if (n == 4)
		{
			code = _ldr(rs, rt, rd);
			return true;
		}
	}
	if (eq(instName, "fldr"))
	{
		int n = sscanf(buffer, formFRR, dummy, &rd, &rs, &rt);
		if (n == 4)
		{
			code = _fldr(rs, rt, rd);
			return true;
		}
	}
	if (eq(instName, "sti"))
	{
		int n = sscanf(buffer, formRRI, dummy, &rt, &rs, &imm);
		if (n == 4)
		{
			code = _sti(rs, rt, imm);
			return true;
		}
	}
	if (eq(instName, "ldi"))
	{
		int n = sscanf(buffer, formRRI, dummy, &rt, &rs, &imm);
		if (n == 4)
		{
			code = _ldi(rs, rt, imm);
			return true;
		}
	}
	if (eq(instName, "fsti"))
	{
		int n = sscanf(buffer, formFRI, dummy, &rt, &rs, &imm);
		if (n == 4)
		{
			code = _fsti(rs, rt, imm);
			return true;
		}
	}
	if (eq(instName, "fldi"))
	{
		int n = sscanf(buffer, formFRI, dummy, &rt, &rs, &imm);
		if (n == 4)
		{
			code = _fldi(rs, rt, imm);
			return true;
		}
	}
	if (eq(instName, "inputb"))
	{
		int n = sscanf(buffer, formR, dummy, &rt);
		if (n == 2)
		{
			code = _inputb(rs, rt, rd);
			return true;
		}
	}
	if (eq(instName, "outputb"))
	{
		int n = sscanf(buffer, formR, dummy, &rt);
		if (n == 2)
		{
			code = _outputb(rs, rt, rd);
			return true;
		}
	}
	if (eq(instName, "halt"))
	{
		int n = sscanf(buffer, form, dummy);
		if (n == 1)
		{
			code = _halt(rs, rt, rd);
			return true;
		}
	}
	if (eq(instName, "dump"))
	{
		int n = sscanf(buffer, form, dummy);
		if (n == 1)
		{
			code = _dump(rs, rt, rd);
			return true;
		}
	}
	
	return false;
}
예제 #17
0
ISTBOOL GetSphereFrom4Points(struct sphere_model *model)
{
	ISTFLOAT a[4][4] = {{0}};
	ISTFLOAT ho[3] = {0};
	ISTFLOAT norm = 0;
	ISTFLOAT rad = 0;
	ISTFLOAT tmpf = 0;
	ISTFLOAT two = _float(2);
	ISTFLOAT m11, m12, m13, m14, m15;
	ISTINT i, j;

	// Get sphere from 4 points
	for (i = 0; i < 4; i++) { /* find minor 11 */
		a[i][0] = model->p4s[i][0];
		a[i][1] = model->p4s[i][1];
		a[i][2] = model->p4s[i][2];
		a[i][3] = _one;
	}
	m11 = GetDet(a, 4);
	for (i = 0; i < 4; i++) { /* find minor 12 */
		a[i][0] = _add(_add(_mul(model->p4s[i][0], model->p4s[i][0]),
			_mul(model->p4s[i][1], model->p4s[i][1])),
			_mul(model->p4s[i][2], model->p4s[i][2]));
		a[i][1] = model->p4s[i][1];
		a[i][2] = model->p4s[i][2];
		a[i][3] = _one;
	}
	m12 = GetDet(a, 4);
	for (i = 0; i < 4; i++) { /* find minor 13 */
		a[i][0] = _add(_add(_mul(model->p4s[i][0], model->p4s[i][0]),
			_mul(model->p4s[i][1], model->p4s[i][1])),
			_mul(model->p4s[i][2], model->p4s[i][2]));
		a[i][1] = model->p4s[i][0];
		a[i][2] = model->p4s[i][2];
		a[i][3] = _one;
	}
	m13 = GetDet(a, 4);
	for (i = 0; i < 4; i++) { /* find minor 14 */
		a[i][0] = _add(_add(_mul(model->p4s[i][0], model->p4s[i][0]),
			_mul(model->p4s[i][1], model->p4s[i][1])),
			_mul(model->p4s[i][2], model->p4s[i][2]));
		a[i][1] = model->p4s[i][0];
		a[i][2] = model->p4s[i][1];
		a[i][3] = _one;
	}
	m14 = GetDet(a, 4);
	for (i = 0; i < 4; i++) { /* find minor 15 */
		a[i][0] = _add(_add(_mul(model->p4s[i][0], model->p4s[i][0]),
			_mul(model->p4s[i][1], model->p4s[i][1])),
			_mul(model->p4s[i][2], model->p4s[i][2]));
		a[i][1] = model->p4s[i][0];
		a[i][2] = model->p4s[i][1];
		a[i][3] = model->p4s[i][2];
	}
	m15 = GetDet(a, 4);
	if (_eq(m11, 0)) {
		rad = 0;
	} else { /* center of sphere */
		ho[0] = _div(_div(m12, m11), two);
		ho[1] = _neg(_div(_div(m13, m11), two));
		ho[2] = _div(_div(m14, m11), two);
		norm = _sub(_add(_add(_mul(ho[0], ho[0]),
			_mul(ho[1], ho[1])),
			_mul(ho[2], ho[2])),
			_div(m15, m11));
		if (_ge(norm, 0)) {
			rad = _sqrt(norm);
		}
	}
	if (_le(rad, 0)) {
		goto EXIT;
	}
	// Check distance
	for (i = 0; i < 4; i++) {
		for (j = (i + 1); j < 4; j++) {
			tmpf = GetDistance(model->p4s[i], model->p4s[j]);
			if (_lt(tmpf, rad) || _lt(tmpf, model->rad_min)) {
				goto EXIT;
			}
		}
	}
	// Update offset 
	for (i = 1; i < IST_SPHERE_OFFSET_NUM; i++) {
		for (j = 0; j < 3; ++j) {
			model->offsets[IST_SPHERE_OFFSET_NUM - i][j] = model->offsets[IST_SPHERE_OFFSET_NUM - i - 1][j];
		}
	}
	for (j = 0; j < 3; ++j) {
		model->offsets[0][j] = ho[j];
	}
	for (i = (IST_SPHERE_DATAMAX >> 1); i < IST_SPHERE_DATAMAX; i++) {
		for (j = 0; j < 3; ++j) {
			model->data[i][j] = _max;
		}
	}
	// Check offset buffer full
	if (IsInitedVector(model->offsets[IST_SPHERE_OFFSET_NUM - 1])) {
		goto EXIT;
	}
	// Calculate mean bias and radius
	if (!GetParams(model, rad)) {
		goto EXIT;
	}
	return ISTTRUE;

EXIT:
	return ISTFALSE;
}
예제 #18
0
		vector<vector<int>> pathSum(TreeNode* root, int sum) {
			_sub(root, sum);
			return res_;
		}
예제 #19
0
void VMDriver::execute(){
	if( this->m_state == STATE_IDLE ){
		printf( "Error: state is idle. \n");
		return;
	}

	assert( this->currentAssembly() );
	while( this->isActive() ){
		if( this->isBreak() ){
			break;
		}
		unsigned char content = this->getByte( m_funcAddr , m_pc );
		m_pc++;
		switch( content ){
			case EMnemonic::MovPtr :
				_mov_ptr();
				break;
			case EMnemonic::Mov :
				_mov();
				break;
			case EMnemonic::Add :
				_add();
				break;
			case EMnemonic::Sub :
				_sub();
				break;
			case EMnemonic::Mul :
				_mul();
				break;
			case EMnemonic::Div :
				_div();
				break;
			case EMnemonic::Rem :
				_rem();
				break;
			case EMnemonic::Inc :
				_inc();
				break;
			case EMnemonic::Dec :
				_dec();
				break;
			case EMnemonic::Push :
				_push();
				break;
			case EMnemonic::PushPtr :
				_push_ptr();
				break;
			case EMnemonic::Pop :
				_pop();
				break;
			case EMnemonic::Call :
				_call();
				break;
			case EMnemonic::ST :
				_st();
				break;
			case EMnemonic::LD :
				_ld();
				break;
			case EMnemonic::EndFunc :
				_endFunc();
				break;

			case EMnemonic::CmpGeq : 
			case EMnemonic::CmpG :
			case EMnemonic::CmpLeq : 
			case EMnemonic::CmpL :
			case EMnemonic::CmpEq : 
			case EMnemonic::CmpNEq :
				_cmp( content );
				break;
			case EMnemonic::Not :
				_not();
				break;
			case EMnemonic::Minus :
				_minus();
				break;
			case EMnemonic::LogOr :
			case EMnemonic::LogAnd :
				_log( content );
				break;
			case EMnemonic::Jmp :
				_jmp();
				break;
			case EMnemonic::JumpZero :
				_jumpzero();
				break;
			case EMnemonic::JumpNotZero :
				_jumpnotzero();
				break;
			case EMnemonic::RET :
				_ret();
				break;
		}
	}
}