Thanks !

On Thu, Oct 2, 2014 at 11:04 AM, Igor Mironchik <igor.mironchik@gmail.com> wrote:
And one more... If you use C++11 then better to use emplace_back() instead of push_back()...
 
Sent: Thursday, October 02, 2014 5:02 PM
Subject: Re: [Boost-users] [Boost] [DateTime] dividing a time_period in Ntime_periods
 
Hi.
 
Try this:
 
list< time_period > splitTimePeriod( time_period timePeriod, int n )
{
	const time_duration equalPeriod =
		( timePeriod.end() - timePeriod.begin() ) / n;

	list< time_period > timePeriods;

	// tiempo de comienzo del primer período de tiempo
	ptime tpBegin = timePeriod.begin();

	// tiempo de fin del último período de tiempo
	const ptime tpLastEnd = timePeriod.end();


	for( int i = 0; i < n; ++i )
	{
		// tiempo de fin del período de tiempo
		ptime tpEnd;

		if( i == n - 1 )
			tpEnd = tpLastEnd;
		else
		{
			tpEnd = tpBegin + equalPeriod;


			// guarda para evitar que por cuestiones
			// de redondeo, el tiempo final de un período
			// sea mayor que el pasado inicialmente
			// como argumento de entrada
			if( tpEnd > tpLastEnd )
				tpEnd = tpLastEnd;
		}

		time_period p( tpBegin, tpEnd );

		// se inserta período de tiempo en la lista
		timePeriods.push_back( p );

		// se actualiza el comienzo del siguiente período de tiempo
		tpBegin = tpEnd;
	}

	return timePeriods;
}
 
It should be a little be more efficient.
 
And I think that this is excess:
 
// guarda para evitar que por cuestiones
// de redondeo, el tiempo final de un período
// sea mayor que el pasado inicialmente
// como argumento de entrada
if( tpEnd > tpLastEnd )
    tpEnd = tpLastEnd;






 





Sent: Thursday, October 02, 2014 4:38 PM



Subject: Re: [Boost-users] [Boost] [DateTime] dividing a time_period 
in Ntime_periods


 




I have changed the method to this: 

 




list<time_period> splitTimePeriod(time_period timePeriod, int 
n)


{


time_duration equalPeriod = 
(timePeriod.end() - timePeriod.begin()) / n;


 


list<time_period> 
timePeriods;


 


// tiempo de comienzo del primer 
período de tiempo


ptime tpBegin = 
timePeriod.begin();


 


// tiempo de fin del último período 
de tiempo


ptime tpLastEnd = 
timePeriod.end();


 


for (int i = 0; i < n; i++)


{


 


// tiempo de comienzo del siguiente 
período de tiempo


ptime tpNextBegin = tpBegin + 
equalPeriod;


 


// tiempo de fin del período de 
tiempo


ptime tpEnd;


 


if (i == n - 1)


{


tpEnd = tpLastEnd;


}


else


{


tpEnd = 
dateTime::decrement(tpNextBegin, 1);


 


// guarda para evitar que por 
cuestiones


// de redondeo, el tiempo final de un 
período


// sea mayor que el pasado 
inicialmente


// como argumento de entrada


if (tpEnd > tpLastEnd)


{


tpEnd = tpLastEnd;


}


}


 


time_period p(tpBegin, tpEnd);


 


// se inserta período de tiempo en la 
lista


timePeriods.push_back(p);


 


// se actualiza el comienzo del 
siguiente período de tiempo


tpBegin = tpNextBegin;


}


 


return timePeriods;


}


 


############################################################


I didn't know I can make these operations to time_duration:


time_duration equalPeriod = (timePeriod.end() - timePeriod.begin()) / 
n;


 


Now it works faster.




 


On Thu, Oct 2, 2014 at 10:21 AM, Pablo Madoery <madoerypablo@gmail.com> wrote:


I think the time_duration s will be equal, but the time_periods 
will be something like this: 



2014-Jan-01 00:00:00 -> 2014-Jan-01 00:00:02.999999


2014-Jan-01 00:00:03 -> 2014-Jan-01 00:00:05.999999


2014-Jan-01 00:00:06 -> 2014-Jan-01 00:00:08.999999


