void tst_storage::tst_rawEvents()
{
// TODO: Should split tests if making more cases outside storage
auto event = KCalCore::Event::Ptr(new KCalCore::Event);
// NOTE: no other events should be made happening this day
QDate startDate(2010, 12, 1);
event->setDtStart(KDateTime(startDate, QTime(12, 0), KDateTime::ClockTime));
event->setDtEnd(KDateTime(startDate, QTime(13, 0), KDateTime::ClockTime));
KCalCore::Recurrence *recurrence = event->recurrence();
recurrence->setDaily(1);
recurrence->setStartDateTime(event->dtStart());
m_calendar->addEvent(event, NotebookId);
m_storage->save();
QString uid = event->uid();
reloadDb();
auto fetchEvent = m_calendar->event(uid);
QVERIFY(fetchEvent);
KCalCore::Recurrence *fetchRecurrence = fetchEvent->recurrence();
QVERIFY(fetchRecurrence);
// should return occurrence for both days
mKCal::ExtendedCalendar::ExpandedIncidenceList events
= m_calendar->rawExpandedEvents(startDate, startDate.addDays(1), false, false, KDateTime::Spec(KDateTime::LocalZone));
QCOMPARE(events.size(), 2);
}
// Exporting Event data to map. Using the same
// encoding as ODateBookAccessBackend_xml does..
// Thus, we could remove the stuff there and use this
// for it and for all other places..
// Encoding should happen at one place, only ! (eilers)
QMap<int, QString> OEvent::toMap()const {
QMap<int, QString> retMap;
retMap.insert( OEvent::FUid, QString::number( uid() ) );
retMap.insert( OEvent::FCategories, Qtopia::escapeString( Qtopia::Record::idsToString( categories() ) ));
retMap.insert( OEvent::FDescription, Qtopia::escapeString( description() ) );
retMap.insert( OEvent::FLocation, Qtopia::escapeString( location() ) );
retMap.insert( OEvent::FType, isAllDay() ? "AllDay" : "" );
OPimAlarm alarm = notifiers().alarms()[0];
retMap.insert( OEvent::FAlarm, QString::number( alarm.dateTime().secsTo( startDateTime() ) / 60 ) );
retMap.insert( OEvent::FSound, (alarm.sound() == OPimAlarm::Loud) ? "loud" : "silent" );
OTimeZone zone( timeZone().isEmpty() ? OTimeZone::current() : timeZone() );
retMap.insert( OEvent::FStart, QString::number( zone.fromUTCDateTime( zone.toDateTime( startDateTime(), OTimeZone::utc() ) ) ) );
retMap.insert( OEvent::FEnd, QString::number( zone.fromUTCDateTime( zone.toDateTime( endDateTime(), OTimeZone::utc() ) ) ) );
retMap.insert( OEvent::FNote, Qtopia::escapeString( note() ) );
retMap.insert( OEvent::FTimeZone, timeZone().isEmpty() ? QString( "None" ) : timeZone() );
if( parent() )
retMap.insert( OEvent::FRecParent, QString::number( parent() ) );
if( children().count() ){
QArray<int> childr = children();
QString buf;
for ( uint i = 0; i < childr.count(); i++ ) {
if ( i != 0 ) buf += " ";
buf += QString::number( childr[i] );
}
retMap.insert( OEvent::FRecChildren, buf );
}
// Add recurrence stuff
if( hasRecurrence() ){
ORecur recur = recurrence();
QMap<int, QString> recFields = recur.toMap();
retMap.insert( OEvent::FRType, recFields[ORecur::RType] );
retMap.insert( OEvent::FRWeekdays, recFields[ORecur::RWeekdays] );
retMap.insert( OEvent::FRPosition, recFields[ORecur::RPosition] );
retMap.insert( OEvent::FRFreq, recFields[ORecur::RFreq] );
retMap.insert( OEvent::FRHasEndDate, recFields[ORecur::RHasEndDate] );
retMap.insert( OEvent::FREndDate, recFields[ORecur::EndDate] );
retMap.insert( OEvent::FRCreated, recFields[ORecur::Created] );
retMap.insert( OEvent::FRExceptions, recFields[ORecur::Exceptions] );
} else {
ORecur recur = recurrence();
QMap<int, QString> recFields = recur.toMap();
retMap.insert( OEvent::FRType, recFields[ORecur::RType] );
}
return retMap;
}
void Basis_HGRAD_LINE_Hermite_FEM<Scalar,ArrayScalar>::legendre_d( ArrayScalar &P,
ArrayScalar &Px,
const int m,
const Scalar x ) const {
// Compute P,P'
recurrence(P,Px,x);
int C = this->getCardinality();
// Loop over derivative orders
for( int k=1;k<m;++k) {
P = Px;
// Loop over polynomial indices
for( int j=0; j<C; ++j ) {
if( j<k ) {
Px(j) = 0;
}
else {
Px(j) = (j+k)*P(j-1) + x*Px(j-1);
}
}
}
} // legendre_d()
void tst_storage::tst_alldayRecurrence()
{
auto event = KCalCore::Event::Ptr(new KCalCore::Event);
QDate startDate(2013, 12, 1);
event->setDtStart(KDateTime(startDate, QTime(), KDateTime::ClockTime));
event->setAllDay(true);
KCalCore::Recurrence *recurrence = event->recurrence();
recurrence->setWeekly(1);
recurrence->setStartDateTime(event->dtStart());
m_calendar->addEvent(event, NotebookId);
m_storage->save();
QString uid = event->uid();
reloadDb();
auto fetchEvent = m_calendar->event(uid);
QVERIFY(fetchEvent);
KCalCore::Recurrence *fetchRecurrence = fetchEvent->recurrence();
QVERIFY(fetchRecurrence);
KDateTime match = recurrence->getNextDateTime(KDateTime(startDate));
QCOMPARE(match, KDateTime(startDate.addDays(7), QTime(), KDateTime::ClockTime));
}
int main(void)
{
/* Compile input program */
struct asmbuf *buf = asmbuf_create();
asmbuf_ins(buf, 3, 0x4889f8); // mov %rdi, %rax
int c;
while ((c = fgetc(stdin)) != '\n' && c != EOF) {
if (c == ' ')
continue;
char operator = c;
long operand;
scanf("%ld", &operand);
asmbuf_ins(buf, 2, 0x48bf); // movq operand, %rdi
asmbuf_immediate(buf, 8, &operand);
switch (operator) {
case '+':
asmbuf_ins(buf, 3, 0x4801f8); // add %rdi, %rax
break;
case '-':
asmbuf_ins(buf, 3, 0x4829f8); // sub %rdi, %rax
break;
case '*':
asmbuf_ins(buf, 4, 0x480fafc7); // imul %rdi, %rax
break;
case '/':
asmbuf_ins(buf, 3, 0x4831d2); // xor %rdx, %rdx
asmbuf_ins(buf, 3, 0x48f7ff); // idiv %rdi
break;
}
}
asmbuf_ins(buf, 1, 0xc3); // retq
asmbuf_finalize(buf);
long init;
unsigned long term;
scanf("%ld %lu", &init, &term);
long (*recurrence)(long) = (void *)buf->code;
for (unsigned long i = 0, x = init; i <= term; i++, x = recurrence(x))
fprintf(stderr, "Term %lu: %ld\n", i, x);
asmbuf_free(buf);
return 0;
}
void Basis_HGRAD_LINE_Hermite_FEM<Scalar,ArrayScalar>::setupVandermonde( bool factor ) {
initializeTags();
int nBf = this->getCardinality();
int n = nBf/2;
V_.shape(nBf,nBf);
// Make containers to store the Legendre polynomials and their derivatives
// at a given point
ArrayScalar P ( nBf );
ArrayScalar Px( nBf );
// Loop over grid points
for( int i=0; i<n; ++i ) {
recurrence(P,Px,latticePts_(i,0));
// Loop over basis functions
for(int j=0; j<nBf; ++j ) {
V_(j, i ) = P (j);
V_(j, i+n) = Px(j);
}
}
solver_.setMatrix(Teuchos::rcpFromRef(V_));
if(factor) {
solver_.factorWithEquilibration(true);
solver_.factor();
isFactored_ = true;
}
else {
isFactored_ = false;
}
}
/**
* set the start date
* @param date the new start date
*/
void ORecurranceWidget::setStartDate( const QDate& date ) {
setRecurrence( recurrence(), date );
}
void Basis_HGRAD_LINE_Hermite_FEM<Scalar, ArrayScalar>::getValues(ArrayScalar & outputValues,
const ArrayScalar & inputPoints,
const EOperator operatorType) const {
// Verify arguments
#ifdef HAVE_INTREPID_DEBUG
Intrepid::getValues_HGRAD_Args<Scalar, ArrayScalar>(outputValues,
inputPoints,
operatorType,
this -> getBaseCellTopology(),
this -> getCardinality() );
#endif
// Number of evaluation points = dim 0 of inputPoints
int nPts = inputPoints.dimension(0);
int nBf = this->getCardinality();
int n = nBf/2;
// Legendre polynomials and their derivatives evaluated on inputPoints
SerialDenseMatrix legendre(nBf,nPts);
// Hermite interpolants evaluated on inputPoints
SerialDenseMatrix hermite(nBf,nPts);
ArrayScalar P (nBf);
ArrayScalar Px(nBf);
int derivative_order;
int derivative_case = static_cast<int>(operatorType);
if( derivative_case == 0 ) {
derivative_order = 0;
}
else if( derivative_case > 0 && derivative_case < 5 ) {
derivative_order = 1;
}
else {
derivative_order = derivative_case - 3;
}
try {
// GRAD,CURL,DIV, and D1 are all the first derivative
switch (operatorType) {
case OPERATOR_VALUE:
{
for( int i=0; i<nPts; ++i ) {
recurrence( P, Px, inputPoints(i,0) );
for( int j=0; j<nBf; ++j ) {
legendre(j,i) = P(j);
}
}
break;
}
case OPERATOR_GRAD:
case OPERATOR_DIV:
case OPERATOR_CURL:
case OPERATOR_D1:
{
for( int i=0; i<nPts; ++i ) {
recurrence( P, Px, inputPoints(i,0) );
for( int j=0; j<nBf; ++j ) {
legendre(j,i) = Px(j);
}
}
break;
}
case OPERATOR_D2:
case OPERATOR_D3:
case OPERATOR_D4:
case OPERATOR_D5:
case OPERATOR_D6:
case OPERATOR_D7:
case OPERATOR_D8:
case OPERATOR_D9:
case OPERATOR_D10:
{
for( int i=0; i<nPts; ++i ) {
legendre_d( P, Px, derivative_order, inputPoints(i,0));
for( int j=0; j<nBf; ++j ) {
legendre(j,i) = Px(j);
}
}
break;
}
default:
TEUCHOS_TEST_FOR_EXCEPTION( !( Intrepid::isValidOperator(operatorType) ), std::invalid_argument,
">>> ERROR (Basis_HGRAD_LINE_Hermite_FEM): Invalid operator type");
} // switch(operatorType)
}
catch (std::invalid_argument &exception){
TEUCHOS_TEST_FOR_EXCEPTION( true , std::invalid_argument,
">>> ERROR (Basis_HGRAD_LINE_Hermite_FEM): Operator failed");
}
if( !isFactored_ ) {
solver_.factorWithEquilibration(true);
solver_.factor();
}
solver_.setVectors(Teuchos::rcpFromRef(hermite),Teuchos::rcpFromRef(legendre));
solver_.solve();
if(derivative_order > 0)
{
for( int i=0; i<n; ++i ) {
for( int j=0; j<nPts; ++j ) {
outputValues(2*i, j,0) = hermite(i, j);
outputValues(2*i+1,j,0) = hermite(i+n,j);
}
}
}
else {
for( int i=0; i<n; ++i ) {
for( int j=0; j<nPts; ++j ) {
outputValues(2*i ,j) = hermite(i, j);
outputValues(2*i+1,j) = hermite(i+n,j);
}
}
}
} // getValues()
