Arithmetic/Rational: Difference between revisions

m
Formatting error.
m (Correcting an error in formatting.)
m (Formatting error.)
Tag: Manual revert
Line 558:
return 0;
}</syntaxhighlight>
 
=={{header|C++}}==
<syntaxhighlight lang="c++">
#include <cmath>
#include <cstdint>
#include <iostream>
#include <numeric>
#include <stdexcept>
 
class Rational {
public:
/// Constructors ///
Rational() : numer(0), denom(1) {}
 
Rational(const int64_t number) : numer(number), denom(1) {}
 
Rational(const int64_t& numerator, const int64_t& denominator) : numer(numerator), denom(denominator) {
if ( numer == 0 ) {
denom = 1;
} else if ( denom == 0 ) {
throw std::invalid_argument("Denominator cannot be zero: " + denom);
} else if ( denom < 0 ) {
numer = -numer;
denom = -denom;
}
 
int64_t divisor = std::gcd(numerator, denom);
numer = numer / divisor;
denom = denom / divisor;
}
 
Rational(const Rational& other) : numer(other.numer), denom(other.denom) {}
 
/// Operators ///
Rational& operator=(const Rational& other) {
if ( *this != other ) { numer = other.numer; denom = other.denom; }
return *this;
}
 
bool operator!=(const Rational& other) const { return ! ( *this == other ); }
 
bool operator==(const Rational& other) const {
if ( numer == other.numer && denom == other.denom ) { return true; }
return false;
}
 
Rational& operator+=(const Rational& other) {
*this = Rational(numer* other.denom + other.numer * denom, denom * other.denom);
return *this;
}
 
Rational operator+(const Rational& other) const { return Rational(*this) += other; }
 
Rational& operator-=(const Rational& other) {
Rational temp(other);
temp.numer = -temp.numer;
return *this += temp;
}
Rational operator-(const Rational& other) const { return Rational(*this) -= other; }
 
Rational& operator*=(const Rational& other) {
*this = Rational(numer * other.numer, denom * other.denom);
return *this;
}
 
Rational operator*(const Rational& other) const { return Rational(*this) *= other; };
 
Rational& operator/=(const Rational other) {
Rational temp(other.denom, other.numer);
*this *= temp;
return *this;
}
 
Rational operator/(const Rational& other) const { return Rational(*this) /= other; };
 
bool operator<(const Rational& other) const { return numer * other.denom < denom * other.numer; }
 
bool operator<=(const Rational& other) const { return ! ( other < *this ); }
 
bool operator>(const Rational& other) const { return other < *this; }
 
bool operator>=(const Rational& other) const { return ! ( *this < other ); }
 
Rational operator-() const { return Rational(-numer, denom); }
 
Rational& operator++() { numer += denom; return *this; }
 
Rational operator++(int) { Rational temp = *this; ++*this; return temp; }
 
Rational& operator--() { numer -= denom; return *this; }
 
Rational operator--(int) { Rational temp = *this; --*this; return temp; }
 
friend std::ostream& operator<<(std::ostream& outStream, const Rational& other) {
outStream << other.numer << "/" << other.denom;
return outStream;
}
 
/// Methods ///
Rational reciprocal() const { return Rational(denom, numer); }
 
Rational positive() const { return Rational(abs(numer), denom); }
 
int64_t to_integer() const { return numer / denom; }
 
double to_double() const { return (double) numer / denom; }
 
int64_t hash() const { return std::hash<int64_t>{}(numer) ^ std::hash<int64_t>{}(denom); }
 
private:
int64_t numer;
int64_t denom;
};
 
int main() {
std::cout << "Perfect numbers less than 2^19:" << std::endl;
const int32_t limit = 1 << 19;
for ( int32_t candidate = 2; candidate < limit; ++candidate ) {
Rational sum = Rational(1, candidate);
int32_t square_root = (int32_t) sqrt(candidate);
for ( int32_t factor = 2; factor <= square_root; ++factor ) {
if ( candidate % factor == 0 ) {
sum += Rational(1, factor);
sum += Rational(1, candidate / factor);
}
}
 
if ( sum == Rational(1) ) {
std::cout << candidate << std::endl;
}
}
}
</syntaxhighlight>
{{ out }}
<pre>
Perfect numbers less than 2^19:
6
28
496
8128
</pre>
 
=={{header|Clojure}}==
871

edits