Esempio n. 1
0
inline double QwtHighResolutionClock::elapsed() const
{
    struct timespec timeStamp;
    ::clock_gettime( d_clockId, &timeStamp );

    return msecsTo( d_timeStamp, timeStamp );
}
Esempio n. 2
0
	void conjagate_gradients(sp::Vector& dp, const sp::SymetryMatrix& K, const sp::Vector& F)
	{
		auto begin_time = QTime::currentTime();

		auto r0 = K * dp;
		r0 -= F;
		r0 *= -1.0; // r0 := B - A * x
		auto p = r0;

		for(int i = 0; i < 1e6; i++)
		{
			double a = (r0 * r0) / (p * K * p);

			dp += a * p; // dp := dp + a * p

			auto aKp = K * p;
			aKp *= a;
			auto r1 = r0 - aKp; // r1 := r0 - a * K * p

			if(r1 * r1 < 1e-10)
			{
				qDebug() << "cgm: counter:\t" << i << "\ttime:\t" << begin_time.msecsTo(QTime::currentTime());
				break;
			}

			double b = (r1 * r1) / (r0 * r0);

			p *= b;
			p += r1; // p := r1 + b * p

			r0 = r1;
		}
	}
Esempio n. 3
0
int QTime::elapsed()
{
    int n = msecsTo( currentTime() );
    if ( n < 0 )				// passed midnight
	n += 86400*1000;
    return n;
}
Esempio n. 4
0
int VSTime::restart()
{
	VSTime t = currentTime();
	int n = msecsTo(t);
	if (n < 0) n += 86400*1000; // passed midnight
	*this = t;
	return n;
}
Esempio n. 5
0
double QwtHighResolutionClock::restart()
{
    const uint64_t timeStamp = mach_absolute_time();
    const double elapsed = msecsTo( d_timeStamp, timeStamp );
    d_timeStamp = timeStamp;

    return elapsed;
}
Esempio n. 6
0
Duration DateTime::duration(const DateTime &dt) const {
    Duration dur;
    if (isValid() && dt.isValid()) {
        qint64 x = msecsTo( dt ); //NOTE: this does conversion to UTC (expensive)
        dur.m_ms = x < 0 ? -x : x;
    }
    //kDebug(planDbg())<<dur.milliseconds();
    return dur;
}
Esempio n. 7
0
int QTime::restart()
{
    QTime t = currentTime();
    int n = msecsTo( t );
    if ( n < 0 )				// passed midnight
	n += 86400*1000;
    *this = t;
    return n;
}
Esempio n. 8
0
double QwtHighResolutionClock::restart()
{
    struct timespec timeStamp;
    ::clock_gettime( d_clockId, &timeStamp );

    const double elapsed = msecsTo( d_timeStamp, timeStamp );

    d_timeStamp = timeStamp;
    return elapsed;
}
Esempio n. 9
0
	void run()
	{
		// init
		sp::size = convert::init(pipe::fix_list, point_size);

		// populate kmx, tmx
		convert::matrix(pipe::point_list, pipe::element_list, element_size);

		sp::SymetryMatrix K = convert::kmx;

		// populate F
		auto F = convert::force(pipe::force_list, force_size);

		auto begin_time = QTime::currentTime();

		// solve K * dp = F
		sp::Vector dp;

		// steepest_descent
		dp = sp::Vector();
		steepest_descent(dp, K, F);
		Q_ASSERT(sp::Vector::norm2(K * dp, F) < 1e-10);

		// conjagate_gradients
		dp = sp::Vector();
		conjagate_gradients(dp, K, F);
		Q_ASSERT(sp::Vector::norm2(K * dp, F) < 1e-10);

		// solve tensions
		QVector<double> reaction(3 * point_size - sp::size);
		sp::mul(reaction, convert::tmx, dp);

		// convert back to 3D domain
		convert::displace(displace_list, dp);
		convert::reaction(reaction_list, pipe::fix_list, fix_size, reaction);

		QVector<clip::Element> original_elements = clip::make(pipe::point_list, pipe::element_list, element_size, rotate);
		QVector<clip::Element> displace_elements = clip::make(displace_list, pipe::element_list, element_size, rotate);
		store_figure_pipe(original_elements, displace_elements);

		qDebug() << "total time: " << begin_time.msecsTo(QTime::currentTime());
	}
Esempio n. 10
0
	void steepest_descent(sp::Vector& dp, const sp::SymetryMatrix& K, const sp::Vector& F)
	{
		auto begin_time = QTime::currentTime();

		for(int i = 0; i < 1e6; i++)
		{
			auto r = K * dp;
			r -= F;
			r *= -1.0; // r := F - K * dp

			if(r * r < 1e-10)
			{
				qDebug() << "sdm: counter:\t" << i << "\ttime:\t" << begin_time.msecsTo(QTime::currentTime());
				break;
			}

			double a = (r * r) / (r * K * r);
			r *= a;
			dp += r; // dp := dp + a * r
		}
	}
