Пример #1
0
/* Derived from SLA_EQGAL */
void eq2gal(double dr,double dd,double *dl,double *db,double rotmat[3][3])
{
  double v1[4],v2[4],p[4],q[4],pg[4],tp[4],tq[4];
  double rmat[4][4],cosb;

  rmat[1][1] = -0.054875539726;
  rmat[1][2] = -0.873437108010;
  rmat[1][3] = -0.483834985808;

  rmat[2][1] = +0.494109453312;
  rmat[2][2] = -0.444829589425;
  rmat[2][3] = +0.746982251810;
  
  rmat[3][1] = -0.867666135858;
  rmat[3][2] = -0.198076386122;
  rmat[3][3] = +0.455983795705;

  cosb=cos(dd);
  v1[1] = cos(dr)*cosb;
  v1[2] = sin(dr)*cosb;
  v1[3] = sin(dd);

  /* Calculate orthogonal vectors */

  p[1] = -sin(dr);
  p[2] = cos(dr);
  p[3] = 0;

  q[1] = -sin(dd)*cos(dr);
  q[2] = -sin(dd)*sin(dr);
  q[3] = cos(dd);

  /* Equatorial to galactic */
  transform(rmat,v1,v2);
  transform(rmat,p,tp);
  transform(rmat,q,tq);

  /* Cartesian to spherical */
  dir2sph(v2,dl,db);

  /* Express in conventional ranges */
  *dl = f_mod(*dl,2.0*M_PI);
  if (*dl < 0) *dl = *dl+M_PI*2.0;

  *db = f_mod(*db,2.0*M_PI);
  if (*db < 0) *db = *db+M_PI*2.0;

  /* Form the p vector in galactic reference frame */
  pg[1] = -sin(*dl);
  pg[2] = cos(*dl);
  pg[3] = 0.0;

  /* Form the proper motion rotation matrix */
  rotmat[1][1] = product(pg,tp);
  rotmat[2][2] = rotmat[1][1];
  rotmat[1][2] = product(pg,tq);
  rotmat[2][1] = -rotmat[1][2];

}
Пример #2
0
inline static VALUE
f_gcd(VALUE x, VALUE y)
{
    VALUE r = f_gcd_orig(x, y);
    if (f_nonzero_p(r)) {
	assert(f_zero_p(f_mod(x, r)));
	assert(f_zero_p(f_mod(y, r)));
    }
    return r;
}
int f_mod(int base,int n,int m)
{
    if(n == 1)
        return base % m;
    if(n == 2)
        return base * base % m;
    if(n % 2 == 0)
        return (f_mod(base,n/2,m)*f_mod(base,n/2,m)) % m;
    if(n % 2 == 1)
        return (f_mod(base,n/2,m)*f_mod(base,n/2+1,m)) % m;
}
Пример #4
0
inline static VALUE
f_gcd(VALUE x, VALUE y)
{
    VALUE z;

    if (FIXNUM_P(x) && FIXNUM_P(y))
	return LONG2NUM(i_gcd(FIX2LONG(x), FIX2LONG(y)));

    if (f_negative_p(x))
	x = f_negate(x);
    if (f_negative_p(y))
	y = f_negate(y);

    if (f_zero_p(x))
	return y;
    if (f_zero_p(y))
	return x;

    for (;;) {
	if (FIXNUM_P(x)) {
	    if (FIX2LONG(x) == 0)
		return y;
	    if (FIXNUM_P(y))
		return LONG2NUM(i_gcd(FIX2LONG(x), FIX2LONG(y)));
	}
	z = x;
	x = f_mod(y, x);
	y = z;
    }
    /* NOTREACHED */
}
int main()
{
    int result;
    int b,exp,m;
    scanf("%d%d%d",&b,&exp,&m);
    result = f_mod(b,exp,m);
    printf("result = %d\n",result);

}
Пример #6
0
/*
 * Read address at location and return updated location.
 */
