Use typedef long long from flower-proto.hh.
/*
- fflower-proto.hh -- typenames in flowerlib
+ flower-proto.hh -- typenames in flowerlib
(c) 1996--2007 Han-Wen Nienhuys
*/
char const *flower_version_str0 ();
typedef unsigned char Byte;
+typedef long long I64;
struct String_convert;
#include "std-string.hh"
typedef unsigned short U16;
typedef unsigned U32;
typedef int I32;
-typedef long long I64;
+typedef unsigned long long U64;
struct File_storage;
#ifndef RATIONAL_HH
#define RATIONAL_HH
+#include "flower-proto.hh"
#include "std-string.hh"
#include <limits.h>
0 if *this is zero.
*/
int sign_;
- unsigned int num_, den_;
+ U64 num_, den_;
void normalize ();
void copy (Rational const &);
void set_infinite (int sign);
bool is_infinity () const;
void invert ();
- int numerator () const { return sign_ * num_; }
- int denominator () const { return den_; }
- int num () const { return numerator (); }
- int den () const { return denominator (); }
+ I64 numerator () const { return sign_ * num_; }
+ I64 denominator () const { return den_; }
+ I64 num () const { return numerator (); }
+ I64 den () const { return denominator (); }
Rational trunc_rat () const;
Rational div_rat (Rational) const;
*/
Rational ();
Rational (int);
- explicit Rational (int, int);
+ Rational (I64);
+ explicit Rational (I64, I64);
explicit Rational (double);
Rational (Rational const &r) { copy (r);}
Rational &operator = (Rational const &r)
operator << (ostream &, Rational);
#endif
-const Rational infinity_rat (INT_MAX);
+const Rational infinity_rat (LLONG_MAX);
#endif // RATIONAL_HH
#define STD_STRING_HH
#include "compare.hh"
+#include "flower-proto.hh"
#if 0
/*
string to_string (double f, char const *format=0);
string to_string (long);
string to_string (long unsigned);
+string to_string (I64, char const *format=0);
string to_string (unsigned);
string to_string (bool b);
string to_string (char const *format, ...)
num_ = den_ = 1;
}
-Rational::Rational (int n, int d)
+Rational::Rational (I64 n, I64 d)
{
sign_ = ::sign (n) * ::sign (d);
num_ = ::abs (n);
normalize ();
}
+Rational::Rational (I64 n)
+{
+ sign_ = ::sign (n);
+ num_ = ::abs (n);
+ den_ = 1;
+}
+
Rational::Rational (int n)
{
sign_ = ::sign (n);
/*
copy & paste from scm_gcd (GUILE).
*/
-static int
-gcd (long u, long v)
+static I64
+gcd (I64 u, I64 v)
{
- long result = 0;
+ I64 result = 0;
if (u == 0)
result = v;
else if (v == 0)
result = u;
else
{
- long k = 1;
- long t;
+ I64 k = 1;
+ I64 t;
/* Determine a common factor 2^k */
while (!(1 & (u | v)))
{
}
else
{
- int g = gcd (num_, den_);
+ I64 g = gcd (num_, den_);
num_ /= g;
den_ /= g;
return 0;
else if (r.sign_ == 0)
return 0;
- return r.sign_ * ::sign (int (r.num_ * s.den_) - int (s.num_ * r.den_));
+ return r.sign_ * ::sign ((I64) (r.num_ * s.den_) - (I64) (s.num_ * r.den_));
}
int
*this = r;
else
{
- int lcm = (den_ / gcd (r.den_, den_)) * r.den_;
- int n = sign_ * num_ * (lcm / den_) + r.sign_ * r.num_ * (lcm / r.den_);
- int d = lcm;
+ I64 lcm = (den_ / gcd (r.den_, den_)) * r.den_;
+ I64 n = sign_ * num_ * (lcm / den_) + r.sign_ * r.num_ * (lcm / r.den_);
+ I64 d = lcm;
sign_ = ::sign (n) * ::sign (d);
num_ = ::abs (n);
den_ = ::abs (d);
easily.
*/
- num_ = (unsigned int) (mantissa * FACT);
- den_ = (unsigned int) FACT;
+ num_ = (U64) (mantissa * FACT);
+ den_ = (U64) FACT;
normalize ();
if (expt < 0)
den_ <<= -expt;
void
Rational::invert ()
{
- int r (num_);
+ I64 r (num_);
num_ = den_;
den_ = r;
}
return String_convert::unsigned_string (u);
}
+string
+to_string (I64 b, char const *format)
+{
+ return String_convert::i64_string (b, format);
+}
+
string
to_string (char const *format, ...)
{
SCM
ly_rational2scm (Rational r)
{
- return scm_divide (scm_from_int (r.numerator ()), scm_from_int (r.denominator ()));
+ return scm_divide (scm_from_long_long (r.numerator ()),
+ scm_from_long_long (r.denominator ()));
}
Rational
ly_scm2rational (SCM r)
{
- return Rational (scm_to_int (scm_numerator (r)),
- scm_to_int (scm_denominator (r)));
+ return Rational (scm_to_long_long (scm_numerator (r)),
+ scm_to_long_long (scm_denominator (r)));
}
Rational