void tst_QDate::roundtrip() const
{
// Test round trip, this exercises setDate(), isValid(), isLeapYear(),
// year(), month(), day(), julianDayFromDate(), and getDateFromJulianDay()
// to ensure they are internally consistent (but doesn't guarantee correct)
// Test Julian round trip in both BC and AD
QDate testDate;
QDate loopDate = QDate::fromJulianDay(1684899); // 1 Jan 100 BC
while ( loopDate.toJulianDay() <= 1757948 ) { // 31 Dec 100 AD
testDate.setDate( loopDate.year(), loopDate.month(), loopDate.day() );
QCOMPARE( loopDate.toJulianDay(), testDate.toJulianDay() );
loopDate = loopDate.addDays(1);
}
// Test Julian and Gregorian round trip during changeover period
loopDate = QDate::fromJulianDay(2298153); // 1 Jan 1580 AD
while ( loopDate.toJulianDay() <= 2300334 ) { // 31 Dec 1585 AD
testDate.setDate( loopDate.year(), loopDate.month(), loopDate.day() );
QCOMPARE( loopDate.toJulianDay(), testDate.toJulianDay() );
loopDate = loopDate.addDays(1);
}
// Test Gregorian round trip during current useful period
loopDate = QDate::fromJulianDay(2378497); // 1 Jan 1900 AD
while ( loopDate.toJulianDay() <= 2488433 ) { // 31 Dec 2100 AD
testDate.setDate( loopDate.year(), loopDate.month(), loopDate.day() );
QCOMPARE( loopDate.toJulianDay(), testDate.toJulianDay() );
loopDate = loopDate.addDays(1);
}
}
QDate GeldRechen::maxDate(QDate a,QDate b) {
//check for null date
if (a.toJulianDay()> b.toJulianDay()) {
return a;
}
else {
return b;
}
}
int KCalendarSystem::dayOfYear( const QDate &date ) const
{
//Take the jd of the given date, and subtract the jd of the first day of that year
if ( isValid( date ) ) {
QDate firstDayOfYear;
if ( setDate( firstDayOfYear, year( date ), 1, 1 ) ) {
return ( date.toJulianDay() - firstDayOfYear.toJulianDay() + 1 );
}
}
return -1;
}
void KStarsDateTime::setDate( const QDate &_d ) {
//Save the JD fraction
long double jdFrac = djd() - (long double)( date().toJulianDay() );
//set the integer portion of the JD and add back the JD fraction:
setDJD( (long double)_d.toJulianDay() + jdFrac );
}
QList<int> tradeDateCalendar::computeFrequencyTradeMonthly(int date_, int minimumDate_, int maximumDate_)
{
QList<int> tradeDates;
QDate monthDayCounter = QDate::fromJulianDay(minimumDate_);
int dayOfMonth = QDate::fromJulianDay(date_).day();
forever
{
QDate monthDayComputation = monthDayCounter;
if (monthDayComputation.day() > dayOfMonth)
monthDayComputation = monthDayComputation.addMonths(1);
if (dayOfMonth > monthDayComputation.daysInMonth())
{
monthDayComputation = monthDayComputation.addMonths(1);
monthDayComputation = QDate(monthDayComputation.year(), monthDayComputation.month(), 1);
}
else
monthDayComputation = QDate(monthDayComputation.year(), monthDayComputation.month(), dayOfMonth);
date_ = checkTradeDate(monthDayComputation.toJulianDay(), direction_ascending);
if (date_ > maximumDate_)
break;
tradeDates.append(date_);
monthDayCounter = monthDayCounter.addMonths(1);
}
return tradeDates;
}
QDate KCalendarSystem::addYears( const QDate &date, int numYears ) const
{
if ( isValid( date ) ) {
int originalYear, originalMonth, originalDay;
int newYear, newMonth, newDay;
QDate firstOfNewMonth, newDate;
julianDayToDate( date.toJulianDay(), originalYear, originalMonth, originalDay );
newYear = originalYear + numYears;
newMonth = originalMonth;
//Adjust day number if new month has fewer days than old month
if ( setDate( firstOfNewMonth, newYear, newMonth, 1 ) ) {
int daysInNewMonth = daysInMonth( firstOfNewMonth );
newDay = ( daysInNewMonth < originalDay ) ? daysInNewMonth : originalDay;
if ( setDate( newDate, newYear, newMonth, newDay ) ) {
return newDate;
}
}
}
//Is QDate's way of saying is invalid
return QDate::fromJulianDay( 0 );
}
bool DbManager::addLicenseToPerson(const int id_person, const int id_license, const QDate& date_of_issue) const
{
if(id_person > 0 && id_license > 0) {
QSqlQuery query_select;
QString query_select_string = "SELECT id FROM people_license WHERE id_person = :id_person AND id_license = :id_license";
query_select.prepare(query_select_string);
query_select.bindValue(":id_person", id_person);
query_select.bindValue(":id_license", id_license);
if(query_select.exec()) {
if(query_select.isActive()) {
if(!query_select.first()) {
QSqlQuery query;
QString query_string = "INSERT INTO people_license (id_person, id_license, date_of_issue, is_valid, last_notification)"
"VALUES (:id_person, :id_license, :date, 'true', '-1')";
query.prepare(query_string);
query.bindValue(":id_person", id_person);
query.bindValue(":id_license", id_license);
if(date_of_issue != QDate(0, 0, 0)) {
query.bindValue(":date", date_of_issue.toJulianDay());
} else {
query.bindValue(":date", 0);
}
if(query.exec()) {
return true;
}
}
}
}
}
return false;
}
inline boost::chrono::system_clock::time_point ToBoostChrono(QDate date)
{
/// https://en.wikipedia.org/wiki/Julian_day
/// (JD − 2440587.5) × 86400
auto unix_time = (date.toJulianDay() - QDATE_JULIAN_DAY_FOR_UNIX_EPOCH) * 24 * 60 * 60;
return boost::chrono::system_clock::from_time_t(unix_time);
}
QList<int> tradeDateCalendar::computeFrequencyTradeYearly(int date_, int minimumDate_, int maximumDate_)
{
QList<int> tradeDates;
QDate yearDayCounter = QDate::fromJulianDay(minimumDate_);
int dayOfYear = QDate::fromJulianDay(date_).dayOfYear();
forever
{
QDate yearDayComputation = yearDayCounter;
int leapDayofYear = dayOfYear + (dayOfYear > 59 /* Feb 28th */ && QDate::isLeapYear(yearDayComputation.year()) ? 1 : 0);
if (yearDayComputation.dayOfYear() > leapDayofYear)
{
yearDayComputation = yearDayComputation.addYears(1);
leapDayofYear = dayOfYear + (dayOfYear > 59 /* Feb 28th */ && QDate::isLeapYear(yearDayComputation.year()) ? 1 : 0);
}
date_ = checkTradeDate(yearDayComputation.toJulianDay(), direction_ascending);
if (date_ > maximumDate_)
break;
tradeDates.append(date_);
yearDayCounter = yearDayCounter.addYears(1);
}
return tradeDates;
}
KStarsDateTime::KStarsDateTime( const QDate &_d, const QTime &_t ) :
//QDateTime( _d, _t, QDateTime::Spec::UTC() )
QDateTime( _d, _t, Qt::UTC )
{
//don't call setDJD() because we don't need to compute the time; just set DJD directly
long double jdFrac = ( _t.hour()-12 + ( _t.minute() + ( _t.second() + _t.msec()/1000.)/60.)/60.)/24.;
DJD = (long double)( _d.toJulianDay() ) + jdFrac;
}
void DDateTable::unsetCustomDatePainting(const QDate& date)
{
d->customPaintingModes.remove(date.toJulianDay());
if (d->customPaintingModes.isEmpty())
{
d->useCustomColors = false;
}
update();
}
QDate GeldRechen::minDate(QDate a,QDate b) {
//qDebug () << "date compar " << a.toString() << " with " << b.toString();
if ((a.month()==0) && (a.year()==0) && (a.day()==0)) {
return b;
}
else {
if (a.toJulianDay()> b.toJulianDay()) {
return b;
}
else {
return a;
}
}
}
// Fake version using QDate, each Calendar System MUST implement the correct version for themselves
// The implementation MUST NOT do validity checking on date ranges, all calls to this function MUST
// instead be wrapped in validity checks, as sometimes we want this to work outside the public valid
// range, i.e. to allow us to internally set dates of 1/1/10000 which are not publically valid but
// are required for internal maths
bool KCalendarSystem::dateToJulianDay( int year, int month, int day, int &jd ) const
{
QDate date;
if ( date.setDate( year, month, day ) ) {
jd = date.toJulianDay();
return true;
}
return false;
}
int KCalendarSystem::year( const QDate &date ) const
{
if ( isValid( date ) ) {
int year, month, day;
julianDayToDate( date.toJulianDay(), year, month, day );
return year;
}
return 0; // How do you denote invalid year when we support -ve years?
}
int KCalendarSystem::day( const QDate &date ) const
{
if ( isValid( date ) ) {
int year, month, day;
julianDayToDate( date.toJulianDay(), year, month, day );
return day;
}
return 0;
}
int KCalendarSystem::dayOfWeek( const QDate &date ) const
{
// Makes assumption that Julian Day 0 was day 1 of week
// This is true for Julian/Gregorian calendar with jd 0 being Monday
// We add 1 for ISO compliant numbering for 7 day week
// Assumes we've never skipped weekdays
if ( isValid( date ) ) {
return ( ( date.toJulianDay() % daysInWeek( date ) ) + 1 );
}
return -1;
}
// Function: ISOWEEKNUM
//
// method startday name of day
// default: 1 1 sunday
// 2 0 monday
//
Value func_isoWeekNum(valVector args, ValueCalc *calc, FuncExtra *)
{
QDate date = calc->conv()->asDate(args[0]).asDate(calc->settings());
if (!date.isValid())
return Value::errorVALUE();
int method = 2; // default method = 2
if (args.count() > 1)
method = calc->conv()->asInteger(args[1]).asInteger();
if (method < 1 || method > 2)
return Value::errorVALUE();
int startday = 1;
if (method != 1)
startday = 0;
int weeknum;
int day; // current date
int day4; // 4th of jan.
int day0; // offset to 4th of jan.
// date to find
day = date.toJulianDay();
// 4th of jan. of current year
day4 = QDate(date.year(), 1, 4).toJulianDay();
// difference in days to the 4th of jan including correction of startday
day0 = QDate::fromJulianDay(day4 - 1 + startday).dayOfWeek();
// do we need to count from last year?
if (day < day4 - day0) { // recalculate day4 and day0
day4 = QDate(date.year() - 1, 1, 4).toJulianDay(); // 4th of jan. last year
day0 = QDate::fromJulianDay(day4 - 1 + startday).dayOfWeek();
}
// calc weeeknum
weeknum = (day - (day4 - day0)) / 7 + 1;
// if weeknum is greater 51, we have to do some extra checks
if (weeknum >= 52) {
day4 = QDate(date.year() + 1, 1, 4).toJulianDay(); // 4th of jan. next year
day0 = QDate::fromJulianDay(day4 - 1 + startday).dayOfWeek();
if (day >= day4 - day0) { // recalculate weeknum
weeknum = (day - (day4 - day0)) / 7 + 1;
}
}
return Value(weeknum);
}
QDate KCalendarSystem::addDays( const QDate &date, int numDays ) const
{
// QDate only holds a uint and has no boundary checking in addDays(), so we need to check
if ( isValid( date ) && (long) date.toJulianDay() + (long) numDays > 0 ) {
// QDate adds straight to jd
QDate temp = date.addDays( numDays );
if ( isValid( temp ) ) {
return temp;
}
}
//Is QDate's way of saying is invalid
return QDate::fromJulianDay( 0 );
}
bool frmPriceImport::validateRow(int row_, const QStringList line_, const QHash<int, int> &columns_, const QString &dateFormat_)
{
++row_; // for display
if (line_.count() != columns_.count())
{
QMessageBox::critical(this, "Import", "Incorrect number of columns on row " + QString::number(row_) + ".");
return false;
}
if (line_.at(columns_.value(column_Symbol)).isEmpty())
{
QMessageBox::critical(this, "Import", "No symbol specified on row " + QString::number(row_) + ".");
return false;
}
QDate date = QDate::fromString(line_.at(columns_.value(column_Date)), dateFormat_);
if (!date.isValid())
{
QMessageBox::critical(this, "Import", "Incorrect date format on row " + QString::number(row_) +
". Date is \"" + line_.at(columns_.value(column_Date)) + "\".");
return false;
}
if (!ui->columnOrderDateIgnore->isChecked() && !tradeDateCalendar::isTradeDate(date.toJulianDay()))
{
QMessageBox::critical(this, "Import", "Row " + QString::number(row_) +
" is not a valid US trade date. Date is \"" + line_.at(columns_.value(column_Date)) + "\".");
return false;
}
QString type = line_.at(columns_.value(column_Type)).toUpper();
if (type != "PRICE" && type != "DIVIDEND" && type != "SPLIT")
{
QMessageBox::critical(this, "Import", "Incorrect price type on row " + QString::number(row_) +
". Price type is \"" + line_.at(columns_.value(column_Type)) + "\", but valid choices" +
" are only Price, Dividend, or Split.");
return false;
}
bool ok;
line_.at(columns_.value(column_Value)).toDouble(&ok);
if (!ok)
{
QMessageBox::critical(this, "Import", "Incorrect value on row " + QString::number(row_) +
". Value is \"" + line_.at(columns_.value(column_Value)) + "\", but could not be" +
" converted to a number.");
return false;
}
return true;
}
void DDateTable::setCustomDatePainting(const QDate& date, const QColor& fgColor,
BackgroundMode bgMode, const QColor& bgColor)
{
if (!fgColor.isValid())
{
unsetCustomDatePainting(date);
return;
}
Private::DatePaintingMode mode;
mode.bgMode = bgMode;
mode.fgColor = fgColor;
mode.bgColor = bgColor;
d->customPaintingModes.insert(date.toJulianDay(), mode);
d->useCustomColors = true;
update();
}
QList<QObject*> DatabaseManager::dateRents(const int year, const int month, const int day)
{
QList<QObject*> result;
QDate date;
date.setDate(year,month,day);
QSqlQuery query(QString("select * from rent where date = %1").arg(date.toJulianDay()));
while (query.next()) {
Rent* item = new Rent();
item->m_id = query.value(0).toInt();
item->m_rentBlockIndex = query.value(1).toInt();
item->m_itemId = query.value(2).toInt();
item->m_renterId = query.value(3).toInt();
item->m_date = query.value(4).toInt();
result.append(item);
}
return result;
}
void tst_QDate::julianDay()
{
QFETCH(int, year);
QFETCH(int, month);
QFETCH(int, day);
QFETCH(uint, jd);
{
QDate d;
d.setDate(year, month, day);
QCOMPARE(uint(d.toJulianDay()), jd);
}
if (jd) {
QDate d = QDate::fromJulianDay(jd);
QCOMPARE(d.year(), year);
QCOMPARE(d.month(), month);
QCOMPARE(d.day(), day);
}
}
void DatabaseManager::insertRent(const int year, const int month, const int day,
const int rentBlock, const int rentItemId, const int renterId)
{
QDate date;
date.setDate(year,month,day);
if (db.isOpen()) {
Rent* rent = new Rent();
rent->m_id = nextId();
rent->m_rentBlockIndex = rentBlock;
rent->m_itemId = rentItemId;
rent->m_renterId = renterId;
rent->m_date = date.toJulianDay();
QSqlQuery query;
query.exec(QString("insert into rent values(%1,%2,'%3',%4,%5)").arg(rent->m_id).arg(rent->m_rentBlockIndex).arg(
rent->m_itemId).arg(rent->m_renterId).arg(rent->m_date));
delete rent;
}
}
QDate KCalendarSystem::addMonths( const QDate &date, int numMonths ) const
{
if ( isValid( date ) ) {
int originalYear, originalMonth, originalDay;
int newYear, newMonth, newDay;
int monthsInOriginalYear, daysInNewMonth;
QDate firstOfNewMonth, newDate;
julianDayToDate( date.toJulianDay(), originalYear, originalMonth, originalDay );
monthsInOriginalYear = monthsInYear( date );
newYear = originalYear + ( ( originalMonth + numMonths ) / monthsInOriginalYear );
newMonth = ( originalMonth + numMonths ) % monthsInOriginalYear;
if ( newMonth == 0 ) {
newYear = newYear - 1;
newMonth = monthsInOriginalYear;
}
if ( newMonth < 0 ) {
newYear = newYear - 1;
newMonth = newMonth + monthsInOriginalYear;
}
//Adjust day number if new month has fewer days than old month
if ( setDate( firstOfNewMonth, newYear, newMonth, 1 ) ) {
daysInNewMonth = daysInMonth( firstOfNewMonth );
newDay = ( daysInNewMonth < originalDay ) ? daysInNewMonth : originalDay;
if ( setDate( newDate, newYear, newMonth, newDay ) ) {
return newDate;
}
}
}
//Is QDate's way of saying is invalid
return QDate::fromJulianDay( 0 );
}
int moon_phase_trig1 (int year, int month, int day)
{
QDate d (year, month, day);
int thisJD = d.toJulianDay();
double degToRad = 3.14159265 / 180;
double K0, T, T2, T3, J0, F0, M0, M1, B1;
int oldJ = 0;
K0 = floor ((year - 1900) * 12.3685);
T = (year - 1899.5) / 100;
T2 = T * T;
T3 = T * T * T;
J0 = 2415020 + 29*K0;
F0 = 0.0001178 * T2 - 0.000000155 * T3 + (0.75933 + 0.53058868 * K0) - (0.000837 * T + 0.000335 * T2);
M0 = 360 * (GetFrac (K0 * 0.08084821133)) + 359.2242 - 0.0000333 *T2 - 0.00000347 * T3;
M1 = 360 * (GetFrac (K0 * 0.07171366128)) + 306.0253 + 0.0107306 * T2 + 0.00001236 * T3;
B1 = 360 * (GetFrac (K0 * 0.08519585128)) + 21.2964 - (0.0016528 * T2) - (0.00000239 * T3);
int phase = 0;
int jday = 0;
while (jday < thisJD)
{
double F = F0 + 1.530588 * phase;
double M5 = (M0 + phase * 29.10535608) * degToRad;
double M6 = (M1 + phase * 385.81691806) * degToRad;
double B6 = (B1 + phase * 390.67050646) * degToRad;
F -= 0.4068 * sin (M6) + (0.1734 - 0.000393 * T) * sin(M5);
F += 0.0161 * sin (2 * M6) + 0.0104 * sin (2 * B6);
F -= 0.0074 * sin (M5 - M6) - 0.0051 * sin(M5 + M6);
F += 0.0021 * sin (2 * M5) + 0.0010 * sin(2 * B6 - M6);
F += 0.5 / 1440;
oldJ = jday;
jday = J0 + 28 * phase + floor(F);
phase++;
}
return (thisJD - oldJ) % 30;
}
int moon_phase_trig2 (int year, int month, int day)
{
double n = floor (12.37 * (year - 1900 + ((1.0 * month - 0.5) / 12.0)));
double RAD = 3.14159265 / 180.0;
double t = n / 1236.85;
double t2 = t * t;
double as = 359.2242 + 29.105356 * n;
double am = 306.0253 + 385.816918 * n + 0.010730 * t2;
double xtra = 0.75933 + 1.53058868 * n + ((1.178e-4) - (1.55e-7) * t) * t2;
xtra += (0.1734 - 3.93e-4 * t) * sin (RAD * as) - 0.4068 * sin (RAD * am);
double i = (xtra > 0.0 ? floor (xtra) : ceil (xtra - 1.0));
QDate d (year, month, day);
int j1 = d.toJulianDay();
int jd = (2415020 + 28 * n) + i;
//return (j1 - jd + 30) % 30;
int r = (j1 - jd + 30) % 30;
if (r == 0)
r = 30;
return r;
}
bool DatabaseManager::isFreeRentDate(const int rentItemId, const int year, const int month, const int day)
{
QDate date;
date.setDate(year,month,day);
QSqlQuery query(QString("select * from rent where date = %1 and itemid = %2").arg(date.toJulianDay()).arg(rentItemId));
while (query.next()) {
return false;
}
return true;
}
// Converts a date/time value into msecs
static inline qint64 timeToMSecs(const QDate &date, const QTime &time)
{
return ((date.toJulianDay() - JULIAN_DAY_FOR_EPOCH) * MSECS_PER_DAY)
+ time.msecsSinceStartOfDay();
}
// http://unicode.org/reports/tr35/tr35-6.html#Date_Format_Patterns
static void finishStr(QString &str, const WeekDate &week_date, const QDate &date, const QTime &time, QChar c, int length)
{
if (length <= 0)
return;
switch (c.unicode())
{
case L'G':
{
bool ad = date.year() > 0;
if (length < 4)
str += ad ? "AD" : "BC";
else if (length == 4)
str += ad ? "Anno Domini" : "Before Christ";
else
str += ad ? "A" : "B";
break;
}
case L'y':
if (length == 2)
appendInt(str, date.year() % 100, 2);
else
appendInt(str, date.year(), length);
break;
case L'Y':
appendInt(str, week_date.year(), length);
break;
case L'u':
{
int year = date.year();
if (year < 0)
year++;
appendInt(str, date.year(), length);
break;
}
case L'q':
case L'Q':
{
int q = (date.month() + 2) / 3;
if (length < 3)
appendInt(str, q, length);
else if (length == 3)
{
str += 'Q';
str += QString::number(q);
}
else
{
switch (q)
{
case 1:
str += qApp->translate("AdiumTimeFormatter", "1st quarter");
break;
case 2:
str += qApp->translate("AdiumTimeFormatter", "2nd quarter");
break;
case 3:
str += qApp->translate("AdiumTimeFormatter", "3rd quarter");
break;
case 4:
str += qApp->translate("AdiumTimeFormatter", "4th quarter");
break;
default:
break;
}
}
break;
}
case L'M':
case L'L':
if (length < 3)
appendInt(str, date.month(), length);
else if (length == 3)
str += QDate::shortMonthName(date.month());
else if (length == 4)
str += QDate::longMonthName(date.month());
else
str += QDate::shortMonthName(date.month()).at(0);
break;
case L'w':
TRIM_LENGTH(2);
appendInt(str, length, week_date.week());
break;
case L'W':
while (length-- > 0)
str += QString::number((date.day() + 6) / 7);
break;
case L'd':
TRIM_LENGTH(2);
appendInt(str, date.day(), length);
break;
case L'D':
TRIM_LENGTH(3);
appendInt(str, date.dayOfYear(), length);
break;
case L'F':
while (length-- > 0)
str += QString::number(1);
break;
case L'g':
appendInt(str, date.toJulianDay(), length);
break;
case L'c':
case L'e':
if (length < 3)
{
appendInt(str, date.dayOfWeek(), length);
break;
}
case L'E':
if (length < 4)
str += QDate::shortDayName(date.dayOfWeek());
else if (length == 4)
str += QDate::longDayName(date.dayOfWeek());
else
str += QDate::shortDayName(date.dayOfWeek()).at(0);
break;
case L'a':
str += time.hour() < 12 ? "AM" : "PM";
break;
case L'H':
TRIM_LENGTH(2);
appendInt(str, time.hour(), length);
break;
case L'h':
TRIM_LENGTH(2);
appendInt(str, time.hour() % 12, length);
break;
case L'K':
TRIM_LENGTH(2);
appendInt(str, time.hour() - 1, length);
break;
case L'k':
TRIM_LENGTH(2);
appendInt(str, time.hour() % 12 - 1, length);
break;
case L'm':
TRIM_LENGTH(2);
appendInt(str, time.minute(), length);
break;
case L's':
TRIM_LENGTH(2);
appendInt(str, time.second(), length);
break;
case L'S':
str += QString::number(time.msec() / 1000.0, 'f', length).section('.', 1);
break;
case L'A':
appendInt(str, QTime(0,0).msecsTo(time), length);
break;
case L'v':
// I don't understand the difference
case L'z':
if (length < 4)
str += SystemInfo::instance()->timezone();
else
// There should be localized name, but I don't know how get it
str += SystemInfo::instance()->timezone();
break;
case L'Z':
{
if (length == 4)
str += "GMT";
int offset = SystemInfo::instance()->timezoneOffset();
if (offset < 0)
str += '+';
else
str += '-';
appendInt(str, qAbs((offset/60)*100 + offset%60), 4);
break;
}
default:
while (length-- > 0)
str += c;
break;
}
}
inline double ToJulianDay(const QDate & date) { return date.toJulianDay(); }
