swisseph 1.4.1 → 1.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d3bd5d41ff56c59145864cde33f26a5cf624b821f12261b45bf6c6c32aa0006b
-  data.tar.gz: b0c23352d9117a5f89b72b02c72785e6ab30e768552a52161363ad98ac53bfd5
+  metadata.gz: 4d6f0a41f6d7670ef96d6b2d55ecaef8e052654a92e8e860ac7f8f42c72fe5c5
+  data.tar.gz: e4eb00865e165d73f78680e0d66421655352af5c6dbfaa09f7e84fb77f4dd32a
 SHA512:
-  metadata.gz: 1691fd37c14307225d04365279d8f0ba96b4cd95e9ed6ca4ec769bcb8c9a350238f00f9d68084fd0c1a9ad0347022cdb721b08abbfb71100645e1a372def5b8e
-  data.tar.gz: 75dce6e93170c127ecb97eb57660357046864128ede073e13913c97dba0b3357cad69ebd428d39fecd3c60efe01de696ab02b63c6c3a19938c4a159f2cc164a5
+  metadata.gz: d4d06845c78d2eb0f5588aa1fde5c59266483ee1b8f6b9351ae601df8a6768ff4085ff7ac3fce3483f8aeb5de5558592c5ab4ff11427f50dd9c186f9ae7c3178
+  data.tar.gz: 2a9a8daff77a5540280fb4c899efb99764abcf1e99434a605dea463f0bca61fcd049eac9da43152306e9acff33002addc84d79c0d8c50e06762d287e0ba2c15e

data/ext/swisseph/extconf.rb

@@ -54,6 +54,21 @@ if !swisseph_sources_exist || !File.exist?(stamp_file)
   fetch_swisseph_with_cmake
 end
 
+# Enable thread-local `swed` on Apple too. Upstream sweodef.h gates TLS off for
+# __APPLE__ -- a legacy guard for Apple's old GCC 4.2, which lacked __thread.
+# Modern clang supports it on Intel and Apple Silicon, so dropping the exclusion
+# makes libswe per-thread reentrant on macOS as it already is on Linux (verified
+# under ThreadSanitizer). Idempotent; runs whether or not sources were re-fetched.
+sweodef = File.join(__dir__, 'sweodef.h')
+if File.exist?(sweodef)
+  src = File.read(sweodef)
+  patched = src.sub('!defined(TLSOFF) && !defined( __APPLE__ )', '!defined(TLSOFF)')
+  if patched != src
+    File.write(sweodef, patched)
+    puts 'Patched sweodef.h to enable thread-local swed on Apple.'
+  end
+end
+
 # Get all C source files, excluding utility programs
 $srcs = Dir.glob('*.c').select { |f|
   !['swephgen4.c', 'swemini.c', 'sweasp.c', 'swevents.c', 'swetest.c', 'sweephe4.c'].include?(f)

data/ext/swisseph/swisseph.c

@@ -21,6 +21,7 @@ along with Swisseph.  If not, see <http://www.gnu.org/licenses/>.
 
 // https://docs.ruby-lang.org/en/3.0/extension_rdoc.html
 #include <ruby.h>
+#include <string.h>
 #include "swephexp.h"
 
 // Module Name
@@ -1660,6 +1661,280 @@ static VALUE t_swe_lun_eclipse_how(VALUE self, VALUE tjd, VALUE ifl, VALUE lon,
 	return output;
 }
 
+/*
+ * Extended atmospheric refraction, with geographic altitude and lapse rate.
+ * double swe_refrac_extended(double inalt, double geoalt, double atpress, double attemp,
+ *     double lapse_rate, int32 calc_flag, double *dret);
+ * calc_flag: SE_TRUE_TO_APP or SE_APP_TO_TRUE
+ * Returns [result, dret[4]] where dret is
+ *   [0] true altitude (if possible), [1] apparent altitude,
+ *   [2] refraction, [3] dip of horizon
+ */
+static VALUE t_swe_refrac_extended(VALUE self, VALUE inalt, VALUE geoalt, VALUE atpress, VALUE attemp, VALUE lapse_rate, VALUE calc_flag)
+{
+	double dret[20];
+	double result = swe_refrac_extended(NUM2DBL(inalt), NUM2DBL(geoalt), NUM2DBL(atpress), NUM2DBL(attemp), NUM2DBL(lapse_rate), NUM2INT(calc_flag), dret);
+
+	VALUE output = rb_ary_new();
+	rb_ary_push(output, rb_float_new(result));
+	for (int i = 0; i < 4; i++)
+		rb_ary_push(output, rb_float_new(dret[i]));
+	return output;
+}
+
+/*
+ * Phenomena relevant to heliacal (and other) visibility events.
+ * int32 swe_heliacal_pheno_ut(double tjd_ut, double *geopos, double *datm, double *dobs,
+ *     char *ObjectName, int32 TypeEvent, int32 helflag, double *darr, char *serr);
+ * Args: (tjd_ut, object_name, type_event, helflag, lon, lat, height, datm_array, dobs_array)
+ * Returns darr[50]
+ */
+static VALUE t_swe_heliacal_pheno_ut(int argc, VALUE *argv, VALUE self)
+{
+	if (argc != 9)
+		rb_raise(rb_eArgError, "wrong number of arguments (9 required: tjd_ut, object_name, type_event, helflag, lon, lat, height, datm_array, dobs_array)");
+
+	char serr[AS_MAXCH];
+	double geopos[3];
+	geopos[0] = NUM2DBL(argv[4]); // lon
+	geopos[1] = NUM2DBL(argv[5]); // lat
+	geopos[2] = NUM2DBL(argv[6]); // height
+
+	VALUE datm_arr = argv[7];
+	if (TYPE(datm_arr) != T_ARRAY || RARRAY_LEN(datm_arr) < 4)
+		rb_raise(rb_eArgError, "datm must be array of 4 values [pressure, temp, humidity, extinction_coeff]");
+	double datm[4];
+	for (int i = 0; i < 4; i++)
+		datm[i] = NUM2DBL(rb_ary_entry(datm_arr, i));
+
+	VALUE dobs_arr = argv[8];
+	if (TYPE(dobs_arr) != T_ARRAY || RARRAY_LEN(dobs_arr) < 6)
+		rb_raise(rb_eArgError, "dobs must be array of 6 values [age, snellen_left, snellen_right, telescope_mag, telescope_diam, binoc_factor]");
+	double dobs[6];
+	for (int i = 0; i < 6; i++)
+		dobs[i] = NUM2DBL(rb_ary_entry(dobs_arr, i));
+
+	double darr[50];
+	char *object_name = StringValuePtr(argv[1]);
+
+	if (swe_heliacal_pheno_ut(NUM2DBL(argv[0]), geopos, datm, dobs, object_name, NUM2INT(argv[2]), NUM2INT(argv[3]), darr, serr) < 0)
+		rb_raise(rb_eRuntimeError, "%s", serr);
+
+	VALUE output = rb_ary_new();
+	for (int i = 0; i < 50; i++)
+		rb_ary_push(output, rb_float_new(darr[i]));
+	return output;
+}
+
+/*
+ * Compute the angle (arcus visionis, and object/sun altitudes) at which an object
+ * of given magnitude becomes heliacally visible.
+ * int32 swe_heliacal_angle(double tjdut, double *dgeo, double *datm, double *dobs, int32 helflag,
+ *     double mag, double azi_obj, double azi_sun, double azi_moon, double alt_moon, double *dret, char *serr);
+ * Args: (tjdut, helflag, mag, azi_obj, azi_sun, azi_moon, alt_moon, lon, lat, height, datm_array, dobs_array)
+ * Returns dret[3]: [0] topocentric arcus visionis, [1] object altitude, [2] sun altitude
+ */
+static VALUE t_swe_heliacal_angle(int argc, VALUE *argv, VALUE self)
+{
+	if (argc != 12)
+		rb_raise(rb_eArgError, "wrong number of arguments (12 required: tjdut, helflag, mag, azi_obj, azi_sun, azi_moon, alt_moon, lon, lat, height, datm_array, dobs_array)");
+
+	char serr[AS_MAXCH];
+	double dgeo[3];
+	dgeo[0] = NUM2DBL(argv[7]); // lon
+	dgeo[1] = NUM2DBL(argv[8]); // lat
+	dgeo[2] = NUM2DBL(argv[9]); // height
+
+	VALUE datm_arr = argv[10];
+	if (TYPE(datm_arr) != T_ARRAY || RARRAY_LEN(datm_arr) < 4)
+		rb_raise(rb_eArgError, "datm must be array of 4 values [pressure, temp, humidity, extinction_coeff]");
+	double datm[4];
+	for (int i = 0; i < 4; i++)
+		datm[i] = NUM2DBL(rb_ary_entry(datm_arr, i));
+
+	VALUE dobs_arr = argv[11];
+	if (TYPE(dobs_arr) != T_ARRAY || RARRAY_LEN(dobs_arr) < 6)
+		rb_raise(rb_eArgError, "dobs must be array of 6 values [age, snellen_left, snellen_right, telescope_mag, telescope_diam, binoc_factor]");
+	double dobs[6];
+	for (int i = 0; i < 6; i++)
+		dobs[i] = NUM2DBL(rb_ary_entry(dobs_arr, i));
+
+	double dret[20];
+	if (swe_heliacal_angle(NUM2DBL(argv[0]), dgeo, datm, dobs, NUM2INT(argv[1]),
+			NUM2DBL(argv[2]), NUM2DBL(argv[3]), NUM2DBL(argv[4]), NUM2DBL(argv[5]), NUM2DBL(argv[6]), dret, serr) < 0)
+		rb_raise(rb_eRuntimeError, "%s", serr);
+
+	VALUE output = rb_ary_new();
+	for (int i = 0; i < 3; i++)
+		rb_ary_push(output, rb_float_new(dret[i]));
+	return output;
+}
+
+/*
+ * Compute the topocentric arcus visionis for an object of given magnitude and geometry.
+ * int32 swe_topo_arcus_visionis(double tjdut, double *dgeo, double *datm, double *dobs, int32 helflag,
+ *     double mag, double azi_obj, double alt_obj, double azi_sun, double azi_moon, double alt_moon, double *dret, char *serr);
+ * Args: (tjdut, helflag, mag, azi_obj, alt_obj, azi_sun, azi_moon, alt_moon, lon, lat, height, datm_array, dobs_array)
+ * Returns dret[1]: topocentric arcus visionis in degrees
+ */
+static VALUE t_swe_topo_arcus_visionis(int argc, VALUE *argv, VALUE self)
+{
+	if (argc != 13)
+		rb_raise(rb_eArgError, "wrong number of arguments (13 required: tjdut, helflag, mag, azi_obj, alt_obj, azi_sun, azi_moon, alt_moon, lon, lat, height, datm_array, dobs_array)");
+
+	char serr[AS_MAXCH];
+	double dgeo[3];
+	dgeo[0] = NUM2DBL(argv[8]);  // lon
+	dgeo[1] = NUM2DBL(argv[9]);  // lat
+	dgeo[2] = NUM2DBL(argv[10]); // height
+
+	VALUE datm_arr = argv[11];
+	if (TYPE(datm_arr) != T_ARRAY || RARRAY_LEN(datm_arr) < 4)
+		rb_raise(rb_eArgError, "datm must be array of 4 values [pressure, temp, humidity, extinction_coeff]");
+	double datm[4];
+	for (int i = 0; i < 4; i++)
+		datm[i] = NUM2DBL(rb_ary_entry(datm_arr, i));
+
+	VALUE dobs_arr = argv[12];
+	if (TYPE(dobs_arr) != T_ARRAY || RARRAY_LEN(dobs_arr) < 6)
+		rb_raise(rb_eArgError, "dobs must be array of 6 values [age, snellen_left, snellen_right, telescope_mag, telescope_diam, binoc_factor]");
+	double dobs[6];
+	for (int i = 0; i < 6; i++)
+		dobs[i] = NUM2DBL(rb_ary_entry(dobs_arr, i));
+
+	double dret[20];
+	if (swe_topo_arcus_visionis(NUM2DBL(argv[0]), dgeo, datm, dobs, NUM2INT(argv[1]),
+			NUM2DBL(argv[2]), NUM2DBL(argv[3]), NUM2DBL(argv[4]), NUM2DBL(argv[5]), NUM2DBL(argv[6]), NUM2DBL(argv[7]), dret, serr) < 0)
+		rb_raise(rb_eRuntimeError, "%s", serr);
+
+	VALUE output = rb_ary_new();
+	rb_ary_push(output, rb_float_new(dret[0]));
+	return output;
+}
+
+/*
+ * Find geographic location where an occultation of a body by the Moon is
+ * central (or maximal) at a given tjd. This is the occultation analogue of
+ * swe_sol_eclipse_where (a solar eclipse is the Moon occulting the Sun).
+ * int32 swe_lun_occult_where(double tjd, int32 ipl, char *starname, int32 ifl, double *geopos, double *attr, char *serr);
+ * ipl: planet number of the occulted body (ignored when starname is given)
+ * starname: fixed-star name, or nil / "" to occult the planet in ipl
+ * Returns [type, geopos[2], attr[20]]
+ */
+static VALUE t_swe_lun_occult_where(VALUE self, VALUE tjd, VALUE ipl, VALUE starname, VALUE ifl)
+{
+	char serr[AS_MAXCH];
+	char star[AS_MAXCH];
+	double geopos[10];
+	double attr[20];
+
+	if (NIL_P(starname))
+		star[0] = '\0';
+	else {
+		strncpy(star, StringValueCStr(starname), AS_MAXCH - 1);
+		star[AS_MAXCH - 1] = '\0';
+	}
+
+	int32 result = swe_lun_occult_where(NUM2DBL(tjd), NUM2INT(ipl), star, NUM2INT(ifl), geopos, attr, serr);
+	if (result < 0)
+		rb_raise(rb_eRuntimeError, "%s", serr);
+
+	VALUE output = rb_ary_new();
+	rb_ary_push(output, INT2NUM(result)); // eclipse type flags
+
+	VALUE _geopos = rb_ary_new();
+	rb_ary_push(_geopos, rb_float_new(geopos[0])); // longitude
+	rb_ary_push(_geopos, rb_float_new(geopos[1])); // latitude
+	rb_ary_push(output, _geopos);
+
+	VALUE _attr = rb_ary_new();
+	for (int i = 0; i < 20; i++)
+		rb_ary_push(_attr, rb_float_new(attr[i]));
+	rb_ary_push(output, _attr);
+
+	return output;
+}
+
+/*
+ * Find the time of the next (or previous) occultation of a body by the Moon
+ * visible from a given location. Occultation analogue of swe_sol_eclipse_when_loc.
+ * int32 swe_lun_occult_when_loc(double tjd_start, int32 ipl, char *starname, int32 ifl,
+ *     double *geopos, double *tret, double *attr, int32 backward, char *serr);
+ * starname: fixed-star name, or nil / "" to occult the planet in ipl
+ * Returns [type, tret[10], attr[20]]
+ */
+static VALUE t_swe_lun_occult_when_loc(VALUE self, VALUE tjd_start, VALUE ipl, VALUE starname, VALUE ifl, VALUE lon, VALUE lat, VALUE height, VALUE backward)
+{
+	char serr[AS_MAXCH];
+	char star[AS_MAXCH];
+	double geopos[3];
+	double tret[10];
+	double attr[20];
+
+	geopos[0] = NUM2DBL(lon);
+	geopos[1] = NUM2DBL(lat);
+	geopos[2] = NUM2DBL(height);
+
+	if (NIL_P(starname))
+		star[0] = '\0';
+	else {
+		strncpy(star, StringValueCStr(starname), AS_MAXCH - 1);
+		star[AS_MAXCH - 1] = '\0';
+	}
+
+	int32 result = swe_lun_occult_when_loc(NUM2DBL(tjd_start), NUM2INT(ipl), star, NUM2INT(ifl), geopos, tret, attr, NUM2INT(backward), serr);
+	if (result < 0)
+		rb_raise(rb_eRuntimeError, "%s", serr);
+
+	VALUE output = rb_ary_new();
+	rb_ary_push(output, INT2NUM(result)); // eclipse type flags
+
+	VALUE _tret = rb_ary_new();
+	for (int i = 0; i < 10; i++)
+		rb_ary_push(_tret, rb_float_new(tret[i]));
+	rb_ary_push(output, _tret);
+
+	VALUE _attr = rb_ary_new();
+	for (int i = 0; i < 20; i++)
+		rb_ary_push(_attr, rb_float_new(attr[i]));
+	rb_ary_push(output, _attr);
+
+	return output;
+}
+
+/*
+ * Find the time of the next (or previous) occultation of a body by the Moon
+ * anywhere on Earth. Occultation analogue of swe_sol_eclipse_when_glob.
+ * int32 swe_lun_occult_when_glob(double tjd_start, int32 ipl, char *starname, int32 ifl, int32 ifltype,
+ *     double *tret, int32 backward, char *serr);
+ * ifltype: SE_ECL_TOTAL, SE_ECL_ANNULAR, SE_ECL_PARTIAL, SE_ECL_CENTRAL, SE_ECL_NONCENTRAL, or 0 for any
+ * starname: fixed-star name, or nil / "" to occult the planet in ipl
+ * Returns [type, tret[10]]
+ */
+static VALUE t_swe_lun_occult_when_glob(VALUE self, VALUE tjd_start, VALUE ipl, VALUE starname, VALUE ifl, VALUE ifltype, VALUE backward)
+{
+	char serr[AS_MAXCH];
+	char star[AS_MAXCH];
+	double tret[10];
+
+	if (NIL_P(starname))
+		star[0] = '\0';
+	else {
+		strncpy(star, StringValueCStr(starname), AS_MAXCH - 1);
+		star[AS_MAXCH - 1] = '\0';
+	}
+
+	int32 result = swe_lun_occult_when_glob(NUM2DBL(tjd_start), NUM2INT(ipl), star, NUM2INT(ifl), NUM2INT(ifltype), tret, NUM2INT(backward), serr);
+	if (result < 0)
+		rb_raise(rb_eRuntimeError, "%s", serr);
+
+	VALUE output = rb_ary_new();
+	rb_ary_push(output, INT2NUM(result)); // eclipse type flags
+	for (int i = 0; i < 10; i++)
+		rb_ary_push(output, rb_float_new(tret[i]));
+	return output;
+}
+
 void Init_swisseph()
 {
 	// Module
@@ -1698,6 +1973,7 @@ void Init_swisseph()
 	rb_define_module_function(rb_mSwisseph, "swe_azalt", t_swe_azalt, 10);
 	rb_define_module_function(rb_mSwisseph, "swe_azalt_rev", t_swe_azalt_rev, 7);
 	rb_define_module_function(rb_mSwisseph, "swe_refrac", t_swe_refrac, 4);
+	rb_define_module_function(rb_mSwisseph, "swe_refrac_extended", t_swe_refrac_extended, 6);
 	rb_define_module_function(rb_mSwisseph, "swe_pheno_ut", t_swe_pheno_ut, 3);
 	rb_define_module_function(rb_mSwisseph, "swe_time_equ", t_swe_time_equ, 1);
 	rb_define_module_function(rb_mSwisseph, "swe_lmt_to_lat", t_swe_lmt_to_lat, 2);
@@ -1726,9 +2002,15 @@ void Init_swisseph()
 	rb_define_module_function(rb_mSwisseph, "swe_lun_eclipse_when", t_swe_lun_eclipse_when, 4);
 	rb_define_module_function(rb_mSwisseph, "swe_lun_eclipse_when_loc", t_swe_lun_eclipse_when_loc, 6);
 	rb_define_module_function(rb_mSwisseph, "swe_lun_eclipse_how", t_swe_lun_eclipse_how, 5);
+	rb_define_module_function(rb_mSwisseph, "swe_lun_occult_where", t_swe_lun_occult_where, 4);
+	rb_define_module_function(rb_mSwisseph, "swe_lun_occult_when_loc", t_swe_lun_occult_when_loc, 8);
+	rb_define_module_function(rb_mSwisseph, "swe_lun_occult_when_glob", t_swe_lun_occult_when_glob, 6);
 	rb_define_module_function(rb_mSwisseph, "swe_gauquelin_sector", t_swe_gauquelin_sector, 9);
 	rb_define_module_function(rb_mSwisseph, "swe_heliacal_ut", t_swe_heliacal_ut, -1);
 	rb_define_module_function(rb_mSwisseph, "swe_vis_limit_mag", t_swe_vis_limit_mag, -1);
+	rb_define_module_function(rb_mSwisseph, "swe_heliacal_pheno_ut", t_swe_heliacal_pheno_ut, -1);
+	rb_define_module_function(rb_mSwisseph, "swe_heliacal_angle", t_swe_heliacal_angle, -1);
+	rb_define_module_function(rb_mSwisseph, "swe_topo_arcus_visionis", t_swe_topo_arcus_visionis, -1);
 
 	// ET (Ephemeris Time) versions
 	rb_define_module_function(rb_mSwisseph, "swe_calc", t_swe_calc, 3);

data/lib/swisseph.rb

@@ -17,26 +17,39 @@ module Swisseph
 end
 
 module Swisseph
-  # The Swiss Ephemeris C library (libswe) keeps process-global state and a
-  # shared file descriptor for its data files, so it is NOT thread-safe: two
-  # threads executing inside it at once can segfault the process. Every native
-  # call is serialized through one global re-entrant lock so concurrent threads
-  # -- e.g. a multi-threaded Puma app plus in-process background workers --
-  # can never be inside libswe simultaneously. A single-threaded caller never
-  # contends for the lock; concurrent callers are serialized (a brief wait, not
-  # a segfault).
+  # The Swiss Ephemeris C library keeps its mutable state in one `struct swe_data
+  # swed`. On a build where `swed` is a plain process global it is NOT thread-safe:
+  # two threads inside the C library at once can segfault the process, so every
+  # native call is serialized through this global re-entrant lock.
+  #
+  # BUT libswe declares `swed` with the `TLS` macro (sweodef.h). On any build where
+  # TLS resolves to real thread-local storage (`__thread` / `_Thread_local` /
+  # `__declspec(thread)`) each thread gets its own `swed` -- own file descriptors,
+  # own caches -- and the library is genuinely per-thread reentrant. That is the
+  # case on Linux, and on macOS with the extconf.rb patch that drops the legacy
+  # `__APPLE__` exclusion (modern clang supports __thread). On such a build the
+  # lock is pure overhead: it serializes ephemeris work that could run in parallel.
   LOCK = Monitor.new
+
+  # Serialize native calls through LOCK unless explicitly disabled. Set
+  # SWISSEPH_NOLOCK=1 ONLY on a thread-local (TLS) build -- disabling the lock on a
+  # non-TLS build will segfault under concurrency. Reentrancy verified 2026-08-19
+  # under ThreadSanitizer (12 threads, no lock, zero data races, exact values).
+  LOCKING = ENV['SWISSEPH_NOLOCK'] != '1'
 end
 
-# Wrap every current singleton method (the native swe_* methods and the
-# shorthand aliases defined above) so each public entry point takes the lock.
-Swisseph.singleton_class.prepend(
-  Module.new do
-    lock = Swisseph::LOCK
-    Swisseph.singleton_methods(false).each do |name|
-      define_method(name) do |*args, &block|
-        lock.synchronize { super(*args, &block) }
+# Wrap every current singleton method (the native swe_* methods and the shorthand
+# aliases defined above) so each public entry point takes the lock -- unless
+# locking is disabled, in which case the native methods are called directly.
+if Swisseph::LOCKING
+  Swisseph.singleton_class.prepend(
+    Module.new do
+      lock = Swisseph::LOCK
+      Swisseph.singleton_methods(false).each do |name|
+        define_method(name) do |*args, &block|
+          lock.synchronize { super(*args, &block) }
+        end
       end
     end
-  end
-)
+  )
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: swisseph
 version: !ruby/object:Gem::Version
-  version: 1.4.1
+  version: 1.4.2
 platform: ruby
 authors:
 - David Lowenfels