zmanim 0.1.0

data/lib/zmanim/hebrew_calendar/jewish_calendar.rb

@@ -0,0 +1,390 @@
+require_relative 'jewish_date'
+
+module Zmanim::HebrewCalendar
+  class JewishCalendar < JewishDate
+    attr_accessor :in_israel, :use_modern_holidays
+
+    SIGNIFICANT_DAYS = %i(erev_rosh_hashana rosh_hashana tzom_gedalyah erev_yom_kippur yom_kippur
+                          erev_succos succos chol_hamoed_succos hoshana_rabbah shemini_atzeres simchas_torah
+                          chanukah tenth_of_teves tu_beshvat
+                          taanis_esther purim shushan_purim purim_katan shushan_purim_katan
+                          erev_pesach pesach chol_hamoed_pesach pesach_sheni erev_shavuos shavuos
+                          seventeen_of_tammuz tisha_beav tu_beav
+                          yom_hashoah yom_hazikaron yom_haatzmaut yom_yerushalayim)
+
+    SIGNIFICANT_TEFILOS = %i(yaaleh_veyavo al_hanissim begin_mashiv_haruach end_mashiv_haruach mashiv_haruach begin_morid_hatal morid_hatal vesein_tal_umatar vesein_beracha atah_yatzarta borchi_nafshi)
+
+    SIGNIFICANT_SHABBOS = %i(parshas_shekalim parshas_zachor parshas_parah parshas_hachodesh shabbos_hagadol shabbos_shuva)
+
+    def initialize(*args)
+      if args.count == 4
+        super(*args[0..2])
+      else
+        super
+      end
+      @in_israel = !!args[3]
+      @use_modern_holidays = false
+    end
+
+    def significant_day
+      send("#{jewish_month_name}_significant_day")
+    end
+
+    def yom_tov?
+      sd = significant_day
+      sd && !sd.to_s.start_with?('erev_') && (!taanis? || sd == :yom_kippur)
+    end
+
+    def yom_tov_assur_bemelacha?
+      %i(pesach shavuos rosh_hashana yom_kippur succos shemini_atzeres simchas_torah).include?(significant_day)
+    end
+
+    def chol_hamoed?
+      sd = significant_day
+      sd && (sd.to_s.start_with?('chol_hamoed_') || sd == :hoshana_rabbah)
+    end
+
+    def erev_yom_tov?
+      return false unless sd = significant_day
+      sd.to_s.start_with?('erev_') || sd == :hoshana_rabbah ||
+          (sd == :chol_hamoed_pesach && jewish_day == 20)
+    end
+
+    def taanis?
+      %i(seventeen_of_tammuz tisha_beav tzom_gedalyah yom_kippur tenth_of_teves taanis_esther).include?(significant_day)
+    end
+
+    def rosh_chodesh?
+      jewish_day == 30 || (jewish_day == 1 && jewish_month != 7)
+    end
+
+    def erev_rosh_chodesh?
+      jewish_day == 29 && jewish_month != 6
+    end
+
+    def chanukah?
+      significant_day == :chanukah
+    end
+
+    def day_of_chanukah
+      return unless chanukah?
+      if jewish_month_name == :kislev
+        jewish_day - 24
+      else
+        (kislev_short? ? 5 : 6) + jewish_day
+      end
+    end
+
+    def day_of_omer
+      case jewish_month_name
+        when :nissan
+          return (jewish_day - 15 if jewish_day > 15)
+        when :iyar
+          return jewish_day + 15
+        when :sivan
+          return (jewish_day + 44) if jewish_day < 6
+      end
+    end
+
+    # DateTime for molad as UTC
+    def molad_as_datetime
+      m = molad
+      location_name = 'Jerusalem, Israel'
+      latitude = 31.778   # Har Habayis latitude
+      longitude = 35.2354 # Har Habayis longitude
+      tz = TZInfo::Timezone.get('Asia/Jerusalem')
+
+      geo = Zmanim::Util::GeoLocation.new(location_name, latitude, longitude, tz)
+      seconds = (m.molad_chalakim * 10) / 3.0
+      # molad as local mean time
+      time = DateTime.new(m.gregorian_year, m.gregorian_month, m.gregorian_day,
+                          m.molad_hours, m.molad_minutes, seconds, '+2')
+      offset_hours = geo.local_mean_time_offset / Zmanim::AstronomicalCalendar::HOUR_MILLIS.to_f
+      # molad as Jerusalem standard time
+      time -= offset_hours / 24.0
+      # molad as UTC
+      time.new_offset(0)
+    end
+
+    def techilas_zman_kiddush_levana_3_days
+      molad_as_datetime + 3
+    end
+
+    def techilas_zman_kiddush_levana_7_days
+      molad_as_datetime + 7
+    end
+
+    def sof_zman_kiddush_levana_between_moldos
+      half_molad_in_days = CHALAKIM_PER_MONTH.to_f / (1080 * 24 * 2)
+      molad_as_datetime + half_molad_in_days
+    end
+
+    def sof_zman_kiddush_levana_15_days
+      molad_as_datetime + 15
+    end
+
+    def daf_yomi_bavli
+      Zmanim::Limudim::Calculators::DafYomiBavli.new.limud(self)
+    end
+
+    def daf_yomi_yerushalmi
+      Zmanim::Limudim::Calculators::DafYomiYerushalmi.new.limud(self)
+    end
+
+    def parshas_hashavua
+      Zmanim::Limudim::Calculators::Parsha.new(in_israel: in_israel).limud(self)
+    end
+
+    def tehillim_portion
+      Zmanim::Limudim::Calculators::TehillimMonthly.new.limud(self)
+    end
+
+    def mishna_yomis
+      Zmanim::Limudim::Calculators::MishnaYomis.new.limud(self)
+    end
+
+    def tefilah_additions(walled_city: false, nusach: :ashkenaz)
+      additions = []
+      if mashiv_haruach_starts?
+        additions << :begin_mashiv_haruach
+      elsif mashiv_haruach_ends?
+        additions << (nusach == :sefard ? :begin_morid_hatal : :end_mashiv_haruach)
+      else
+        additions << :mashiv_haruach if mashiv_haruach?
+        additions << :morid_hatal if nusach == :sefard && morid_hatal?
+      end
+      additions << :vesein_beracha if vesein_beracha?
+      additions << :vesein_tal_umatar if vesein_tal_umatar?
+      additions << :atah_yatzarta if day_of_week == 7 && rosh_chodesh?
+      additions << :yaaleh_veyavo if yaaleh_veyavo?
+      additions << :al_hanissim if al_hanissim?(walled_city)
+      additions << :borchi_nafshi if rosh_chodesh?
+      additions
+    end
+
+    def significant_shabbos
+      return nil unless day_of_week == 7
+      if jewish_month == 1
+        if jewish_day == 1
+          :parshas_hachodesh
+        elsif jewish_day.between?(8,14)
+          :shabbos_hagadol
+        end
+      elsif jewish_month == 7 && jewish_day.between?(3,9)
+        :shabbos_shuva
+      elsif jewish_month == months_in_jewish_year - 1 && jewish_day.between?(25,30)
+        :parshas_shekalim
+      elsif jewish_month == months_in_jewish_year
+        if jewish_day == 1
+          :parshas_shekalim
+        elsif jewish_day.between?(7, 13)
+          :parshas_zachor
+        elsif jewish_day.between?(17,23)
+          :parshas_parah
+        elsif jewish_day.between?(24,29)
+          :parshas_hachodesh
+        end
+      end
+    end
+
+    def mashiv_haruach_starts?
+      jewish_month == 7 && jewish_day == 22
+    end
+
+    def mashiv_haruach_ends?
+      jewish_month == 1 && jewish_day == 15
+    end
+
+    def mashiv_haruach?
+      start_date = JewishDate.new(jewish_year, 7, 22)
+      end_date = JewishDate.new(jewish_year, 1, 15)
+      self.between?(start_date, end_date)
+    end
+
+    def morid_hatal?
+      !mashiv_haruach? || mashiv_haruach_starts? || mashiv_haruach_ends?
+    end
+
+    # This presumes the evenings of December 4/5 are always the initial start date outside of Israel
+    # Because the jewish date does not auto-increment in the evening, we use December 5/6 as the start date
+    # and rely on the user to increment the jewish date after nightfall.
+    # Note that according to many, the date for Vesein Tal Umatar is tied to the Julian calendar and has historically
+    # moved over time as the deviance from the Gregorian calendar increases.  The date of December 4/5 is to be used
+    # for the 20th and 21st century.
+    def vesein_tal_umatar?
+      return false if day_of_week == 7 || yom_tov_assur_bemelacha?
+      start_date = JewishDate.new(jewish_year, 8, 7)
+      start_date.set_gregorian_date(start_date.gregorian_year, 12, gregorian_leap_year?(start_date.gregorian_year+1) ? 6 : 5) unless in_israel
+      end_date = JewishDate.new(jewish_year, 1, 15)
+      self.between?(start_date, end_date)
+    end
+
+    def vesein_beracha?
+      return false if day_of_week == 7 || yom_tov_assur_bemelacha?
+      !vesein_tal_umatar?
+    end
+
+    def yaaleh_veyavo?
+      rosh_chodesh? || chol_hamoed? || yom_tov_assur_bemelacha?
+    end
+
+    def al_hanissim?(walled_city=false)
+      purim_day = walled_city ? :shushan_purim : :purim
+      [:chanukah, purim_day].include?(significant_day)
+    end
+
+    private
+
+    def nissan_significant_day
+      pesach = [15, 21]
+      pesach |= [16, 22] unless in_israel
+      chol_hamoed_pesach = (16..20)
+      if jewish_day == 14
+        :erev_pesach
+      elsif pesach.include? jewish_day
+        :pesach
+      elsif chol_hamoed_pesach.include? jewish_day
+        :chol_hamoed_pesach
+      elsif use_modern_holidays
+        if (jewish_day == 26 && day_of_week == 5) ||
+           (jewish_day == 27 && ![1,6].include?(day_of_week)) ||
+           (jewish_day == 28 && day_of_week == 2)
+          :yom_hashoah
+        end
+      end
+    end
+
+    def iyar_significant_day
+      if jewish_day == 14
+        :pesach_sheni
+      elsif use_modern_holidays
+        # Note that this logic follows the current rules, which were last revised in 5764.
+        # The calculations for years prior may not reflect the actual dates observed at that time.
+        if ([2,3].include?(jewish_day) && day_of_week == 4) ||
+           (jewish_day == 4 && day_of_week == 3) ||
+           (jewish_day == 5 && day_of_week == 2)
+          :yom_hazikaron
+        elsif ([3,4].include?(jewish_day) && day_of_week == 5) ||
+              (jewish_day == 5 && day_of_week == 4) ||
+              (jewish_day == 6 && day_of_week == 3)
+          :yom_haatzmaut
+        elsif jewish_day == 28
+          :yom_yerushalayim
+        end
+      end
+    end
+
+    def sivan_significant_day
+      shavuos = [6]
+      shavuos << 7 unless in_israel
+      if jewish_day == 5
+        :erev_shavuos
+      elsif shavuos.include?(jewish_day)
+        :shavuos
+      end
+    end
+
+    def tammuz_significant_day
+      if (jewish_day == 17 && day_of_week != 7) ||
+         (jewish_day == 18 && day_of_week == 1)
+        :seventeen_of_tammuz
+      end
+    end
+
+    def av_significant_day
+      if (jewish_day == 9 && day_of_week != 7) ||
+         (jewish_day == 10 && day_of_week == 1)
+        :tisha_beav
+      elsif jewish_day == 15
+        :tu_beav
+      end
+    end
+
+    def elul_significant_day
+      if jewish_day == 29
+        :erev_rosh_hashana
+      end
+    end
+
+    def tishrei_significant_day
+      succos = [15]
+      succos << 16 unless in_israel
+      chol_hamoed_succos = (16..20)
+      if [1,2].include? jewish_day
+        :rosh_hashana
+      elsif (jewish_day == 3 && day_of_week != 7) ||
+            (jewish_day == 4 && day_of_week == 1)
+        :tzom_gedalyah
+      elsif jewish_day == 9
+        :erev_yom_kippur
+      elsif jewish_day == 10
+        :yom_kippur
+      elsif jewish_day == 14
+        :erev_succos
+      elsif succos.include?(jewish_day)
+        :succos
+      elsif chol_hamoed_succos.include?(jewish_day)
+        :chol_hamoed_succos
+      elsif jewish_day == 21
+        :hoshana_rabbah
+      elsif jewish_day == 22
+        :shemini_atzeres
+      elsif jewish_day == 23 && !in_israel
+        :simchas_torah
+      end
+    end
+
+    def cheshvan_significant_day
+      nil
+    end
+
+    def kislev_significant_day
+      if jewish_day >= 25
+        :chanukah
+      end
+    end
+
+    def teves_significant_day
+      chanukah = [1,2]
+      chanukah << 3 if kislev_short?
+      if chanukah.include?(jewish_day)
+        :chanukah
+      elsif jewish_day == 10
+        :tenth_of_teves
+      end
+    end
+
+    def shevat_significant_day
+      if jewish_day == 15
+        :tu_beshvat
+      end
+    end
+
+    def adar_significant_day
+      if jewish_leap_year?
+        if jewish_day == 14
+          :purim_katan
+        elsif jewish_day == 15
+          :shushan_purim_katan
+        end
+      else
+        purim_significant_day
+      end
+    end
+
+    def adar_ii_significant_day
+      purim_significant_day
+    end
+
+    def purim_significant_day
+      if (jewish_day == 13 && day_of_week != 7) ||
+          (jewish_day == 11 && day_of_week == 5)
+        :taanis_esther
+      elsif jewish_day == 14
+        :purim
+      elsif jewish_day == 15
+        :shushan_purim
+      end
+    end
+  end
+end

data/lib/zmanim/hebrew_calendar/jewish_date.rb

@@ -0,0 +1,397 @@
+module Zmanim::HebrewCalendar
+  class JewishDate
+    include Comparable
+
+    MONTHS = %i(nissan iyar sivan tammuz av elul tishrei cheshvan kislev teves shevat adar adar_ii)
+
+    RD = Date.new(1,1,1, Date::GREGORIAN)
+    JEWISH_EPOCH = -1373429     # 1 Tishrei of year 1 (Shnas Tohu)
+                                # Note that while the Gregorian year will be calculated as -3760, the actual year is -3761BCE
+                                # This discrepancy is due to the presence of a year 0 in the Ruby implementation
+
+    CHALAKIM_PER_MINUTE = 18
+    CHALAKIM_PER_HOUR = CHALAKIM_PER_MINUTE * 60
+    CHALAKIM_PER_DAY = CHALAKIM_PER_HOUR * 24
+    CHALAKIM_PER_MONTH = (CHALAKIM_PER_DAY * 29.5).to_i + 793
+
+    CHALAKIM_MOLAD_TOHU = CHALAKIM_PER_DAY + (CHALAKIM_PER_HOUR * 5) + 204
+
+    CHESHVAN_KISLEV_KEVIAH = %i(chaseirim kesidran shelaimim)
+
+    attr_reader :molad_hours, :molad_minutes, :molad_chalakim
+    attr_reader :jewish_year, :jewish_month, :jewish_day, :day_of_week, :gregorian_date
+
+    def initialize(*args)
+      if args.size == 0
+        reset_date!
+      elsif args.size == 3
+        set_jewish_date(*args)
+      elsif args.size == 1 && args.first.is_a?(Date)
+        self.date = args.first
+      elsif args.size == 1 && args.first.is_a?(Numeric)
+        set_from_molad(args.first)
+      else
+        raise ArgumentError
+      end
+    end
+
+    def self.from_molad(molad)
+      new(molad)
+    end
+
+    def self.from_jewish_date(year, month, day)
+      new(year, month, day)
+    end
+
+    def self.from_date(date)
+      new(date)
+    end
+
+    def reset_date!
+      self.date = Date.today
+      self
+    end
+
+    def date=(date)
+      @gregorian_date = date.gregorian
+      @absolute_date = gregorian_date_to_abs_date(gregorian_date)
+      reset_day_of_week
+      @molad_hours = @molad_minutes = @molad_chalakim = 0
+      @jewish_year, @jewish_month, @jewish_day = jewish_date_from_abs_date(@absolute_date)
+    end
+
+    def set_gregorian_date(year, month, day)
+      raise ArgumentError if year < -3760 || month < 1 || month > 12 || day < 1 || day > 31
+      if day > (max_days = days_in_gregorian_month(month, year))
+        day = max_days
+      end
+      self.date = Date.new(year, month, day, Date::GREGORIAN)
+    end
+
+    def set_jewish_date(year, month, day, hours=0, minutes=0, chalakim=0)
+      raise ArgumentError if year < 1 || month < 1 || month > 13 || day < 1 || day > 30 ||
+          hours < 0 || hours > 23 || minutes < 0 || minutes > 59  || chalakim < 0 || chalakim > 17
+      if month > (max_months = months_in_jewish_year(year))
+        month = max_months
+      end
+      if day > (max_days = days_in_jewish_month(month, year))
+        day = max_days
+      end
+      self.date = gregorian_date_from_abs_date(jewish_date_to_abs_date(year, month, day))
+      @molad_hours, @molad_minutes, @molad_chalakim = hours, minutes, chalakim
+    end
+
+    def forward!(increment=1)
+      return back!(-increment) if increment < 0
+      if increment > 500
+        self.date = gregorian_date + increment
+        return self
+      end
+      days_of_year = sorted_days_in_jewish_year
+      y, m, d = jewish_year, jewish_month, jewish_day
+      d += increment
+      while d > (days_in_month = days_of_year.assoc(m)[1]) do
+        d -= days_in_month
+        m += 1
+        m = 1 if m > days_of_year.length
+        if m == 7
+          y += 1
+          days_of_year = sorted_days_in_jewish_year(y)
+        end
+      end
+      @gregorian_date += increment
+      @absolute_date += increment
+      reset_day_of_week
+      @jewish_year, @jewish_month, @jewish_day = y, m, d
+      self
+    end
+
+    def back!(decrement=1)
+      return forward!(-decrement) if decrement < 0
+      if decrement > 500
+        self.date = gregorian_date - decrement
+        return self
+      end
+      days_of_year = sorted_days_in_jewish_year
+      y, m, d = jewish_year, jewish_month, jewish_day
+      d -= decrement
+      while d <= 0 do
+        m -= 1
+        m = days_of_year.length if m == 0
+        if m == 6
+          y -= 1
+          days_of_year = sorted_days_in_jewish_year(y)
+        end
+        days_in_month = days_of_year.assoc(m)[1]
+        d += days_in_month
+      end
+      @gregorian_date -= decrement
+      @absolute_date -= decrement
+      reset_day_of_week
+      @jewish_year, @jewish_month, @jewish_day = y, m, d
+      self
+    end
+
+    def +(addend)
+      raise ArgumentError unless addend.is_a?(Numeric)
+      self.dup.forward!(addend)
+    end
+
+    def -(subtrahend)
+      if subtrahend.is_a?(Numeric)
+        self.dup.back!(subtrahend)
+      elsif subtrahend.is_a?(JewishDate)
+        absolute_date - subtrahend.send(:absolute_date)
+      elsif subtrahend.respond_to?(:to_date)
+        gregorian_date - subtrahend.to_date
+      else
+        raise ArgumentError
+      end
+    end
+
+    def <=>(other)
+      if other.is_a?(JewishDate)
+        gregorian_date <=> other.gregorian_date
+      else
+        gregorian_date <=> other
+      end
+    end
+
+    def gregorian_year=(year)
+      set_gregorian_date(year, gregorian_month, gregorian_day)
+    end
+
+    def gregorian_year
+      gregorian_date.year
+    end
+
+    def gregorian_month=(month)
+      set_gregorian_date(gregorian_year, month, gregorian_day)
+    end
+
+    def gregorian_month
+      gregorian_date.month
+    end
+
+    def gregorian_day=(day)
+      set_gregorian_date(gregorian_year, gregorian_month, day)
+    end
+
+    def gregorian_day
+      gregorian_date.day
+    end
+
+    def days_in_gregorian_year(year=gregorian_year)
+      gregorian_leap_year?(year) ? 366 : 365
+    end
+
+    def days_in_gregorian_month(month=gregorian_month, year=gregorian_year)
+      case month
+        when 2
+          gregorian_leap_year?(year) ? 29 : 28
+        when 4, 6, 9, 11
+          30
+        else
+          31
+      end
+    end
+
+    def gregorian_leap_year?(year=gregorian_year)
+      (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)
+    end
+
+    def jewish_year=(year)
+      set_jewish_date(year, jewish_month, jewish_day)
+    end
+
+    def jewish_month=(month)
+      set_jewish_date(jewish_year, month, jewish_day)
+    end
+
+    def jewish_day=(day)
+      set_jewish_date(jewish_year, jewish_month, day)
+    end
+
+    def days_in_jewish_year(year=jewish_year)
+      jewish_calendar_elapsed_days(year+1) - jewish_calendar_elapsed_days(year)
+    end
+
+    def months_in_jewish_year(year=jewish_year)
+      jewish_leap_year?(year) ? 13 : 12
+    end
+
+    # Returns the list of jewish months for a given jewish year in chronological order
+    #   sorted_months_in_jewish_year(5779)
+    #   => [7, 8, 9, 10, 11, 12, 13, 1, 2, 3, 4, 5, 6]
+    def sorted_months_in_jewish_year(year=jewish_year)
+      (1..months_in_jewish_year(year)).sort_by{|y| [y >= 7 ? 0 : 1, y]}
+    end
+
+    # Returns the number of days in each jewish month for a given jewish year in chronological order
+    #   sorted_days_in_jewish_year(5779)
+    #   => [[7, 30], [8, 29], [9, 30], [10, 29], [11, 30], [12, 30], [13, 29], [1, 30], [2, 29], [3, 30], [4, 29], [5, 30], [6, 29]]
+    def sorted_days_in_jewish_year(year=jewish_year)
+      sorted_months_in_jewish_year(year).map{|month| [month, days_in_jewish_month(month, year)]}
+    end
+
+    def days_in_jewish_month(month=jewish_month, year=jewish_year)
+      m = jewish_month_name(month)
+      if %i(iyar tammuz elul teves adar_ii).include?(m) ||
+          (m == :cheshvan && cheshvan_short?(year)) ||
+          (m == :kislev && kislev_short?(year)) ||
+          (m == :adar && !jewish_leap_year?(year))
+        29
+      else
+        30
+      end
+    end
+
+    def day_number_of_jewish_year(year=jewish_year, month=jewish_month, day=jewish_day)
+      month_index = month_number_from_tishrei(year, month) - 1
+      day + sorted_months_in_jewish_year(year)[0...month_index].sum{|m| days_in_jewish_month(m, year)}
+    end
+
+    def jewish_leap_year?(year=jewish_year)
+      ((7 * year) + 1) % 19 < 7
+    end
+
+    def cheshvan_long?(year=jewish_year)
+      days_in_jewish_year(year) % 10 == 5
+    end
+
+    def cheshvan_short?(year=jewish_year)
+      !cheshvan_long?(year)
+    end
+
+    def kislev_long?(year=jewish_year)
+      !kislev_short?(year)
+    end
+
+    def kislev_short?(year=jewish_year)
+      days_in_jewish_year(year) % 10 == 3
+    end
+
+    def cheshvan_kislev_kviah(year=jewish_year)
+      CHESHVAN_KISLEV_KEVIAH[(days_in_jewish_year(year) % 10) - 3]
+    end
+
+    # Returns a new JewishDate as the molad for given month
+    def molad(month=jewish_month, year=jewish_year)
+      self.class.from_molad(chalakim_since_molad_tohu(year, month))
+    end
+
+    def jewish_month_from_name(month_name)
+      MONTHS.index(month_name) + 1
+    end
+
+    def jewish_month_name(month=jewish_month)
+      MONTHS[month - 1]
+    end
+
+    private
+
+    attr_accessor :absolute_date
+    attr_writer :gregorian_date
+
+    def set_from_molad(molad)
+      gregorian_date = gregorian_date_from_abs_date(molad_to_abs_date(molad))
+      remainder = molad % CHALAKIM_PER_DAY
+      molad_hours, remainder = remainder.divmod CHALAKIM_PER_HOUR
+      # molad hours start at 18:00, which means that
+      # we cross a secular date boundary if hours are 6 or greater
+      gregorian_date += 1 if molad_hours >= 6
+      self.date = gregorian_date
+      # Normalize hours to start at 00:00
+      @molad_hours = (molad_hours + 18) % 24
+      @molad_minutes, @molad_chalakim = remainder.divmod CHALAKIM_PER_MINUTE
+      self
+    end
+
+    def month_number_from_tishrei(year, month)
+      leap = jewish_leap_year?(year)
+      1 + ((month + (leap ? 6 : 5)) % (leap ? 13 : 12))
+    end
+
+    def dechiyos_count(year, days, remainder)
+      count = 0
+      # 'days' is Monday-based due to start of Molad at BaHaRaD
+      # add 1 to convert to Sunday-based, '0' represents Shabbos
+      rosh_hashana_day = (days+1) % 7
+      if (remainder >= 19440) ||
+          ((rosh_hashana_day == 3) && (remainder >= 9924) && !jewish_leap_year?(year)) ||
+          ((rosh_hashana_day == 2) && (remainder >= 16789) && jewish_leap_year?(year-1))
+        count = 1
+      end
+      count += 1 if [1, 4, 6].include?((rosh_hashana_day+count) % 7)
+      count
+    end
+
+    def molad_components_for_year(year)
+      chalakim = chalakim_since_molad_tohu(year, 7)  # chalakim up to tishrei of given year
+      chalakim.divmod(CHALAKIM_PER_DAY)
+    end
+
+    def jewish_calendar_elapsed_days(year)
+      days, remainder = molad_components_for_year(year)
+      days + dechiyos_count(year, days, remainder)
+    end
+
+    def chalakim_since_molad_tohu(year=jewish_year, month=jewish_month)
+      prev_year = year - 1
+      months = month_number_from_tishrei(year, month) - 1
+      cycles, remainder = prev_year.divmod(19)
+      months += (235 * cycles) +
+          (12 * remainder) +
+          (((7 * remainder) + 1) / 19)
+      CHALAKIM_MOLAD_TOHU + (CHALAKIM_PER_MONTH * months)
+    end
+
+    def jewish_date_to_abs_date(year, month, day)
+      day_number_of_jewish_year(year, month, day) +
+          jewish_year_start_to_abs_date(year) - 1
+    end
+
+    def jewish_year_start_to_abs_date(year)
+      jewish_calendar_elapsed_days(year) + JEWISH_EPOCH + 1
+    end
+
+   def jewish_date_from_abs_date(absolute_date)
+      jewish_year = (absolute_date - JEWISH_EPOCH) / 366
+
+      # estimate may be low for CE
+      while absolute_date >= jewish_year_start_to_abs_date(jewish_year+1) do
+        jewish_year += 1
+      end
+
+      # estimate may be high for BCE
+      while absolute_date < jewish_year_start_to_abs_date(jewish_year) do
+        jewish_year -= 1
+      end
+
+      months = sorted_months_in_jewish_year(jewish_year)
+      jewish_month = months[0..-2].detect.with_index do |m, i|
+        absolute_date < jewish_date_to_abs_date(jewish_year, months[i+1], 1)
+      end || months.last
+
+      jewish_day = absolute_date - jewish_date_to_abs_date(jewish_year, jewish_month, 1) + 1
+
+      [jewish_year, jewish_month, jewish_day]
+    end
+
+    def molad_to_abs_date(chalakim)
+      (chalakim / CHALAKIM_PER_DAY) + JEWISH_EPOCH
+    end
+
+    def gregorian_date_from_abs_date(absolute_date)
+      RD + (absolute_date - 1)
+    end
+
+    def gregorian_date_to_abs_date(date)
+      (date - RD).to_i + 1
+    end
+
+    def reset_day_of_week
+      @day_of_week = (gregorian_date.cwday % 7) + 1   # 1-based starting with Sunday
+    end
+  end
+end