sao3c.cpp

一个包含若干个类

// Definitions of class(es) in sao3c.h

#include "sao3c.h"

// class Time

Time::Time(int hour_in, int minute_in, int second_in)
{
    setTime(hour_in, minute_in, second_in);
}

Time::Time(const Time &time_in)
{
    *this = time_in;
}

void Time::setTime(int hour_in, int minute_in, int second_in)
{
    hour = (hour_in >= 0 && hour_in < 24) ? hour_in : 0;
    minute = (minute_in >= 0 && minute_in < 60) ? minute_in : 0;
    second = (second_in >= 0 && second_in < 60) ? second_in : 0;
}

Time &Time::incHour(int num)
{
    if(num > 0)
        hour = (hour + num) % 24;
    return *this;
}

Time &Time::incMinute(int num)
{
    if(num > 0){
        incHour((minute + num) / 60);
        minute = (minute + num) % 60;
    }
    return *this;
}

Time &Time::incSecond(int num)
{
    if(num > 0){
        incMinute((second + num) / 60);
        second = (second + num) % 60;
    }
    return *this;
}

Time &Time::decHour()
{
    hour = (hour + 23) % 24;
    return *this;
}

Time &Time::decMinute()
{
    minute = (minute + 59) % 60;
    if(minute == 59)
        decHour();
    return *this;
}

Time &Time::decSecond()
{
    second = (second + 59) % 60;
    if(second == 59)
        incMinute();
    return *this;
}

int Time::Hour() const
{
    return hour;
}

int Time::Minute() const
{
    return minute;
}

int Time::Second() const
{
    return second;
}

bool Time::operator==(const Time &time) const
{
    return (hour == time.hour && minute == time.minute && second == time.second);
}

bool Time::operator!=(const Time &time) const
{
    return (hour != time.hour || minute != time.minute || second != time.second);
}

// class Time friend(s)

ostream &operator<<(ostream &cout, const Time &time)
{
    return cout << (time.hour < 10 ? "0" : "") << time.hour
        << (time.minute < 10 ? ":0" : ":") << time.minute
        << (time.second < 10 ? ":0" : ":") << time.second;
}

// class Date

const int Date::days[] = {0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};

Date::Date(int year_in, int month_in, int day_in)
{
    setDate(year_in, month_in, day_in);
}

Date::Date(const Date &date_in)
{
    *this = date_in;
}

void Date::setDate(int year_in, int month_in, int day_in)
{
    year = (year_in != 0) ? year_in : 1;
    month = (month_in > 0 && month_in <= 12) ? month_in : 1;
    day = (day_in > 0 && day_in <= endofmonth()) ? day_in : 1;
}

Date &Date::incYear(int num)
{
    if(num > 0){
        if(year < 0 && year + num >= 0)
            year += num + 1;
        else
            year += num;
    }
    return *this;
}

Date &Date::incMonth(int num)
{
    if(num > 0){
        incYear((month + num) / 12);
        month = (month + num) % 12;
        day = (day > endofmonth()) ? endofmonth() : day;
    }
    return *this;
}

Date &Date::incDay(int num)
{
    if(num > 0){
        num += day;
        while(num > endofmonth()){
            num -= endofmonth();
            incMonth();
        }
        day = num;
    }
    return *this;
}

inline int Date::Year() const
{
    return year;
}

inline int Date::Month() const
{
    return month;
}

inline int Date::Day() const
{
    return day;
}

bool Date::leapyear() const
{
    return (year % 4 == 0 && (year % 100 != 0 || year % 400 == 0));
}

bool Date::leapyear(int year_in) const
{
    return (year_in % 4 == 0 && (year_in % 100 != 0 || year_in % 400 == 0));
}

int Date::endofmonth() const
{
    if(!leapyear() && month == 2)
        return 28;
    else
        return days[month];
}

bool Date::operator==(const Date &date) const
{
    return (year == date.year && month == date.month && day == date.day);
}

bool Date::operator!=(const Date &date) const
{
    return (year != date.year || month != date.month || day != date.day);
}

// class Date friend(s)

ostream &operator<<(ostream &cout, const Date &date)
{
    return cout << (date.year > 0 ? "": "B.C. ") << abs(date.year) << "-"
        << date.month << "-"
        << date.day;
}

// class Complex

Complex::Complex(double a_in, double b_in)
{
    setComplex(a_in, b_in);
}

Complex::Complex(const Complex &comp_in)
{
    *this = comp_in;
}

void Complex::setComplex(double a_in, double b_in)
{
    a = a_in;
    b = b_in;
}

double Complex::Real() const
{
    return a;
}

double Complex::Image() const
{
    return b;
}

double Complex::Modules() const
{
    return sqrt(a * a + b * b);
}

