int main(void)
{
struct rational a = make_rational(1, 8);
struct rational b = make_rational(-1, 8);
print_rational(add_rational(a, b));
print_rational(sub_rational(a, b));
print_rational(mul_rational(a, b));
print_rational(div_rational(a, b));
return 0;
}
int main()
{
rational r1=make_rational(1,3);
rational r2=make_rational(3,9);
rational r3=add_rational(r1,r2);
rational r4=product_rational(r1,r2);
equal_rational(r1,r2);
printf("The product of rational numbers is %d/%d.\n",r4.numerator,r4.denomenator);
printf("The sum of rational number is %d/%d.",r3.numerator,r3.denomenator);
}
int main(void) {
struct rational a = make_rational(1, 8); /* a=1/8 */
struct rational b = make_rational(-1, 8); /* b=-1/8 */
print_rational(a);
print_rational(b);
print_rational(add_rational(a, b));
print_rational(sub_rational(a, b));
print_rational(mul_rational(a, b));
print_rational(div_rational(a, b));
return 0;
}
Scheme_Object *scheme_rational_add(const Scheme_Object *a, const Scheme_Object *b)
{
Scheme_Rational *ra = (Scheme_Rational *)a;
Scheme_Rational *rb = (Scheme_Rational *)b;
Scheme_Object *ac, *bd, *sum, *cd;
int no_normalize = 0;
if (SCHEME_INTP(ra->denom) && (SCHEME_INT_VAL(ra->denom) == 1)) {
/* Swap, to take advantage of the next optimization */
Scheme_Rational *rx = ra;
ra = rb;
rb = rx;
}
if (SCHEME_INTP(rb->denom) && (SCHEME_INT_VAL(rb->denom) == 1)) {
/* From Brad Lucier: */
/* (+ p/q n) = (make-rational (+ p (* n q)) q), no normalize */
ac = ra->num;
cd = ra->denom;
no_normalize = 1;
} else {
ac = scheme_bin_mult(ra->num, rb->denom);
cd = scheme_bin_mult(ra->denom, rb->denom);
}
bd = scheme_bin_mult(ra->denom, rb->num);
sum = scheme_bin_plus(ac, bd);
if (no_normalize)
return make_rational(sum, cd, 0);
else
return scheme_make_rational(sum, cd);
}
Scheme_Object *scheme_rational_power(const Scheme_Object *o, const Scheme_Object *p)
{
double b, e, v;
if (((Scheme_Rational *)p)->denom == one) {
Scheme_Object *a[2], *n;
a[0] = ((Scheme_Rational *)o)->num;
a[1] = ((Scheme_Rational *)p)->num;
n = scheme_expt(2, a);
a[0] = ((Scheme_Rational *)o)->denom;
return make_rational(n, scheme_expt(2, a), 0);
}
if (scheme_is_rational_positive(o)) {
b = scheme_rational_to_double(o);
e = scheme_rational_to_double(p);
v = pow(b, e);
#ifdef USE_SINGLE_FLOATS_AS_DEFAULT
return scheme_make_float(v);
#else
return scheme_make_double(v);
#endif
} else {
return scheme_complex_power(scheme_real_to_complex(o),
scheme_real_to_complex(p));
}
}
Scheme_Object *scheme_rational_negate(const Scheme_Object *o)
{
Scheme_Rational *r = (Scheme_Rational *)o;
return make_rational(scheme_bin_minus(scheme_make_integer(0),
r->num),
r->denom, 0);
}
Scheme_Object *scheme_rational_divide(const Scheme_Object *n, const Scheme_Object *d)
{
Scheme_Rational *rd = (Scheme_Rational *)d, *rn = (Scheme_Rational *)n;
Scheme_Rational d_inv;
/* Check for [negative] inverse, which is easy */
if ((SCHEME_INTP(rn->num) && ((SCHEME_INT_VAL(rn->num) == 1)
|| (SCHEME_INT_VAL(rn->num) == -1)))
&& (SCHEME_INTP(rn->denom) && SCHEME_INT_VAL(rn->denom) == 1)) {
int negate = (SCHEME_INT_VAL(rn->num) == -1);
if (SCHEME_INTP(rd->num)) {
if ((SCHEME_INT_VAL(rd->num) == 1)) {
if (negate)
return negate_simple(rd->denom);
else
return rd->denom;
}
if (SCHEME_INT_VAL(rd->num) == -1) {
if (negate)
return rd->denom;
else
return negate_simple(rd->denom);
}
}
if (((SCHEME_INTP(rd->num))
&& (SCHEME_INT_VAL(rd->num) < 0))
|| (!SCHEME_INTP(rd->num)
&& !SCHEME_BIGPOS(rd->num))) {
Scheme_Object *v;
v = negate ? rd->denom : negate_simple(rd->denom);
return make_rational(v, negate_simple(rd->num), 0);
} else {
Scheme_Object *v;
v = negate ? negate_simple(rd->denom) : rd->denom;
return make_rational(v, rd->num, 0);
}
}
d_inv.so.type = scheme_rational_type;
d_inv.denom = rd->num;
d_inv.num = rd->denom;
return scheme_rational_multiply(n, (Scheme_Object *)&d_inv);
}
// Multiplies two rational numbers; returns a new Rational.
Rational *mult_rational(Rational *r1, Rational *r2) {
int nums = (r1->numer)*(r2->numer);
int dens = (r1->denom)*(r2->denom);
if (dens%nums == 0){
nums = 1;
dens = dens/nums;
}
Rational *r = make_rational(nums,dens);
return r;
}
cons_t* proc_div(cons_t *p, environment_t *e)
{
assert_length(p, 2);
cons_t *a = car(p);
cons_t *b = cadr(p);
assert_number(a);
assert_number(b);
bool exact = (a->number.exact && b->number.exact);
if ( zerop(b) )
raise(runtime_exception(format(
"Division by zero: %s", sprint(cons(symbol("/"), p)).c_str())));
if ( type_of(a) == type_of(b) ) {
if ( integerp(a) ) {
// division yields integer?
if ( gcd(a->number.integer, b->number.integer) == 0)
return integer(a->number.integer / b->number.integer, exact);
else
return rational(make_rational(a) /= make_rational(b), exact);
} else if ( realp(a) )
return real(a->number.real / b->number.real);
else if ( rationalp(a) )
return rational(a->number.rational / b->number.rational, exact);
else
raise(runtime_exception(format("Cannot perform division on %s",
indef_art(to_s(type_of(a))).c_str())));
}
bool anyrational = (rationalp(a) || rationalp(b));
bool anyinteger = (integerp(a) || integerp(b));
// int/rat or rat/int ==> turn into rational, and not an int
if ( anyrational && anyinteger )
return rational(make_rational(a) /= make_rational(b), exact, false);
// proceed with real division
return proc_divf(p, e);
}
int main(void)
{
Rational *rational = make_rational(3, 7);
print_rational(rational);
double d = rational_to_double(rational);
printf("%lf\n", d);
Rational *square = mult_rational(rational, rational);
print_rational(square);
free_rational(rational);
free_rational(square);
return EXIT_SUCCESS;
}
Scheme_Object *scheme_make_fixnum_rational(intptr_t n, intptr_t d)
{
/* This function is called to implement division on small integers,
so don't allocate unless necessary. */
Small_Rational s;
Scheme_Object *o;
s.so.type = scheme_rational_type;
s.num = scheme_make_integer(n);
s.denom = scheme_make_integer(d);
o = scheme_rational_normalize((Scheme_Object *)&s);
if (o == (Scheme_Object *)&s)
return make_rational(s.num, s.denom, 0);
else
return o;
}
Scheme_Object *scheme_rational_sqrt(const Scheme_Object *o)
{
Scheme_Rational *r = (Scheme_Rational *)o;
Scheme_Object *n, *d;
double v;
n = scheme_integer_sqrt(r->num);
if (!SCHEME_DBLP(n)) {
d = scheme_integer_sqrt(r->denom);
if (!SCHEME_DBLP(d))
return make_rational(n, d, 0);
}
v = sqrt(scheme_rational_to_double(o));
#ifdef USE_SINGLE_FLOATS_AS_DEFAULT
return scheme_make_float(v);
#else
return scheme_make_double(v);
#endif
}
struct rational add_rational(struct rational r1, struct rational r2)
{
return make_rational(r1.a*r2.b + r2.a*r1.b, r1.b*r2.b);
}
// Multiplies two rational numbers; returns a new Rational. Does not simplify.
Rational *mult_rational(Rational *r1, Rational *r2) {
int numer = (r1->numer)*(r2->numer);
int denom = (r1->denom)*(r2->denom);
Rational *new_rat = make_rational(numer,denom);
return new_rat;
}
Scheme_Object *scheme_integer_to_rational(const Scheme_Object *n)
{
return make_rational(n, one, 0);
}
Scheme_Object *scheme_make_rational(const Scheme_Object *n, const Scheme_Object *d)
{
return make_rational(scheme_bignum_normalize(n),
scheme_bignum_normalize(d), 1);
}
struct rational sub_rational(struct rational r1, struct rational r2)
{
return make_rational(r1.a*r2.b - r2.a*r1.b, r1.b*r2.b);
}
struct rational mul_rational(struct rational r1, struct rational r2)
{
return make_rational(r1.a*r2.a, r1.b*r2.b);
}
struct rational div_rational(struct rational r1, struct rational r2)
{
return make_rational(r1.a*r2.b, r1.b*r2.a);
}