db_addr_t
db_read_address(db_addr_t loc, int short_addr, int regmodrm, int rex,
    struct i_addr *addrp)
{
	int		mod, rm, sib, index, disp, size;

	size = (short_addr ? LONG : QUAD);
	mod = f_mod(regmodrm);
	rm  = f_rm(regmodrm, rex);

	if (mod == 3) {
		addrp->is_reg = TRUE;
		addrp->disp = rm;
		return (loc);
	}
	addrp->is_reg = FALSE;
	addrp->index = 0;

	if (rm == 4 || rm == 12) {
		get_value_inc(sib, loc, 1, FALSE);
		rm = sib_base(sib, rex);
		index = sib_index(sib, rex);
		if (index != 4)
			addrp->index = db_reg[size][index];
		addrp->ss = sib_ss(sib);
	}

	switch (mod) {
	case 0:
		if (rm == 5) {
		get_value_inc(addrp->disp, loc, 4, FALSE);
			addrp->base = 0;
		} else {
			addrp->disp = 0;
			addrp->base = db_reg[size][rm];
		}
		break;
	case 1:
		get_value_inc(disp, loc, 1, TRUE);
		addrp->disp = disp;
		addrp->base = db_reg[size][rm];
		break;
	case 2:
		get_value_inc(disp, loc, 4, FALSE);
		addrp->disp = disp;
		addrp->base = db_reg[size][rm];
		break;
	}
	return (loc);
}
Пример #7
0
/*
 * Disassemble floating-point ("escape") instruction
 * and return updated location.
 */
db_addr_t
db_disasm_esc(db_addr_t loc, int inst, int short_addr, int size, int rex,
    char *seg)
{
	int		regmodrm;
	struct finst	*fp;
	int		mod;
	struct i_addr	address;
	char *		name;

	get_value_inc(regmodrm, loc, 1, FALSE);
	fp = &db_Esc_inst[inst - 0xd8][f_reg(regmodrm, 0)];
	mod = f_mod(regmodrm);
	if (mod != 3) {
		if (*fp->f_name == '\0') {
			db_printf("<bad instruction>");
			return (loc);
		}

		/*
		 * Normal address modes.
		 */
		loc = db_read_address(loc, short_addr, regmodrm, rex, &address);
		db_printf("%s", fp->f_name);
		switch (fp->f_size) {
		case SNGL:
			db_printf("s");
			break;
		case DBLR:
			db_printf("l");
			break;
		case EXTR:
			db_printf("t");
			break;
		case WORD:
			db_printf("s");
			break;
		case LONG:
			db_printf("l");
			break;
		case QUAD:
			db_printf("q");
			break;
		default:
			break;
		}
		db_printf("\t");
		db_print_address(seg, BYTE, &address);
	} else {
		/*
		 * 'reg-reg' - special formats
		 */
		switch (fp->f_rrmode) {
		case op2(ST,STI):
			name = (fp->f_rrname) ? fp->f_rrname : fp->f_name;
			db_printf("%s\t%%st,%%st(%d)",name, f_rm(regmodrm, 0));
			break;
		case op2(STI,ST):
			name = (fp->f_rrname) ? fp->f_rrname : fp->f_name;
			db_printf("%s\t%%st(%d),%%st",name, f_rm(regmodrm, 0));
			break;
		case op1(STI):
			name = (fp->f_rrname) ? fp->f_rrname : fp->f_name;
			db_printf("%s\t%%st(%d)",name, f_rm(regmodrm, 0));
			break;
		case op1(X):
			name = ((char * const *)fp->f_rrname)[f_rm(regmodrm,0)];
			if (*name == '\0')
				goto bad;
			db_printf("%s", name);
			break;
		case op1(XA):
			name = ((char * const *)fp->f_rrname)[f_rm(regmodrm,0)];
			if (*name == '\0')
				goto bad;
			db_printf("%s\t%%ax", name);
			break;
		default:
		bad:
			db_printf("<bad instruction>");
			break;
		}
	}

	return (loc);
}
Пример #8
0
/*
 * Read address at location and return updated location.
 */