double Complex::Arg() const
{
    if(a == 0 && b == 0)
        return 0;
    else{
        return b >= 0 ? acos(a / Modules()) : 2 * PI - acos(a / Modules());
    }
}

bool Complex::operator==(const Complex &comp) const
{
    return (a == comp.a && b == comp.b);
}

bool Complex::operator!=(const Complex &comp) const
{
    return (a != comp.a || b != comp.b);
}

Complex Complex::operator+(const Complex &comp) const
{
    return Complex(a + comp.a, b + comp.b);
}

Complex Complex::operator-(const Complex &comp) const
{
    return Complex(a - comp.a, b - comp.b);
}

Complex Complex::operator*(const Complex &comp) const
{
    return Complex(a * comp.a - b * comp.b, a * comp.b + b * comp.a);
}

Complex Complex::operator/(const Complex &comp) const
{
    return Complex((a * comp.a + b * comp.b) / (comp.a * comp.a + comp.b * comp.b)
        , (b * comp.a - a * comp.b) / (comp.a * comp.a + comp.b * comp.b));
}

void Complex::operator+=(const Complex &comp)
{
    a += comp.a;
    b += comp.b;
}

void Complex::operator-=(const Complex &comp)
{
    a -= comp.a;
    b -= comp.b;
}

void Complex::operator*=(const Complex &comp)
{
    double ta = a;
    a = a * comp.a - b * comp.b;
    b = ta * comp.b + b * comp.a;
}

void Complex::operator/=(const Complex &comp)
{
    double ta = a;
    a = (a * comp.a + b * comp.b) / (comp.a * comp.a + comp.b * comp.b);
    b = (b * comp.a - ta * comp.b) / (comp.a * comp.a + comp.b * comp.b);
}

Complex Complex::operator+(double db) const
{
    return Complex(a + db, b);
}

Complex Complex::operator-(double db) const
{
    return Complex(a - db, b);
}

Complex Complex::operator*(double db) const
{
    return Complex(a * db, b * db);
}

Complex Complex::operator/(double db) const
{
    return Complex(a / db, b / db);
}

void Complex::operator+=(double db)
{
    a += db;
}

void Complex::operator-=(double db)
{
    a -= db;
}

void Complex::operator*=(double db)
{
    a *= db;
    b *= db;
}

void Complex::operator/=(double db)
{
    a /= db;
    b /= db;
}

// class Complex friend(s)

ostream &operator<<(ostream & cout, const Complex &comp)
{
    if(comp.a == 0 && comp.b == 0)
        return cout << 0;
    if(comp.a != 0) // output real part
        cout << comp.a;
    
    if(comp.b > 0 && comp.a != 0) // output '+' or '-'
        cout << "+";
    else if(comp.b < 0)
        cout << "-";
    
    if(comp.b != 0){
        if(abs(comp.b) != 1)
            cout << abs(comp.b);
        cout << "i";
    }
    
    return cout;
}

Complex operator+(double db, const Complex &comp)
{
    return Complex(db + comp.a, comp.b);
}

Complex operator-(double db, const Complex &comp)
{
    return Complex(db - comp.a, -comp.b);
}

Complex operator*(double db, const Complex &comp)
{
    return Complex(db * comp.a, db * comp.b);
}

Complex operator/(double db, const Complex &comp)
{
    return Complex((comp.a * db) / (comp.a * comp.a + comp.b * comp.b),
        - (comp.b * db) / (comp.a * comp.a + comp.b * comp.b));
}

// class Vector3D

Vector3D::Vector3D(const double x_in, const double y_in, const double z_in)
{
    setVector3D(x_in, y_in, z_in);
}

Vector3D::Vector3D(const Vector3D &vec_in)
{
    *this = vec_in;
}

void Vector3D::setVector3D(double x_in, double y_in, double z_in)
{
    x = x_in;
    y = y_in;
    z = z_in;
}

double Vector3D::X() const
{
    return x;
}

double Vector3D::Y() const
{
    return y;
}

double Vector3D::Z() const
{
    return z;
}

double Vector3D::Modules() const
{
    return sqrt(x * x + y * y + z * z);
}

bool Vector3D::operator==(const Vector3D &vec_in) const
{
    return x == vec_in.x && y == vec_in.y && z == vec_in.z;
}

bool Vector3D::operator!=(const Vector3D &vec_in) const
{
    return x != vec_in.x || y != vec_in.y || z != vec_in.z;
}

Vector3D Vector3D::operator+(const Vector3D &vec_in) const
{
    return Vector3D(x + vec_in.x, y + vec_in.y, z + vec_in.z);
}

Vector3D Vector3D::operator-(const Vector3D &vec_in) const
{
    return Vector3D(x - vec_in.x, y - vec_in.y, z - vec_in.z);
}

Vector3D Vector3D::operator*(const Vector3D &vec_in) const
{
    return Vector3D(y * vec_in.z - vec_in.y * z,
        z * vec_in.x - vec_in.z * x,
        x * vec_in.y - vec_in.x * y);
}

