Example #1
0
 static inline Fractional< Natural > ReducingDivide(const Fractional< Natural > &left, const Fractional< Natural > &right)
 {
   const Natural
     lnrn_divisor = GreatestCommonDivisor(left.numerator, right.numerator),
     ldrd_divisor = GreatestCommonDivisor(left.denominator, right.denominator);
   const Fractional< Natural > result = {
     (left.numerator / lnrn_divisor) * (right.denominator / ldrd_divisor),
     (left.denominator / ldrd_divisor) * (right.numerator / lnrn_divisor)
   };
   return result;
 }
Example #2
0
int GreatestCommonDivisor (int i1, int i2) {
	if (i1 > i2) {
		if (i2 == 0)
			return (i1);
		return GreatestCommonDivisor (i2, i1 % i2);
	} else {
		if (i1 == 0)
			return (i2);
		return GreatestCommonDivisor (i1, i2 % i1);
	}
}
Example #3
0
 static inline Natural LeastCommonMultiple(const Natural &a, const Natural &b)
 {
   const Natural divisor = GreatestCommonDivisor(a, b);
   if (a > b)
     return a / divisor * b;
   return b / divisor * a;
 }
Example #4
0
/**
 * Compute least common multiple (lcm) of arguments \a a and \a b, the smallest
 * integer value that is a multiple of both \a a and \a b.
 * @param a First number.
 * @param b second number.
 * @return Least common multiple of values \a a and \a b.
 *
 * @note This function only works for non-negative values of \a a and \a b.
 */
int LeastCommonMultiple(int a, int b)
{
	if (a == 0 || b == 0) return 0; // By definition.
	if (a == 1 || a == b) return b;
	if (b == 1) return a;

	return a * b / GreatestCommonDivisor(a, b);
}
fraction fraction::operator /(const fraction& a) const
{
    int tmpNumerator=numerator*a.denominator;
    int tmpDenominator=denominator*a.numerator;
    int GCD;
    GCD=GreatestCommonDivisor(tmpNumerator,tmpDenominator);
    if(GCD==1)
    return fraction(tmpNumerator,tmpDenominator);
    else
        return fraction(tmpNumerator/GCD,tmpDenominator/GCD);
}
Example #6
0
 static inline Fractional< Natural > Reduce(const Fractional< Natural > &fraction)
 {
   Natural divisor;
   Fractional< Natural > result;
   if (fraction.numerator == 0) {
     result.numerator = 0;
     result.denominator = 1;
   } else {
     divisor = GreatestCommonDivisor(fraction.numerator, fraction.denominator);
     result.numerator = fraction.numerator / divisor;
     result.denominator = fraction.denominator / divisor;
   }
   return result;
 }
Example #7
0
/*
=============
R_SetSkyFrame
==============
*/
void R_SetSkyFrame (void)
{
	int		g, s1, s2;
	float	temp;

	skyspeed = iskyspeed;
	skyspeed2 = iskyspeed2;

	g = GreatestCommonDivisor (iskyspeed, iskyspeed2);
	s1 = iskyspeed / g;
	s2 = iskyspeed2 / g;
	temp = SKYSIZE * s1 * s2;

	skytime = cl.time - ((int)(cl.time / temp) * temp);

}
fraction fraction::operator -(const fraction& a) const
{
    int tmpNumerator;
    int tmpDenominator;
    int GCD;
    int cnt1,cnt2;
    tmpDenominator=LeastCommonMultiple(denominator,a.denominator);
    cnt1=tmpDenominator/denominator;
    cnt2=tmpDenominator/a.denominator;
    tmpNumerator=cnt1*numerator-cnt2*a.numerator;
    GCD=GreatestCommonDivisor(tmpNumerator,tmpDenominator);
    if(GCD==1)
    return fraction(tmpNumerator,tmpDenominator);
    else
    return fraction(tmpNumerator/GCD,tmpDenominator/GCD);
}
fraction::fraction(const int a,const int b)
{
    if(b==0)
      exit(0);
    int  GCD=GreatestCommonDivisor(a,b);
    if(GCD==1)
    {
        numerator=a;
        denominator=b;
    }
    else
    {
        numerator=a/GCD;
        denominator=b/GCD;
    }
}
Example #10
0
void R_SetSkyFrameFPM (void)
{
	int		g, s1, s2;
	float	temp;

	skyspeed = (float)iskyspeed;
	skyspeed2 = (float)iskyspeed2;

	g = GreatestCommonDivisor (iskyspeed, iskyspeed2);
	s1 = iskyspeed / g;
	s2 = iskyspeed2 / g;
	temp = (float)(SKYSIZE * s1 * s2);

	skytime = (float)(clFPM.time - ((int)(clFPM.time / temp) * temp));
	

	r_skymade = 0;
}
Example #11
0
void Rational::Reduce()
{
	long GCD = GreatestCommonDivisor(numerator, denominator);
	numerator = numerator / GCD;
	denominator = denominator / GCD;
}