db_addr_t
db_read_address(db_addr_t loc, int short_addr, int regmodrm,
    struct i_addr *addrp)
{
	int		mod, rm, sib, index, disp;

	mod = f_mod(regmodrm);
	rm  = f_rm(regmodrm);

	if (mod == 3) {
		addrp->is_reg = TRUE;
		addrp->disp = rm;
		return (loc);
	}
	addrp->is_reg = FALSE;
	addrp->index = 0;

	if (short_addr) {
		addrp->index = 0;
		addrp->ss = 0;
		switch (mod) {
		    case 0:
			if (rm == 6) {
				get_value_inc(disp, loc, 2, FALSE);
				addrp->disp = disp;
				addrp->base = 0;
			} else {
				addrp->disp = 0;
				addrp->base = db_index_reg_16[rm];
			}
			break;
		    case 1:
			get_value_inc(disp, loc, 1, TRUE);
			disp &= 0xffff;
			addrp->disp = disp;
			addrp->base = db_index_reg_16[rm];
			break;
		    case 2:
			get_value_inc(disp, loc, 2, FALSE);
			addrp->disp = disp;
			addrp->base = db_index_reg_16[rm];
			break;
		}
	} else {
		if (rm == 4) {
			get_value_inc(sib, loc, 1, FALSE);
			rm = sib_base(sib);
			index = sib_index(sib);
			if (index != 4)
				addrp->index = db_reg[LONG][index];
			addrp->ss = sib_ss(sib);
		}

		switch (mod) {
		    case 0:
			if (rm == 5) {
				get_value_inc(addrp->disp, loc, 4, FALSE);
				addrp->base = 0;
			} else {
				addrp->disp = 0;
				addrp->base = db_reg[LONG][rm];
			}
			break;
		    case 1:
			get_value_inc(disp, loc, 1, TRUE);
			addrp->disp = disp;
			addrp->base = db_reg[LONG][rm];
			break;
		    case 2:
			get_value_inc(disp, loc, 4, FALSE);
			addrp->disp = disp;
			addrp->base = db_reg[LONG][rm];
			break;
		}
	}
	return (loc);
}
Пример #9
0
/*
 * Read address at location and return updated location.
 */
static db_addr_t
db_read_address(db_addr_t loc, int short_addr, int rex, int regmodrm,
    struct i_addr *addrp)
{
	int		mod, rm, sib, index, disp, size, have_sib;

	mod = f_mod(rex, regmodrm);
	rm  = f_rm(rex, regmodrm);

	if (mod == 3) {
	    addrp->is_reg = TRUE;
	    addrp->disp = rm;
	    return (loc);
	}
	addrp->is_reg = FALSE;
	addrp->index = NULL;

	if (short_addr)
	    size = LONG;
	else
	    size = QUAD;

	if ((rm & 0x7) == 4) {
	    get_value_inc(sib, loc, 1, FALSE);
	    rm = sib_base(rex, sib);
	    index = sib_index(rex, sib);
	    if (index != 4)
		addrp->index = db_reg[1][size][index];
	    addrp->ss = sib_ss(rex, sib);
	    have_sib = 1;
	} else
	    have_sib = 0;

	switch (mod) {
	    case 0:
		if (rm == 5) {
		    get_value_inc(addrp->disp, loc, 4, FALSE);
		    if (have_sib)
			addrp->base = NULL;
		    else if (short_addr)
			addrp->base = "%eip";
		    else
			addrp->base = "%rip";
		} else {
		    addrp->disp = 0;
		    addrp->base = db_reg[1][size][rm];
		}
		break;

	    case 1:
		get_value_inc(disp, loc, 1, TRUE);
		addrp->disp = disp;
		addrp->base = db_reg[1][size][rm];
		break;

	    case 2:
		get_value_inc(disp, loc, 4, FALSE);
		addrp->disp = disp;
		addrp->base = db_reg[1][size][rm];
		break;
	}
	return (loc);
}