public void GetValue_WithLocalInstant()
{
LocalInstant when = new LocalInstant(987654321L);
Assert.AreEqual(0, field.GetValue(new Duration(0L), when));
Assert.AreEqual(12345, field.GetValue(new Duration(123456789L), when));
Assert.AreEqual(-1, field.GetValue(new Duration(-12345L), when));
}
internal override LocalInstant SetValue(LocalInstant localInstant, long value)
{
FieldUtils.VerifyValueBounds(this, value, min, max);
long wrappedValue = WrappedField.GetInt64Value(localInstant);
long remainder = wrappedValue >= 0 ? wrappedValue % divisor : (divisor - 1) + ((wrappedValue + 1) % divisor);
return WrappedField.SetValue(localInstant, value * divisor + remainder);
}
internal override int GetDifference(LocalInstant minuendInstant, LocalInstant subtrahendInstant)
{
differences++;
DiffFirstArg = minuendInstant;
DiffSecondArg = subtrahendInstant;
return 30;
}
internal override LocalInstant Add(LocalInstant localInstant, int value)
{
int32Additions++;
AddInstantArg = localInstant;
AddValueArg = value;
return new LocalInstant(localInstant.Ticks + value * unitTicks);
}
public void MinusOffset_Zero_IsNeutralElement()
{
Instant sampleInstant = new Instant(1, 23456L);
LocalInstant sampleLocalInstant = new LocalInstant(1, 23456L);
Assert.AreEqual(sampleInstant, sampleLocalInstant.Minus(Offset.Zero));
Assert.AreEqual(sampleInstant, sampleLocalInstant.MinusZeroOffset());
}
internal override LocalInstant SetValue(LocalInstant localInstant, long value)
{
FieldUtils.VerifyValueBounds(this, value, 0, divisor - 1);
int wrappedValue = WrappedField.GetValue(localInstant);
int divided = wrappedValue >= 0 ? wrappedValue / divisor : ((wrappedValue + 1) / divisor) - 1;
return WrappedField.SetValue(localInstant, divided * divisor + value);
}
public void GetZoneIntervals_WithinFirstSummer()
{
var early = new LocalInstant(2000, 6, 1, 0, 0);
var pair = TestZone.GetZoneIntervals(early);
Assert.AreEqual("Summer", pair.EarlyInterval.Name);
Assert.IsNull(pair.LateInterval);
}
internal override long GetInt64Difference(LocalInstant minuendInstant, LocalInstant subtrahendInstant)
{
DateTimeField field = calendarSystem.Fields.WeekYear;
if (minuendInstant < subtrahendInstant)
{
return -GetInt64Difference(subtrahendInstant, minuendInstant);
}
int minuendWeekYear = field.GetValue(minuendInstant);
int subtrahendWeekYear = field.GetValue(subtrahendInstant);
Duration minuendRemainder = field.Remainder(minuendInstant);
Duration subtrahendRemainder = field.Remainder(subtrahendInstant);
// Balance leap weekyear differences on remainders.
if (subtrahendRemainder >= Week53Ticks && calendarSystem.GetWeeksInYear(minuendWeekYear) <= 52)
{
subtrahendRemainder -= Duration.OneWeek;
}
int difference = minuendWeekYear - subtrahendWeekYear;
if (minuendRemainder < subtrahendRemainder)
{
difference--;
}
return difference;
}
internal override LocalInstant Add(LocalInstant localInstant, long value)
{
int64Additions++;
Add64InstantArg = localInstant;
Add64ValueArg = value;
return new LocalInstant(localInstant.Ticks + value * unitTicks);
}
public void GetInt64Value_WithLocalInstant()
{
LocalInstant when = new LocalInstant(56789L);
Assert.AreEqual(0L, TicksDurationField.Instance.GetInt64Value(new Duration(0L), when));
Assert.AreEqual(1234L, TicksDurationField.Instance.GetInt64Value(new Duration(1234L), when));
Assert.AreEqual(-1234L, TicksDurationField.Instance.GetInt64Value(new Duration(-1234L), when));
Assert.AreEqual(int.MaxValue + 1L, TicksDurationField.Instance.GetInt64Value(new Duration(int.MaxValue + 1L), when));
}
internal override LocalInstant SetValue(LocalInstant localInstant, long value)
{
FieldUtils.VerifyValueBounds(this, value, 0, GetMaximumValue());
if (WrappedField.GetValue(localInstant) < 0)
{
value = -value;
}
return base.SetValue(localInstant, value);
}
internal override LocalInstant SetValue(LocalInstant localInstant, long value)
{
FieldUtils.VerifyValueBounds(this, value, 1, GetMaximumValue());
if (calendarSystem.GetYear(localInstant) <= 0)
{
value = 1 - value;
}
return base.SetValue(localInstant, value);
}
public void GetValue_DelegatesToGetInt64Value()
{
var field = new StubDateTimeField();
var arg = new LocalInstant(60);
field.GetValue(arg);
Assert.That(field.GetInt64ValueWasCalled, Is.True);
Assert.That(field.GetInt64ValueArg, Is.EqualTo(arg));
}
public void FromDateTime()
{
LocalInstant expected = new LocalInstant(2011, 08, 18, 20, 53);
foreach (DateTimeKind kind in Enum.GetValues(typeof(DateTimeKind)))
{
DateTime x = new DateTime(2011, 08, 18, 20, 53, 0, kind);
LocalInstant actual = LocalInstant.FromDateTime(x);
Assert.AreEqual(expected, actual);
}
}
/// <summary>
/// Add the specified month to the specified time instant.
/// The amount added may be negative.
/// </summary>
/// <param name="localInstant">The local instant to update</param>
/// <param name="value">The months to add (can be negative).</param>
/// <returns>The updated local instant</returns>
/// <remarks>
/// If the new month has less total days than the specified
/// day of the month, this value is coerced to the nearest
/// sane value. e.g.
/// 07-31 - (1 month) = 06-30
/// 03-31 - (1 month) = 02-28 or 02-29 depending
/// </remarks>
internal override LocalInstant Add(LocalInstant localInstant, int value)
{
// Keep the parameter name the same as the original declaration, but
// use a more meaningful name in the method
int months = value;
if (months == 0)
{
return localInstant;
}
// Save the time part first
long timePart = calendarSystem.GetTickOfDay(localInstant);
// Get the year and month
int thisYear = calendarSystem.GetYear(localInstant);
int thisMonth = calendarSystem.GetMonthOfYear(localInstant, thisYear);
// Do not refactor without careful consideration.
// Order of calculation is important.
int yearToUse;
// Initially, monthToUse is zero-based
int monthToUse = thisMonth - 1 + months;
if (monthToUse >= 0)
{
yearToUse = thisYear + (monthToUse / monthsPerYear);
monthToUse = (monthToUse % monthsPerYear) + 1;
}
else
{
yearToUse = thisYear + (monthToUse / monthsPerYear) - 1;
monthToUse = Math.Abs(monthToUse);
int remMonthToUse = monthToUse % monthsPerYear;
// Take care of the boundary condition
if (remMonthToUse == 0)
{
remMonthToUse = monthsPerYear;
}
monthToUse = monthsPerYear - remMonthToUse + 1;
// Take care of the boundary condition
if (monthToUse == 1)
{
yearToUse++;
}
}
// End of do not refactor.
// Quietly force DOM to nearest sane value.
int dayToUse = calendarSystem.GetDayOfMonth(localInstant, thisYear, thisMonth);
int maxDay = calendarSystem.GetDaysInMonth(yearToUse, monthToUse);
dayToUse = Math.Min(dayToUse, maxDay);
// Get proper date part, and return result
long datePart = calendarSystem.GetYearMonthDayTicks(yearToUse, monthToUse, dayToUse);
return new LocalInstant(datePart + timePart);
}
public void TestLocalInstantOperators()
{
const long diff = TestTime2 - TestTime1;
var time1 = new LocalInstant(TestTime1);
var time2 = new LocalInstant(TestTime2);
Duration duration = time2 - time1;
Assert.AreEqual(diff, duration.Ticks);
Assert.AreEqual(TestTime2, (time1 + duration).Ticks);
Assert.AreEqual(TestTime1, (time2 - duration).Ticks);
}
internal override LocalInstant AddWrapField(LocalInstant localInstant, int value)
{
if (value == 0)
{
return localInstant;
}
int thisYear = calendarSystem.GetYear(localInstant);
int wrappedYear = FieldUtils.GetWrappedValue(thisYear, value, calendarSystem.MinYear, calendarSystem.MaxYear);
return SetValue(localInstant, wrappedYear);
}
public void Equality()
{
LocalInstant equal = new LocalInstant(1, 100L);
LocalInstant different1 = new LocalInstant(1, 200L);
LocalInstant different2 = new LocalInstant(2, 100L);
TestHelper.TestEqualsStruct(equal, equal, different1);
TestHelper.TestOperatorEquality(equal, equal, different1);
TestHelper.TestEqualsStruct(equal, equal, different2);
TestHelper.TestOperatorEquality(equal, equal, different2);
}
internal override LocalInstant SetValue(LocalInstant localInstant, long value)
{
FieldUtils.VerifyValueBounds(this, value, MinimumValue, max);
int month = (int)value;
int thisYear = calendarSystem.GetYear(localInstant);
int thisDom = calendarSystem.GetDayOfMonth(localInstant, thisYear);
int maxDom = calendarSystem.GetDaysInMonth(thisYear, month);
if (thisDom > maxDom)
{
// Quietly force DOM to nearest sane value.
thisDom = maxDom;
}
return new LocalInstant(calendarSystem.GetYearMonthDayTicks(thisYear, month, thisDom) + calendarSystem.GetTickOfDay(localInstant));
}
internal override LocalInstant SetValue(LocalInstant localInstant, long value)
{
FieldUtils.VerifyValueBounds(this, value, BeforeCommonEraIndex, CommonEraIndex);
int oldEra = GetValue(localInstant);
if (oldEra != value)
{
int year = calendarSystem.GetYear(localInstant);
return calendarSystem.SetYear(localInstant, -year);
}
else
{
return localInstant;
}
}
internal override long GetYearDifference(LocalInstant minuendInstant, LocalInstant subtrahendInstant)
{
// Optimized implementation due to fixed months
int minuendYear = GetYear(minuendInstant);
int subtrahendYear = GetYear(subtrahendInstant);
// Inlined remainder method to avoid duplicate calls to get.
long minuendRem = minuendInstant.Ticks - GetYearTicks(minuendYear);
long subtrahendRem = subtrahendInstant.Ticks - GetYearTicks(subtrahendYear);
int difference = minuendYear - subtrahendYear;
if (minuendRem < subtrahendRem)
{
difference--;
}
return difference;
}
public long Subtract(LocalInstant minuendInstant, LocalInstant subtrahendInstant)
{
ulong ticks;
if (minuendInstant < subtrahendInstant)
{
return(-Subtract(subtrahendInstant, minuendInstant));
}
unchecked
{
// This will handle overflow appropriately, so we'll end up with the right
// positive value.
ticks = (ulong)(minuendInstant.Ticks - subtrahendInstant.Ticks);
// This will naturally truncate towards 0, which is what we want.
}
return((long)(ticks / unitTicks));
}
/// <summary>
/// Initializes a new instance of the <see cref="ZoneRecurrence"/> class.
/// </summary>
/// <param name="name">The name of the time zone period e.g. PST.</param>
/// <param name="savings">The savings for this period.</param>
/// <param name="yearOffset">The year offset of when this period starts in a year.</param>
/// <param name="fromYear">The first year in which this recurrence is valid</param>
/// <param name="toYear">The last year in which this recurrence is valid</param>
public ZoneRecurrence([NotNull] String name, Offset savings, [NotNull] ZoneYearOffset yearOffset, int fromYear, int toYear)
{
Preconditions.CheckNotNull(name, nameof(name));
Preconditions.CheckNotNull(yearOffset, nameof(yearOffset));
Preconditions.CheckArgument(fromYear == int.MinValue || (fromYear >= -9998 && fromYear <= 9999), nameof(fromYear),
"fromYear must be in the range [-9998, 9999] or Int32.MinValue");
Preconditions.CheckArgument(toYear == int.MaxValue || (toYear >= -9998 && toYear <= 9999), nameof(toYear),
"toYear must be in the range [-9998, 9999] or Int32.MaxValue");
this.Name = name;
this.Savings = savings;
this.YearOffset = yearOffset;
this.FromYear = fromYear;
this.ToYear = toYear;
this.minLocalInstant = fromYear == int.MinValue ? LocalInstant.BeforeMinValue : yearOffset.GetOccurrenceForYear(fromYear);
this.maxLocalInstant = toYear == int.MaxValue ? LocalInstant.AfterMaxValue : yearOffset.GetOccurrenceForYear(toYear);
}
protected override int GetMonthOfYear(LocalInstant localInstant, int year)
{
int dayOfYearZeroBased = (int)((localInstant.Ticks - GetStartOfYearInTicks(year)) / NodaConstants.TicksPerStandardDay);
if (dayOfYearZeroBased == DaysPerLeapYear - 1)
{
return(12);
}
// First 6 months are all 31 days, which makes it a simple division.
if (dayOfYearZeroBased < 6 * 31)
{
return(dayOfYearZeroBased / 31 + 1);
}
// Remaining months are 30 days (until the last one, for a non-leap year), so just take the
// first six months as read, divide by 30 and then re-add the first 6 months.
return((dayOfYearZeroBased - 6 * 31) / 30 + 7);
}
public void UnsupportedOperations_ThrowNotSupportedException()
{
LocalInstant when = new LocalInstant();
Duration duration = new Duration();
AssertUnsupported(x => x.Add(when, 0));
AssertUnsupported(x => x.Add(when, 0L));
AssertUnsupported(x => x.GetDifference(when, when));
AssertUnsupported(x => x.GetDuration(10));
AssertUnsupported(x => x.GetDuration(10, when));
AssertUnsupported(x => x.GetInt64Difference(when, when));
AssertUnsupported(x => x.GetInt64Value(duration));
AssertUnsupported(x => x.GetInt64Value(duration, when));
AssertUnsupported(x => x.GetValue(duration));
AssertUnsupported(x => x.GetValue(duration, when));
AssertUnsupported(x => x.Subtract(when, 0));
AssertUnsupported(x => x.Subtract(when, 0L));
}
public LocalInstant Add(LocalInstant localInstant, long value)
{
// It's possible that there are better ways to do this, but this at least feels simple.
if (value > 0)
{
// Check that we wouldn't wrap round *more* than once, by performing
// this multiplication in a checked context.
ulong ticks = (ulong)value * unitTicks;
// Now add in an unchecked context...
long newTicks;
unchecked
{
newTicks = localInstant.Ticks + (long)ticks;
}
// And check that we're not earlier than we should be.
if (newTicks < localInstant.Ticks)
{
throw new OverflowException("Period addition overflowed.");
}
return(new LocalInstant(newTicks));
}
else
{
ulong positiveValue = value == long.MinValue ? long.MaxValue + 1UL : (ulong)Math.Abs(value);
// Check that we wouldn't wrap round *more* than once, by performing
// this multiplication in a checked context.
ulong ticks = positiveValue * unitTicks;
// Now add in an unchecked context...
long newTicks;
unchecked
{
newTicks = localInstant.Ticks - (long)ticks;
}
// And check that we're not later than we should be.
if (newTicks > localInstant.Ticks)
{
throw new OverflowException("Period addition overflowed.");
}
return(new LocalInstant(newTicks));
}
}
public void UnsupportedOperations_ThrowNotSupportedException()
{
LocalInstant when = new LocalInstant();
AssertUnsupported(x => x.GetInt64Value(when));
AssertUnsupported(x => x.GetLeapAmount(when));
AssertUnsupported(x => x.GetMaximumValue());
AssertUnsupported(x => x.GetMaximumValue(when));
AssertUnsupported(x => x.GetMinimumValue());
AssertUnsupported(x => x.GetMinimumValue(when));
AssertUnsupported(x => x.GetValue(when));
AssertUnsupported(x => x.IsLeap(when));
AssertUnsupported(x => x.Remainder(when));
AssertUnsupported(x => x.RoundCeiling(when));
AssertUnsupported(x => x.RoundFloor(when));
AssertUnsupported(x => x.RoundHalfCeiling(when));
AssertUnsupported(x => x.RoundHalfEven(when));
AssertUnsupported(x => x.RoundHalfFloor(when));
AssertUnsupported(x => x.SetValue(when, 0L));
}
internal override LocalInstant SetYear(LocalInstant localInstant, int year)
{
// Optimized implementation of set, due to fixed months
int thisYear = GetYear(localInstant);
int dayOfYear = GetDayOfYear(localInstant, thisYear);
long tickOfDay = GetTickOfDay(localInstant);
if (dayOfYear > 365)
{
// Current year is leap, and day is leap.
if (!IsLeapYear(year))
{
// Moving to a non-leap year, leap day doesn't exist.
dayOfYear--;
}
}
return new LocalInstant(GetYearMonthDayTicks(year, 1, dayOfYear) + tickOfDay);
}
// Note to self: this is (minuendInstant - subtrahendInstant) in months. So if minuendInstant
// is later than subtrahendInstant, the result should be positive.
internal override int MonthsBetween(LocalInstant minuendInstant, LocalInstant subtrahendInstant)
{
var minuendDate = HebrewScripturalCalculator.HebrewFromAbsolute(AbsoluteDayFromLocalInstant(minuendInstant));
var subtrahendDate = HebrewScripturalCalculator.HebrewFromAbsolute(AbsoluteDayFromLocalInstant(subtrahendInstant));
// First (quite rough) guess... we could probably be more efficient than this, but it's unlikely to be very far off.
double minuendMonths = (minuendDate.Year * MonthsPerLeapCycle) / (double)YearsPerLeapCycle + HebrewMonthConverter.ScripturalToCivil(minuendDate.Year, minuendDate.Month);
double subtrahendMonths = (subtrahendDate.Year * MonthsPerLeapCycle) / (double)YearsPerLeapCycle + HebrewMonthConverter.ScripturalToCivil(subtrahendDate.Year, subtrahendDate.Month);
int diff = (int)(minuendMonths - subtrahendMonths);
if (subtrahendInstant <= minuendInstant)
{
// Go backwards until we've got a tight upper bound...
while (AddMonths(subtrahendInstant, diff) > minuendInstant)
{
diff--;
}
// Go forwards until we've overshot
while (AddMonths(subtrahendInstant, diff) <= minuendInstant)
{
diff++;
}
// Take account of the overshoot
return(diff - 1);
}
else
{
// Moving backwards, so we need to end up with a result greater than or equal to
// minuendInstant...
// Go forwards until we've got a tight upper bound...
while (AddMonths(subtrahendInstant, diff) < minuendInstant)
{
diff++;
}
// Go backwards until we've overshot
while (AddMonths(subtrahendInstant, diff) >= minuendInstant)
{
diff--;
}
// Take account of the overshoot
return(diff + 1);
}
}
internal static long GetTickOfDay(LocalInstant localInstant)
{
// This is guaranteed not to overflow based on the operations we'll be performing.
unchecked
{
long ticks = localInstant.Ticks;
if (ticks >= 0)
{
// Surprisingly enough, this is faster than (but equivalent to)
// return ticks % NodaConstants.TicksPerStandardDay;
int days = TickArithmetic.FastTicksToDays(ticks);
return(ticks - ((days * 52734375L) << 14));
}
else
{
// I'm sure this can be optimized using shifting, but it's complicated enough as it is...
return((NodaConstants.TicksPerStandardDay - 1) + ((ticks + 1) % NodaConstants.TicksPerStandardDay));
}
}
}
internal int GetYear(LocalInstant localInstant)
{
long targetTicks = localInstant.Ticks;
// Get an initial estimate of the year, and the ticks value that
// represents the start of that year. Then verify estimate and fix if
// necessary.
// Initial estimate uses values divided by two to avoid overflow.
long halfTicksPerYear = averageTicksPerYear >> 1;
long halfTicksSinceStartOfYear1 = (targetTicks >> 1) - (ticksAtStartOfYear1 >> 1);
if (halfTicksSinceStartOfYear1 < 0)
{
// When we divide, we want to round down, not towards 0.
halfTicksSinceStartOfYear1 += 1 - halfTicksPerYear;
}
int candidate = (int)(halfTicksSinceStartOfYear1 / halfTicksPerYear) + 1;
// Most of the time we'll get the right year straight away, and we'll almost
// always get it after one adjustment - but it's safer (and easier to think about)
// if we just keep going until we know we're right.
while (true)
{
long candidateStart = GetYearTicksSafe(candidate);
long ticksFromCandidateStartToTarget = targetTicks - candidateStart;
if (ticksFromCandidateStartToTarget < 0)
{
// Our candidate year is later than we want.
candidate--;
continue;
}
long candidateLength = GetTicksInYear(candidate);
if (ticksFromCandidateStartToTarget >= candidateLength)
{
// Out candidate year is earlier than we want.
candidate++;
continue;
}
return(candidate);
}
}
internal override LocalInstant SetYear(LocalInstant localInstant, int year)
{
// Optimized implementation of set, due to fixed months
int thisYear = GetYear(localInstant);
int dayOfYear = GetDayOfYear(localInstant, thisYear);
long tickOfDay = TimeOfDayCalculator.GetTickOfDay(localInstant);
if (dayOfYear > 365)
{
// Current year is leap, and day is leap.
if (!IsLeapYear(year))
{
// Moving to a non-leap year, leap day doesn't exist.
dayOfYear--;
}
}
long ticks = GetYearTicks(year) + (dayOfYear - 1) * NodaConstants.TicksPerStandardDay + tickOfDay;
return(new LocalInstant(ticks));
}
/// <summary>
/// Adds the given transition to the transition list if it represents a new transition.
/// </summary>
/// <param name="transitions">The list of <see cref="ZoneTransition"/> to add to.</param>
/// <param name="transition">The transition to add.</param>
/// <returns><c>true</c> if the transition was added.</returns>
private static bool AddTransition(IList <ZoneTransition> transitions, ZoneTransition transition)
{
int transitionCount = transitions.Count;
if (transitionCount == 0)
{
transitions.Add(transition);
return(true);
}
ZoneTransition lastTransition = transitions[transitionCount - 1];
if (!transition.IsTransitionFrom(lastTransition))
{
return(false);
}
// A transition after the "beginning of time" one will always be valid.
if (lastTransition.Instant == Instant.BeforeMinValue)
{
transitions.Add(transition);
return(true);
}
Offset lastOffset = transitions.Count < 2 ? Offset.Zero : transitions[transitions.Count - 2].WallOffset;
Offset newOffset = lastTransition.WallOffset;
// If the local time just before the new transition is the same as the local time just
// before the previous one, just replace the last transition with new one.
// TODO(Post-V1): It's not clear what this is doing... work it out and give an example
LocalInstant lastLocalStart = lastTransition.Instant.Plus(lastOffset);
LocalInstant newLocalStart = transition.Instant.Plus(newOffset);
if (lastLocalStart == newLocalStart)
{
transitions.RemoveAt(transitionCount - 1);
return(AddTransition(transitions, transition));
}
transitions.Add(transition);
return(true);
}
internal static int GetDayOfWeek(LocalInstant localInstant)
{
// 1970-01-01 is day of week 4, Thursday.
long daysSince19700101;
long ticks = localInstant.Ticks;
if (ticks >= 0)
{
daysSince19700101 = ticks / NodaConstants.TicksPerStandardDay;
}
else
{
daysSince19700101 = (ticks - (NodaConstants.TicksPerStandardDay - 1)) / NodaConstants.TicksPerStandardDay;
if (daysSince19700101 < -3)
{
return(7 + (int)((daysSince19700101 + 4) % 7));
}
}
return(1 + (int)((daysSince19700101 + 3) % 7));
}
protected override int GetMonthOfYear(LocalInstant localInstant, int year)
{
// Perform a binary search to get the month. To make it go even faster,
// compare using ints instead of longs. The number of ticks per
// year exceeds the limit of a 32-bit int's capacity, so divide by
// 1024 * 10000. No precision is lost (except time of day) since the number of
// ticks per day contains 1024 * 10000 as a factor. After the division,
// the instant isn't measured in ticks, but in units of
// (128/125) seconds.
int i = (int)((((localInstant.Ticks - GetStartOfYearInTicks(year))) >> 10) / NodaConstants.TicksPerMillisecond);
return((IsLeapYear(year))
? ((i < 182 * 84375)
? ((i < 91 * 84375) ? ((i < 31 * 84375) ? 1 : (i < 60 * 84375) ? 2 : 3) : ((i < 121 * 84375) ? 4 : (i < 152 * 84375) ? 5 : 6))
: ((i < 274 * 84375)
? ((i < 213 * 84375) ? 7 : (i < 244 * 84375) ? 8 : 9)
: ((i < 305 * 84375) ? 10 : (i < 335 * 84375) ? 11 : 12)))
: ((i < 181 * 84375)
? ((i < 90 * 84375) ? ((i < 31 * 84375) ? 1 : (i < 59 * 84375) ? 2 : 3) : ((i < 120 * 84375) ? 4 : (i < 151 * 84375) ? 5 : 6))
: ((i < 273 * 84375)
? ((i < 212 * 84375) ? 7 : (i < 243 * 84375) ? 8 : 9)
: ((i < 304 * 84375) ? 10 : (i < 334 * 84375) ? 11 : 12))));
}
protected internal override int GetMonthOfYear(LocalInstant localInstant, int year)
{
// Perform a binary search to get the month. To make it go even faster,
// compare using ints instead of longs. The number of ticks per
// year exceeds the limit of a 32-bit int's capacity, so divide by
// 1024 * 10000. No precision is lost (except time of day) since the number of
// ticks per day contains 1024 * 10000 as a factor. After the division,
// the instant isn't measured in ticks, but in units of
// (128/125)seconds.
int i = (int)((((localInstant.Ticks - GetYearTicks(year))) >> 10) / NodaConstants.TicksPerMillisecond);
return (IsLeapYear(year))
? ((i < 182 * 84375)
? ((i < 91 * 84375) ? ((i < 31 * 84375) ? 1 : (i < 60 * 84375) ? 2 : 3) : ((i < 121 * 84375) ? 4 : (i < 152 * 84375) ? 5 : 6))
: ((i < 274 * 84375)
? ((i < 213 * 84375) ? 7 : (i < 244 * 84375) ? 8 : 9)
: ((i < 305 * 84375) ? 10 : (i < 335 * 84375) ? 11 : 12)))
: ((i < 181 * 84375)
? ((i < 90 * 84375) ? ((i < 31 * 84375) ? 1 : (i < 59 * 84375) ? 2 : 3) : ((i < 120 * 84375) ? 4 : (i < 151 * 84375) ? 5 : 6))
: ((i < 273 * 84375)
? ((i < 212 * 84375) ? 7 : (i < 243 * 84375) ? 8 : 9)
: ((i < 304 * 84375) ? 10 : (i < 334 * 84375) ? 11 : 12)));
}
/// <summary>
/// Change the year, maintaining month and day as well as possible. This doesn't
/// work in the same way as other calendars; see http://judaism.stackexchange.com/questions/39053
/// for the reasoning behind the rules.
/// </summary>
internal override LocalInstant SetYear(LocalInstant localInstant, int year)
{
long tickOfDay = TimeOfDayCalculator.GetTickOfDay(localInstant);
int absoluteSourceDay = AbsoluteDayFromLocalInstant(localInstant);
YearMonthDay ymd = HebrewScripturalCalculator.HebrewFromAbsolute(absoluteSourceDay);
int targetDay = ymd.Day;
int targetScripturalMonth = ymd.Month;
if (targetScripturalMonth == 13 && !IsLeapYear(year))
{
// If we were in Adar II and the target year is not a leap year, map to Adar.
targetScripturalMonth = 12;
}
else if (targetScripturalMonth == 12 && IsLeapYear(year) && !IsLeapYear(ymd.Year))
{
// If we were in Adar (non-leap year), go to Adar II rather than Adar I in a leap year.
targetScripturalMonth = 13;
}
// If we're aiming for the 30th day of Heshvan, Kislev or an Adar, it's possible that the change in year
// has meant the day becomes invalid. In that case, roll over to the 1st of the subsequent month.
if (targetDay == 30 && (targetScripturalMonth == 8 || targetScripturalMonth == 9 || targetScripturalMonth == 12))
{
if (HebrewScripturalCalculator.DaysInMonth(year, targetScripturalMonth) != 30)
{
targetDay = 1;
targetScripturalMonth++;
// From Adar, roll to Nisan.
if (targetScripturalMonth == 13)
{
targetScripturalMonth = 1;
}
}
}
int absoluteTargetDay = HebrewScripturalCalculator.AbsoluteFromHebrew(year, targetScripturalMonth, targetDay);
return(LocalInstantFromAbsoluteDay(absoluteTargetDay, tickOfDay));
}
public long Subtract(LocalInstant minuendInstant, LocalInstant subtrahendInstant)
{
int minuendYear = calculator.GetYear(minuendInstant);
int subtrahendYear = calculator.GetYear(subtrahendInstant);
int diff = minuendYear - subtrahendYear;
// If we just add the difference in years to subtrahendInstant, what do we get?
LocalInstant simpleAddition = Add(subtrahendInstant, diff);
if (subtrahendInstant <= minuendInstant)
{
// Moving forward: if the result of the simple addition is before or equal to the minuend,
// we're done. Otherwise, rewind a year because we've overshot.
return(simpleAddition <= minuendInstant ? diff : diff - 1);
}
else
{
// Moving backward: if the result of the simple addition (of a non-positive number)
// is after or equal to the minuend, we're done. Otherwise, increment by a year because
// we've overshot backwards.
return(simpleAddition >= minuendInstant ? diff : diff + 1);
}
}
/// <summary> /// Subtract subtrahendInstant from minuendInstant, in terms of months. /// </summary> internal abstract int MonthsBetween(LocalInstant minuendInstant, LocalInstant subtrahendInstant);
internal abstract LocalInstant SetYear(LocalInstant localInstant, int year);
internal abstract LocalInstant AddMonths(LocalInstant localInstant, int months);
internal static int GetClockHourOfHalfDay(LocalInstant localInstant)
{
int hourOfHalfDay = GetHourOfHalfDay(localInstant);
return(hourOfHalfDay == 0 ? 12 : hourOfHalfDay);
}
internal static int GetMillisecondOfSecond(LocalInstant localInstant)
{
return(GetMillisecondOfSecondFromTickOfDay(GetTickOfDay(localInstant)));
}
internal static int GetHourOfDay(LocalInstant localInstant)
{
return(GetHourOfDayFromTickOfDay(GetTickOfDay(localInstant)));
}
internal static int GetMinuteOfHour(LocalInstant localInstant)
{
return(GetMinuteOfHourFromTickOfDay(GetTickOfDay(localInstant)));
}
// TODO: addWrapField
internal override LocalInstant SetValue(LocalInstant localInstant, long value)
{
FieldUtils.VerifyValueBounds(this, value, GetMinimumValue(), GetMaximumValue());
long ticks = localInstant.Ticks;
return new LocalInstant(ticks + (value - GetInt64Value(localInstant)) * UnitTicks);
}
internal LocalInstantWrapper(LocalInstant value) => this.value = value;
public void GetZoneIntervals_WithinFirstWinter()
{
var winter = new LocalInstant(2000, 12, 1, 0, 0);
var pair = TestZone.GetZoneIntervals(winter);
Assert.AreEqual("Winter", pair.EarlyInterval.Name);
Assert.IsNull(pair.LateInterval);
}
internal override long GetInt64Value(LocalInstant localInstant)
{
long ticks = localInstant.Ticks;
return ticks >= 0 ? (ticks / UnitTicks) % effectiveRange : effectiveRange - 1 + (((ticks + 1) / UnitTicks) % effectiveRange);
}
internal int GetDayOfYear(LocalInstant localInstant)
{
return(GetDayOfYear(localInstant, GetYear(localInstant)));
}
internal static int GetSecondOfMinute(LocalInstant localInstant)
{
return(GetSecondOfMinuteFromTickOfDay(GetTickOfDay(localInstant)));
}
internal virtual int GetMonthOfYear(LocalInstant localInstant)
{
return(GetMonthOfYear(localInstant, GetYear(localInstant)));
}
internal static int GetMinuteOfDay(LocalInstant localInstant)
{
return((int)(GetTickOfDay(localInstant) / NodaConstants.TicksPerMinute));
}
/// <summary>
/// Returns the year-of-era for the given local instant. The base implementation is to return the plain
/// year, which is suitable for single-era calendars.
/// </summary>
internal virtual int GetYearOfEra(LocalInstant localInstant)
{
return(GetYear(localInstant));
}
internal static int GetHourOfHalfDay(LocalInstant localInstant)
{
return(GetHourOfDay(localInstant) % 12);
}
/// <summary>
/// Returns the era for the given local instant. The base implementation is to return 0, which is
/// suitable for single-era calendars.
/// </summary>
internal virtual int GetEra(LocalInstant localInstant)
{
return(0);
}
public void GetZoneIntervals_MiddleOfArbitraryAmbiguity()
{
var ambiguity = new LocalInstant(2010, 10, 5, 1, 30);
var pair = TestZone.GetZoneIntervals(ambiguity);
Assert.AreEqual("Summer", pair.EarlyInterval.Name);
Assert.AreEqual("Winter", pair.LateInterval.Name);
}
protected abstract int GetMonthOfYear(LocalInstant localInstant, int year);
internal static int GetMillisecondOfDay(LocalInstant localInstant)
{
return((int)(GetTickOfDay(localInstant) / NodaConstants.TicksPerMillisecond));
}
public void GetZoneIntervals_AfterArbitraryAmbiguity()
{
var unambiguousWinter = new LocalInstant(2010, 10, 5, 2, 0);
var pair = TestZone.GetZoneIntervals(unambiguousWinter);
Assert.AreEqual("Winter", pair.EarlyInterval.Name);
Assert.IsNull(pair.LateInterval);
}
