sekki24 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5bdf885e4ca0e21b77551f6427a178103ee21dbb51d90c20071ca6c49d7cdd57
+  data.tar.gz: 245dbf4c386e79531c8b80a3f211a556b6b1aeb1611c2658e9b7be7749319ee8
+SHA512:
+  metadata.gz: 31d2de370880b1412f61d9bd96363e633c7992e55fc21b152fa3df272411f50af4c6501eb7c78274f8df69b0e0563f2ce79696c923ad0fd2430ea97ecf939674
+  data.tar.gz: d284de5b5f90eceea4ff5e979d28caf76df77269cc1f6c8b308889e971cf307d327b11d7e01567752135437c5f3294068521e64c2dc2df41a43c62a0888bb25f

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Yudai Takada
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,190 @@
+# Sekki24
+
+[![CI](https://github.com/ydah/sekki24/actions/workflows/main.yml/badge.svg)](https://github.com/ydah/sekki24/actions/workflows/main.yml)
+
+Japanese seasonal and lunisolar calendar calculations in Ruby for 1900–2100.
+
+- 24 solar terms (二十四節気)
+- 72 microseasons (七十二候)
+- Supplementary observances (雑節)
+- New moons and Japanese lunisolar dates (旧暦)
+
+## Installation
+
+Sekki24 requires Ruby 3.0 or later.
+
+```bash
+gem install sekki24
+```
+
+Or add it to a bundle:
+
+```bash
+bundle add sekki24
+```
+
+## Usage
+
+### Solar terms
+
+```ruby
+require "sekki24"
+
+# UTC is used unless tz: is supplied.
+terms = Sekki24.year(2026, tz: "+09:00")
+terms.length # => 24
+
+risshun = Sekki24.term(2026, :risshun, tz: "+09:00")
+risshun.name_ja   # => "立春"
+risshun.reading   # => "りっしゅん"
+risshun.name_en   # => "Start of spring"
+risshun.name_zh   # => "立春"
+risshun.longitude # => 315
+risshun.time      # => 2026-02-04 05:02... +0900
+risshun.to_date   # => #<Date: 2026-02-04 ...>
+
+Sekki24.current(Time.now, tz: "+09:00")
+Sekki24.next_term(Time.now, tz: "+09:00")
+Sekki24.prev_term(Time.now, tz: "+09:00")
+Sekki24.on(Date.new(2026, 2, 4), tz: "+09:00") # => 立春
+```
+
+### Microseasons and observances
+
+```ruby
+microseasons = Sekki24.kou_year(2026, tz: "+09:00")
+microseasons.length # => 72
+
+first = Sekki24.kou(2026, 1, tz: "+09:00")
+first.name_ja # => "東風解凍"
+first.reading # => "はるかぜこおりをとく"
+
+observances = Sekki24.zassetsu_year(2026, tz: "+09:00")
+observances.length # => 14
+Sekki24.zassetsu(2026, :summer_doyo, tz: "+09:00")
+Sekki24.zassetsu_on(Date.new(2026, 2, 3), tz: "+09:00")
+```
+
+The 14 observances include four doyo periods, Setsubun, both Higan periods,
+Hachijuhachiya, Nyubai, Hangesho, Nihyakutoka, Nihyakuhatsuka, and both
+Shanichi days. Doyo and Higan include their complete date ranges.
+
+`kou_year` associates three microseasons with each solar term in the requested
+year. The final microseason can begin just after the Gregorian year boundary.
+
+### New moons and lunisolar dates
+
+```ruby
+Sekki24.new_moons(2026, tz: "+09:00")
+Sekki24.new_moon_before(Time.now)
+Sekki24.new_moon_after(Time.now)
+
+old_date = Sekki24.lunisolar(Date.new(2026, 2, 17), tz: "+09:00")
+old_date.year          # => 2026
+old_date.month_name_ja # => "正月"
+old_date.day           # => 1
+old_date.leap?         # => false
+
+Sekki24.lunisolar_year(2026, tz: "+09:00")
+Sekki24.gregorian(2026, 1, 1, tz: "+09:00") # => 2026-02-17
+```
+
+## API
+
+| Calendar | Methods on `Sekki24` |
+| --- | --- |
+| Solar terms | `year`, `term`, `current`, `next_term`, `prev_term`, `on` |
+| Microseasons | `kou_year`, `kou`, `current_kou`, `next_kou`, `prev_kou` |
+| Observances | `zassetsu_year`, `zassetsu`, `zassetsu_on`, `current_zassetsu` |
+| New moons | `new_moons`, `new_moon_before`, `new_moon_after`, `moon_longitude` |
+| Lunisolar calendar | `lunisolar`, `lunisolar_year`, `gregorian` |
+
+`Term`, `Kou`, `Zassetsu`, `Lunisolar::Date`, and `Lunisolar::Month` are
+immutable value objects with `#to_h`. `Term`, `Kou`, and `Zassetsu` also
+implement `Comparable`.
+
+## Timezones
+
+`tz:` accepts:
+
+- a UTC offset string such as `"+09:00"` or `"-08:00"`;
+- an offset in seconds such as `32_400`; or
+- an object responding to `utc_to_local(Time)`, such as a loaded
+  `TZInfo::Timezone` instance.
+
+Named-zone daylight-saving rules are used only when the caller supplies a
+timezone object.
+
+## Precision
+
+```ruby
+Sekki24.year(2026, precision: :precise) # default, within one minute
+Sekki24.year(2026, precision: :fast)    # approximately within 20 minutes
+```
+
+`:precise` is validated against the National Astronomical Observatory of Japan
+almanac. `precision:` applies to solar terms, microseasons, and supplementary
+observances. New-moon and lunisolar APIs always use the precise lunar model.
+
+Results are memoized. Use `Sekki24.clear_cache!` to clear all caches.
+
+## Command line
+
+The executable prints text by default and supports JSON output:
+
+```bash
+sekki24 2026 --tz +09:00
+sekki24 2026 --tz +09:00 --format json
+sekki24 2026 --tz +09:00 --calendar kou
+sekki24 2026 --tz +09:00 --calendar zassetsu
+sekki24 2026 --tz +09:00 --calendar new-moons
+sekki24 2026 --tz +09:00 --calendar lunisolar
+```
+
+Run `sekki24 --help` for every option.
+
+## Lunisolar calendar rules
+
+Lunisolar months begin on the local civil date containing a new moon. When 13
+months occur between winter-solstice months, the first month without a
+principal solar term becomes a leap month.
+
+For the ambiguous 2033 case, Sekki24 prioritizes the winter-solstice month and
+uses the recommended leap eleventh month. The selected rule is available as
+`Sekki24::Lunisolar::Calendar::LEAP_MONTH_RULE`.
+
+Gregorian conversion is supported from 1900-01-01 through 2100-12-31. Lunar
+year 1899 is accepted only because its final months overlap the start of that
+range.
+
+The historical Tenpo calendar was abolished in 1873. This API is a modern
+astronomical reconstruction of its lunisolar rules, not an official Japanese
+civil calendar.
+
+## Accuracy and implementation
+
+- UTC is converted to Terrestrial Time with the Espenak–Meeus ΔT polynomials.
+- Solar longitude uses the IMCCE VSOP87D Earth series in precise mode and the
+  Meeus Chapter 25 approximation in fast mode.
+- Lunar longitude uses the principal Meeus periodic terms.
+- Solar terms and new moons are solved numerically, with bisection fallbacks.
+
+Coefficients are embedded in the gem; no ephemeris or calendar data is fetched
+at runtime. Tests compare published solar terms, supplementary observances, and
+every 2026 new moon against National Astronomical Observatory of Japan values.
+They also cover all supported years, timezone boundaries, leap-month cases,
+and Gregorian/lunisolar round trips.
+
+## Development
+
+```bash
+bundle install
+bundle exec rake
+```
+
+CI tests Ruby 3.0, 3.2, 3.3, 3.4, 4.0, and Ruby head. actionlint and zizmor
+check the GitHub Actions workflows.
+
+## License
+
+Sekki24 is available under the [MIT License](LICENSE.txt).

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/exe/sekki24

@@ -0,0 +1,104 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "date"
+require "json"
+require "optparse"
+require "sekki24"
+
+options = {
+  timezone: Sekki24::DEFAULT_TIMEZONE,
+  precision: Sekki24::DEFAULT_PRECISION,
+  format: "text",
+  calendar: "terms"
+}
+
+parser = OptionParser.new do |command|
+  command.banner = "Usage: sekki24 [YEAR] [options]"
+  command.separator ""
+  command.separator "Calculate a Japanese seasonal or lunisolar calendar for a year."
+  command.separator ""
+  command.on("--tz OFFSET", 'UTC offset such as "+09:00" (default: +00:00)') do |value|
+    options[:timezone] = value
+  end
+  command.on("--precision MODE", %w[precise fast], "precise or fast (default: precise)") do |value|
+    options[:precision] = value.to_sym
+  end
+  command.on("--format FORMAT", %w[text json], "text or json (default: text)") do |value|
+    options[:format] = value
+  end
+  command.on(
+    "--calendar TYPE",
+    %w[terms kou zassetsu new-moons lunisolar],
+    "terms, kou, zassetsu, new-moons, or lunisolar"
+  ) do |value|
+    options[:calendar] = value
+  end
+  command.on("-v", "--version", "Print the version") do
+    puts Sekki24::VERSION
+    exit
+  end
+  command.on("-h", "--help", "Print this help") do
+    puts command
+    exit
+  end
+end
+
+begin
+  parser.parse!
+  raise OptionParser::InvalidArgument, "too many arguments" if ARGV.length > 1
+
+  year = ARGV.empty? ? Date.today.year : Integer(ARGV.first, 10)
+  records = case options[:calendar]
+            when "terms"
+              Sekki24.year(year, tz: options[:timezone], precision: options[:precision])
+            when "kou"
+              Sekki24.kou_year(year, tz: options[:timezone], precision: options[:precision])
+            when "zassetsu"
+              Sekki24.zassetsu_year(year, tz: options[:timezone], precision: options[:precision])
+            when "new-moons"
+              Sekki24.new_moons(year, tz: options[:timezone])
+            when "lunisolar"
+              Sekki24.lunisolar_year(year, tz: options[:timezone])
+            end
+
+  serialize = nil
+  serialize = lambda do |value|
+    case value
+    when Time then value.iso8601
+    when Date then value.iso8601
+    when Array then value.map { |entry| serialize.call(entry) }
+    when Hash then value.transform_values { |entry| serialize.call(entry) }
+    else value
+    end
+  end
+  hashes = records.map do |record|
+    hash = record.respond_to?(:to_h) ? record.to_h : { phase: :new_moon, time: record, date: record.to_date }
+    hash = hash.merge(date: record.to_date) if record.respond_to?(:to_date) && !hash.key?(:date)
+    serialize.call(hash)
+  end
+
+  if options[:format] == "json"
+    puts JSON.pretty_generate(hashes)
+  else
+    records.each do |record|
+      case options[:calendar]
+      when "terms"
+        puts format("%s  %s (%s)  %3d°", record.time.iso8601, record.name_ja, record.key, record.longitude)
+      when "kou"
+        puts format("%s  第%02d候 %s  %3d°", record.time.iso8601, record.ordinal, record.name_ja, record.longitude)
+      when "zassetsu"
+        period = record.date == record.end_date ? record.date.iso8601 : "#{record.date.iso8601}..#{record.end_date.iso8601}"
+        puts format("%-21s  %s (%s)", period, record.name_ja, record.key)
+      when "new-moons"
+        puts record.iso8601
+      when "lunisolar"
+        puts format("%d年%-4s  %s..%s  %d日", record.year, record.name_ja, record.start_date, record.end_date, record.length)
+      end
+    end
+  end
+rescue OptionParser::ParseError, ArgumentError, RangeError => error
+  warn "sekki24: #{error.message}"
+  warn parser
+  exit 1
+end

data/lib/sekki24/delta_t.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Sekki24
+  module DeltaT
+    module_function
+
+    # Espenak & Meeus polynomials. The return value is TT - UT in seconds.
+    def seconds(decimal_year)
+      year = Float(decimal_year)
+
+      case year
+      when 1860...1900 then between_1860_and_1900(year - 1860.0)
+      when 1900...1920 then between_1900_and_1920(year - 1900.0)
+      when 1920...1941 then between_1920_and_1941(year - 1920.0)
+      when 1941...1961 then between_1941_and_1961(year - 1950.0)
+      when 1961...1986 then between_1961_and_1986(year - 1975.0)
+      when 1986...2005 then between_1986_and_2005(year - 2000.0)
+      when 2005...2050 then between_2005_and_2050(year - 2000.0)
+      when 2050..2150 then between_2050_and_2150(year)
+      else
+        raise RangeError, "delta T is supported for years 1860..2150"
+      end
+    end
+
+    def between_1860_and_1900(t)
+      7.62 + (0.5737 * t) - (0.251754 * t**2) + (0.01680668 * t**3) -
+        (0.0004473624 * t**4) + (t**5 / 233_174.0)
+    end
+    private_class_method :between_1860_and_1900
+
+    def between_1900_and_1920(t)
+      -2.79 + (1.494119 * t) - (0.0598939 * t**2) + (0.0061966 * t**3) - (0.000197 * t**4)
+    end
+    private_class_method :between_1900_and_1920
+
+    def between_1920_and_1941(t)
+      21.20 + (0.84493 * t) - (0.0761 * t**2) + (0.0020936 * t**3)
+    end
+    private_class_method :between_1920_and_1941
+
+    def between_1941_and_1961(t)
+      29.07 + (0.407 * t) - (t**2 / 233.0) + (t**3 / 2547.0)
+    end
+    private_class_method :between_1941_and_1961
+
+    def between_1961_and_1986(t)
+      45.45 + (1.067 * t) - (t**2 / 260.0) - (t**3 / 718.0)
+    end
+    private_class_method :between_1961_and_1986
+
+    def between_1986_and_2005(t)
+      63.86 + (0.3345 * t) - (0.060374 * t**2) + (0.0017275 * t**3) +
+        (0.000651814 * t**4) + (0.00002373599 * t**5)
+    end
+    private_class_method :between_1986_and_2005
+
+    def between_2005_and_2050(t)
+      62.92 + (0.32217 * t) + (0.005589 * t**2)
+    end
+    private_class_method :between_2005_and_2050
+
+    def between_2050_and_2150(year)
+      -20.0 + (32.0 * ((year - 1820.0) / 100.0)**2) - (0.5628 * (2150.0 - year))
+    end
+    private_class_method :between_2050_and_2150
+  end
+end

data/lib/sekki24/finder.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module Sekki24
+  module Finder
+    MEAN_SOLAR_MOTION = 0.9856
+    DERIVATIVE_HALF_WINDOW = 1.0 / 24.0
+    ANGULAR_TOLERANCE = 1e-6
+    NEWTON_ATTEMPTS = 5
+    MAX_NEWTON_STEP = 5.0
+    BISECTION_ATTEMPTS = 80
+
+    class ConvergenceError < Sekki24::Error; end
+
+    module_function
+
+    def find(year:, longitude:, solar:)
+      start = TimeScale.utc_to_jde(Time.utc(Integer(year), 1, 1))
+      find_from(start, longitude, solar)
+    end
+
+    def find_after(time:, longitude:, solar:)
+      start = TimeScale.utc_to_jde(time)
+      find_from(start, longitude, solar)
+    end
+
+    def find_from(start, longitude, solar)
+      estimate = start + (positive_difference(longitude, solar.longitude(start)) / MEAN_SOLAR_MOTION)
+      root = newton(estimate, longitude, solar)
+      TimeScale.jde_to_utc(root)
+    end
+    private_class_method :find_from
+
+    def newton(estimate, target, solar)
+      jde = estimate
+
+      NEWTON_ATTEMPTS.times do
+        error = signed_difference(solar.longitude(jde), target)
+        return jde if error.abs < ANGULAR_TOLERANCE
+
+        derivative = numerical_derivative(jde, solar)
+        break unless derivative.finite? && derivative.positive?
+
+        step = error / derivative
+        break if step.abs > MAX_NEWTON_STEP
+
+        jde -= step
+      end
+
+      bisect(estimate, target, solar)
+    end
+    private_class_method :newton
+
+    def numerical_derivative(jde, solar)
+      before = solar.longitude(jde - DERIVATIVE_HALF_WINDOW)
+      after = solar.longitude(jde + DERIVATIVE_HALF_WINDOW)
+      signed_difference(after, before) / (2.0 * DERIVATIVE_HALF_WINDOW)
+    end
+    private_class_method :numerical_derivative
+
+    def bisect(estimate, target, solar)
+      radius = 2.0
+      lower, upper, lower_error, upper_error = bracket(estimate, target, solar, radius)
+
+      while lower_error * upper_error > 0.0 && radius < 32.0
+        radius *= 2.0
+        lower, upper, lower_error, upper_error = bracket(estimate, target, solar, radius)
+      end
+
+      if lower_error * upper_error > 0.0
+        raise ConvergenceError, "could not bracket solar longitude #{target}°"
+      end
+
+      BISECTION_ATTEMPTS.times do
+        midpoint = (lower + upper) / 2.0
+        midpoint_error = signed_difference(solar.longitude(midpoint), target)
+        return midpoint if midpoint_error.abs < ANGULAR_TOLERANCE
+
+        if lower_error * midpoint_error <= 0.0
+          upper = midpoint
+        else
+          lower = midpoint
+          lower_error = midpoint_error
+        end
+      end
+
+      (lower + upper) / 2.0
+    end
+    private_class_method :bisect
+
+    def bracket(estimate, target, solar, radius)
+      lower = estimate - radius
+      upper = estimate + radius
+      [
+        lower,
+        upper,
+        signed_difference(solar.longitude(lower), target),
+        signed_difference(solar.longitude(upper), target)
+      ]
+    end
+    private_class_method :bracket
+
+    def positive_difference(target, actual)
+      (Float(target) - actual) % 360.0
+    end
+    private_class_method :positive_difference
+
+    def signed_difference(left, right)
+      ((left - right + 180.0) % 360.0) - 180.0
+    end
+    private_class_method :signed_difference
+  end
+end

data/lib/sekki24/kou.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Sekki24
+  class Kou
+    include Comparable
+
+    ATTRIBUTES = %i[ordinal name_ja reading longitude term_key position time].freeze
+
+    attr_reader(*ATTRIBUTES)
+
+    def initialize(definition:, time:)
+      @ordinal = definition.ordinal
+      @name_ja = definition.name_ja
+      @reading = definition.reading
+      @longitude = definition.longitude
+      @term_key = definition.term_key
+      @position = definition.position
+      @time = time.dup.freeze
+      freeze
+    end
+
+    def <=>(other)
+      return unless other.respond_to?(:time)
+
+      time <=> other.time
+    end
+
+    def ==(other)
+      other.is_a?(Kou) && ordinal == other.ordinal && time == other.time
+    end
+    alias eql? ==
+
+    def hash
+      [self.class, ordinal, time].hash
+    end
+
+    def to_date
+      time.to_date
+    end
+
+    def to_h
+      ATTRIBUTES.to_h { |attribute| [attribute, public_send(attribute)] }
+    end
+
+    def inspect
+      "#<#{self.class} 第#{ordinal}候 #{name_ja} #{time.iso8601} longitude=#{longitude}°>"
+    end
+  end
+end

data/lib/sekki24/kou_names.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Sekki24
+  module KouNames
+    Definition = Struct.new(:ordinal, :name_ja, :reading, :longitude, :term_key, :position, keyword_init: true)
+
+    NAMES = [
+      ["東風解凍", "はるかぜこおりをとく"], ["黄鶯睍睆", "うぐいすなく"], ["魚上氷", "うおこおりをいずる"],
+      ["土脉潤起", "つちのしょううるおいおこる"], ["霞始靆", "かすみはじめてたなびく"], ["草木萌動", "そうもくめばえいずる"],
+      ["蟄虫啓戸", "すごもりむしとをひらく"], ["桃始笑", "ももはじめてさく"], ["菜虫化蝶", "なむしちょうとなる"],
+      ["雀始巣", "すずめはじめてすくう"], ["桜始開", "さくらはじめてひらく"], ["雷乃発声", "かみなりすなわちこえをはっす"],
+      ["玄鳥至", "つばめきたる"], ["鴻雁北", "こうがんかえる"], ["虹始見", "にじはじめてあらわる"],
+      ["葭始生", "あしはじめてしょうず"], ["霜止出苗", "しもやみてなえいずる"], ["牡丹華", "ぼたんはなさく"],
+      ["蛙始鳴", "かわずはじめてなく"], ["蚯蚓出", "みみずいずる"], ["竹笋生", "たけのこしょうず"],
+      ["蚕起食桑", "かいこおきてくわをはむ"], ["紅花栄", "べにばなさかう"], ["麦秋至", "むぎのときいたる"],
+      ["螳螂生", "かまきりしょうず"], ["腐草為螢", "くされたるくさほたるとなる"], ["梅子黄", "うめのみきばむ"],
+      ["乃東枯", "なつかれくさかるる"], ["菖蒲華", "あやめはなさく"], ["半夏生", "はんげしょうず"],
+      ["温風至", "あつかぜいたる"], ["蓮始開", "はすはじめてひらく"], ["鷹乃学習", "たかすなわちわざをならう"],
+      ["桐始結花", "きりはじめてはなをむすぶ"], ["土潤溽暑", "つちうるおうてむしあつし"], ["大雨時行", "たいうときどきふる"],
+      ["涼風至", "すずかぜいたる"], ["寒蝉鳴", "ひぐらしなく"], ["蒙霧升降", "ふかききりまとう"],
+      ["綿柎開", "わたのはなしべひらく"], ["天地始粛", "てんちはじめてさむし"], ["禾乃登", "こくものすなわちみのる"],
+      ["草露白", "くさのつゆしろし"], ["鶺鴒鳴", "せきれいなく"], ["玄鳥去", "つばめさる"],
+      ["雷乃収声", "かみなりすなわちこえをおさむ"], ["蟄虫坏戸", "むしかくれてとをふさぐ"], ["水始涸", "みずはじめてかるる"],
+      ["鴻雁来", "こうがんきたる"], ["菊花開", "きくのはなひらく"], ["蟋蟀在戸", "きりぎりすとにあり"],
+      ["霜始降", "しもはじめてふる"], ["霎時施", "こさめときどきふる"], ["楓蔦黄", "もみじつたきばむ"],
+      ["山茶始開", "つばきはじめてひらく"], ["地始凍", "ちはじめてこおる"], ["金盞香", "きんせんかさく"],
+      ["虹蔵不見", "にじかくれてみえず"], ["朔風払葉", "きたかぜこのはをはらう"], ["橘始黄", "たちばなはじめてきばむ"],
+      ["閉塞成冬", "そらさむくふゆとなる"], ["熊蟄穴", "くまあなにこもる"], ["鱖魚群", "さけのうおむらがる"],
+      ["乃東生", "なつかれくさしょうず"], ["麋角解", "さわしかのつのおつる"], ["雪下出麦", "ゆきわたりてむぎのびる"],
+      ["芹乃栄", "せりすなわちさかう"], ["水泉動", "しみずあたたかをふくむ"], ["雉始雊", "きじはじめてなく"],
+      ["款冬華", "ふきのはなさく"], ["水沢腹堅", "さわみずこおりつめる"], ["鶏始乳", "にわとりはじめてとやにつく"]
+    ].map(&:freeze).freeze
+
+    POSITIONS = %i[initial secondary final].freeze
+
+    TERMS = Names::TERMS.each_with_index.flat_map do |term, term_index|
+      3.times.map do |position_index|
+        ordinal = (term_index * 3) + position_index + 1
+        name_ja, reading = NAMES.fetch(ordinal - 1)
+        Definition.new(
+          ordinal: ordinal,
+          name_ja: name_ja,
+          reading: reading,
+          longitude: (term.longitude + (position_index * 5)) % 360,
+          term_key: term.key,
+          position: POSITIONS.fetch(position_index)
+        ).freeze
+      end
+    end.freeze
+
+    BY_ORDINAL = TERMS.to_h { |definition| [definition.ordinal, definition] }.freeze
+    module_function
+
+    def fetch(ordinal)
+      BY_ORDINAL.fetch(Integer(ordinal))
+    rescue ArgumentError, TypeError, KeyError
+      raise ArgumentError, "kou ordinal must be between 1 and 72"
+    end
+  end
+end