Esempio n. 11
0
//! Writes line to log file, decorated with information on context and timing.
void Logger::log(const QString& lineArg) const
{
    QString line = lineArg;
    static auto lastTime = startTime_;
    const auto currTime = QDateTime::currentDateTime();
    int tDiff = lastTime.msecsTo(currTime);
    lastTime = currTime;
    QString prefix = "[";
    if (caller_=="gui" && line[0]!='#') {
        prefix += "       "; // direct user action: we don't care how long the user was idle
    } else {
        prefix += QString::number(tDiff).rightJustified(5) + "ms";
        computingTime_ += tDiff;
    }
    prefix += " " + level_ + " " + caller_ + "] ";
    log_ << prefix << line << "\n";
    log_.flush();
    if (line.indexOf("##")!=0) { // copy to terminal unless already done by messageHandler
        qterr << line << "\n";
        qterr.flush();
    }
}
Esempio n. 12
0
void QGeoInfoThreadWinCE::setUpdateInterval(int interval)
{
    QMutexLocker locker(&mutex);

    if (interval == updatesInterval)
        return;

    int oldInterval = updatesInterval;
    updatesInterval = interval;

    if (updatesScheduled) {
        QDateTime now = currentDateTime();

        // The periodic update interval has been changed and updates are still ocurring.

        if (oldInterval != 0) {
            if (updatesInterval != 0) {
                // If we are changing fixed intervals we update the scheduled time for the next
                // periodic update, making sure that it is scheduled in the future.
                updatesNextTime = updatesNextTime.addMSecs(updatesInterval - oldInterval);
                while (msecsTo(now, updatesNextTime) < 0)
                    updatesNextTime = updatesNextTime.addMSecs(updatesInterval);
            } else {
                // If we now want to emit updates as the data arrives we invalidate the scheduled
                // time for the next update, just to be on the safe side.
                updatesNextTime = now;
            }
        } else {
            // If we were previously emitting updates as the data arrived we set the scheduled time
            // for the next periodic update.
            updatesNextTime = now.addMSecs(updatesInterval);
        }

        locker.unlock();
        wakeUp();
    }
}
Esempio n. 13
0
qint64 QElapsedTimer::secsTo(const QElapsedTimer &other) const
{
    return msecsTo(other) / 1000;
}
Esempio n. 14
0
int WTime::secsTo(const WTime& t) const
{
  return msecsTo(t) / 1000;
}
qint64 QElapsedTimer::elapsed() const
{
    QElapsedTimer now;
    now.start();
    return msecsTo(now);
}
Esempio n. 16
0
double QwtHighResolutionClock::elapsed() const
{
    return msecsTo( d_timeStamp, mach_absolute_time() );
}
Esempio n. 17
0
// We try to keep the GPS turned off as much as we can to preserve battery life.
// When run() is called we turn on the GPS device and we leave it on
// until the request is satisfied or periodic updates are stopped.
// The methods requestUpdate() and startUpdates() will call start() if required.
void QGeoInfoThreadWinCE::run()
{
    mutex.lock();
    gpsReachedOnState = false;
    m_gps = NULL;

    const int handleCount = 3;
    HANDLE handles[handleCount] = { m_newDataEvent, m_gpsStateChange, m_wakeUpEvent };

    if (updatesScheduled || requestScheduled) {
        m_gps = GPSOpenDevice(m_newDataEvent, m_gpsStateChange, NULL, 0);
    }

    while (true) {

        if (stopping)
            break;

        if (!updatesScheduled && !requestScheduled) {
            if (m_gps != NULL) {
                GPSCloseDevice(m_gps);
                m_gps = NULL;
            }
            statusUpdated.wait(&mutex);
            if (updatesScheduled || requestScheduled) {
                gpsReachedOnState = false;
                m_gps = GPSOpenDevice(m_newDataEvent, m_gpsStateChange, NULL, 0);
            }
        }

        // If the periodic update is 0 then updates are returned as available.
        // If this is not the case then the next timeout will be set for whichever of
        // the request and periodic updates that is due next.

        // We cap the amount of time we spend waiting for updates.
        DWORD timeout = MaximumMainLoopWaitTime;

        QDateTime now = currentDateTime();

        if (requestScheduled) {
            if (!updatesScheduled || (updatesInterval == 0)
                    || (msecsTo(requestNextTime, updatesNextTime) >= 0)) {
                timeout = msecsTo(now, requestNextTime) + 100;
            } else {
                if (updatesInterval != 0)
                    timeout = msecsTo(now, updatesNextTime) + 100;
            }
        } else {
            // updatesScheduled has to be true or we wouldn't still be in the larger while loop.
            if (updatesInterval != 0)
                timeout = msecsTo(now, updatesNextTime) + 100;
        }

        if (timeout > MaximumMainLoopWaitTime)
            timeout = MaximumMainLoopWaitTime;

        mutex.unlock();
        DWORD dwRet = WaitForMultipleObjects(handleCount, handles, FALSE, timeout);
        mutex.lock();

        // The GPS data has been updated.
        if (dwRet == WAIT_OBJECT_0) {
            // The other options are:
            // dwRet == WAIT_OBJECT_0 + 1
            //   => The GPS state has been updated.
            // dwRet == WAIT_OBJECT_0 + 2
            //   => We called QGeoInfoThreadWinCE::wakeUp().
            // dwRet == WAIT_TIMEOUT
            //   => WaitForMultipleObjects() timed out.

            GPS_POSITION posn;
            posn.dwVersion = GPS_VERSION_1;
            posn.dwSize = sizeof(posn);

            dwRet = GPSGetPosition(m_gps, &posn, timeout, 0);

            if (dwRet == ERROR_SUCCESS) {
                if (!validator->valid(posn)) {
                    invalidDataReceived = true;
                } else {
                    m_lastPosition = posn;
                    hasLastPosition = true;
                    updateTimeoutTriggered = false;

                    // A request and a periodic update could both be satisfied at once.
                    // We use this flag to prevent a double update.
                    bool emitDataUpdated = false;

                    // If a request is in process we emit the dataUpdated signal.
                    if (requestScheduled) {
                        emitDataUpdated = true;
                        requestScheduled = false;
                    }

                    // If we are updating as data becomes available or if the update period has elapsed
                    // we emit the dataUpdated signal.
                    if (updatesScheduled) {
                        QDateTime now = currentDateTime();
                        if (updatesInterval == 0) {
                            emitDataUpdated = true;
                        } else if (msecsTo(now, updatesNextTime) < 0) {
                            while (msecsTo(now, updatesNextTime) < 0)
                                updatesNextTime = updatesNextTime.addMSecs(updatesInterval);
                            emitDataUpdated = true;
                        }
                    }

                    if (emitDataUpdated) {
                        hasLastPosition = false;
                        mutex.unlock();
                        emit dataUpdated(m_lastPosition);
                        mutex.lock();
                    }
                }
            }
        }
        if (dwRet != WAIT_OBJECT_0 || invalidDataReceived) {
            invalidDataReceived = false;

            // Third party apps may have the ability to turn off the gps hardware independently of
            // the Microsoft GPS API.
            // This checks for an unexpected power down and turns the hardware back on.

            // The GPS state has been updated.

            if (dwRet == WAIT_OBJECT_0 + 1) {
                GPS_DEVICE device;
                device.dwVersion = GPS_VERSION_1;
                device.dwSize = sizeof(device);

                dwRet = GPSGetDeviceState(&device);

                if (device.dwDeviceState == SERVICE_STATE_ON) {
                    gpsReachedOnState = true;
                } else if ((device.dwDeviceState == SERVICE_STATE_OFF) && gpsReachedOnState) {
                    // We do not want to mess with devices that are slow starting up, so we only
                    // turn on devices that have previously reached the "On" state.
                    gpsReachedOnState = false;
                    m_gps = GPSOpenDevice(m_newDataEvent, m_gpsStateChange, NULL, 0);
                }
            }

            // We reach this point if the gps state has changed, if the wake up event has been
            // triggered, if we received data we were not interested in from the GPS,
            // or if a timeout occurred while waiting for gps data.
            //
            // In all of these cases we should check for request and periodic update timeouts.

            QDateTime now = currentDateTime();

            bool emitUpdateTimeout = false;

            // Check for request timeouts.
            if (requestScheduled && msecsTo(now, requestNextTime) < 0) {
                requestScheduled = false;
                emitUpdateTimeout = true;
            }

            // Check to see if a periodic update is due.
            if (updatesScheduled && updatesInterval != 0 && (msecsTo(now, updatesNextTime) < 0)) {
                while (msecsTo(now, updatesNextTime) < 0)
                    updatesNextTime = updatesNextTime.addMSecs(updatesInterval);
                if (hasLastPosition) {
                    hasLastPosition = false;
                    mutex.unlock();
                    emit dataUpdated(m_lastPosition);
                    mutex.lock();
                } else {
                    if (timeoutsForPeriodicUpdates && !updateTimeoutTriggered) {
                        updateTimeoutTriggered = true;
                        emitUpdateTimeout = true;
                    }
                }
            }

            if (emitUpdateTimeout) {
                mutex.unlock();
                emit updateTimeout();
                mutex.lock();
            }
        }
    }

    if (m_gps != NULL)
        GPSCloseDevice(m_gps);

    mutex.unlock();
}