P-Adic numbers, basic: Difference between revisions

m
Minor code improvement.
m (Corrected a mistake in a comment.)
m (Minor code improvement.)
Line 63:
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");
Line 119:
}
 
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.digitsother_digits.insert(digitsthis_digits.begin(), 0);
}
 
for ( int32_t i = 0; i < -other.order + order; ++i ) {
digitsthis_digits.insert(digitsthis_digits.begin(), 0);
}
 
// Standard digit by digit addition
uint32_t carry = 0;
for ( uint32_t i = 0; i < std::min(digitsthis_digits.size(), other.digitsother_digits.size()); ++i ) {
const uint32_t sum = digitsthis_digits[i] + other.digitsother_digits[i] + carry;
const uint32_t remainder = sum % prime;
carry = ( sum >= prime ) ? 1 : 0;
result.emplace_back(remainder);
}
 
// Reverse the changes made to the digits
for ( int32_t i = 0; i < -order + other.order; ++i ) {
other.digits.erase(digits.begin());
}
 
for ( int32_t i = 0; i < -other.order + order; ++i ) {
digits.erase(digits.begin());
}
 
Line 230 ⟶ 223:
* '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) {
}
Line 244 ⟶ 237:
 
// 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 ) {
Line 253 ⟶ 246:
 
// 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;
Line 266 ⟶ 259:
 
// 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;
Line 277 ⟶ 270:
 
// 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 ) {
Line 287 ⟶ 280:
 
// 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 ) {
894

edits