int
elem_equal(elem_srcptr op1, elem_srcptr op2, const ring_t ring)
{
switch (ring->type)
{
case TYPE_FMPZ:
return fmpz_equal(op1, op2);
case TYPE_LIMB:
return *((mp_srcptr) op1) == *((mp_srcptr) op2);
case TYPE_POLY:
return elem_poly_equal(op1, op2, ring);
case TYPE_MOD:
return elem_equal(op1, op2, ring->parent);
case TYPE_FRAC:
return elem_equal(NUMER(op1, ring), NUMER(op2, ring), RING_NUMER(ring)) &&
elem_equal(DENOM(op1, ring), DENOM(op2, ring), RING_DENOM(ring));
case TYPE_COMPLEX:
return elem_equal(REALPART(op1, ring), REALPART(op2, ring), RING_PARENT(ring)) &&
elem_equal(IMAGPART(op1, ring), IMAGPART(op2, ring), RING_PARENT(ring));
default:
NOT_IMPLEMENTED("equal", ring);
}
}
void
elem_frac_poly_divrem(elem_ptr Q, elem_ptr R, elem_srcptr A, elem_srcptr B, const ring_t ring)
{
if (elem_is_zero(B, ring))
{
printf("Exception: division by zero in elem_frac_poly_divrem\n");
abort();
}
else if (Q == R)
{
printf("Exception: output arguments Q and R may not be aliased\n");
abort();
}
else if (((const elem_poly_struct *) A)->length < ((const elem_poly_struct *) B)->length)
{
elem_set(R, A, ring);
elem_zero(Q, ring);
}
else if (Q == A || Q == B)
{
elem_ptr tmp;
ELEM_TMP_INIT(tmp, ring);
elem_frac_poly_divrem(tmp, R, A, B, ring);
elem_swap(Q, tmp, ring);
ELEM_TMP_CLEAR(tmp, ring);
}
else if (R == B)
{
elem_ptr tmp;
ELEM_TMP_INIT(tmp, ring);
elem_frac_poly_divrem(Q, tmp, A, B, ring);
elem_swap(R, tmp, ring);
ELEM_TMP_CLEAR(tmp, ring);
}
else
{
/* if the denominators are the same as coefficients, we can do pseudo division */
if (RING_DENOM(ring) == RING_PARENT(RING_NUMER(ring)))
{
_elem_frac_poly_divrem_wrap(NUMER(Q, ring), DENOM(Q, ring),
NUMER(R, ring), DENOM(R, ring),
NUMER(A, ring), DENOM(A, ring),
NUMER(B, ring), DENOM(B, ring), RING_NUMER(ring), RING_DENOM(ring));
}
else
{
NOT_IMPLEMENTED("polynomial divrem with different denominator type", ring);
}
}
}
/* Return the product of two expressions */
static exp_t *
prod(exp_t *a1, exp_t *a2)
{
exp_t *res;
CHKNUM(a1, *);
CHKNUM(a2, *);
if (isfloat(a1) || isfloat(a2))
res = nfloat(VALUE(a1) * VALUE(a2));
else
res = nrat(NUMER(a1) * NUMER(a2), DENOM(a1) * DENOM(a2));
return res;
}
/* Return the division of two expressions */
static exp_t *
divs(exp_t *a1, exp_t *a2)
{
exp_t *res;
CHKNUM(a1, /);
CHKNUM(a2, /);
if (VALUE(a2) == 0)
everr("/: argument is divided by zero", a1);
if (isfloat(a1) || isfloat(a2))
res = nfloat(VALUE(a1) / VALUE(a2));
else
res = nrat(NUMER(a1) * DENOM(a2), NUMER(a2) * DENOM(a1));
return res;
}
/* Return the difference of two expressions */
static exp_t *
sub(exp_t *a1, exp_t *a2)
{
long n1, n2, d1, d2;
exp_t *res;
CHKNUM(a1, -);
CHKNUM(a2, -);
if (isfloat(a1) || isfloat(a2))
res = nfloat(VALUE(a1) - VALUE(a2));
else {
n1 = NUMER(a1), n2 = NUMER(a2);
d1 = DENOM(a1), d2 = DENOM(a2);
res = nrat(n1*d2 - n2*d1, d1 * d2);
}
return res;
}
static char *lin_bid(card bid)
{
static char buf[3];
if (bid == bid_pass)
return "p";
else if (bid == bid_x)
return "d";
else if (bid == bid_xx)
return "r";
snprintf(buf, sizeof (buf), "%d%c", LEVEL(bid), "CDHSN"[DENOM(bid)]);
return buf;
}
void
elem_set(elem_ptr res, elem_srcptr src, const ring_t ring)
{
if (res != src)
{
switch (ring->type)
{
case TYPE_FMPZ:
fmpz_set(res, src);
break;
case TYPE_LIMB:
*((mp_ptr) res) = *((mp_srcptr) src);
break;
case TYPE_MOD:
elem_set(res, src, ring->parent);
break;
case TYPE_POLY:
elem_poly_set(res, src, ring);
break;
case TYPE_FRAC:
elem_set(NUMER(res, ring), NUMER(src, ring), RING_NUMER(ring));
elem_set(DENOM(res, ring), DENOM(src, ring), RING_DENOM(ring));
break;
case TYPE_COMPLEX:
elem_set(REALPART(res, ring), REALPART(src, ring), RING_PARENT(ring));
elem_set(IMAGPART(res, ring), IMAGPART(src, ring), RING_PARENT(ring));
break;
default:
NOT_IMPLEMENTED("set", ring);
}
}
}
void
elem_set_si(elem_ptr elem, long v, const ring_t ring)
{
switch (ring->type)
{
case TYPE_FMPZ:
fmpz_set_si(elem, v);
break;
case TYPE_LIMB:
*((mp_ptr) elem) = v;
break;
case TYPE_POLY:
elem_poly_set_si(elem, v, ring);
break;
case TYPE_MOD:
{
switch (RING_PARENT(ring)->type)
{
case TYPE_FMPZ:
fmpz_set_si(elem, v);
fmpz_mod(elem, elem, RING_MODULUS(ring));
break;
case TYPE_LIMB:
*((mp_ptr) elem) = nmod_set_si(v, ring->nmod);
break;
default:
NOT_IMPLEMENTED("set_si (mod)", ring);
}
}
break;
case TYPE_FRAC:
elem_set_si(NUMER(elem, ring), v, RING_NUMER(ring));
elem_one(DENOM(elem, ring), RING_DENOM(ring));
break;
case TYPE_COMPLEX:
elem_set_si(REALPART(elem, ring), v, ring->parent);
elem_zero(IMAGPART(elem, ring), ring->parent);
break;
default:
NOT_IMPLEMENTED("set_si", ring);
}
}
void
elem_frac_canonicalise(elem_srcptr x, const ring_t ring)
{
_elem_frac_canonicalise(NUMER(x, ring), DENOM(x, ring), RING_NUMER(ring), RING_DENOM(ring));
}
double UNITS::ConvFactor() {
bool InIsLinear=false, OutIsLinear=false;
for (int i=ANG;i<=MPC;i++) {
InIsLinear = InIsLinear || in==i;
OutIsLinear = OutIsLinear || out==i;
}
if (InIsLinear && OutIsLinear) return LinearFactor();
bool InIsTime=false, OutIsTime=false;
for (int i=S;i<=GYR;i++) {
InIsTime = InIsTime || in==i;
OutIsTime = OutIsTime || out==i;
}
if (InIsTime && OutIsTime) return TimeFactor();
bool InIsMass=false, OutIsMass=false;
for (int i=GR;i<=MSUN;i++) {
InIsMass = InIsMass || in==i;
OutIsMass = OutIsMass || out==i;
}
if (InIsMass && OutIsMass) return MassFactor();
bool InIsFreq=false, OutIsFreq=false;
for (int i=HZ;i<=GHZ;i++) {
InIsFreq = InIsFreq || in==i;
OutIsFreq = OutIsFreq || out==i;
}
if (InIsFreq && OutIsFreq) return FrequencyFactor();
bool InIsAngle=false, OutIsAngle=false;
for (int i=DEG;i<=RAD;i++) {
InIsAngle = InIsAngle || in==i;
OutIsAngle = OutIsAngle || out==i;
}
if (InIsAngle && OutIsAngle) return AngleFactor();
bool InIsVel=false, OutIsVel=false;
for (int i=CM_S;i<=KM_H;i++) {
InIsVel = InIsVel || in==i;
OutIsVel = OutIsVel || out==i;
}
if (InIsVel && OutIsVel) {
Unit NumIn=M, NumOut=M, DenIn=S, DenOut=S;
if (in==CM_S) NumIn = CM;
else if (in==M_S) NumIn = M;
else if (in==KM_S || in==KM_H) NumIn = KM;
if (out==CM_S) NumOut = CM;
else if (out==M_S) NumOut = M;
else if (out==KM_S || out==KM_H) NumOut = KM;
if (in==CM_S || in==M_S || in==KM_S) DenIn = S;
else if (in==KM_H) DenIn = H;
if (out==CM_S || out==M_S || out==KM_S) DenOut = S;
else if (out==KM_H) DenOut = H;
UNITS NUM(NumIn,NumOut), DENOM(DenIn,DenOut);
return NUM.factor/DENOM.factor;
}
std::cout << "Unknown conversion!!" << std::endl;
return -1;
}
static void
add_bezier_rect(SKRectObject * rect,
double p1x, double p1y, double p2x, double p2y,
double p3x, double p3y, double p4x, double p4y)
{
double discr, denom, p;
discr = DISCR(p1x, p2x, p3x, p4x);
if (discr >= 0)
{
double p13 = 3 * p1x, p23 = 3 * p2x, p33 = 3 * p3x;
double c1 = p23 - p1x - p33 + p4x;
double c2 = p13 - 2 * p23 + p33;
double c3 = p23 - p13;
double t;
denom = DENOM(p1x, p2x, p3x, p4x);
if (denom)
{
discr = sqrt(discr);
p = p1x - 2 * p2x + p3x;
t = (p + discr) / denom;
if (0 < t && t < 1)
SKRect_AddX(rect, ((c1 * t + c2) * t + c3) * t + p1x);
t = (p - discr) / denom;
if (0 < t && t < 1)
SKRect_AddX(rect, ((c1 * t + c2) * t + c3) * t + p1x);
}
else
{
denom = p1x - 2 * p2x + p3x;
if (denom)
{
t = 0.5 * (p1x - p2x) / denom;
if (0 < t && t < 1)
SKRect_AddX(rect, ((c1 * t + c2) * t + c3) * t + p1x);
}
}
}
discr = DISCR(p1y, p2y, p3y, p4y);
if (discr >= 0)
{
double p13 = 3 * p1y, p23 = 3 * p2y, p33 = 3 * p3y;
double c1 = p23 - p1y - p33 + p4y;
double c2 = p13 - 2 * p23 + p33;
double c3 = p23 - p13;
double t;
denom = DENOM(p1y, p2y, p3y, p4y);
if (denom)
{
discr = sqrt(discr);
p = p1y - 2 * p2y + p3y;
t = (p + discr) / denom;
if (0 < t && t < 1)
SKRect_AddY(rect, ((c1 * t + c2) * t + c3) * t + p1y);
t = (p - discr) / denom;
if (0 < t && t < 1)
SKRect_AddY(rect, ((c1 * t + c2) * t + c3) * t + p1y);
}
else
{
denom = p1y - 2 * p2y + p3y;
if (denom)
{
t = 0.5 * (p1y - p2y) / denom;
if (0 < t && t < 1)
SKRect_AddY(rect, ((c1 * t + c2) * t + c3) * t + p1y);
}
}
}
}