double Vector3D::operator%(const Vector3D &vec_in) const
{
    return x * vec_in.x + y * vec_in.y + z * vec_in.z;
}

void Vector3D::operator+=(const Vector3D &vec_in)
{
    x += vec_in.x;
    y += vec_in.y;
    z += vec_in.z;
}

void Vector3D::operator-=(const Vector3D &vec_in)
{
    x -= vec_in.x;
    y -= vec_in.y;
    z -= vec_in.z;
}

void Vector3D::operator*=(const Vector3D &vec_in)
{
    x = y * vec_in.z - vec_in.y * z;
    y = z * vec_in.x - vec_in.z * x;
    z = x * vec_in.y - vec_in.x * y;
}

Vector3D Vector3D::operator*(double db) const
{
    return Vector3D(x * db, y * db, z * db);
}

Vector3D Vector3D::operator/(double db) const
{
    return Vector3D(x / db, y / db, z / db);
}

void Vector3D::operator*=(double db)
{
    x *= db;
    y *= db;
    z *= db;
}

void Vector3D::operator/=(double db)
{
    x /= db;
    y /= db;
    z /= db;
}

// class Vector3D friend(s)

ostream &operator<<(ostream &cout, const Vector3D &vec_in)
{
    return cout << "(" << vec_in.x << ","
        << vec_in.y << ","
        << vec_in.z << ")";
}

Vector3D operator*(double db, const Vector3D &vec_in)
{
    return Vector3D(vec_in.x * db, vec_in.y * db, vec_in.z * db);
}

double MixP(const Vector3D &a, const Vector3D &b, const Vector3D &c)
{
    return (a * b) % c;
}

double Cosine(const Vector3D &a, const Vector3D &b)
{
    return (a % b) / a.Modules() / b.Modules();
}

// class Rational

Rational::Rational(long num_in, long de_in)
{
    setRational(num_in, de_in);
}

Rational::Rational(const Rational &rat_in)
{
    *this = rat_in;
}

void Rational::setRational(long num_in, long de_in)
{
    num = num_in;
    de = de_in != 0 ? de_in : 1;
    Reduct();
}

void Rational::Reduct()
{
    long temp = hcd(num, de);
    num /= temp;
    de /= temp;
}

long Rational::Numerator() const
{
    return num;
}

long Rational::Denominator() const
{
    return de;
}

double Rational::Value() const
{
    return (double)num / de;
}

bool Rational::operator==(const Rational &rat_in)
{
    return (num == rat_in.num && de == rat_in.de) || (num == 0 && rat_in.num == 0);
}

bool Rational::operator!=(const Rational &rat_in) const
{
    return (num != rat_in.num || de != rat_in.de) && (num != 0 || rat_in.num != 0);
}

Rational Rational::operator+(const Rational &rat_in) const
{
    return Rational(num * rat_in.de + rat_in.num * de, de * rat_in.de);
}

Rational Rational::operator-(const Rational &rat_in) const
{
    return Rational(num * rat_in.de - rat_in.num * de , de * rat_in.de);
}

Rational Rational::operator*(const Rational &rat_in) const
{
    return Rational(num * rat_in.num, de * rat_in.de);
}

Rational Rational::operator/(const Rational &rat_in) const
{
    return Rational(num * rat_in.de, de * rat_in.num);
}

void Rational::operator+=(const Rational &rat_in)
{
    num = num * rat_in.de + rat_in.num * de;
    de *= rat_in.de;
    Reduct();
}

void Rational::operator-=(const Rational &rat_in)
{
    num = num * rat_in.de - rat_in.num * de;
    de *= rat_in.de;
    Reduct();
}

void Rational::operator*=(const Rational &rat_in)
{
    num *= rat_in.num;
    de *= rat_in.de;
    Reduct();
}

void Rational::operator/=(const Rational &rat_in)
{
    num *= rat_in.de;
    de *= rat_in.num;
    Reduct();
}

Rational Rational::operator+(long l) const
{
    return Rational(num + l * de, de);
}

Rational Rational::operator-(long l) const
{
    return Rational(num - l * de, de);
}

Rational Rational::operator*(long l) const
{
    return Rational(num * l, de);
}

Rational Rational::operator/(long l) const
{
    return Rational(num, de * l);
}

void Rational::operator+=(long l)
{
    num += l * de;
}

void Rational::operator-=(long l)
{
    num -= l * de;
}

void Rational::operator*=(long l)
{
    num *= l;
    Reduct();
}

void Rational::operator/=(long l)
{
    de *= l;
    Reduct();
}

// class Rational friend(s)

ostream &operator<<(ostream &cout, const Rational &rat_in)
{
    return cout << rat_in.num << " / " << rat_in.de;
}