Data update
This commit is contained in:
Ingy dot Net
parent
0df55f9f24
commit
aec8ed51b6
1045 changed files with 18889 additions and 2777 deletions
305
Task/P-Adic-numbers-basic/C++/p-adic-numbers-basic.cpp
Normal file
305
Task/P-Adic-numbers-basic/C++/p-adic-numbers-basic.cpp
Normal file
|
|
@ -0,0 +1,305 @@
|
|||
#include <cmath>
|
||||
#include <cstdint>
|
||||
#include <iostream>
|
||||
#include <numeric>
|
||||
#include <stdexcept>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
class Rational {
|
||||
public:
|
||||
Rational(const int32_t& aNumerator, const int32_t& aDenominator) {
|
||||
if ( aDenominator < 0 ) {
|
||||
numerator = -aNumerator;
|
||||
denominator = -aDenominator;
|
||||
} else {
|
||||
numerator = aNumerator;
|
||||
denominator = aDenominator;
|
||||
}
|
||||
|
||||
if ( aNumerator == 0 ) {
|
||||
denominator = 1;
|
||||
}
|
||||
|
||||
const uint32_t divisor = std::gcd(numerator, denominator);
|
||||
numerator /= divisor;
|
||||
denominator /= divisor;
|
||||
}
|
||||
|
||||
std::string to_string() const {
|
||||
return std::to_string(numerator) + " / " + std::to_string(denominator);
|
||||
}
|
||||
|
||||
private:
|
||||
int32_t numerator;
|
||||
int32_t denominator;
|
||||
};
|
||||
|
||||
class P_adic {
|
||||
public:
|
||||
// Create a P-adic number, with p = 'prime', from the given rational 'numerator' / 'denominator'.
|
||||
P_adic(const uint32_t& prime, int32_t numerator, int32_t denominator) : prime(prime) {
|
||||
if ( denominator == 0 ) {
|
||||
std::invalid_argument("Denominator cannot be zero");
|
||||
}
|
||||
|
||||
order = 0;
|
||||
|
||||
// Process rational zero
|
||||
if ( numerator == 0 ) {
|
||||
order = ORDER_MAX;
|
||||
return;
|
||||
}
|
||||
|
||||
// Remove multiples of 'prime' and adjust the order of the P-adic number accordingly
|
||||
while ( modulo_prime(numerator) == 0 ) {
|
||||
numerator /= static_cast<int32_t>(prime);
|
||||
order += 1;
|
||||
}
|
||||
|
||||
while ( modulo_prime(denominator) == 0 ) {
|
||||
denominator /= static_cast<int32_t>(prime);
|
||||
order -= 1;
|
||||
}
|
||||
|
||||
// Standard calculation of P-adic digits
|
||||
const uint64_t inverse = modulo_inverse(denominator);
|
||||
while ( digits.size() < DIGITS_SIZE ) {
|
||||
const uint32_t digit = modulo_prime(numerator * inverse);
|
||||
digits.emplace_back(digit);
|
||||
|
||||
numerator -= digit * denominator;
|
||||
|
||||
if ( numerator != 0 ) {
|
||||
// The denominator is not a power of a prime
|
||||
uint32_t count = 0;
|
||||
while ( modulo_prime(numerator) == 0 ) {
|
||||
numerator /= static_cast<int32_t>(prime);
|
||||
count += 1;
|
||||
}
|
||||
|
||||
for ( uint32_t i = count; i > 1; --i ) {
|
||||
digits.emplace_back(0);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Return the sum of this P-adic number with the given P-adic number.
|
||||
P_adic add(P_adic other) {
|
||||
if ( prime != other.prime ) {
|
||||
std::invalid_argument("Cannot add p-adic's with different primes");
|
||||
}
|
||||
|
||||
std::vector<uint32_t> this_digits = digits;
|
||||
std::vector<uint32_t> other_digits = other.digits;
|
||||
std::vector<uint32_t> result;
|
||||
|
||||
// Adjust the digits so that the P-adic points are aligned
|
||||
for ( int32_t i = 0; i < -order + other.order; ++i ) {
|
||||
other_digits.insert(other_digits.begin(), 0);
|
||||
}
|
||||
|
||||
for ( int32_t i = 0; i < -other.order + order; ++i ) {
|
||||
this_digits.insert(this_digits.begin(), 0);
|
||||
}
|
||||
|
||||
// Standard digit by digit addition
|
||||
uint32_t carry = 0;
|
||||
for ( uint32_t i = 0; i < std::min(this_digits.size(), other_digits.size()); ++i ) {
|
||||
const uint32_t sum = this_digits[i] + other_digits[i] + carry;
|
||||
const uint32_t remainder = sum % prime;
|
||||
carry = ( sum >= prime ) ? 1 : 0;
|
||||
result.emplace_back(remainder);
|
||||
}
|
||||
|
||||
return P_adic(prime, result, all_zero_digits(result) ? ORDER_MAX : std::min(order, other.order));
|
||||
}
|
||||
|
||||
// Return the Rational representation of this P-adic number.
|
||||
Rational convert_to_rational() {
|
||||
std::vector<uint32_t> numbers = digits;
|
||||
|
||||
// Zero
|
||||
if ( all_zero_digits(numbers) ) {
|
||||
return Rational(1, 0);
|
||||
}
|
||||
|
||||
// Positive integer
|
||||
if ( order >= 0 && ends_with(numbers, 0) ) {
|
||||
for ( int32_t i = 0; i < order; ++i ) {
|
||||
numbers.emplace(numbers.begin(), 0);
|
||||
}
|
||||
|
||||
return Rational(convert_to_decimal(numbers), 1);
|
||||
}
|
||||
|
||||
// Negative integer
|
||||
if ( order >= 0 && ends_with(numbers, prime - 1) ) {
|
||||
negate_digits(numbers);
|
||||
for ( int32_t i = 0; i < order; ++i ) {
|
||||
numbers.emplace(numbers.begin(), 0);
|
||||
}
|
||||
|
||||
return Rational(-convert_to_decimal(numbers), 1);
|
||||
}
|
||||
|
||||
// Rational
|
||||
const P_adic copy(prime, digits, order);
|
||||
P_adic sum(prime, digits, order);
|
||||
int32_t denominator = 1;
|
||||
do {
|
||||
sum = sum.add(copy);
|
||||
denominator += 1;
|
||||
} while ( ! ( ends_with(sum.digits, 0) || ends_with(sum.digits, prime - 1) ) );
|
||||
|
||||
const bool negative = ends_with(sum.digits, 6);
|
||||
if ( negative ) {
|
||||
negate_digits(sum.digits);
|
||||
}
|
||||
|
||||
int32_t numerator = negative ? -convert_to_decimal(sum.digits) : convert_to_decimal(sum.digits);
|
||||
|
||||
if ( order > 0 ) {
|
||||
numerator *= std::pow(prime, order);
|
||||
}
|
||||
|
||||
if ( order < 0 ) {
|
||||
denominator *= std::pow(prime, -order);
|
||||
}
|
||||
|
||||
return Rational(numerator, denominator);
|
||||
}
|
||||
|
||||
// Return a string representation of this p-adic.
|
||||
std::string to_string() {
|
||||
while ( digits.size() > PRECISION ) {
|
||||
digits.pop_back();
|
||||
}
|
||||
pad_with_zeros(digits);
|
||||
|
||||
std::string result = "";
|
||||
for ( int64_t i = digits.size() - 1; i >= 0; --i ) {
|
||||
result += std::to_string(digits[i]);
|
||||
}
|
||||
|
||||
if ( order >= 0 ) {
|
||||
for ( int32_t i = 0; i < order; ++i ) {
|
||||
result += "0";
|
||||
result.erase(result.begin());
|
||||
}
|
||||
|
||||
result += ".0";
|
||||
} else {
|
||||
result.insert(result.length() + order, ".");
|
||||
}
|
||||
|
||||
return " ..." + result;
|
||||
}
|
||||
|
||||
private:
|
||||
/**
|
||||
* Create a P-adic, with p = 'prime', directly from a vector of digits.
|
||||
*
|
||||
* With 'order' = 0, the vector [1, 2, 3, 4, 5] creates the p-adic ...54321.0
|
||||
* 'order' > 0 shifts the vector 'order' places to the left and
|
||||
* 'order' < 0 shifts the vector 'order' places to the right.
|
||||
*/
|
||||
P_adic(const uint32_t& prime, const std::vector<uint32_t>& digits, const int32_t& order)
|
||||
: prime(prime), digits(digits), order(order) {
|
||||
}
|
||||
|
||||
// Transform the given vector of digits representing a p-adic number
|
||||
// into a vector which represents the negation of the p-adic number.
|
||||
void negate_digits(std::vector<uint32_t> numbers) {
|
||||
numbers[0] = ( prime - numbers[0] ) % prime;
|
||||
for ( uint64_t i = 1; i < numbers.size(); ++i ) {
|
||||
numbers[i] = prime - 1 - numbers[i];
|
||||
}
|
||||
}
|
||||
|
||||
// Return the multiplicative inverse of the given number modulo 'prime'.
|
||||
uint32_t modulo_inverse(const uint32_t& number) const {
|
||||
uint32_t inverse = 1;
|
||||
while ( ( inverse * number ) % prime != 1 ) {
|
||||
inverse += 1;
|
||||
}
|
||||
return inverse;
|
||||
}
|
||||
|
||||
// Return the given number modulo 'prime' in the range 0..'prime' - 1.
|
||||
int32_t modulo_prime(const int64_t& number) const {
|
||||
const int32_t div = static_cast<int32_t>(number % prime);
|
||||
return ( div >= 0 ) ? div : div + prime;
|
||||
}
|
||||
|
||||
// The given vector is padded on the right by zeros up to a maximum length of 'PRECISION'.
|
||||
void pad_with_zeros(std::vector<uint32_t> vector) {
|
||||
while ( vector.size() < PRECISION ) {
|
||||
vector.emplace_back(0);
|
||||
}
|
||||
}
|
||||
|
||||
// Return the given vector of base 'prime' integers converted to a decimal integer.
|
||||
uint32_t convert_to_decimal(const std::vector<uint32_t>& numbers) const {
|
||||
uint32_t decimal = 0;
|
||||
uint32_t multiple = 1;
|
||||
for ( const uint32_t& number : numbers ) {
|
||||
decimal += number * multiple;
|
||||
multiple *= prime;
|
||||
}
|
||||
return decimal;
|
||||
}
|
||||
|
||||
// Return whether the given vector consists of all zeros.
|
||||
bool all_zero_digits(const std::vector<uint32_t>& numbers) const {
|
||||
for ( uint32_t number : numbers ) {
|
||||
if ( number != 0 ) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
// Return whether the given vector ends with multiple instances of the given number.
|
||||
bool ends_with(const std::vector<uint32_t>& numbers, const uint32_t& number) const {
|
||||
for ( uint64_t i = numbers.size() - 1; i >= numbers.size() - PRECISION / 2; --i ) {
|
||||
if ( numbers[i] != number ) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
uint32_t prime;
|
||||
std::vector<uint32_t> digits;
|
||||
int32_t order;
|
||||
|
||||
static const uint32_t PRECISION = 40;
|
||||
static const uint32_t ORDER_MAX = 1'000;
|
||||
static const uint32_t DIGITS_SIZE = PRECISION + 5;
|
||||
};
|
||||
|
||||
int main() {
|
||||
std::cout << "3-adic numbers:" << std::endl;
|
||||
P_adic padic_one(3, -2, 87);
|
||||
std::cout << "-2 / 87 => " << padic_one.to_string() << std::endl;
|
||||
P_adic padic_two(3, 4, 97);
|
||||
std::cout << "4 / 97 => " << padic_two.to_string() << std::endl;
|
||||
|
||||
P_adic sum = padic_one.add(padic_two);
|
||||
std::cout << "sum => " << sum.to_string() << std::endl;
|
||||
std::cout << "Rational = " << sum.convert_to_rational().to_string() << std::endl;
|
||||
std::cout << std::endl;
|
||||
|
||||
std::cout << "7-adic numbers:" << std::endl;
|
||||
padic_one = P_adic(7, 5, 8);
|
||||
std::cout << "5 / 8 => " << padic_one.to_string() << std::endl;
|
||||
padic_two = P_adic(7, 353, 30809);
|
||||
std::cout << "353 / 30809 => " << padic_two.to_string() << std::endl;
|
||||
|
||||
sum = padic_one.add(padic_two);
|
||||
std::cout << "sum => " << sum.to_string() << std::endl;
|
||||
std::cout << "Rational = " << sum.convert_to_rational().to_string() << std::endl;
|
||||
std::cout << std::endl;
|
||||
}
|
||||
332
Task/P-Adic-numbers-basic/Java/p-adic-numbers-basic.java
Normal file
332
Task/P-Adic-numbers-basic/Java/p-adic-numbers-basic.java
Normal file
|
|
@ -0,0 +1,332 @@
|
|||
public final class PAdicNumbersBasic {
|
||||
|
||||
public static void main(String[] args) {
|
||||
System.out.println("3-adic numbers:");
|
||||
Padic padicOne = new Padic(3, -5, 9);
|
||||
System.out.println("-5 / 9 => " + padicOne);
|
||||
Padic padicTwo = new Padic(3, 47, 12);
|
||||
System.out.println("47 / 12 => " + padicTwo);
|
||||
|
||||
Padic sum = padicOne.add(padicTwo);
|
||||
System.out.println("sum => " + sum);
|
||||
System.out.println("Rational = " + sum.convertToRational());
|
||||
System.out.println();
|
||||
|
||||
System.out.println("7-adic numbers:");
|
||||
padicOne = new Padic(7, 5, 8);
|
||||
System.out.println("5 / 8 => " + padicOne);
|
||||
padicTwo = new Padic(7, 353, 30809);
|
||||
System.out.println("353 / 30809 => " + padicTwo);
|
||||
|
||||
sum = padicOne.add(padicTwo);
|
||||
System.out.println("sum => " + sum);
|
||||
System.out.println("Rational = " + sum.convertToRational());
|
||||
}
|
||||
}
|
||||
|
||||
final class Padic {
|
||||
/**
|
||||
* Create a p-adic, with p = aPrime, from the given rational 'aNumerator' / 'aDenominator'.
|
||||
*/
|
||||
public Padic(int aPrime, int aNumerator, int aDenominator) {
|
||||
if ( aDenominator == 0 ) {
|
||||
throw new IllegalArgumentException("Denominator cannot be zero");
|
||||
}
|
||||
|
||||
prime = aPrime;
|
||||
digits = new ArrayList<Integer>(DIGITS_SIZE);
|
||||
order = 0;
|
||||
|
||||
// Process rational zero
|
||||
if ( aNumerator == 0 ) {
|
||||
order = MAX_ORDER;
|
||||
return;
|
||||
}
|
||||
|
||||
// Remove multiples of 'prime' and adjust the order of the p-adic number accordingly
|
||||
while ( Math.floorMod(aNumerator, prime) == 0 ) {
|
||||
aNumerator /= prime;
|
||||
order += 1;
|
||||
}
|
||||
|
||||
while ( Math.floorMod(aDenominator, prime) == 0 ) {
|
||||
aDenominator /= prime;
|
||||
order -= 1;
|
||||
}
|
||||
|
||||
// Standard calculation of p-adic digits
|
||||
final long inverse = moduloInverse(aDenominator);
|
||||
while ( digits.size() < DIGITS_SIZE ) {
|
||||
final int digit = Math.floorMod(aNumerator * inverse, prime);
|
||||
digits.addLast(digit);
|
||||
|
||||
aNumerator -= digit * aDenominator;
|
||||
|
||||
if ( aNumerator != 0 ) {
|
||||
// The denominator is not a power of a prime
|
||||
int count = 0;
|
||||
while ( Math.floorMod(aNumerator, prime) == 0 ) {
|
||||
aNumerator /= prime;
|
||||
count += 1;
|
||||
}
|
||||
|
||||
for ( int i = count; i > 1; i-- ) {
|
||||
digits.addLast(0);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Return the sum of this p-adic number and the given p-adic number.
|
||||
*/
|
||||
public Padic add(Padic aOther) {
|
||||
if ( prime != aOther.prime ) {
|
||||
throw new IllegalArgumentException("Cannot add p-adic's with different primes");
|
||||
}
|
||||
|
||||
List<Integer> result = new ArrayList<Integer>();
|
||||
|
||||
// Adjust the digits so that the p-adic points are aligned
|
||||
for ( int i = 0; i < -order + aOther.order; i++ ) {
|
||||
aOther.digits.addFirst(0);
|
||||
}
|
||||
|
||||
for ( int i = 0; i < -aOther.order + order; i++ ) {
|
||||
digits.addFirst(0);
|
||||
}
|
||||
|
||||
// Standard digit by digit addition
|
||||
int carry = 0;
|
||||
for ( int i = 0; i < Math.min(digits.size(), aOther.digits.size()); i++ ) {
|
||||
final int sum = digits.get(i) + aOther.digits.get(i) + carry;
|
||||
final int remainder = Math.floorMod(sum, prime);
|
||||
carry = ( sum >= prime ) ? 1 : 0;
|
||||
result.addLast(remainder);
|
||||
}
|
||||
|
||||
// Reverse the changes made to the digits
|
||||
for ( int i = 0; i < -order + aOther.order; i++ ) {
|
||||
aOther.digits.removeFirst();
|
||||
}
|
||||
|
||||
for ( int i = 0; i < -aOther.order + order; i++ ) {
|
||||
digits.removeFirst();
|
||||
}
|
||||
|
||||
return new Padic(prime, result, allZeroDigits(result) ? MAX_ORDER : Math.min(order, aOther.order));
|
||||
}
|
||||
|
||||
/**
|
||||
* Return the Rational representation of this p-adic number.
|
||||
*/
|
||||
public Rational convertToRational() {
|
||||
List<Integer> numbers = new ArrayList<Integer>(digits);
|
||||
|
||||
// Zero
|
||||
if ( allZeroDigits(numbers) ) {
|
||||
return new Rational(0, 1);
|
||||
}
|
||||
|
||||
// Positive integer
|
||||
if ( order >= 0 && endsWith(numbers, 0) ) {
|
||||
for ( int i = 0; i < order; i++ ) {
|
||||
numbers.addFirst(0);
|
||||
}
|
||||
|
||||
return new Rational(convertToDecimal(numbers), 1);
|
||||
}
|
||||
|
||||
// Negative integer
|
||||
if ( order >= 0 && endsWith(numbers, prime - 1) ) {
|
||||
negateList(numbers);
|
||||
for ( int i = 0; i < order; i++ ) {
|
||||
numbers.addFirst(0);
|
||||
}
|
||||
|
||||
return new Rational(-convertToDecimal(numbers), 1);
|
||||
}
|
||||
|
||||
// Rational
|
||||
Padic sum = new Padic(prime, digits, order);
|
||||
Padic self = new Padic(prime, digits, order);
|
||||
int denominator = 1;
|
||||
do {
|
||||
sum = sum.add(self);
|
||||
denominator += 1;
|
||||
} while ( ! ( endsWith(sum.digits, 0) || endsWith(sum.digits, prime - 1) ) );
|
||||
|
||||
final boolean negative = endsWith(sum.digits, prime - 1);
|
||||
if ( negative ) {
|
||||
negateList(sum.digits);
|
||||
}
|
||||
|
||||
int numerator = negative ? -convertToDecimal(sum.digits) : convertToDecimal(sum.digits);
|
||||
|
||||
if ( order > 0 ) {
|
||||
numerator *= Math.pow(prime, order);
|
||||
}
|
||||
|
||||
if ( order < 0 ) {
|
||||
denominator *= Math.pow(prime, -order);
|
||||
}
|
||||
|
||||
return new Rational(numerator, denominator);
|
||||
}
|
||||
|
||||
/**
|
||||
* Return a string representation of this p-adic.
|
||||
*/
|
||||
public String toString() {
|
||||
while ( digits.size() > PRECISION ) {
|
||||
digits.removeLast();
|
||||
}
|
||||
padWithZeros(digits);
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
for ( int i = digits.size() - 1; i >= 0; i-- ) {
|
||||
builder.append(digits.get(i));
|
||||
}
|
||||
|
||||
if ( order >= 0 ) {
|
||||
for ( int i = 0; i < order; i++ ) {
|
||||
builder.append("0");
|
||||
builder.deleteCharAt(0);
|
||||
}
|
||||
|
||||
builder.append(".0");
|
||||
} else {
|
||||
builder.insert(builder.length() + order, ".");
|
||||
}
|
||||
|
||||
return " ..." + builder.toString();
|
||||
}
|
||||
|
||||
// PRIVATE //
|
||||
|
||||
/**
|
||||
* Create a p-adic, with p = 'aPrime', directly from a list of digits.
|
||||
*
|
||||
* With 'aOrder' = 0, the list [1, 2, 3, 4, 5] creates the p-adic ...54321.0
|
||||
* 'aOrder' > 0 shifts the list 'aOrder' places to the left and
|
||||
* 'aOrder' < 0 shifts the list 'aOrder' places to the right.
|
||||
*/
|
||||
private Padic(int aPrime, List<Integer> aDigits, int aOrder) {
|
||||
prime = aPrime;
|
||||
digits = new ArrayList<Integer>(aDigits);
|
||||
padWithZeros(digits);
|
||||
order = aOrder;
|
||||
}
|
||||
|
||||
/**
|
||||
* Return the multiplicative inverse of the given decimal number modulo 'prime'.
|
||||
*/
|
||||
private int moduloInverse(int aNumber) {
|
||||
int inverse = 1;
|
||||
while ( Math.floorMod(inverse * aNumber, prime) != 1 ) {
|
||||
inverse += 1;
|
||||
}
|
||||
|
||||
return inverse;
|
||||
}
|
||||
|
||||
/**
|
||||
* Transform the given list of digits representing a p-adic number
|
||||
* into a list which represents the negation of the p-adic number.
|
||||
*/
|
||||
private void negateList(List<Integer> aDigits) {
|
||||
aDigits.set(0, ( prime - aDigits.get(0) ) % prime);
|
||||
for ( int i = 1; i < aDigits.size(); i++ ) {
|
||||
aDigits.set(i, prime - 1 - aDigits.get(i));
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Return the given list of base 'prime' integers converted to a decimal integer.
|
||||
*/
|
||||
private int convertToDecimal(List<Integer> aNumbers) {
|
||||
int decimal = 0;
|
||||
int multiple = 1;
|
||||
for ( int number : aNumbers ) {
|
||||
decimal += number * multiple;
|
||||
multiple *= prime;
|
||||
}
|
||||
|
||||
return decimal;
|
||||
}
|
||||
|
||||
/**
|
||||
* Return whether the given list consists of all zeros.
|
||||
*/
|
||||
private static boolean allZeroDigits(List<Integer> aList) {
|
||||
return aList.stream().allMatch( i -> i == 0 );
|
||||
}
|
||||
|
||||
/**
|
||||
* The given list is padded on the right by zeros up to a maximum length of 'PRECISION'.
|
||||
*/
|
||||
private static void padWithZeros(List<Integer> aList) {
|
||||
while ( aList.size() < PRECISION ) {
|
||||
aList.addLast(0);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Return whether the given list ends with multiple instances of the given number.
|
||||
*/
|
||||
private static boolean endsWith(List<Integer> aDigits, int aDigit) {
|
||||
for ( int i = aDigits.size() - 1; i >= aDigits.size() - PRECISION / 2; i-- ) {
|
||||
if ( aDigits.get(i) != aDigit ) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
private static class Rational {
|
||||
|
||||
public Rational(int aNumerator, int aDenominator) {
|
||||
if ( aDenominator < 0 ) {
|
||||
numerator = -aNumerator;
|
||||
denominator = -aDenominator;
|
||||
} else {
|
||||
numerator = aNumerator;
|
||||
denominator = aDenominator;
|
||||
}
|
||||
|
||||
if ( aNumerator == 0 ) {
|
||||
denominator = 1;
|
||||
}
|
||||
|
||||
final int gcd = gcd(numerator, denominator);
|
||||
numerator /= gcd;
|
||||
denominator /= gcd;
|
||||
}
|
||||
|
||||
public String toString() {
|
||||
return numerator + " / " + denominator;
|
||||
}
|
||||
|
||||
private int gcd(int aOne, int aTwo) {
|
||||
if ( aTwo == 0 ) {
|
||||
return Math.abs(aOne);
|
||||
}
|
||||
return gcd(aTwo, Math.floorMod(aOne, aTwo));
|
||||
}
|
||||
|
||||
private int numerator;
|
||||
private int denominator;
|
||||
|
||||
}
|
||||
|
||||
private List<Integer> digits;
|
||||
private int order;
|
||||
|
||||
private final int prime;
|
||||
|
||||
private static final int MAX_ORDER = 1_000;
|
||||
private static final int PRECISION = 40;
|
||||
private static final int DIGITS_SIZE = PRECISION + 5;
|
||||
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue