diff --git a/Sources/KosherSwift/ZmanimCalendar.swift b/Sources/KosherSwift/ZmanimCalendar.swift
index f7ddf88..7400097 100644
--- a/Sources/KosherSwift/ZmanimCalendar.swift
+++ b/Sources/KosherSwift/ZmanimCalendar.swift
@@ -10,8 +10,8 @@ import Foundation
/**
* The ZmanimCalendar is a specialized calendar that can calculate sunrise, sunset and Jewish zmanim
* (religious times) for prayers and other Jewish religious duties. This class contains the main functionality of the
- * Zmanim library. For a much more extensive list of zmanim, use the``ComplexZmanimCalendar`` that
- * extends this class. See documentation for the``ComplexZmanimCalendar`` and ``AstronomicalCalendar`` for
+ * Zmanim library. For a much more extensive list of zmanim, use the ``ComplexZmanimCalendar`` that
+ * extends this class. See documentation for the ``ComplexZmanimCalendar`` and ``AstronomicalCalendar`` for
* simple examples on using the API.
* Elevation based zmanim (even sunrise and sunset) should not be used lekula without the guidance
* of a posek. According to Rabbi Dovid Yehudah Bursztyn in his
@@ -24,12 +24,12 @@ import Foundation
* "https://www.worldcat.org/oclc/919472094">Shimush Zekeinim, Ch. 1, page 17 states that obstructing horizons should
* be factored into zmanim calculations. The setting defaults to false (elevation will not be used for
* zmanim calculations besides sunrise and sunset), unless the setting is changed to true in
- * ``setUseElevation()``. This will impact sunrise and sunset-based zmanim such as ``getSunrise()``,
+ * ``setUseElevation(useElevation:)``. This will impact sunrise and sunset-based zmanim such as ``getSunrise()``,
* ``getSunset()``, ``getSofZmanShmaGRA()``, alos-based zmanim such as ``getSofZmanShmaMGA()``
* that are based on a fixed offset of sunrise or sunset and zmanim based on a percentage of the day such as
- * {@link ComplexZmanimCalendar#getSofZmanShmaMGA90MinutesZmanis()} that are based on sunrise and sunset. Even when set to
- * true it will not impact zmanim that are a degree-based offset of sunrise and sunset, such as {@link
- * ComplexZmanimCalendar#getSofZmanShmaMGA16Point1Degrees()} or {@link ComplexZmanimCalendar#getSofZmanShmaBaalHatanya()} since
+ * ``ComplexZmanimCalendar.getSofZmanShmaMGA90MinutesZmanis()`` that are based on sunrise and sunset. Even when set to
+ * true it will not impact zmanim that are a degree-based offset of sunrise and sunset, such as
+ * ``ComplexZmanimCalendar.getSofZmanShmaMGA16Point1Degrees()`` or ``ComplexZmanimCalendar.getSofZmanShmaBaalHatanya()`` since
* these zmanim are not linked to sunrise or sunset times (the calculations are based on the astronomical definition of
* sunrise and sunset calculated in a vacuum with the solar radius above the horizon), and are therefore not impacted by the use
* of elevation.
@@ -75,10 +75,10 @@ public class ZmanimCalendar : AstronomicalCalendar {
* zmanim calculations), unless the setting is changed to true in ``setUseElevation(useElevation:)``. This will
* impact sunrise and sunset based zmanim such as ``getSunrise()``, ``getSunset()``,
* ``getSofZmanShmaGRA()``, alos based zmanim such as ``getSofZmanShmaMGA()`` that are based on a
- * fixed offset of sunrise or sunset and zmanim based on a percentage of the day such as {@link
- * ComplexZmanimCalendar#getSofZmanShmaMGA90MinutesZmanis()} that are based on sunrise and sunset. It will not impact
+ * fixed offset of sunrise or sunset and zmanim based on a percentage of the day such as
+ * ``ComplexZmanimCalendar#getSofZmanShmaMGA90MinutesZmanis()`` that are based on sunrise and sunset. It will not impact
* zmanim that are a degree based offset of sunrise and sunset, such as
- * {@link ComplexZmanimCalendar#getSofZmanShmaMGA16Point1Degrees()} or {@link ComplexZmanimCalendar#getSofZmanShmaBaalHatanya()}.
+ * ``ComplexZmanimCalendar.getSofZmanShmaMGA16Point1Degrees()`` or ``ComplexZmanimCalendar.getSofZmanShmaBaalHatanya()``.
*
* @return if the use of elevation is active
*
@@ -113,7 +113,7 @@ public class ZmanimCalendar : AstronomicalCalendar {
public var useAstronomicalChatzos = true;
/**
- * Is {@link #getSunTransit() astronomical chatzos} used for {@link #getChatzos()} for enhanced accuracy. For
+ * Is ``getSunTransit()`` astronomical chatzos used for ``getChatzos()`` for enhanced accuracy. For
* example as the day is lengthens, the second half of the day is longer than the first and astronomical chatzos
* would be a drop earlier than half of the time between sunrise and sunset.
*
@@ -122,8 +122,8 @@ public class ZmanimCalendar : AstronomicalCalendar {
* zmaniyos would be calculated a a 6th of the time between sunrise and chatzos, as opposed to a 12th of the
* time between sunrise and sunset. ``getMinchaGedola()`` will be calculated as half a
* shaah zmanis of afternoon hours (a 6th of the time between chatzos and sunset after astronomical
- * chatzos as opposed to 6.5 shaaos zmaniyos after sunrise. {@link #getPlagHamincha() Plag
- * hamincha} would be calculated as 4.75 shaaos zmaniyos after astronomical chatzos as opposed to 10.75
+ * chatzos as opposed to 6.5 shaaos zmaniyos after sunrise. ``getPlagHamincha()`` Plag
+ * hamincha would be calculated as 4.75 shaaos zmaniyos after astronomical chatzos as opposed to 10.75
* shaaos zmaniyos after sunrise. Etc.
*
* @return if the use of astronomical chatzos is active.
@@ -170,13 +170,13 @@ public class ZmanimCalendar : AstronomicalCalendar {
* the first and astronomical chatzos would be a drop earlier than half of the time between sunrise and sunset.
* Conversely, the second half of the day would be shorter in the fall season as the days start getting shorter.
*
- * @todo In the future, if this is set to true, the following may change to enhance accuracy. {@link #getSofZmanShmaGRA()
- * Sof zman Shma GRA} would be calculated as 3 shaaos zmaniyos after sunrise, but the shaaos
- * zmaniyos would be calculated a a 6th of the time between sunrise and chatzos, as opposed to a 12th of the
+ * In the future, if this is set to true, the following may change to enhance accuracy. ``getSofZmanShmaGRA()``
+ * would be calculated as 3 shaaos zmaniyos after sunrise, but the shaaos
+ * zmaniyos would be calculated as a 6th of the time between sunrise and chatzos, as opposed to a 12th of the
* time between sunrise and sunset. ``getMinchaGedola()`` will be calculated as half a
* shaah zmanis of afternoon hours (a 6th of the time between chatzos and sunset after astronomical
- * chatzos as opposed to 6.5 shaaos zmaniyos after sunrise. {@link #getPlagHamincha() Plag
- * hamincha} would be calculated as 4.75 shaaos zmaniyos after astronomical chatzos as opposed to 10.75
+ * chatzos as opposed to 6.5 shaaos zmaniyos after sunrise. ``getPlagHamincha()`` Plag
+ * hamincha would be calculated as 4.75 shaaos zmaniyos after astronomical chatzos as opposed to 10.75
* shaaos zmaniyos after sunrise. Etc.
*
* @return if the use of astronomical chatzos is active.
@@ -204,9 +204,9 @@ public class ZmanimCalendar : AstronomicalCalendar {
* (dawn) and tzais (nightfall) in some opinions. It is based on the calculation that the time between dawn
* and sunrise (and sunset to nightfall) is 72 minutes, the time that is takes to walk 4 mil at 18 minutes
* a mil (Rambam and others). The sun's position at
- * 72 minutes before {@link #getSunrise sunrise} in Jerusalem around the equinox / equilux is
- * 16.1° below {@link #GEOMETRIC_ZENITH geometric zenith}.
+ * 16.1° below ``GEOMETRIC_ZENITH``.
*
* @see #getAlosHashachar()
* @see ComplexZmanimCalendar#getAlos16Point1Degrees()
@@ -226,7 +226,7 @@ public class ZmanimCalendar : AstronomicalCalendar {
* (dawn) and tzais (nightfall) in some opinions. This calculation is based on the position of the sun 36
* minutes after ``getSunset()`` in Jerusalem around the equinox / equilux, which
- * is 8.5° below {@link #GEOMETRIC_ZENITH geometric zenith}. The Ohr Meir considers this the time that 3 small stars are visible,
* which is later than the required 3 medium stars.
*
@@ -237,17 +237,16 @@ public class ZmanimCalendar : AstronomicalCalendar {
/**
* The default Shabbos candle lighting offset is 18 minutes. This can be changed via the
- * {@link #setCandleLightingOffset(double)} and retrieved by the {@link #getCandleLightingOffset()}.
+ * ``setCandleLightingOffset(candleLightingOffset:)`` and retrieved by the ``getCandleLightingOffset()``.
*/
public var candleLightingOffset = 18;
/**
* This method will return ``getSeaLevelSunrise()`` if ``setUseElevation(useElevation:)`` is false (the
- * default), or elevation adjusted {@link AstronomicalCalendar#getSunrise()} if it is true. This allows relevant zmanim
- * in this and extending classes (such as the``ComplexZmanimCalendar``) to automatically adjust to the elevation setting.
+ * default), or elevation adjusted ``AstronomicalCalendar.getSunrise()`` if it is true. This allows relevant zmanim
+ * in this and extending classes (such as the ``ComplexZmanimCalendar``) to automatically adjust to the elevation setting.
*
- * @return {@link #getSeaLevelSunrise()} if ``setUseElevation(useElevation:)`` is false (the default), or elevation adjusted
- * {@link AstronomicalCalendar#getSunrise()} if it is true.
+ * @return ``getSeaLevelSunrise()`` if ``setUseElevation(useElevation:)`` is false (the default), or elevation adjusted ``AstronomicalCalendar.getSunrise()`` if it is true.
* @see com.kosherjava.zmanim.AstronomicalCalendar#getSunrise()
*/
public func getElevationAdjustedSunrise() -> Date? {
@@ -259,11 +258,10 @@ public class ZmanimCalendar : AstronomicalCalendar {
/**
* This method will return ``getSeaLevelSunrise()`` if ``setUseElevation(useElevation:)`` is false (the default),
- * or elevation adjusted {@link AstronomicalCalendar#getSunrise()} if it is true. This allows relevant zmanim
- * in this and extending classes (such as the``ComplexZmanimCalendar``) to automatically adjust to the elevation setting.
+ * or elevation adjusted ``AstronomicalCalendar.getSunrise()`` if it is true. This allows relevant zmanim
+ * in this and extending classes (such as the ``ComplexZmanimCalendar``) to automatically adjust to the elevation setting.
*
- * @return {@link #getSeaLevelSunset()} if ``setUseElevation(useElevation:)`` is false (the default), or elevation adjusted
- * {@link AstronomicalCalendar#getSunset()} if it is true.
+ * @return ``getSeaLevelSunset()`` if ``setUseElevation(useElevation:)`` is false (the default), or elevation adjusted ``AstronomicalCalendar.getSunset()`` if it is true.
* @see com.kosherjava.zmanim.AstronomicalCalendar#getSunset()
*/
public func getElevationAdjustedSunset() -> Date? {
@@ -275,7 +273,7 @@ public class ZmanimCalendar : AstronomicalCalendar {
/**
* A method that returns tzais (nightfall) when the sun is ``ZENITH_8_POINT_5`` below the
- * {@link #GEOMETRIC_ZENITH geometric horizon} (90°) after ``getSunset()``, a time that Rabbi Meir
+ * ``GEOMETRIC_ZENITH`` geometric horizon (90°) after ``getSunset()``, a time that Rabbi Meir
* Posen in his the Ohr Meir calculated that 3 small
* stars are visible, which is later than the required 3 medium stars. See the ``ZENITH_8_POINT_5``constant.
*
@@ -293,13 +291,12 @@ public class ZmanimCalendar : AstronomicalCalendar {
}
/**
- * Returns alos (dawn) based on the time when the sun is {@link #ZENITH_16_POINT_1 16.1°} below the
- * eastern {@link #GEOMETRIC_ZENITH geometric horizon} before {@link #getSunrise sunrise}. This is based on the
+ * Returns alos (dawn) based on the time when the sun is ``ZENITH_16_POINT_1`` 16.1° below the
+ * eastern ``GEOMETRIC_ZENITH`` geometric horizon before ``getSunrise()``. This is based on the
* calculation that the time between dawn and sunrise (and sunset to nightfall) is 72 minutes, the time that is
- * takes to walk 4 mil at 18 minutes a mil (Rambam and others). The sun's position at 72 minutes before {@link #getSunrise sunrise} in Jerusalem
+ * takes to walk 4 mil at 18 minutes a mil (Rambam and others). The sun's position at 72 minutes before ``getSunrise()`` in Jerusalem
* on the around the equinox /
- * equilux is 16.1° below {@link #GEOMETRIC_ZENITH}.
+ * equilux is 16.1° below ``GEOMETRIC_ZENITH``.
*
* @see #ZENITH_16_POINT_1
* @see ComplexZmanimCalendar#getAlos16Point1Degrees()
@@ -331,24 +328,19 @@ public class ZmanimCalendar : AstronomicalCalendar {
}
/**
- * This method returns {@link #getSunTransit() Astronomical chatzos} if the
- * {@link com.kosherjava.zmanim.util.AstronomicalCalculator calculator} class used supports it and
- * {@link #isUseAstronomicalChatzos() isUseAstronomicalChatzos()} is set to true or the {@link #getChatzosAsHalfDay()
+ * This method returns ``getSunTransit()`` Astronomical chatzos if the
+ * ``AstronomicalCalculator`` class used supports it and
+ * ``isUseAstronomicalChatzos()`` is set to true or the ``getChatzosAsHalfDay()``
* halfway point between sunrise and sunset} if it does not support it or it is not configured to use it. There are currently
- * two {@link com.kosherjava.zmanim.util.AstronomicalCalculator calculators} available in the API, the default {@link
- * com.kosherjava.zmanim.util.NOAACalculator NOAA calculator} and the {@link com.kosherjava.zmanim.util.SunTimesCalculator USNO
- * calculator}. The USNO calculator calculates chatzos as halfway between sunrise and sunset (identical to six shaaos
- * zmaniyos after sunrise), while the NOAACalculator calculates it more accurately as {@link #getSunTransit() astronomical
- * chatzos}. See The Definition of Chatzos
+ * two ``AstronomicalCalculator`` calculators available in the API, the default ``NOAACalculator`` and the ``SunTimesCalculator`` USNO
+ * calculator. The USNO calculator calculates chatzos as halfway between sunrise and sunset (identical to six shaaos
+ * zmaniyos after sunrise), while the ``NOAACalculator`` calculates it more accurately as ``getSunTransit()`` astronomical
+ * chatzos. See The Definition of Chatzos
* for a detailed explanation of the ways to calculate Chatzos. Since half-day chatzos can be nil in
* the Arctic on a day when either sunrise or sunset did not happen and astronomical chatzos can be calculated even in the
* Arctic, if half-day chatzos calculates as nil and astronomical chatzos is supported by the
* calculator, astronomical chatzos will be returned to avoid returning a nil.
*
- * @see AstronomicalCalendar#getSunTransit()
- * @see #getChatzosAsHalfDay()
- * @see #isUseAstronomicalChatzos()
- * @see #setUseAstronomicalChatzos(boolean)
* @return the Date of chatzos. If the calculation can't be computed such as in the Arctic Circle
* where there is at least one day where the sun does not rise, and one where it does not set, and the calculator does not
* support astronomical calculations (that will never report a nil) a nil will be returned.
@@ -368,28 +360,20 @@ public class ZmanimCalendar : AstronomicalCalendar {
}
/**
- * Returns chatzos calculated as halfway between sunrise and sunset. Many are of the opinion opinion that
- * chatzos is calculated as the the midpoint between {@link #getSeaLevelSunrise sea level sunrise} and
- * {@link #getSeaLevelSunset sea level sunset}, despite it not being the most accurate way to calculate it. A day
+ * Returns chatzos calculated as halfway between sunrise and sunset. Many are of the opinion that
+ * chatzos is calculated as the the midpoint between ``getSeaLevelSunrise()`` and
+ * ``getSeaLevelSunset()``, despite it not being the most accurate way to calculate it. A day
* starting at alos and ending at tzais using the same time or degree offset will also return
* the same time. In reality due to lengthening or shortening of day, this is not necessarily the exact midpoint of
- * the day, but it is very close. This method allows you to use the NOAACalculator and still calculate chatzos
- * as six shaaos zmaniyos after sunrise. There are currently two {@link
- * com.kosherjava.zmanim.util.AstronomicalCalculator calculators} available in the API, the {@link
- * com.kosherjava.zmanim.util.NOAACalculator} and the {@link com.kosherjava.zmanim.util.SunTimesCalculator}.
- * The SunTimesCalculator calculates chatzos as halfway between sunrise and sunset (and of six shaaos
- * zmaniyos), while the NOAACalculator calculates it as astronomical chatzos that is slightly more
- * accurate. This method allows you to use the NOAACalculator and still calculate chatzos as six shaaos
+ * the day, but it is very close. This method allows you to use the ``NOAACalculator`` and still calculate chatzos
+ * as six shaaos zmaniyos after sunrise. There are currently two ``AstronomicalCalculator`` calculators available in the API, the
+ * ``NOAACalculator`` and the ``SunTimesCalculator``.
+ * The ``SunTimesCalculator`` calculates chatzos as halfway between sunrise and sunset (and of six shaaos
+ * zmaniyos), while the ``NOAACalculator`` calculates it as astronomical chatzos that is slightly more
+ * accurate. This method allows you to use the ``NOAACalculator`` and still calculate chatzos as six shaaos
* zmaniyos after sunrise. See The Definition
* of Chatzos for a detailed explanation of the ways to calculate Chatzos.
*
- * @see com.kosherjava.zmanim.util.NOAACalculator#getUTCNoon(Calendar, GeoLocation)
- * @see com.kosherjava.zmanim.util.SunTimesCalculator#getUTCNoon(Calendar, GeoLocation)
- * @see com.kosherjava.zmanim.util.AstronomicalCalculator#getUTCNoon(Calendar, GeoLocation)
- * @see AstronomicalCalendar#getSunTransit(Date, Date)
- * @see #getChatzos()
- * @see #getSunTransit()
- * @see #isUseAstronomicalChatzos()
*
* @return the Date of the latest chatzos. If the calculation can't be computed such
* as in the Arctic Circle where there is at least one day a year where the sun does not rise, and one where
@@ -401,19 +385,18 @@ public class ZmanimCalendar : AstronomicalCalendar {
}
/**
- * A generic method for calculating the latest zman krias shema (time to recite shema in the morning) that is 3 *
+ * A generic method for calculating the latest zman krias shema (time to recite shema in the morning) that is 3 x
* shaos zmaniyos (temporal hours) after the start of the day, calculated using the start and end of the day passed
* to this method. The time from the start of day to the end of day are divided into 12 shaos zmaniyos (temporal
* hours), and the latest zman krias shema is calculated as 3 of those shaos zmaniyos after the beginning of
- * the day. If {@link #isUseAstronomicalChatzosForOtherZmanim()} is true, the 3 shaos zmaniyos will be
- * based on 1/6 of the time between sunrise and {@link #getSunTransit() astronomical chatzos}. As an example, passing
- * ``getSunrise()`` and ``getSunset()`` or ``getSeaLevelSunrise()`` and {@link
- * #getSeaLevelSunset() sea level sunset} to this method (or {@link #getElevationAdjustedSunrise()} and {@link
- * #getElevationAdjustedSunset()} that is driven off the ``setUseElevation(useElevation:)`` setting) will return sof zman krias
+ * the day. If ``isUseAstronomicalChatzosForOtherZmanim()`` is true, the 3 shaos zmaniyos will be
+ * based on 1/6 of the time between sunrise and ``getSunTransit()`` astronomical chatzos}. As an example, passing
+ * ``getSunrise()`` and ``getSunset()`` or ``getSeaLevelSunrise()`` and
+ * ``getSeaLevelSunset()`` to this method (or ``getElevationAdjustedSunrise()`` and
+ * ``getElevationAdjustedSunset()`` that is driven off the ``setUseElevation(useElevation:)`` setting) will return sof zman krias
* shema according to the opinion of the GRA. In cases
- * where the start and end dates are not synchronous such as in {@link ComplexZmanimCalendar
- * #getSofZmanShmaAlos16Point1ToTzaisGeonim7Point083Degrees()} false should be passed to the synchronous parameter
- * to ensure that {@link #isUseAstronomicalChatzosForOtherZmanim()} will not be used.
+ * where the start and end dates are not synchronous such as in ``ComplexZmanimCalendar.getSofZmanShmaAlos16Point1ToTzaisGeonim7Point083Degrees()`` false should be passed to the synchronous parameter
+ * to ensure that ``isUseAstronomicalChatzosForOtherZmanim()`` will not be used.
*
* @param startOfDay
* the start of day for calculating zman krias shema. This can be sunrise or any alos passed
@@ -422,10 +405,8 @@ public class ZmanimCalendar : AstronomicalCalendar {
* the end of day for calculating zman krias shema. This can be sunset or any tzais passed to
* this method.
* @param synchronous
- * If the zman has a synchronous start and end of the day. If this is false, using a {@link
- * #isUseAstronomicalChatzosForOtherZmanim()} makes no sense and will be ignored even if set to true, since by
+ * If the zman has a synchronous start and end of the day. If this is false, using a ``isUseAstronomicalChatzosForOtherZmanim()`` makes no sense and will be ignored even if set to true, since by
* definition chatzos will not be the middle of the day for the zman.
- * @see #isUseAstronomicalChatzosForOtherZmanim()
* @return the Date of the latest zman shema based on the start and end of day times passed to this
* method. If the calculation can't be computed such as in the Arctic Circle where there is at least one day
* a year where the sun does not rise, and one where it does not set, a nil will be returned. See
@@ -440,8 +421,8 @@ public class ZmanimCalendar : AstronomicalCalendar {
}
/**
- * A generic method for calculating the latest zman krias shema that calls {@link #getSofZmanShma(Date, Date, boolean)}
- * passing false to the synchronous parameter since there is now way to know if the start and end of the day are
+ * A generic method for calculating the latest zman krias shema that calls ``getSofZmanShma(startOfDay:endOfDay:)``
+ * passing false to the synchronous parameter since there is no way to know if the start and end of the day are
* synchronous. Passing true when they are not synchronous is too much of a risk. See information on that method for more details.
* @param startOfDay
* the start of day for calculating zman krias shema. This can be sunrise or any alos passed
@@ -460,18 +441,13 @@ public class ZmanimCalendar : AstronomicalCalendar {
}
/**
- * This method returns the latest zman krias shema (time to recite shema in the morning) that is 3 *
- * {@link #getShaahZmanisGra() shaos zmaniyos} (solar hours) after ``getSunrise()`` or
+ * This method returns the latest zman krias shema (time to recite shema in the morning) that is 3 x
+ * ``getShaahZmanisGra()`` shaos zmaniyos (solar hours) after ``getSunrise()`` or
* ``getSeaLevelSunrise()`` (depending on the ``setUseElevation(useElevation:)`` setting), according
* to the GRA.
- * The day is calculated from ``getSeaLevelSunrise()`` to {@link #getSeaLevelSunrise sea level
- * sunset} or ``getSunrise()`` to ``getSunset()`` (depending on the ``setUseElevation(useElevation:)``
+ * The day is calculated from ``getSeaLevelSunrise()`` to ``getSeaLevelSunrise`` or ``getSunrise()`` to ``getSunset()`` (depending on the ``setUseElevation(useElevation:)``
* setting).
*
- * @see #getSofZmanShma(Date, Date)
- * @see #getShaahZmanisGra()
- * @see #isUseElevation()
- * @see ComplexZmanimCalendar#getSofZmanShmaBaalHatanya()
* @return the Date of the latest zman shema according to the GRA. If the calculation can't be
* computed such as in the Arctic Circle where there is at least one day a year where the sun does not rise,
* and one where it does not set, a nil will be returned. See the detailed explanation on top
@@ -482,12 +458,11 @@ public class ZmanimCalendar : AstronomicalCalendar {
}
/**
- * This method returns the latest zman krias shema (time to recite shema in the morning) that is 3 *
- * {@link #getShaahZmanisMGA() shaos zmaniyos} (solar hours) after {@link #getAlos72()}, according to the
+ * This method returns the latest zman krias shema (time to recite shema in the morning) that is 3 x
+ * ``getShaahZmanisMGA()`` shaos zmaniyos (solar hours) after ``getAlos72()``, according to the
* Magen Avraham (MGA). The day is calculated
- * from 72 minutes before ``getSeaLevelSunrise()`` to 72 minutes after {@link
- * #getSeaLevelSunrise sea level sunset} or from 72 minutes before ``getSunrise()`` to {@link #getSunset()
- * sunset} (depending on the ``setUseElevation(useElevation:)`` setting).
+ * from 72 minutes before ``getSeaLevelSunrise()`` to 72 minutes after ``getSeaLevelSunrise()`` or from 72 minutes before ``getSunrise()`` to ``getSunset()``
+ * (depending on the ``setUseElevation(useElevation:)`` setting).
*
* @return the Date of the latest zman shema. If the calculation can't be computed such as in
* the Arctic Circle where there is at least one day a year where the sun does not rise, and one where it
@@ -526,7 +501,7 @@ public class ZmanimCalendar : AstronomicalCalendar {
* ``getSeaLevelSunset()``. This will return the time for any day of the week, since it can be
* used to calculate candle lighting time for Yom Tov (mid-week holidays) as well. Elevation adjustments
* are intentionally not performed by this method, but you can calculate it by passing the elevation adjusted sunset
- * to {@link #getTimeOffset(Date, long)}.
+ * to ``getTimeOffset(Date, Int64)``.
*
* @return candle lighting time. If the calculation can't be computed such as in the Arctic Circle where there is at
* least one day a year where the sun does not rise, and one where it does not set, a nil will
@@ -546,14 +521,14 @@ public class ZmanimCalendar : AstronomicalCalendar {
* end of the day passed to this method.
* The time from the start of day to the end of day are divided into 12 shaos zmaniyos (temporal hours),
* and sof zman tfila is calculated as 4 of those shaos zmaniyos after the beginning of the day.
- * As an example, passing ``getSunrise()`` and ``getSunset()`` or {@link #getSeaLevelSunrise()
+ * As an example, passing ``getSunrise()`` and ``getSunset()`` or ``getSeaLevelSunrise()``
* sea level sunrise} and ``getSeaLevelSunset()`` (depending on the ``setUseElevation(useElevation:)``
* elevation setting) to this method will return zman tfilah according to the opinion of the GRA. This method's synchronous parameter indicates if the start
* and end of day for the calculation are synchronous, having the same offset. This is typically the case, but some
* zmanim calculations are based on a start and end at different offsets from the real start and end of the day,
* such as starting the day at alos and an ending it at tzais genoim or some other variant. If the day
- * is not synchronous a {@link #getHalfDayBasedZman(Date, Date, double) half-day based calculations} will be bypassed.
+ * is not synchronous a ``getHalfDayBasedZman(startOfHalfDay:endOfHalfDay:hours:)`` half-day based calculations will be bypassed.
* It would be illogical to use a half-day based calculation that start/end at chatzos when the two "halves" of
* the day are not equal, and the halfway point between them is not at chatzos.
*
@@ -564,8 +539,7 @@ public class ZmanimCalendar : AstronomicalCalendar {
* the end of day for calculating zman tfilah. This can be sunset or any tzais passed
* to this method.
* @param synchronous
- * If the zman has a synchronous start and end of the day. If this is false, using a {@link
- * #isUseAstronomicalChatzosForOtherZmanim()} makes no sense and will be ignored even if set to true, since by
+ * If the zman has a synchronous start and end of the day. If this is false, using a ``isUseAstronomicalChatzosForOtherZmanim()`` makes no sense and will be ignored even if set to true, since by
* definition chatzos will not be the middle of the day for the zman.
* @return the Date of the latest zman tfilah based on the start and end of day times passed
* to this method. If the calculation can't be computed such as in the Arctic Circle where there is at least
@@ -581,8 +555,8 @@ public class ZmanimCalendar : AstronomicalCalendar {
}
/**
- * A generic method for calculating the latest zman tfila that calls {@link #getSofZmanTfila(Date, Date, boolean)}
- * passing false to the synchronous parameter since there is now way to know if the start and end of the day are
+ * A generic method for calculating the latest zman tfila that calls ``getSofZmanTfila(startOfDay:endOfDay:synchronous:)``
+ * passing false to the synchronous parameter since there is no way to know if the start and end of the day are
* synchronous. Passing true when they are not synchronous is too much of a risk. See information on that method for more details.
* @param startOfDay
* the start of day for calculating zman tfilah. This can be sunrise or any alos passed
@@ -601,17 +575,13 @@ public class ZmanimCalendar : AstronomicalCalendar {
}
/**
- * This method returns the latest zman tfila (time to recite shema in the morning) that is 4 *
- * {@link #getShaahZmanisGra() shaos zmaniyos }(solar hours) after ``getSunrise()`` or
+ * This method returns the latest zman tfila (time to recite shema in the morning) that is 4 x
+ * ``getShaahZmanisGra()`` shaos zmaniyos (solar hours) after ``getSunrise()`` or
* ``getSeaLevelSunrise()`` (depending on the ``setUseElevation(useElevation:)`` setting), according
* to the GRA.
- * The day is calculated from ``getSeaLevelSunrise()`` to {@link #getSeaLevelSunrise sea level
- * sunset} or ``getSunrise()`` to ``getSunset()`` (depending on the ``setUseElevation(useElevation:)``
+ * The day is calculated from ``getSeaLevelSunrise()`` to ``getSeaLevelSunrise()`` or ``getSunrise()`` to ``getSunset()`` (depending on the ``setUseElevation(useElevation:)``
* setting).
*
- * @see #getSofZmanTfila(Date, Date)
- * @see #getShaahZmanisGra()
- * @see ComplexZmanimCalendar#getSofZmanTfilaBaalHatanya()
* @return the Date of the latest zman tfilah. If the calculation can't be computed such as in
* the Arctic Circle where there is at least one day a year where the sun does not rise, and one where it
* does not set, a nil will be returned. See detailed explanation on top of the
@@ -622,11 +592,10 @@ public class ZmanimCalendar : AstronomicalCalendar {
}
/**
- * This method returns the latest zman tfila (time to recite shema in the morning) that is 4 *
- * {@link #getShaahZmanisMGA() shaos zmaniyos} (solar hours) after ``getAlos72()``, according to the
+ * This method returns the latest zman tfila (time to recite shema in the morning) that is 4 x
+ * ``getShaahZmanisMGA()`` shaos zmaniyos} (solar hours) after ``getAlos72()``, according to the
* Magen Avraham (MGA). The day is calculated
- * from 72 minutes before ``getSeaLevelSunrise()`` to 72 minutes after {@link
- * #getSeaLevelSunrise sea level sunset} or from 72 minutes before ``getSunrise()`` to {@link #getSunset()
+ * from 72 minutes before ``getSeaLevelSunrise()`` to 72 minutes after ``getSeaLevelSunset()`` or from 72 minutes before ``getSunrise()`` to ``getSunset()``
* sunset} (depending on the ``setUseElevation(useElevation:)`` setting).
*
* @return the Date of the latest zman tfila. If the calculation can't be computed such as in
@@ -642,22 +611,20 @@ public class ZmanimCalendar : AstronomicalCalendar {
}
/**
- * A generic method for calculating mincha gedola (the earliest time to recite the mincha1 prayers) that
+ * A generic method for calculating mincha gedola (the earliest time to recite the mincha prayers) that
* is 6.5 x shaos zmaniyos (temporal hours) after the start of the day, calculated using the start and end of the
* day passed to this method. The time from the start of day to the end of day are divided into 12 shaos zmaniyos
* (temporal hours), and mincha gedola is calculated as 6.5 of those shaos zmaniyos after the beginning
- * of the day. As an example, passing ``getSunrise()`` and ``getSunset()`` or {@link
- * #getSeaLevelSunrise() sea level sunrise} and ``getSeaLevelSunset()`` (depending on the {@link
- * #isUseElevation()} elevation setting) to this method will return mincha gedola according to the opinion of the
- * GRA. Alternatively, this method uses {@link
- * #isUseAstronomicalChatzosForOtherZmanim()} to control if the time is based on 6.5 sha'os zmaniyos into the day
- * mentioned above, or as half an hour zmaniyos based on the second half of the day after chatzos ({@link
- * #getSunTransit() astronomical chatzos} if supported by the {@link AstronomicalCalculator calculator} and {@link
- * #isUseAstronomicalChatzos() configured} or {@link #getChatzosAsHalfDay() chatzos as half a day} if not. This
+ * of the day. As an example, passing ``getSunrise()`` and ``getSunset()`` or ``getSeaLevelSunrise()`` sea level sunrise and ``getSeaLevelSunset()`` (depending on the
+ * ``isUseElevation()`` elevation setting) to this method will return mincha gedola according to the opinion of the
+ * GRA. Alternatively, this method uses
+ * ``isUseAstronomicalChatzosForOtherZmanim()`` to control if the time is based on 6.5 sha'os zmaniyos into the day
+ * mentioned above, or as half an hour zmaniyos based on the second half of the day after chatzos (``getSunTransit()`` astronomical chatzos if supported by the ``AstronomicalCalculator`` calculator and
+ * ``isUseAstronomicalChatzos()`` configured or ``getChatzosAsHalfDay()`` chatzos as half a day if not. This
* method's synchronous parameter indicates if the start and end of day for the calculation are synchronous, having the same
* offset. This is typically the case, but some zmanim calculations are based on a start and end at different offsets
* from the real start and end of the day, such as starting the day at alos and an ending it at tzais genoim
- * or some other variant. If the day is not synchronous a {@link #getHalfDayBasedZman(Date, Date, double) half-day based
+ * or some other variant. If the day is not synchronous a ``getHalfDayBasedZman(startOfHalfDay:endOfHalfDay:hours:)`` half-day based
* calculations} will be bypassed. It would be illogical to use a half-day based calculation that start/end at chatzos
* when the two "halves" of the day are not equal, and the halfway point between them is not at chatzos.
*
@@ -668,8 +635,7 @@ public class ZmanimCalendar : AstronomicalCalendar {
* the end of day for calculating Mincha gedola. This can be sunset or any tzais passed
* to this method.
* @param synchronous
- * If the zman has a synchronous start and end of the day. If this is false, using a {@link
- * #isUseAstronomicalChatzosForOtherZmanim()} makes no sense and will be ignored even if set to true, since by
+ * If the zman has a synchronous start and end of the day. If this is false, using a ``isUseAstronomicalChatzosForOtherZmanim()`` makes no sense and will be ignored even if set to true, since by
* definition chatzos will not be the middle of the day for the zman.
* @return the Date of the time of Mincha gedola based on the start and end of day times
* passed to this method. If the calculation can't be computed such as in the Arctic Circle where there is
@@ -691,7 +657,7 @@ public class ZmanimCalendar : AstronomicalCalendar {
/**
* A generic method for calculating mincha gedola that calls ``getMinchaGedola(startOfDay:endOfDay:synchronous:)`` passing
- * false to the synchronous parameter since there is now way to know if the start and end of the day are
+ * false to the synchronous parameter since there is no way to know if the start and end of the day are
* synchronous. Passing true when they are not synchronous is too much of a risk. See information on that method for more
* details.
* @param startOfDay
@@ -711,24 +677,19 @@ public class ZmanimCalendar : AstronomicalCalendar {
}
/**
- * This method returns the latest mincha gedola,the earliest time one can pray mincha that is 6.5 *
- * {@link #getShaahZmanisGra() shaos zmaniyos} (solar hours) after ``getSunrise()`` or
+ * This method returns the latest mincha gedola,the earliest time one can pray mincha that is 6.5 x
+ * ``getShaahZmanisGra()`` shaos zmaniyos (solar hours) after ``getSunrise()`` or
* ``getSeaLevelSunrise()`` (depending on the ``setUseElevation(useElevation:)`` setting), according
* to the GRA. Mincha gedola is the earliest
* time one can pray mincha. The Ramba"m is of the opinion that it is better to delay mincha until
- * {@link #getMinchaKetana() mincha ketana} while the Ra"sh, Tur, GRA and others are of the
+ * ``getMinchaKetana()`` mincha ketana while the Ra"sh, Tur, GRA and others are of the
* opinion that mincha can be prayed lechatchila starting at mincha gedola.
- * The day is calculated from ``getSeaLevelSunrise()`` to {@link #getSeaLevelSunrise sea level
- * sunset} or ``getSunrise()`` to ``getSunset()`` (depending on the ``setUseElevation(useElevation:)``
+ * The day is calculated from ``getSeaLevelSunrise()`` to ``getSeaLevelSunset()`` sea level
+ * sunset or ``getSunrise()`` to ``getSunset()`` (depending on the ``setUseElevation(useElevation:)``
* setting).
- * @todo Consider adjusting this to calculate the time as half an hour zmaniyos after either {@link
- * #getSunTransit() astronomical chatzos} or {@link #getChatzosAsHalfDay() chatzos as half a day}
- * for {@link AstronomicalCalculator calculators} that support it, based on {@link #isUseAstronomicalChatzos()}.
+ * TODO: Consider adjusting this to calculate the time as half an hour zmaniyos after either ``getSunTransit()`` astronomical chatzos or ``getChatzosAsHalfDay()`` chatzos as half a day
+ * for ``AstronomicalCalculator`` calculators that support it, based on ``isUseAstronomicalChatzos()``.
*
- * @see #getMinchaGedola(Date, Date)
- * @see #getShaahZmanisGra()
- * @see #getMinchaKetana()
- * @see ComplexZmanimCalendar#getMinchaGedolaBaalHatanya()
* @return the Date of the time of mincha gedola. If the calculation can't be computed such as in the
* Arctic Circle where there is at least one day a year where the sun does not rise, and one where it does
* not set, a nil will be returned. See detailed explanation on top of the
@@ -755,8 +716,7 @@ public class ZmanimCalendar : AstronomicalCalendar {
* the end of day for calculating samuch lemincha ketana. This can be sunset or any tzais
* passed to this method.
* @param synchronous
- * If the zman has a synchronous start and end of the day. If this is false, using a {@link
- * #isUseAstronomicalChatzosForOtherZmanim()} makes no sense and will be ignored even if set to true, since by
+ * If the zman has a synchronous start and end of the day. If this is false, using a ``isUseAstronomicalChatzosForOtherZmanim()`` makes no sense and will be ignored even if set to true, since by
* definition chatzos will not be the middle of the day for the zman.
* @return the Date of the time of Mincha ketana based on the start and end of day times
* passed to this method. If the calculation can't be computed such as in the Arctic Circle where there is
@@ -776,8 +736,8 @@ public class ZmanimCalendar : AstronomicalCalendar {
}
/**
- * A generic method for calculating samuch lemincha ketana that calls {@link #getSamuchLeMinchaKetana(Date, Date, boolean)}
- * passing false to the synchronous parameter since there is now way to know if the start and end of the day are
+ * A generic method for calculating samuch lemincha ketana that calls ``getSamuchLeMinchaKetana(startOfDay:endOfDay:synchronous:)``
+ * passing false to the synchronous parameter since there is no way to know if the start and end of the day are
* synchronous. Passing true when they are not synchronous is too much of a risk. See information on that method for more details.
* @param startOfDay
* the start of day for calculating samuch lemincha ketana. This can be sunrise or any alos
@@ -798,18 +758,17 @@ public class ZmanimCalendar : AstronomicalCalendar {
/**
* A generic method for calculating mincha ketana, (the preferred time to recite the mincha prayers in
* the opinion of the Rambam and others) that is
- * 9.5 * shaos zmaniyos (temporal hours) after the start of the day, calculated using the start and end
+ * 9.5 x shaos zmaniyos (temporal hours) after the start of the day, calculated using the start and end
* of the day passed to this method.
* The time from the start of day to the end of day are divided into 12 shaos zmaniyos (temporal hours), and
* mincha ketana is calculated as 9.5 of those shaos zmaniyos after the beginning of the day. As an
- * example, passing ``getSunrise()`` and ``getSunset()`` or {@link #getSeaLevelSunrise() sea
- * level sunrise} and ``getSeaLevelSunset()`` (depending on the ``setUseElevation(useElevation:)``
+ * example, passing ``getSunrise()`` and ``getSunset()`` or ``getSeaLevelSunrise()`` and ``getSeaLevelSunset()`` (depending on the ``setUseElevation(useElevation:)``
* elevation setting) to this method will return mincha ketana according to the opinion of the
* GRA. This method's synchronous parameter indicates ifthe start
* and end of day for the calculation are synchronous, having the same offset. This is typically the case, but some
* zmanim calculations are based on a start and end at different offsets from the real start and end of the day,
* such as starting the day at alos and an ending it at tzais genoim or some other variant. If the day
- * is not synchronous a {@link #getHalfDayBasedZman(Date, Date, double) half-day based calculations} will be bypassed.
+ * is not synchronous a ``getHalfDayBasedZman(startOfHalfDay:endOfHalfDay:hours:)`` half-day based calculations will be bypassed.
* It would be illogical to use a half-day based calculation that start/end at chatzos when the two "halves" of
* the day are not equal, and the halfway point between them is not at chatzos.
*
@@ -820,8 +779,7 @@ public class ZmanimCalendar : AstronomicalCalendar {
* the end of day for calculating Mincha ketana. This can be sunset or any tzais passed to
* this method.
* @param synchronous
- * If the zman has a synchronous start and end of the day. If this is false, using a {@link
- * #isUseAstronomicalChatzosForOtherZmanim()} makes no sense and will be ignored even if set to true, since by
+ * If the zman has a synchronous start and end of the day. If this is false, using a ``isUseAstronomicalChatzosForOtherZmanim()`` makes no sense and will be ignored even if set to true, since by
* definition chatzos will not be the middle of the day for the zman.
* @return the Date of the time of Mincha ketana based on the start and end of day times
* passed to this method. If the calculation can't be computed such as in the Arctic Circle where there is
@@ -837,8 +795,8 @@ public class ZmanimCalendar : AstronomicalCalendar {
}
/**
- * A generic method for calculating mincha ketana that calls {@link #getMinchaKetana(Date, Date, boolean)} passing
- * false to the synchronous parameter since there is now way to know if the start and end of the day are synchronous.
+ * A generic method for calculating mincha ketana that calls ``getMinchaKetana(startOfDay:endOfDay:synchronous:)`` passing
+ * false to the synchronous parameter since there is no way to know if the start and end of the day are synchronous.
* Passing true when they are not synchronous is too much of a risk. See information on that method for more details.
* @param startOfDay
* the start of day for calculating Mincha ketana. This can be sunrise or any alos passed
@@ -858,18 +816,13 @@ public class ZmanimCalendar : AstronomicalCalendar {
/**
* This method returns mincha ketana,the preferred earliest time to pray mincha in the
- * opinion of the Rambam and others, that is 9.5
- * * {@link #getShaahZmanisGra() shaos zmaniyos} (solar hours) after ``getSunrise()`` or
+ * opinion of the Rambam and others, that is 9.5 x ``getShaahZmanisGra()`` shaos zmaniyos (solar hours) after ``getSunrise()`` or
* ``getSeaLevelSunrise()`` (depending on the ``setUseElevation(useElevation:)`` setting), according
* to the GRA. For more information on this see the
* documentation on ``getMinchaGedola()``.
* The day is calculated from ``getSeaLevelSunrise()`` to ``getSeaLevelSunset()`` or ``getSunrise()`` to ``getSunset()`` (depending on the ``setUseElevation(useElevation:)``
* setting.
*
- * @see #getMinchaKetana(Date, Date)
- * @see #getShaahZmanisGra()
- * @see #getMinchaGedola()
- * @see ComplexZmanimCalendar#getMinchaKetanaBaalHatanya()
* @return the Date of the time of mincha ketana. If the calculation can't be computed such as in the
* Arctic Circle where there is at least one day a year where the sun does not rise, and one where it does
* not set, a nil will be returned. See detailed explanation on top of the
@@ -885,14 +838,13 @@ public class ZmanimCalendar : AstronomicalCalendar {
* the day passed to the method.
* The time from the start of day to the end of day are divided into 12 shaos zmaniyos (temporal hours), and
* plag hamincha is calculated as 10.75 of those shaos zmaniyos after the beginning of the day. As an
- * example, passing ``getSunrise()`` and ``getSunset()`` or {@link #getSeaLevelSunrise() sea level
- * sunrise} and ``getSeaLevelSunset()`` (depending on the ``setUseElevation(useElevation:)`` elevation
+ * example, passing ``getSunrise()`` and ``getSunset()`` or ``getSeaLevelSunrise()`` and ``getSeaLevelSunset()`` (depending on the ``setUseElevation(useElevation:)`` elevation
* setting) to this method will return plag mincha according to the opinion of the
* GRA. This method's synchronous parameter indicates if
* the start and end of day for the calculation are synchronous, having the same offset. This is typically the case, but
* some zmanim calculations are based on a start and end at different offsets from the real start and end of the
* day, such as starting the day at alos and an ending it at tzais genoim or some other variant. If the
- * day is not synchronous a {@link #getHalfDayBasedZman(Date, Date, double) half-day based calculations} will be bypassed.
+ * day is not synchronous a ``getHalfDayBasedZman(startOfHalfDay:endOfHalfDay:hours:)`` half-day based calculations will be bypassed.
* It would be illogical to use a half-day based calculation that start/end at chatzos when the two "halves" of
* the day are not equal, and the halfway point between them is not at chatzos.
*
@@ -901,8 +853,7 @@ public class ZmanimCalendar : AstronomicalCalendar {
* @param endOfDay
* the end of day for calculating plag. This can be sunset or any tzais passed to this method.
* @param synchronous
- * If the zman has a synchronous start and end of the day. If this is false, using a {@link
- * #isUseAstronomicalChatzosForOtherZmanim()} makes no sense and will be ignored even if set to true, since by
+ * If the zman has a synchronous start and end of the day. If this is false, using a ``isUseAstronomicalChatzosForOtherZmanim()`` makes no sense and will be ignored even if set to true, since by
* definition chatzos will not be the middle of the day for the zman.
* @return the Date of the time of plag hamincha based on the start and end of day times
* passed to this method. If the calculation can't be computed such as in the Arctic Circle where there is
@@ -918,8 +869,8 @@ public class ZmanimCalendar : AstronomicalCalendar {
}
/**
- * A generic method for calculating plag hamincha that calls {@link #getPlagHamincha(Date, Date, boolean)} passing
- * false to the synchronous parameter since there is now way to know if the start and end of the day are synchronous.
+ * A generic method for calculating plag hamincha that calls ``getPlagHamincha(startOfDay:endOfDay:synchronous:)`` passing
+ * false to the synchronous parameter since there is no way to know if the start and end of the day are synchronous.
* Passing true when they are not synchronous is too much of a risk. See information on that method for more details.
* @param startOfDay
* the start of day for calculating plag. This can be sunrise or any alos passed to this method.
@@ -936,16 +887,12 @@ public class ZmanimCalendar : AstronomicalCalendar {
}
/**
- * This method returns plag hamincha, that is 10.75 * {@link #getShaahZmanisGra() shaos zmaniyos}
+ * This method returns plag hamincha, that is 10.75 x ``getShaahZmanisGra()`` shaos zmaniyos}
* (solar hours) after ``getSunrise()`` or ``getSeaLevelSunrise()`` (depending on
- * the ``setUseElevation(useElevation:)`` setting), according to the GRA. Plag hamincha is the earliest time that Shabbos can be started.
- * The day is calculated from ``getSeaLevelSunrise()`` to {@link #getSeaLevelSunrise sea level
- * sunset} or ``getSunrise()`` to ``getSunset()`` (depending on the ``setUseElevation(useElevation:)``
+ * the ``setUseElevation(useElevation:)`` setting), according to the GRA. Plag hamincha is the earliest time that Shabbos can be started.
+ * The day is calculated from ``getSeaLevelSunrise()`` to ``getSeaLevelSunset()`` sea level
+ * sunset or ``getSunrise()`` to ``getSunset()`` (depending on the ``setUseElevation(useElevation:)``
*
- * @see #getPlagHamincha(Date, Date, boolean)
- * @see #getPlagHamincha(Date, Date)
- * @see ComplexZmanimCalendar#getPlagHaminchaBaalHatanya()
* @return the Date of the time of plag hamincha. If the calculation can't be computed such as
* in the Arctic Circle where there is at least one day a year where the sun does not rise, and one where it
* does not set, a nil will be returned. See detailed explanation on top of the
@@ -956,17 +903,17 @@ public class ZmanimCalendar : AstronomicalCalendar {
}
/**
- * A method that returns a shaah zmanis ({@link #getTemporalHour(Date, Date) temporal hour}) according to
+ * A method that returns a shaah zmanis (``getTemporalHour(Date, Date)`` temporal hour) according to
* the opinion of the GRA. This calculation divides
- * the day based on the opinion of the GRA that the day runs from from {@link #getSeaLevelSunrise() sea
- * level sunrise} to {@link #getSeaLevelSunrise sea level sunset} or ``getSunrise()`` to
+ * the day based on the opinion of the GRA that the day runs from from ``getSeaLevelSunrise()`` sea
+ * level sunrise to ``getSeaLevelSunset()`` or ``getSunrise()`` to
* ``getSunset()`` (depending on the ``setUseElevation(useElevation:)`` setting). The day is split into 12 equal
- * parts with each one being a shaah zmanis. This method is similar to {@link #getTemporalHour}, but can
+ * parts with each one being a shaah zmanis. This method is similar to ``getTemporalHour()``, but can
* account for elevation.
*
* @return the long millisecond length of a shaah zmanis calculated from sunrise to sunset.
* If the calculation can't be computed such as in the Arctic Circle where there is at least one day a year
- * where the sun does not rise, and one where it does not set, ``Int64.min``will be returned. See
+ * where the sun does not rise, and one where it does not set, ``Int64.min`` will be returned. See
* detailed explanation on top of the ``AstronomicalCalendar`` documentation.
* @see #getTemporalHour(Date, Date)
* @see #getSeaLevelSunrise()
@@ -981,11 +928,10 @@ public class ZmanimCalendar : AstronomicalCalendar {
* A method that returns a shaah zmanis (temporal hour) according to the opinion of the Magen Avraham (MGA) based on a 72 minutes alos
* and tzais. This calculation divides the day that runs from dawn to dusk (for sof zman krias shema and
- * tfila). Dawn for this calculation is 72 minutes before ``getSunrise()`` or {@link #getSeaLevelSunrise()
- * sea level sunrise} (depending on the ``setUseElevation(useElevation:)`` elevation setting) and dusk is 72 minutes after {@link
- * #getSunset sunset} or ``getSeaLevelSunset()`` (depending on the ``setUseElevation(useElevation:)`` elevation
+ * tfila). Dawn for this calculation is 72 minutes before ``getSunrise()`` or ``getSeaLevelSunset()``
+ * sea level sunrise (depending on the ``setUseElevation(useElevation:)`` elevation setting) and dusk is 72 minutes after ``getSunset()`` sunset or ``getSeaLevelSunset()`` (depending on the ``setUseElevation(useElevation:)`` elevation
* setting). This day is split into 12 equal parts with each part being a shaah zmanis. Alternate methods of calculating
- * a shaah zmanis according to the Magen Avraham (MGA) are available in the subclass``ComplexZmanimCalendar``.
+ * a shaah zmanis according to the Magen Avraham (MGA) are available in the subclass ``ComplexZmanimCalendar``.
*
* @return the long millisecond length of a shaah zmanis. If the calculation can't be computed
* such as in the Arctic Circle where there is at least one day a year where the sun does not rise, and one
@@ -998,7 +944,7 @@ public class ZmanimCalendar : AstronomicalCalendar {
/**
* Default constructor will set a default ``GeoLocation()``, a default
- * ``AstronomicalCalculator#getDefault()`` and default the date to the current workingDate.
+ * ``AstronomicalCalculator.getDefault()`` and default the date to the current workingDate.
*
* @see AstronomicalCalendar#AstronomicalCalendar()
*/
@@ -1008,10 +954,10 @@ public class ZmanimCalendar : AstronomicalCalendar {
}
/**
- * A constructor that takes a {@link GeoLocation} as a parameter.
+ * A constructor that takes a ``GeoLocation`` as a parameter.
*
* @param location
- * the location
+ * the location as a ``GeoLocation``
*/
public init(location:GeoLocation) {
self.useElevation = false
@@ -1019,7 +965,7 @@ public class ZmanimCalendar : AstronomicalCalendar {
}
/**
- * A method to get the offset in minutes before {@link AstronomicalCalendar#getSeaLevelSunset() sea level sunset} which
+ * A method to get the offset in minutes before ``getSeaLevelSunset()`` sea level sunset which
* is used in calculating candle lighting time. The default time used is 18 minutes before sea level sunset. Some
* calendars use 15 minutes, while the custom in Jerusalem is to use a 40 minute offset. Please check the local custom
* for candle lighting time.
@@ -1033,7 +979,7 @@ public class ZmanimCalendar : AstronomicalCalendar {
}
/**
- * A method to set the offset in minutes before {@link AstronomicalCalendar#getSeaLevelSunset() sea level sunset} that is
+ * A method to set the offset in minutes before ``getSeaLevelSunset()`` sea level sunset that is
* used in calculating candle lighting time. The default time used is 18 minutes before sunset. Some calendars use 15
* minutes, while the custom in Jerusalem is to use a 40 minute offset.
*
@@ -1050,7 +996,7 @@ public class ZmanimCalendar : AstronomicalCalendar {
* This is a utility method to determine if the current Date (date-time) passed in has a melacha (work) prohibition.
* Since there are many opinions on the time of tzais, the tzais for the current day has to be passed to this
* class. Sunset is the classes current day's ``getElevationAdjustedSunset`` that observes the
- * ``setUseElevation(useElevation:)`` settings. The ``JewishCalendar#getInIsrael()`` will be set by the inIsrael parameter.
+ * ``setUseElevation(useElevation:)`` settings. The ``JewishCalendar.getInIsrael()`` will be set by the inIsrael parameter.
*
* @param currentTime the current time
* @param tzais the time of tzais
@@ -1063,8 +1009,7 @@ public class ZmanimCalendar : AstronomicalCalendar {
* @see JewishCalendar#setInIsrael(boolean)
*/
public func isAssurBemlacha(currentTime:Date?, tzais: Date?, inIsrael: Bool) -> Bool{
- let jewishCalendar = JewishCalendar();
- jewishCalendar.workingDate = workingDate
+ let jewishCalendar = JewishCalendar(workingDate: currentTime!, timezone: geoLocation.timeZone);
jewishCalendar.setInIsrael(inIsrael: inIsrael);
if (jewishCalendar.hasCandleLighting() && currentTime?.compare(getElevationAdjustedSunset()!) == .orderedDescending) { //erev shabbos, YT or YT sheni and after shkiah
@@ -1083,7 +1028,7 @@ public class ZmanimCalendar : AstronomicalCalendar {
* day defined as the start and end of day (or night) and the number of shaahos zmaniyos passed to the
* method. This simplifies the code in other methods such as ``getPlagHamincha(startOfDay:endOfDay:)`` and cuts down on
* code replication. As an example, passing ``getSunrise()`` and ``getSunset()`` or
- * ``#getSeaLevelSunrise()`` and ``getSeaLevelSunset()`` (depending on the
+ * ``getSeaLevelSunrise()`` and ``getSeaLevelSunset()`` (depending on the
* ``setUseElevation(useElevation:)`` elevation setting) and 10.75 hours to this method will return plag mincha
* according to the opinion of the GRA.
*
@@ -1121,7 +1066,7 @@ public class ZmanimCalendar : AstronomicalCalendar {
* @param sunset
* if true the calculation should be degrees after sunset, or if false, degrees before sunrise.
* @return the double percentage of a sha'ah zmanis for a given set of degrees below the astronomical horizon
- * for the current calendar. If the calculation can't be computed a {@link Double#MIN_VALUE} will be returned. See detailed
+ * for the current calendar. If the calculation can't be computed a ``Int64.min`` will be returned. See detailed
* explanation on top of the page.
*/
public func getPercentOfShaahZmanisFromDegrees(degrees:Double, sunset:Bool) -> Double {
@@ -1199,7 +1144,7 @@ public class ZmanimCalendar : AstronomicalCalendar {
* tzais for the second half of the day.
* @return The long millisecond length of a shaah zmanis based on 1/6 of a half-day. If the calculation
* can't be computed such as in the Arctic Circle where there is at least one day a year where the sun does not rise,
- * and one where it does not set, ``Int64.min``will be returned. See detailed explanation on top of the
+ * and one where it does not set, ``Int64.min`` will be returned. See detailed explanation on top of the
* ``AstronomicalCalendar`` documentation.
* @see #getHalfDayBasedZman(Date, Date, double)
* @see #isUseAstronomicalChatzosForOtherZmanim()