void fraction::setBoth(int num, int denom)
{
int gcf=greatestCommonFactor(num,denom);
numerator=num/gcf;
denominator=denom/gcf;
}
bignum greatestCommonFactor(const bignum &bn1, const bignum &bn2)
{
if (bn1.isNegative() != bn2.isNegative())
return greatestCommonFactor(bn1.absolute(), bn2.absolute());
if (bn1.getDecimalCount() > 0 || bn2.getDecimalCount() > 0)
throw error_handler(__FILE__, __LINE__, "Greatest common factor can only be found with two integers");
if (bn1 == bn2)
return bn1;
bignum lowest = bn1 < bn2 ? bn1 : bn2;
bignum highest = bn1 > bn2 ? bn1 : bn2;
int converted_lowest = (int)lowest;
int converted_highest = (int)highest;
if (highest % lowest == 0)
return lowest;
for (int i = converted_lowest; i > 1; i--)
{
if (converted_lowest % i == 0 && converted_highest % i == 0)
{
bignum temp(i);
temp.convertBase(bn1.getBase());
return temp;
}
}
bignum one(1);
one.setBase(bn1.getBase());
return one;
}
void fraction::setDenominator(int denom)
{
int gcf=greatestCommonFactor(numerator,denom);
numerator=numerator/gcf;
denominator=denom/gcf;
}
void fraction::setNumerator(int num)
{
int gcf=greatestCommonFactor(num,denominator);
numerator=num/gcf;
denominator=denominator/gcf;
}
fraction::fraction(int num, int denom):numerator(num), denominator(denom)
{
int gcf=greatestCommonFactor(num,denom);
numerator=num/gcf;
denominator=denom/gcf;
}
bignum exponent(const bignum &base_value, const bignum &power, int precision)
{
if (base_value.getBase() != power.getBase())
return exponent(base_value, power.getConverted(power.getBase()));
bignum one(1);
one.setBase(base_value.getBase());
one.setPositive();
if (power.isZero())
return one;
//if the power is negative, return 1/solution
if (power.isNegative())
return one / exponent(base_value, power.absolute());
if (power.getDecimalCount() > 0)
{
if (power < 1)
{
bignum modified_power(power);
modified_power.leftShift(power.getDecimalCount());
bignum divisor(1);
divisor.setBase(power.getBase());
divisor.leftShift(power.getDecimalCount());
bignum gcf(greatestCommonFactor(modified_power, divisor));
modified_power /= gcf;
divisor /= gcf;
bignum divisor_root_of_base = jep::root(divisor, base_value, precision);
return exponent(divisor_root_of_base, modified_power).getRoundedAllDigits(ONES_PLACE - precision);
}
else
{
bignum power_decimal = power % 1;
bignum power_int = power.getRoundedDown(ONES_PLACE);
return exponent(base_value, power_int, precision) * exponent(base_value, power_decimal, precision);
}
}
bignum counter = power.absolute();
bignum temp(base_value);
//n^0 always returns 1
if (power.isZero())
return one;
while (counter > one)
{
temp *= base_value;
counter--;
}
return temp;
}
fraction::fraction(double number)//1.55
{
numerator=0;
denominator=1;
decimalToFraction(number,numerator,denominator);
int gcf=greatestCommonFactor(numerator,denominator);
numerator=numerator/gcf;
denominator=denominator/gcf;
}
size_t
leastCommonMultiple (size_t x, size_t y)
{
return x / greatestCommonFactor (x, y) * y;
}