2014-Jan-01 00:00:09 -> 2014-Jan-01 00:00:11.999999


2014-Jan-01 00:00:12 -> 2014-Jan-01 00:00:14.999999


2014-Jan-01 00:00:15 -> 2014-Jan-01 00:00:17.999999


2014-Jan-01 00:00:18 -> 2014-Jan-01 00:00:21


 


when calling the method like this


 




ptime p1 = 
dateTime::toPtime("2014-1-1 00:00:00");


ptime p2 = 
dateTime::toPtime("2014-1-1 00:00:21");


 


time_period tp(p1,p2);


 


list<time_period> l = 
dateTime::splitTimePeriod(tp, 7);


list<time_period>::iterator i = 
l.begin();


for(; i!= l.end(); ++i)


{


cout<<i->begin()<<" -> 
"<<i->end()<<endl;


}




 






On Thu, Oct 2, 2014 at 10:13 AM, Leon Mlakar <leon@digiverse.si> 
wrote:












On 02/10/14 15:09, Pablo Madoery wrote:


Hi, I want to make a method which divides a time_period in N time 
periods, 

something like this:


 


list<time_period> splitTimePeriod(time_period timePeriod, int 
n);


 


I actually have made it and although it seems to work it results very 
inefficient regarding the time it took to divide a large time_period.


 


The method I did is this:


 




list<time_period> splitTimePeriod(time_period timePeriod, int 
n)


{


double secsTime = 
dateTime::diffSeconds(timePeriod.end(), timePeriod.begin());


 


// tiempo en segundos de cada 
período de tiempo


double ti = secsTime / n;


 


list<time_period> 
timePeriods;


 


// tiempo de comienzo del primer 
período de tiempo


ptime tpBegin = 
timePeriod.begin();


 


// tiempo de fin del último 
período de tiempo


ptime tpLastEnd = 
timePeriod.end();


 


for (int i = 0; i < n; 
i++)


{


int tUnits = ti * 
time_duration::ticks_per_second();


 


// tiempo de comienzo del 
siguiente período de tiempo


ptime tpNextBegin = 
dateTime::increment(tpBegin, tUnits);


 


// tiempo de fin del período de 
tiempo


ptime tpEnd;


 


if (i == n - 1)


{


tpEnd = tpLastEnd;


}


else


{


tpEnd = 
dateTime::decrement(tpNextBegin, 1);


 


// guarda para evitar que por 
cuestiones


// de redondeo, el tiempo final 
de un período


// sea mayor que el pasado 
inicialmente


// como argumento de 
entrada


if (tpEnd > tpLastEnd)


{


tpEnd = tpLastEnd;


}


}


 


time_period p(tpBegin, 
tpEnd);


 


// se inserta período de tiempo 
en la lista


timePeriods.push_back(p);


 


// se actualiza el comienzo del 
siguiente período de tiempo


tpBegin = tpNextBegin;


}


 


return timePeriods;


}


 


Other methods I use are these:


 




double diffSeconds(const ptime &dateA, const ptime &dateB)


{


time_duration diff = dateA - 
dateB;


return 
diff.total_seconds();


}


 




ptime increment(const ptime &date, int n)


{


time_iterator it(date, 
dateTime::unit);


for (int i = 0; i < n; 
i++)


{


++it;


}


return *it;


}


 


ptime decrement(const ptime &date, int n)


{


time_iterator it(date, 
dateTime::unit);


for (int i = 0; i < n; 
i++)


{


--it;


}


return *it;


}


 


const time_duration unit = microseconds(1);


 


#################################################


The question is:  is there a better way to accomplish this? 



 
If you are splitting a time period into N periods 
of equal duration, wouldn't it be enough to return just one time period? The 
other n-1 are going to be equal, except perhaps for the last.

Leon



 
_______________________________________________
Boost-users 
mailing list
Boost-users@lists.boost.org
http://lists.boost.org/mailman/listinfo.cgi/boost-users


 


 





_______________________________________________
Boost-users mailing 
list
Boost-users@lists.boost.org
http://lists.boost.org/mailman/listinfo.cgi/boost-users


_______________________________________________

Boost-users mailing list

Boost-users@lists.boost.org

http://lists.boost.org/mailman/listinfo.cgi/boost-users