P-Adic numbers, basic: Difference between revisions

Content added Content deleted
m (Minor code improvement.)
m (Improved code and added better output example.)
Line 1,647: Line 1,647:


=={{header|Java}}==
=={{header|Java}}==
This example displays p-adic numbers in standard mathematical format, consisting of a possibly infinite list of digits extending leftwards from the p-adic point.
This example displays p-adic numbers in standard mathematical format, consisting of a possibly infinite list of digits extending leftwards from the p-adic point. Answers are given correct to O(prime^20).
<syntaxhighlight lang="java">
<syntaxhighlight lang="java">
import java.util.ArrayList;
import java.util.ArrayList;
Line 1,654: Line 1,654:
public final class PAdicNumbersBasic {
public final class PAdicNumbersBasic {


public static void main(String[] args) {
public static void main(String[] args) {
System.out.println("2-adic numbers:");
System.out.println("3-adic numbers:");
Padic padicOne = new Padic(2, -25, 13);
Padic padicOne = new Padic(3, -5, 9);
System.out.println("-25 / 13 => " + padicOne);
System.out.println("-5 / 9 => " + padicOne);
Padic padicTwo = new Padic(2, 571, 151);
Padic padicTwo = new Padic(3, 47, 12);
System.out.println("571 / 151 => " + padicTwo);
System.out.println("47 / 12 => " + padicTwo);
Padic sum = padicOne.add(padicTwo);
Padic sum = padicOne.add(padicTwo);
System.out.println("sum => " + sum);
System.out.println("sum => " + sum);
System.out.println("Rational = " + sum.convertToRational());
System.out.println("Rational = " + sum.convertToRational());
System.out.println();
System.out.println();
⚫
System.out.println("7-adic numbers:");
System.out.println("7-adic numbers:");
padicOne = new Padic(7, 5, 8);
padicOne = new Padic(7, 5, 8);
Line 1,699: Line 1,699:


// Remove multiples of 'prime' and adjust the order of the p-adic number accordingly
// Remove multiples of 'prime' and adjust the order of the p-adic number accordingly
while ( moduloPrime(aNumerator) == 0 ) {
while ( Math.floorMod(aNumerator, prime) == 0 ) {
aNumerator /= prime;
aNumerator /= prime;
order += 1;
order += 1;
}
}
while ( moduloPrime(aDenominator) == 0 ) {
while ( Math.floorMod(aDenominator, prime) == 0 ) {
aDenominator /= prime;
aDenominator /= prime;
order -= 1;
order -= 1;
Line 1,712: Line 1,712:
final long inverse = moduloInverse(aDenominator);
final long inverse = moduloInverse(aDenominator);
while ( digits.size() < PRECISION ) {
while ( digits.size() < PRECISION ) {
final int digit = moduloPrime(aNumerator * inverse);
final int digit = Math.floorMod(aNumerator * inverse, prime);
digits.addLast(digit);
digits.addLast(digit);
Line 1,723: Line 1,723:
// The denominator is not a power of a prime
// The denominator is not a power of a prime
int count = 0;
int count = 0;
while ( moduloPrime(aNumerator) == 0 ) {
while ( Math.floorMod(aNumerator, prime) == 0 ) {
aNumerator /= prime;
aNumerator /= prime;
count += 1;
count += 1;
Line 1,748: Line 1,748:
for ( int i = 0; i < -order + aOther.order; i++ ) {
for ( int i = 0; i < -order + aOther.order; i++ ) {
aOther.digits.addFirst(0);
aOther.digits.addFirst(0);
}
}
for ( int i = 0; i < -aOther.order + order; i++ ) {
for ( int i = 0; i < -aOther.order + order; i++ ) {
Line 1,779: Line 1,779:
*/
*/
public String convertToRational() {
public String convertToRational() {
List<Integer> numbers = new ArrayList<Integer>(digits);
List<Integer> numbers = new ArrayList<Integer>(digits);
// Zero
// Zero
if ( allZeroDigits(numbers) ) {
if ( allZeroDigits(numbers) ) {
return "0";
return "0 / 1";
}
}
// Positive integer
// Positive integer
Line 1,792: Line 1,792:
}
}
return String.valueOf(convertToDecimal(numbers));
return String.valueOf(convertToDecimal(numbers));
}
}
// Negative integer
// Negative integer
Line 1,801: Line 1,801:
negateList(numbers);
negateList(numbers);
return "-" + String.valueOf(convertToDecimal(numbers));
return "-" + String.valueOf(convertToDecimal(numbers));
}
}
// Rational
// Rational
Padic sum = new Padic(prime, digits, order);
Padic sum = new Padic(prime, digits, order);
Padic self = new Padic(prime, digits, order);
int denominator = 1;
int denominator = 1;
do {
do {
sum = sum.add(this);
sum = sum.add(self);
denominator += 1;
denominator += 1;
} while ( ! endsWith(sum.digits, 0) && ! endsWith(sum.digits, prime - 1) );
} while ( ! endsWith(sum.digits, 0) && ! endsWith(sum.digits, prime - 1) );
Line 1,816: Line 1,817:
}
}
String numerator = String.valueOf(convertToDecimal(sum.digits));
int numerator = convertToDecimal(sum.digits);
⚫
String rational = numerator + " / " + denominator;
if ( order > 0 ) {
numerator *= Math.pow(prime, order);
}
if ( order < 0 ) {
denominator *= Math.pow(prime, -order);
}
⚫
String rational = String.valueOf(numerator) + " / " + denominator;
return negative ? "-" + rational : rational;
return negative ? "-" + rational : rational;
}
}
Line 1,876: Line 1,885:
return inverse;
return inverse;
}
⚫
/**
* Return the given number modulo 'prime' in the range 0..'prime' - 1.
*/
private int moduloPrime(long aNumber) {
final int div = (int) ( aNumber % prime );
return ( div >= 0 ) ? div : div + prime;
}
}
Line 1,942: Line 1,942:
private List<Integer> digits;
private List<Integer> digits;
private int order;
private int order;
private final int prime;
private final int prime;
Line 1,953: Line 1,953:
{{ out }}
{{ out }}
<pre>
<pre>
2-adic numbers:
3-adic numbers:
-25 / 13 => ...0100111011000100111011000100111011000011.0
-5 / 9 => ...22222222222222222222222222222222222222.11
571 / 151 => ...1111111001001101111111001001101111111101.0
47 / 12 => ...020202020202020202020202020202020202101.2
sum => ...0100110100010010111010001110101011000000.0
sum => ...20202020202020202020202020202020202101.01
Rational = 3648 / 1963
Rational = 121 / 36


7-adic numbers:
7-adic numbers:
Retrieved from "https://rosettacode.org/wiki/P-Adic_numbers,_basic"