public static DateTime RoundDateTime(this DateTime dt, int minutes, RoundingDirection direction)
{
if (minutes == 0)
{
return(dt);
}
TimeSpan d = TimeSpan.FromMinutes(minutes);
long delta = 0;
long modTicks = dt.Ticks % d.Ticks;
switch (direction)
{
case RoundingDirection.Up:
delta = modTicks != 0 ? d.Ticks - modTicks : 0;
break;
case RoundingDirection.Down:
delta = -modTicks;
break;
case RoundingDirection.Nearest:
{
bool roundUp = modTicks > d.Ticks / 2;
var offset = roundUp ? d.Ticks : 0;
delta = offset - modTicks;
break;
}
}
return(new DateTime(dt.Ticks + delta, dt.Kind));
}
public void TestRoundToTimeOfDay(string test, RoundingDirection direction, string expected)
{
var testDate = DateTimeOffset.ParseExact(test, AppConfigHelper.Iso8601FormatNoFractionalSeconds, CultureInfo.InvariantCulture);
var expectedDate = DateTimeOffset.ParseExact(expected, AppConfigHelper.Iso8601FormatNoFractionalSeconds, CultureInfo.InvariantCulture);
var actual = testDate.RoundToTimeOfDay(new TimeSpan(11, 30, 0), direction);
Assert.AreEqual(expectedDate, actual);
}
private static double Round( double value, int precision, RoundingDirection roundingDirection )
{
RoundingFunction roundingFunction;
if ( roundingDirection == RoundingDirection.Up )
roundingFunction = Math.Ceiling;
else
roundingFunction = Math.Floor;
value *= Math.Pow( 10, precision );
value = roundingFunction( value );
return value * Math.Pow( 10, -1 * precision );
}
public static LocalDateTime ToNearestHour(this LocalDateTime dateTime, RoundingDirection direction)
{
if (dateTime.Minute == 0)
{
return(dateTime);
}
return(direction == RoundingDirection.Up
? dateTime.PlusMinutes(60 - dateTime.Minute)
: dateTime.PlusMinutes(-dateTime.Minute));
}
/// <summary>
/// Rounds a date value to a given minute interval
/// </summary>
/// <param name="time">Original time value</param>
/// <param name="minuteInterval">Number of minutes to round up or down to</param>
/// <param name="direction"></param>
/// <returns></returns>
public static DateTime RoundDateToMinuteInterval(DateTime time, long minuteInterval,
RoundingDirection direction)
{
//TimeSpan.TicksPerMinute
if (minuteInterval > 0)
{
long t = time.Ticks / (TimeSpan.TicksPerSecond * minuteInterval);
DateTime nt = new DateTime(t * minuteInterval * TimeSpan.TicksPerSecond);
return nt;
}
return time;
}
private static double Round(double value, int precision, RoundingDirection roundingDirection)
{
RoundingFunction roundingFunction;
if (roundingDirection == RoundingDirection.Up)
{
roundingFunction = Math.Ceiling;
}
else
{
roundingFunction = Math.Floor;
}
value *= Math.Pow(10, precision);
value = roundingFunction(value);
return(value * Math.Pow(10, -1 * precision));
}
/// <summary>
/// Round a date to a time of day.
/// </summary>
/// <remarks>
/// Unlike the other rounding methods (which accept an interval), this method
/// will only output values that are 24-hours apart so that values always align
/// to the supplied <paramref name="timeOfDay"/>.
/// </remarks>
/// <param name="date">The date to round.</param>
/// <param name="timeOfDay">The time of day to round to.</param>
/// <param name="direction">The behaviour of the rounding operation.</param>
/// <returns>A rounded date.</returns>
public static DateTimeOffset RoundToTimeOfDay(
this DateTimeOffset date,
TimeSpan timeOfDay,
RoundingDirection direction)
{
var time = date.TimeOfDay;
if (time == timeOfDay)
{
return(date);
}
TimeSpan delta;
if (direction == RoundingDirection.AwayFromZero)
{
var roundDelta = timeOfDay.Subtract(time);
if (roundDelta.Absolute() < TimeSpan.FromHours(12))
{
delta = timeOfDay;
}
else if (roundDelta < TimeSpan.Zero)
{
delta = timeOfDay + TimeSpan.FromDays(1);
}
else
{
delta = timeOfDay - TimeSpan.FromDays(1);
}
}
else if (direction == RoundingDirection.Ceiling)
{
delta = time < timeOfDay ? timeOfDay : timeOfDay + TimeSpan.FromDays(1);
}
else if (direction == RoundingDirection.Floor)
{
delta = time >= timeOfDay ? timeOfDay : timeOfDay - TimeSpan.FromDays(1);
}
else
{
throw new ArgumentOutOfRangeException(nameof(direction));
}
var dayOf = new DateTimeOffset(date.Date.Add(delta), date.Offset);
return(dayOf);
}
private static float Round(float value, int precision,
RoundingDirection roundingDirection)
{
RoundingFunction roundingFunction;
if (roundingDirection == RoundingDirection.Up)
{
roundingFunction = Mathf.Ceil;
}
else
{
roundingFunction = Mathf.Floor;
}
value *= Mathf.Pow(10, precision);
value = roundingFunction(value);
return(value * Mathf.Pow(10, -1 * precision));
}
public static DateTime RoundDateTime(DateTime dt, int minutes, RoundingDirection direction)
{
TimeSpan t;
switch (direction)
{
case RoundingDirection.Up:
t = (dt.Subtract(DateTime.MinValue)).Add(new TimeSpan(0, minutes, 0)); break;
case RoundingDirection.Down:
t = (dt.Subtract(DateTime.MinValue)); break;
default:
t = (dt.Subtract(DateTime.MinValue)).Add(new TimeSpan(0, minutes / 2, 0)); break;
}
return DateTime.MinValue.Add(new TimeSpan(0,
(((int)t.TotalMinutes) / minutes) * minutes, 0));
}
/// <summary>
/// Rounds a TimeSpan based on the provided values.
/// </summary>
/// <param name="ts">The extension target.</param>
/// <param name="Direction">The direction in which to round.</param>
/// <param name="MinutePrecision">The precision to round to.</param>
/// <returns>A new TimeSpan based on the provided values.</returns>
public static TimeSpan Round(this TimeSpan ts, RoundingDirection Direction, int MinutePrecision)
{
if (Direction == RoundingDirection.Up)
{
return(TimeSpan.FromMinutes(
MinutePrecision * Math.Ceiling(ts.TotalMinutes / MinutePrecision)));
}
if (Direction == RoundingDirection.Down)
{
return(TimeSpan.FromMinutes(
MinutePrecision * Math.Floor(ts.TotalMinutes / MinutePrecision)));
}
// Really shouldn't be able to get here...
return(ts);
}
public static DateTime RoundDateTime(DateTime dt, int minutes, RoundingDirection direction)
{
TimeSpan t;
switch (direction)
{
case RoundingDirection.Up:
t = (dt.Subtract(DateTime.MinValue)).Add(new TimeSpan(0, minutes, 0)); break;
case RoundingDirection.Down:
t = (dt.Subtract(DateTime.MinValue)); break;
default:
t = (dt.Subtract(DateTime.MinValue)).Add(new TimeSpan(0, minutes / 2, 0)); break;
}
return(DateTime.MinValue.Add(new TimeSpan(0,
(((int)t.TotalMinutes) / minutes) * minutes, 0)));
}
/// <summary>
/// Rounds an hours value to a minute interval
/// 0 means no rounding
/// </summary>
/// <param name="minuteInterval">Minutes to round up or down to</param>
/// <returns></returns>
public static decimal RoundDateToMinuteInterval(decimal hours, int minuteInterval,
RoundingDirection direction)
{
if (minuteInterval == 0)
{
return(hours);
}
decimal fraction = 60 / minuteInterval;
switch (direction)
{
case RoundingDirection.Round:
return(Math.Round(hours * fraction, 0) / fraction);
case RoundingDirection.RoundDown:
return(Math.Truncate(hours * fraction) / fraction);
}
return(Math.Ceiling(hours * fraction) / fraction);
}
/// <summary>
/// Rounds a date value to a given minute interval
/// </summary>
/// <param name="time">Original time value</param>
/// <param name="minuteInterval">Number of minutes to round up or down to</param>
/// <returns></returns>
public static DateTime RoundDateToMinuteInterval(DateTime time, int minuteInterval,
RoundingDirection direction)
{
if (minuteInterval == 0)
{
return(time);
}
decimal interval = (decimal)minuteInterval;
decimal actMinute = (decimal)time.Minute;
if (actMinute == 0.00M)
{
return(time);
}
int newMinutes = 0;
switch (direction)
{
case RoundingDirection.Round:
newMinutes = (int)(Math.Round(actMinute / interval, 0) * interval);
break;
case RoundingDirection.RoundDown:
newMinutes = (int)(Math.Truncate(actMinute / interval) * interval);
break;
case RoundingDirection.RoundUp:
newMinutes = (int)(Math.Ceiling(actMinute / interval) * interval);
break;
}
// strip time
time = time.AddMinutes(time.Minute * -1);
time = time.AddSeconds(time.Second * -1);
time = time.AddMilliseconds(time.Millisecond * -1);
// add new minutes back on
return(time.AddMinutes(newMinutes));
}
/// <summary>
/// Rounds a date value to a given minute interval
/// </summary>
/// <param name="time">Original time value</param>
/// <param name="minuteInterval">Number of minutes to round up or down to</param>
/// <returns></returns>
public static DateTime RoundDateToMinuteInterval(DateTime time, int minuteInterval,
RoundingDirection direction)
{
if (minuteInterval == 0)
return time;
decimal interval = (decimal)minuteInterval;
decimal actMinute = (decimal)time.Minute;
if (actMinute == 0.00M)
return time;
int newMinutes = 0;
switch (direction)
{
case RoundingDirection.Round:
newMinutes = (int)(Math.Round(actMinute / interval, 0) * interval);
break;
case RoundingDirection.RoundDown:
newMinutes = (int)(Math.Truncate(actMinute / interval) * interval);
break;
case RoundingDirection.RoundUp:
newMinutes = (int)(Math.Ceiling(actMinute / interval) * interval);
break;
}
// strip time
time = time.AddMinutes(time.Minute * -1);
time = time.AddSeconds(time.Second * -1);
time = time.AddMilliseconds(time.Millisecond * -1);
// add new minutes back on
return time.AddMinutes(newMinutes);
}
/// <summary>
/// Rounds an hours value to a minute interval
/// 0 means no rounding
/// </summary>
/// <param name="minuteInterval">Minutes to round up or down to</param>
/// <returns></returns>
public static decimal RoundDateToMinuteInterval(decimal hours, int minuteInterval,
RoundingDirection direction)
{
if (minuteInterval == 0)
return hours;
decimal fraction = 60 / minuteInterval;
switch (direction)
{
case RoundingDirection.Round:
return Math.Round(hours * fraction, 0) / fraction;
case RoundingDirection.RoundDown:
return Math.Truncate(hours * fraction) / fraction;
}
return Math.Ceiling(hours * fraction) / fraction;
}
/// <summary>
/// Rounds datetime up, down or to nearest minutes and all smaller units to zero
/// </summary>
/// <param name="dt">static extension method</param>
/// <param name="rndmin">mins to round to</param>
/// <param name="directn">Up,Down,Nearest</param>
/// <returns>rounded TimeSpan with all smaller units than mins rounded off</returns>
/// <remarks>http://metadataconsulting.blogspot.com/2018/10/C-Round-Datetime-Extension-To-Nearest-Minute-And-Smaller-Units-Are-Rounded-To-Zero.html</remarks>
public static TimeSpan RoundToNearestMinute(this TimeSpan dt, int rndmin = 1, RoundingDirection directn = RoundingDirection.Nearest)
{
if (rndmin == 0) //can be > 60 mins
{
return(dt);
}
TimeSpan d = TimeSpan.FromMinutes(rndmin); //this can be passed as a parameter, or use any timespan unit FromDays, FromHours, etc.
long delta = 0;
Int64 modTicks = dt.Ticks % d.Ticks;
switch (directn)
{
case RoundingDirection.Up:
delta = modTicks != 0 ? d.Ticks - modTicks : 0;
break;
case RoundingDirection.Down:
delta = -modTicks;
break;
case RoundingDirection.Nearest:
{
bool roundUp = modTicks > (d.Ticks / 2);
var offset = roundUp ? d.Ticks : 0;
delta = offset - modTicks;
break;
}
}
return(new TimeSpan(dt.Ticks + delta));
}
