solunar 0.0.2

data/ext/solunar/Source_Files/ilum_2016.txt

@@ -0,0 +1,31 @@
+ 01     055     044     052     039     033     016     010     002     000     001     004     005
+ 02     045     035     042     028     023     008     004     000     002     003     008     010
+ 03     036     026     033     019     014     003     001     001     006     007     014     016
+ 04     027     017     023     011     006     000     000     004     011     012     021     024
+ 05     019     010     015     004     002     001     002     009     017     019     030     033
+ 06     012     005     008     001     000     004     006     015     025     027     039     043
+ 07     006     001     003     000     002     009     013     023     034     036     049     054
+ 08     002     000     000     003     006     017     020     031     043     046     060     065
+ 09     000     002     001     008     012     025     029     041     053     056     070     075
+ 10     001     006     004     016     021     035     038     050     062     066     080     085
+ 11     004     013     010     025     030     044     047     059     072     075     088     092
+ 12     009     022     019     035     040     054     057     069     081     084     095     097
+ 13     016     033     029     046     051     063     066     077     088     092     099     100
+ 14     026     044     040     056     060     072     075     085     094     097     100     099
+ 15     036     055     051     066     070     080     083     092     099     100     098     096
+ 16     048     066     061     075     078     087     089     097     100     099     093     090
+ 17     059     076     071     083     085     093     095     099     099     096     086     082
+ 18     070     084     080     090     091     097     098     100     095     090     077     073
+ 19     079     091     087     095     096     099     100     098     088     082     067     063
+ 20     088     096     093     098     099     100     099     093     079     072     056     053
+ 21     094     099     097     100     100     098     096     086     069     062     046     044
+ 22     098     100     099     100     099     094     091     077     058     051     036     034
+ 23     100     099     100     098     097     089     084     066     046     040     027     026
+ 24     099     096     099     094     092     081     074     055     036     030     019     018
+ 25     097     092     095     089     086     072     064     043     026     021     012     011
+ 26     093     086     091     082     078     061     053     032     017     014     007     006
+ 27     087     079     085     074     069     050     041     022     010     008     003     002
+ 28     080     071     077     065     058     039     030     014     005     004     001     000
+ 29     072     062     069     054     047     028     020     007     002     001     000     000
+ 30     063     ***     059     044     036     018     012     003     000     000     002     002
+ 31     054     ***     049     ***     026     ***     006     000     ***     001     ***     006

data/ext/solunar/Source_Files/ilum_2017.txt

@@ -0,0 +1,31 @@
+ 01     012     024     012     028     035     052     057     070     080     083     092     094 
+ 02     019     034     021     039     046     063     067     078     087     090     097     099
+ 03     028     045     031     050     057     072     075     085     093     095     100     100
+ 04     038     057     042     061     067     080     083     091     097     099     099     098
+ 05     049     068     053     071     076     087     090     096     100     100     096     093
+ 06     061     078     064     080     084     093     095     099     100     099     091     086
+ 07     071     087     075     088     091     097     098     100     097     095     083     077
+ 08     081     094     084     094     096     099     100     099     093     088     073     067
+ 09     090     098     091     098     099     100     100     096     086     080     062     056
+ 10     096     100     096     100     100     099     098     091     077     070     051     046
+ 11     099     099     099     100     099     096     094     084     067     059     040     035
+ 12     100     097     100     098     097     091     088     075     056     047     030     026
+ 13     098     092     099     094     093     085     081     065     045     036     021     018
+ 14     093     085     095     089     087     077     072     054     033     026     013     011
+ 15     087     078     090     082     080     068     062     042     023     017     007     006
+ 16     079     069     084     075     072     058     051     031     014     010     003     002
+ 17     071     060     076     066     063     047     040     021     007     005     001     000
+ 18     061     051     068     057     053     036     029     012     003     001     000     000
+ 19     052     041     059     047     043     026     019     005     000     000     002     002
+ 20     042     032     049     037     032     016     010     001     000     001     005     005
+ 21     033     024     040     027     022     009     004     000     003     004     010     010
+ 22     025     016     030     018     014     003     001     001     007     009     016     017
+ 23     017     009     022     010     007     000     000     005     013     015     023     025
+ 24     010     004     014     005     002     001     003     010     020     022     031     034
+ 25     005     001     007     001     000     004     007     018     028     030     041     044
+ 26     002     000     003     000     002     010     014     026     037     039     051     054
+ 27     000     002     000     003     006     018     022     035     047     048     061     064
+ 28     001     006     001     008     013     027     032     044     056     058     071     075
+ 29     003     ***     004     015     021     037     041     054     065     068     080     084
+ 30     008     ***     010     025     031     047     051     063     074     077     088     092
+ 31     015     ***     018     ***     042     ***     061     072     ***     085     ***     097

data/ext/solunar/Source_Files/ilum_2018.txt

@@ -0,0 +1,32 @@
+ 01     100     098     100     098     097     091     089     079     065     058     038     031
+ 02     099     093     099     094     093     085     083     071     054     046     028     022
+ 03     096     087     096     089     087     078     075     061     043     035     018     013
+ 04     090     078     091     082     080     069     066     050     032     024     010     007
+ 05     082     069     084     073     072     060     056     039     022     015     005     003
+ 06     072     059     076     065     063     050     046     029     013     008     001     000
+ 07     062     049     066     055     053     040     035     019     006     003     000     000
+ 08     052     040     057     046     044     031     025     010     002     000     001     002
+ 09     042     031     047     037     034     021     016     004     000     001     005     006
+ 10     032     022     038     028     025     013     008     001     002     003     010     011
+ 11     024     015     029     019     017     006     003     000     006     008     017     018
+ 12     016     009     021     012     010     002     000     003     012     015     024     025
+ 13     010     004     014     006     004     000     001     008     020     023     033     034
+ 14     005     001     008     002     001     001     004     015     029     031     042     043
+ 15     002     000     003     000     000     006     010     024     038     041     051     053
+ 16     000     001     001     001     002     012     018     034     048     050     061     062
+ 17     000     004     000     004     007     021     028     044     058     060     070     072
+ 18     002     008     002     009     014     031     039     054     067     069     078     081
+ 19     006     015     006     017     024     042     049     064     075     077     086     088
+ 20     012     023     012     026     034     053     060     073     083     085     092     095
+ 21     019     033     020     037     046     064     069     081     089     091     097     099
+ 22     028     044     029     048     057     074     078     088     095     096     100     100
+ 23     038     055     040     060     067     082     086     093     098     099     100     099
+ 24     048     066     051     070     077     089     092     097     100     100     097     094
+ 25     059     076     063     080     085     094     096     099     099     099     092     087
+ 26     070     086     073     088     092     098     099     100     097     095     084     079
+ 27     080     093     083     094     096     100     100     098     093     089     075     068
+ 28     089     098     091     098     099     100     099     095     086     081     064     057
+ 29     095     ***     096     100     100     098     097     090     078     072     053     046
+ 30     099     ***     099     099     099     094     093     083     068     061     042     036
+ 31     100     ***     100     ***     096     ***     087     074     ***     049     ***     026
+

data/ext/solunar/Source_Files/ilum_2019.txt

@@ -0,0 +1,31 @@
+ 01     017     009     020     012     010     003     002     001     008     013     025     027
+ 02     010     004     013     007     005     001     000     004     016     021     034     036
+ 03     005     001     007     003     002     000     001     010     025     030     044     045
+ 04     002     000     003     001     000     002     005     019     035     041     053     054
+ 05     000     001     001     000     001     007     012     028     046     051     063     064
+ 06     000     003     000     002     004     014     021     039     057     060     071     073
+ 07     003     007     001     006     009     023     031     050     066     070     079     081
+ 08     006     013     004     012     016     033     042     061     075     078     087     088
+ 09     012     020     009     019     025     044     053     071     083     085     092     093
+ 10     019     029     015     028     035     056     064     080     090     091     097     098
+ 11     026     038     023     039     047     067     074     087     095     096     099     100
+ 12     035     048     033     050     058     077     083     093     098     099     100     100
+ 13     045     059     043     061     069     086     090     097     100     100     098     097
+ 14     055     069     054     072     079     092     095     099     100     099     095     093
+ 15     065     079     065     082     088     097     099     100     098     097     090     086
+ 16     075     088     075     090     094     100     100     099     094     092     082     077
+ 17     084     095     084     096     098     100     099     095     089     086     073     066
+ 18     091     099     092     099     100     098     097     091     082     078     063     055
+ 19     097     100     097     100     099     094     093     085     074     069     052     044
+ 20     100     098     100     098     096     089     087     077     064     059     040     033
+ 21     100     093     099     093     091     082     080     068     054     048     029     023
+ 22     096     086     096     087     084     074     072     059     043     037     019     014
+ 23     091     078     090     079     077     066     063     049     033     026     011     007
+ 24     082     068     083     071     068     056     053     038     022     016     005     003
+ 25     073     058     074     061     059     047     043     028     013     008     001     000
+ 26     062     047     064     052     050     037     033     019     006     003     000     000
+ 27     052     038     054     042     040     028     024     011     002     000     002     003
+ 28     041     028     045     033     031     019     015     004     000     001     005     007
+ 29     031     ***     035     025     022     012     008     001     002     004     011     013
+ 30     022     ***     026     017     015     006     003     000     006     009     018     020
+ 31     015     ***     019     ***     008     ***     000     003     ***     016     ***     028

data/ext/solunar/Source_Files/ilum_2020.txt

@@ -0,0 +1,31 @@
+ 01     037     047     039     054     060     079     086     096     100     100     099     098
+ 02     046     057     049     064     071     087     093     099     100     099     096     095
+ 03     055     066     059     074     081     094     097     100     098     097     091     089
+ 04     065     076     070     084     089     098     100     099     094     093     085     082
+ 05     074     084     079     092     096     100     100     095     089     087     078     074
+ 06     082     091     087     097     099     099     097     091     082     080     069     064
+ 07     089     097     094     100     100     095     093     084     074     072     059     053
+ 08     095     099     098     099     098     090     087     077     066     063     048     042
+ 09     099     100     100     096     093     082     079     068     056     053     037     031
+ 10     100     097     098     090     086     074     071     059     047     043     027     021
+ 11     099     091     094     082     077     065     062     050     037     032     017     012
+ 12     095     083     087     073     068     055     052     040     027     022     009     005
+ 13     089     074     078     063     058     046     043     031     018     014     003     001
+ 14     080     063     068     052     049     036     034     022     010     007     000     000
+ 15     070     052     057     042     039     027     025     014     004     002     000     002
+ 16     059     041     046     033     030     019     017     007     001     000     003     006
+ 17     048     031     036     024     022     012     010     003     000     001     009     012
+ 18     037     022     027     016     014     007     005     000     003     006     017     020
+ 19     026     014     019     010     008     002     001     001     008     013     026     029
+ 20     018     008     012     005     004     000     000     004     016     021     036     038
+ 21     010     003     006     002     001     000     001     010     025     031     046     048
+ 22     005     001     003     000     000     002     005     018     036     042     056     057
+ 23     001     000     001     001     001     007     012     028     047     052     065     067
+ 24     000     001     000     003     004     014     020     039     057     062     074     075
+ 25     001     004     002     007     009     022     030     050     068     072     082     083
+ 26     003     009     005     012     016     032     041     061     077     080     088     089
+ 27     008     015     010     020     025     043     053     071     085     087     094     095
+ 28     014     022     016     028     035     055     064     081     091     093     097     098
+ 29     021     030     024     038     046     066     074     088     096     097     100     100
+ 30     029     ***     033     049     057     077     083     094     099     099     100     100
+ 31     038     ***     043     ***     068     ***     091     098     ***     100     ***     097

data/ext/solunar/Source_Files/ilum_2021.txt

@@ -0,0 +1,31 @@
+ 01     093     082     092     079     072     056     051     039     028     025     013     010
+ 02     086     072     085     068     062     046     042     030     019     017     007     004
+ 03     078     061     075     058     051     036     032     022     012     009     002     001
+ 04     068     050     065     046     040     027     024     014     006     004     000     000
+ 05     057     039     054     036     031     019     016     008     002     001     001     003
+ 06     046     028     042     026     022     012     010     004     000     000     005     009
+ 07     035     019     032     018     014     006     005     001     001     002     012     017
+ 08     024     011     022     011     008     003     002     000     004     007     021     026
+ 09     015     005     014     005     004     000     000     002     009     015     031     036
+ 10     008     001     008     002     001     000     001     006     017     024     042     047
+ 11     003     000     003     000     000     002     003     012     027     035     052     057
+ 12     000     001     001     000     001     005     008     020     038     046     063     067
+ 13     000     004     000     003     003     010     014     029     049     057     073     076
+ 14     003     009     002     006     008     017     022     040     060     067     081     083
+ 15     008     016     005     012     014     025     032     051     071     077     088     090
+ 16     014     023     010     018     021     035     043     063     080     085     094     095
+ 17     022     031     017     026     030     046     054     073     088     092     098     098
+ 18     030     040     024     035     039     057     065     083     094     096     100     100
+ 19     040     050     033     045     050     068     076     091     098     099     100     100
+ 20     049     059     042     055     060     078     085     096     100     100     098     098
+ 21     058     069     051     065     071     087     092     099     099     099     095     094
+ 22     067     077     061     075     081     094     097     100     097     096     090     089
+ 23     076     085     071     084     089     098     100     098     092     091     084     082
+ 24     084     092     080     092     095     100     099     094     087     085     076     074
+ 25     090     097     088     097     099     099     096     089     080     078     068     064
+ 26     095     099     094     100     100     094     091     082     071     070     058     054
+ 27     099     100     098     099     098     088     084     073     063     061     048     043
+ 28     100     097     100     096     092     080     076     065     053     051     037     032
+ 29     099     ***     099     090     085     071     067     055     044     041     027     022
+ 30     095     ***     094     082     076     061     058     046     034     031     018     013
+ 31     089     ***     088     ***     066     ***     048     037     ***     022     ***     006

data/ext/solunar/Source_Files/ilum_2022.txt

@@ -0,0 +1,31 @@
+ 01     002     001     001     000     001     005     006     015     029     036     056     063
+ 02     000     003     000     002     003     010     012     023     039     047     067     073
+ 03     002     008     001     006     008     016     019     032     050     059     077     082
+ 04     006     015     005     012     014     023     027     042     061     070     085     089
+ 05     012     024     010     019     021     032     036     053     072     080     092     094
+ 06     021     033     017     027     029     041     047     064     082     088     097     098
+ 07     030     042     025     036     038     051     057     075     090     094     099     100
+ 08     040     052     034     045     048     062     068     084     096     098     100     100
+ 09     050     061     044     055     057     072     078     092     099     100     098     098
+ 10     060     070     053     064     067     081     087     097     100     099     095     094
+ 11     069     078     062     073     077     089     094     100     098     096     090     089
+ 12     077     085     071     082     085     095     098     099     093     091     083     082
+ 13     085     091     079     089     092     099     100     096     087     085     075     074
+ 14     091     096     087     095     097     100     098     090     079     077     067     066
+ 15     095     099     093     099     100     097     094     083     070     068     058     056
+ 16     098     100     097     100     100     092     087     074     061     059     048     046
+ 17     100     099     099     099     096     085     079     064     052     050     039     036
+ 18     099     095     100     095     090     075     069     054     042     040     029     027
+ 19     097     090     097     088     082     065     059     045     033     031     020     018
+ 20     093     083     093     080     072     054     049     035     024     023     013     010
+ 21     086     074     086     070     062     044     039     027     017     015     006     004
+ 22     079     063     077     059     050     034     029     019     010     008     002     001
+ 23     069     052     067     047     040     024     021     012     005     003     000     000
+ 24     059     041     056     036     029     017     014     007     002     001     001     003
+ 25     048     030     044     026     020     010     008     003     000     000     005     008
+ 26     037     020     033     017     013     005     004     001     001     002     011     016
+ 27     026     012     023     010     007     002     001     000     004     007     019     025
+ 28     017     005     014     005     003     000     000     002     009     014     030     036
+ 29     009     ***     007     001     000     000     001     006     016     023     040     047
+ 30     003     ***     003     000     000     003     004     012     025     033     052     058
+ 31     001     ***     000     ***     002     ***     009     019     ***     044     ***     068

data/ext/solunar/Source_Files/ilum_2023.txt

@@ -0,0 +1,31 @@
+ 01     077     086     073     082     084     093     096     100     096     093     083     081
+ 02     084     092     080     089     091     097     099     098     090     086     074     073
+ 03     091     096     087     094     096     100     100     094     082     077     065     064
+ 04     096     099     093     098     099     099     097     087     072     068     056     055
+ 05     099     100     097     100     100     096     092     078     062     058     046     045
+ 06     100     099     099     100     099     091     085     068     052     048     037     036
+ 07     099     096     100     097     095     083     075     057     042     039     028     027
+ 08     097     092     099     093     089     073     065     047     032     030     020     019
+ 09     093     086     095     086     081     062     054     037     024     022     013     012
+ 10     088     078     090     078     071     051     043     027     016     014     007     006
+ 11     081     070     083     068     060     040     032     019     010     008     003     002
+ 12     073     060     075     057     048     029     023     012     005     004     000     000
+ 13     064     049     065     046     037     020     015     006     002     001     000     001
+ 14     054     038     054     035     026     012     009     003     000     000     002     004
+ 15     043     028     043     024     017     006     004     001     000     001     006     010
+ 16     033     018     032     015     010     002     001     000     003     004     013     018
+ 17     023     010     021     008     004     000     000     002     007     009     021     028
+ 18     014     004     012     003     001     000     001     005     012     016     031     039
+ 19     007     001     006     000     000     003     004     010     020     025     042     050
+ 20     002     000     001     000     001     006     008     016     029     035     054     061
+ 21     000     003     000     003     005     012     014     024     039     046     065     072
+ 22     001     009     001     008     010     019     021     033     049     057     075     081
+ 23     006     016     005     014     016     026     029     043     061     068     084     089
+ 24     012     025     011     022     024     035     039     054     071     078     092     094
+ 25     021     034     019     030     033     045     048     064     081     087     097     098
+ 26     031     044     028     039     042     054     059     075     090     094     099     100
+ 27     041     054     037     049     051     064     069     084     096     098     100     099
+ 28     051     064     047     058     061     074     078     092     099     100     098     097
+ 29     061     ***     056     067     070     082     087     097     100     099     094     093
+ 30     071     ***     066     076     079     090     094     100     097     095     088     087
+ 31     079     ***     074     ***     087     ***     098     099     ***     090     ***     080

data/ext/solunar/Source_Files/ilum_2024.txt

@@ -0,0 +1,31 @@
+ 01     072     062     069     054     047     027     020     008     002     001     000     000
+ 02     063     052     059     043     036     018     012     003     000     000     001     002
+ 03     054     042     049     032     025     010     006     001     000     001     005     007
+ 04     044     032     038     022     016     004     002     000     003     003     010     013
+ 05     035     023     028     013     008     001     000     002     006     008     017     020
+ 06     026     014     018     006     003     000     001     005     012     014     025     030
+ 07     017     007     010     002     000     002     004     010     018     021     034     040
+ 08     010     002     004     000     001     006     008     016     026     030     045     051
+ 09     004     000     001     001     004     012     014     024     035     039     056     063
+ 10     001     001     000     006     009     019     022     032     045     050     067     073
+ 11     000     005     003     012     016     027     030     042     055     060     077     083
+ 12     002     011     008     020     024     036     039     051     065     071     086     091
+ 13     007     020     016     030     033     046     048     061     075     081     093     096
+ 14     015     030     025     040     043     055     058     071     084     089     098     099
+ 15     024     041     035     050     053     064     067     080     092     096     100     100
+ 16     034     051     046     059     062     073     076     088     097     099     099     097
+ 17     046     062     056     069     071     081     084     094     100     100     095     093
+ 18     057     072     066     077     079     088     091     098     099     097     089     087
+ 19     067     080     075     084     086     094     096     100     096     092     081     079
+ 20     077     087     083     091     092     098     099     099     090     085     072     070
+ 21     085     093     089     095     097     100     100     094     081     076     063     061
+ 22     091     097     094     099     099     099     098     087     072     066     053     052
+ 23     096     099     098     100     100     096     093     079     061     056     044     042
+ 24     099     100     100     099     098     091     085     068     050     046     034     033
+ 25     100     099     100     097     095     083     076     057     040     036     026     025
+ 26     099     096     098     092     089     074     066     046     030     027     018     017
+ 27     096     091     095     086     081     063     054     036     022     019     011     010
+ 28     092     085     089     078     072     052     043     026     014     012     006     005
+ 29     086     077     082     069     061     041     032     017     008     007     002     002
+ 30     079     ***     074     058     050     030     023     010     004     003     000     000
+ 31     071     ***     065     ***     038     ***     014     005     ***     001     ***     001

data/ext/solunar/Source_Files/ilum_2025.txt

@@ -0,0 +1,31 @@
+ 01     004     013     004     016     021     036     040     052     064     067     081     085
+ 02     009     022     010     025     031     046     050     062     073     077     089     093
+ 03     017     032     019     036     042     056     059     071     082     085     095     098
+ 04     026     043     029     046     052     065     068     079     089     092     099     100
+ 05     036     055     040     057     062     074     077     086     095     097     100     099
+ 06     047     066     051     067     071     082     084     093     099     100     098     095
+ 07     059     076     062     076     080     089     090     097     100     099     093     089
+ 08     070     084     072     084     087     094     095     100     099     096     085     081
+ 09     079     091     081     091     092     098     099     100     095     090     076     071
+ 10     088     096     088     095     097     100     100     098     088     082     066     061
+ 11     094     099     094     099     099     100     099     093     079     072     055     051
+ 12     098     100     098     100     100     098     096     086     069     061     045     041
+ 13     100     099     100     099     099     094     091     077     058     050     035     032
+ 14     099     095     100     097     096     088     084     067     047     039     026     024
+ 15     096     091     098     093     091     081     075     055     036     029     018     016
+ 16     092     084     095     088     085     072     064     044     026     020     011     010
+ 17     085     077     090     081     077     062     053     033     017     013     006     005
+ 18     078     069     083     073     068     051     042     023     010     007     002     002
+ 19     069     059     075     063     058     039     031     014     004     003     000     000
+ 20     060     050     067     053     047     029     021     007     001     001     000     001
+ 21     051     040     057     043     036     019     012     003     000     000     002     003
+ 22     042     031     047     032     026     010     006     000     001     002     006     007
+ 23     032     022     037     022     016     004     002     000     004     005     011     013
+ 24     024     014     027     013     008     001     000     002     008     009     017     020
+ 25     016     007     018     006     003     000     001     006     014     016     025     029
+ 26     009     002     010     002     000     002     005     012     021     023     034     039
+ 27     004     000     004     000     001     007     010     019     029     031     044     050
+ 28     001     001     001     001     004     014     017     027     038     041     055     061
+ 29     000     ***     000     006     010     022     025     036     048     051     066     071
+ 30     002     ***     003     013     017     030     033     045     058     061     076     081
+ 31     006     ***     008     ***     026     ***     043     055     ***     071     ***     090

data/ext/solunar/Source_Files/ilum_2026.txt

@@ -0,0 +1,32 @@
+ 01     096     100     096     100     100     098     097     090     078     070     051     045
+ 02     099     099     099     099     099     095     093     083     068     059     040     034
+ 03     100     096     100     097     096     090     087     075     057     048     030     025
+ 04     097     091     098     093     092     083     080     065     045     037     020     017
+ 05     093     084     094     087     086     076     071     054     034     026     013     010
+ 06     086     076     089     081     079     067     061     043     023     017     007     005
+ 07     078     067     082     073     070     057     051     032     014     010     003     002
+ 08     069     058     074     064     061     047     040     021     007     004     000     000
+ 09     059     048     065     054     051     036     029     012     002     001     000     001
+ 10     049     039     056     045     041     026     019     006     000     000     002     003
+ 11     040     030     047     035     031     016     011     001     000     001     006     007
+ 12     031     021     037     026     022     009     004     000     003     005     011     012
+ 13     022     014     028     017     013     003     001     001     008     010     018     019
+ 14     015     008     020     010     006     000     000     005     014     016     025     027
+ 15     009     003     012     004     002     001     003     011     022     024     034     036
+ 16     004     001     006     001     000     004     008     019     030     032     043     045
+ 17     001     000     002     000     001     010     015     028     040     041     053     055
+ 18     000     002     000     002     006     018     023     037     049     051     062     066
+ 19     001     006     001     008     013     028     033     047     058     060     072     076
+ 20     004     012     004     015     021     038     043     056     068     070     081     085
+ 21     009     021     010     024     032     048     053     065     076     078     089     092
+ 22     016     030     018     035     042     059     063     074     084     086     095     097
+ 23     024     041     027     046     053     068     072     082     091     093     099     100
+ 24     034     053     038     057     063     077     080     089     096     097     100     099
+ 25     045     064     050     068     073     084     087     094     099     100     098     096
+ 26     056     075     061     077     081     091     092     098     100     099     093     089
+ 27     068     084     071     085     088     095     097     100     099     096     086     081
+ 28     078     091     081     092     094     098     099     100     095     091     077     072
+ 29     087     ***     088     096     097     100     100     097     088     083     067     061
+ 30     094     ***     094     099     099     099     099     093     080     073     056     051
+ 31     098     ***     098     ***     100     ***     096     086     ***     063     ***     040
+ 

data/ext/solunar/astrocon.h

@@ -0,0 +1,61 @@
+#ifndef _CONSTS_
+#define _CONSTS_
+
+/* Gaussian gravitational constant */
+#define GAUSSK (0.01720209895)
+
+/* values related to PI */
+#ifndef PI
+#define PI (139755218526789.0 / 44485467702853.0)
+#endif
+
+#define TWOPI  (2.0 * PI)
+#define PIDIV2 (0.5 * PI)
+
+/* degrees to radians and radians to degrees */
+#define D2R (PI / 180.0)
+#define R2D (180.0 / PI)
+
+/* hours to radians and radians to hours */
+#define H2R (PI / 12.0)
+#define R2H (12.0 / PI)
+
+/* arcseconds to radians and radians to arcseconds */
+#define A2R (PI / 648000.0)
+#define R2A (648000.0 / PI)
+
+/* AU to km and km to AU */
+#define AU2KM (149597870.66)
+#define KM2AU (1.0 / 149597870.66)
+
+/* speed of light in km/s and AU/day */
+#define CKMS (299792.458)
+#define CAUD (CKMS * 86400.0 * KM2AU)
+
+/* Earth's angular velocity in rad/s */
+#define EarAngVelRD (6.30038748685432)
+
+/* Earth's equatorial radius in km and AU */
+#define EarthRadKM (6378.137)
+#define EarthRadAU (EarthRadKM * KM2AU)
+
+/* Earth's flattening factor */
+#define EFlat (1.0 / 298.257)
+
+/* JED of standard epoch */
+#define J2000 (2451545.0)
+
+/* days in a Julian century */
+#define JulCty (36525.0)
+
+/* Earth's gravitational constant */
+#define MUC (2.0 * GAUSSK * GAUSSK / (CAUD * CAUD))
+
+/* global state vector variable */
+extern double StateVector[15][15][2][6];
+
+extern double obsr_lon;
+extern double obsr_lat;
+extern double obsr_ele;
+
+#endif /* _CONSTS_ */

data/ext/solunar/extconf.rb

@@ -0,0 +1,14 @@
+require 'mkmf'
+
+# have_func returns false if a C function cannot be found.  Sometimes this
+# will be OK (the function changed names between versions) and sometimes it is
+# not so you need to exit without creating the Makefile.
+
+abort 'missing malloc()' unless have_func 'malloc'
+abort 'missing free()'   unless have_func 'free'
+
+# Now we create the Makefile that will install the extension as
+# lib/my_malloc/my_malloc.so.
+
+create_makefile 'solunar/solunar'
+

data/ext/solunar/solunar.c

@@ -0,0 +1,1959 @@
+/***********************   include files   ******************************************************/
+#include <ruby.h>
+#include <astrocon.h>
+#include "stdio.h"
+#include "stdlib.h"
+#include <math.h>
+#include <string.h>
+#include <stdbool.h>
+
+/***********************   macro definitions   **************************************************/
+
+#define SUN 0
+#define MOON 1
+#define RA 23
+#define DEC 33
+#define DATA_NAME       "USA"
+#define CLUB_NAME       "club"
+#define CLUB_EXT        ".txt"
+#define DATA_EXT        ".bin"
+#define DST_NAME        "USA"
+#define DST_EXT         ".txt"
+#define DATA_PATH       "./ext/solunar/Data_Files/"
+#define CLUB_PATH       "./ext/solunar/Club_Files/"
+#define DST_PATH        "./ext/solunar/DST_Files/"
+#define SUN_FILE        "./ext/solunar/Source_Files/sun.txt"
+#define MOON_FILE       "./ext/solunar/Source_Files/moon.txt"
+#define PHASE_FILE      "./ext/solunar/Source_Files/phase.txt"
+#define ILLUM_16_FILE   "./ext/solunar/Source_Files/ilum_2016.txt"
+#define ILLUM_17_FILE   "./ext/solunar/Source_Files/ilum_2017.txt"
+#define ILLUM_18_FILE   "./ext/solunar/Source_Files/ilum_2018.txt"
+#define ILLUM_19_FILE   "./ext/solunar/Source_Files/ilum_2019.txt"
+#define ILLUM_20_FILE   "./ext/solunar/Source_Files/ilum_2020.txt"
+#define ILLUM_21_FILE   "./ext/solunar/Source_Files/ilum_2021.txt"
+#define ILLUM_22_FILE   "./ext/solunar/Source_Files/ilum_2022.txt"
+#define ILLUM_23_FILE   "./ext/solunar/Source_Files/ilum_2023.txt"
+#define ILLUM_24_FILE   "./ext/solunar/Source_Files/ilum_2024.txt"
+#define ILLUM_25_FILE   "./ext/solunar/Source_Files/ilum_2025.txt"
+#define ILLUM_26_FILE   "./ext/solunar/Source_Files/ilum_2026.txt"
+
+#define CLUB_FAIL       1
+#define DATA_FAIL       2       
+#define SUN_FAIL        3       
+#define MOON_FAIL       4   
+#define DTS_FAIL        5       
+#define PHASE_FAIL      6   
+#define ILLUM_16_FAIL   7
+#define ILLUM_17_FAIL   8
+#define ILLUM_18_FAIL   9
+#define ILLUM_19_FAIL   10
+#define ILLUM_20_FAIL   11
+#define ILLUM_21_FAIL   12
+#define ILLUM_22_FAIL   13
+#define ILLUM_23_FAIL   14
+#define ILLUM_24_FAIL   15
+#define ILLUM_25_FAIL   16
+#define ILLUM_26_FAIL   17
+#define ARG_ERROR       99
+//file information
+#define DATA_FILE_SIZE  4018
+#define JPL_DATE_SIZE   12
+#define PHASE_FILE_SIZE 544
+#define DST_FILE_SIZE   11
+#define RST_MAX_TRIES   50
+#define JDATE_BASE      2457388.5   // January 1, 2016
+#define YES             1
+#define NO              0
+#define MINUTES_PER_DAY (24 * 60)
+//exceptions
+#define NEXT_DAY    1
+#define PREV_DAY    2   
+#define NONE_TODAY  3
+#define ROUTINE     4
+#define NEVER_RISE  5
+#define NEVER_SET   6
+#define ERROR       7
+#define RST_ERROR   8
+#define RST_FAIL    9
+//phases
+#define NEW_MOON    1
+#define WAX_CRES    2
+#define FIRST_QTR   3
+#define WAX_GIBB    4
+#define FULL_MOON   5
+#define WAN_GIBB    6
+#define LAST_QTR    7
+#define WAN_CRES    8
+
+/***********************   typedefs   ***********************************************************/
+
+typedef struct {
+    double ra;
+    double dec;
+} jpl_data;
+typedef struct {
+    char date[JPL_DATE_SIZE];
+    jpl_data sun;
+    jpl_data moon;
+    bool dst;
+    int phase;
+    int phase_time;
+    int illum;
+} jpl_type;
+typedef struct {
+    int minute;
+    int second;
+    int exception;
+} time_type;
+typedef struct {
+    time_type ris;
+    time_type set;
+    time_type trn;
+    time_type tru;
+} rst_type;
+typedef struct {
+    char date[JPL_DATE_SIZE];
+    int gmt_offset;
+    rst_type sun;
+    rst_type moon;
+    int moon_phase;
+    int phase_time;
+    int moon_illum;
+} sol_type;
+typedef struct {
+    double start;
+    double stop;
+} dst_type;
+
+/***********************   constant arrays   ****************************************************/
+
+const int year_days[11] = {
+    0,      // 2016
+    366,    // 2017
+    731,    // 2018
+    1096,   // 2019
+    1461,   // 2020
+    1827,   // 2021
+    2192,   // 2022
+    2557,   // 2023
+    2922,   // 2024
+    3288,   // 2025
+    3653,   // 2026
+};
+const int month_days[12] = {
+    0,      // JAN
+    31,     // FEB
+    59,     // MAR
+    90,     // APR
+    120,    // MAY
+    151,    // JUN
+    181,    // JUL
+    212,    // AUG
+    243,    // SEP
+    273,    // OCT
+    304,    // NOV
+    334,    // DEC
+};
+const int leap_days[12] = {
+    0,      // JAN
+    31,     // FEB
+    60,     // MAR
+    91,     // APR
+    121,    // MAY
+    152,    // JUN
+    182,    // JUL
+    213,    // AUG
+    244,    // SEP
+    274,    // OCT
+    305,    // NOV
+    335,    // DEC
+};
+char error_msg[][36] = {
+    "Operation Successful",
+    "Cannot open Club file",
+    "Cannot open Data file",
+    "Cannot open Sun file",
+    "Cannot open Moon file",
+    "Cannot open DST file",
+    "Cannot open Phase file",
+    "Cannot open 2016 Illumination file",
+    "Cannot open 2017 Illumination file",
+    "Cannot open 2018 Illumination file",
+    "Cannot open 2019 Illumination file",
+    "Cannot open 2020 Illumination file",
+    "Cannot open 2021 Illumination file",
+    "Cannot open 2022 Illumination file",
+    "Cannot open 2023 Illumination file",
+    "Cannot open 2024 Illumination file",
+    "Cannot open 2025 Illumination file",
+    "Cannot open 2026 Illumination file"
+};
+
+/***********************   function prototypes   ************************************************/
+
+int         TestBuildDataFile(void);
+int         BuildDataFile(char*);
+int         TestSummary(void);
+int         Summary(char*, double, double, int, int, int, char*);
+int         TestClubFile(void);
+char*       ClubFile(char*, char*, int, double, double, int, int, int, char*, char*);
+double      ConvertDate(char*);
+int         GetSunData(void);
+int         GetMoonData(void);
+int         GetDateData(void);
+int         GetDstData(char*);
+int         GetIllumData(void);
+int         GetPhaseData(void);
+int         SaveDataFile(char*);
+int         Solunar(sol_type*, double, double, double, int, int, char*);
+int         GetIllumYear(const char*, int*);
+time_type   FmtTime(double);
+void        FmtTimeStr(char*, time_type, int);
+time_type   AdjustTimes(time_type, time_type, time_type, int);
+// original Heafner functions with some changes
+rst_type    RST(FILE*, int, double, double, double);
+static int          RST_Interpolate(int, double, double, double, double, double*, double*, double,
+                            double, double, double, double, double, double, double, double*);
+double      deg(double x);
+void        GetGST(double, int, double*);
+double      amodulo(double, double);
+
+/***********************   variable delarations   ***********************************************/
+
+jpl_type jpl_temp[DATA_FILE_SIZE];
+dst_type dst[DST_FILE_SIZE];
+
+/***********************   mode selection   *****************************************************/
+/*
+Uuncomment one of these to control whether the executable will enter the Console Mode, to display
+a one cay summary, the Club Mode, to porepare the Club File, or the build Mode, to build a new
+data file from a revised DST file.                                                              */
+
+//define CONSOLE_MODE
+#define CLUB_MODE
+//#define BUILD_MODE
+
+/***********************   Main
+
+This is the entry point for the program.
+
+RETURN VALUE:   EXIT_SUCCESS or Error Code
+
+PARAMETERS:     Varies depending on mode
+*/
+/*#ifdef CONSOLE_MODE
+int main()
+{
+    enum { BUILD = 'B', CLUB = 'C', DISPLAY = 'D' };
+    int task;
+    char line[100];
+
+    printf("Enter: Club File, Display Summary, Build Data File: ");
+    fgets(line, sizeof line, stdin);
+    if (line[0] == '\n')    strcpy(line, "Club");
+    task = line[0];
+    switch (task)
+    {
+    case BUILD:
+    case BUILD + 32:
+        printf("\nBUILD DATA FILE\n\n");
+        TestBuildDataFile();
+        break;
+    case DISPLAY:
+    case DISPLAY + 32:
+        printf("\nDISPLAY SUMMARY\n\n");
+        TestSummary();
+        break;
+    default:
+        printf("\nCLUB FILE\n\n");
+        TestClubFile();
+        break;
+    }
+    return 0;
+}
+#endif*/
+
+static VALUE generate(VALUE self, VALUE r_date_str, VALUE r_count, VALUE r_lat,
+    VALUE r_lon, VALUE r_gmt_offset, VALUE r_dst_offset, VALUE r_military_time)
+{
+    char* result;
+    int gmt_offset;
+    int dst_time;
+    int am_pm;
+    int count;
+    double lat;
+    double lon;
+    char *club_name;
+    char *date_str;
+    char *data_name;
+    VALUE ret_v;
+
+    club_name = "club"; //Constant, as this isn't really used for anything
+    date_str = RSTRING_PTR(r_date_str);
+    count = NUM2INT(r_count);
+    lat = NUM2DBL(r_lat);
+    lon = NUM2DBL(r_lon);
+    gmt_offset = NUM2INT(r_gmt_offset);
+    dst_time = NUM2INT(r_dst_offset);
+    am_pm = NUM2INT(r_military_time);
+    data_name = "USA"; //Constant, for now
+    int outputLength;
+    outputLength = count*251;
+    char output[outputLength];
+    result = ClubFile(  club_name, date_str, count, lat, lon, 
+                        gmt_offset, dst_time, am_pm, data_name, output);
+    ret_v = rb_str_new2(result);
+
+    return ret_v;
+}
+
+/*#ifdef BUILD_MODE
+int main(int argc, char *argv[])
+{
+    return argc < 2? ARG_ERROR : BuildDataFile(argv[1]);
+
+}
+#endif*/
+
+/***********************   Build Data File Test
+
+This function exercises BuildDataFile(). It is used for testing.
+
+RETURN VALUE:   EXIT_SUCCESS or Error Code
+
+PARAMETERS:     none
+*/
+int TestBuildDataFile()
+{
+    int success;
+    char line[100];
+    char file_name[100];
+
+    printf("Enter DST/Data File Name: ");
+    fgets(line, sizeof line, stdin);
+    if (line[0] == '\n')    strcpy(file_name, DST_NAME);
+    else
+    {
+        line[strlen(line) - 1] = '\0';
+        strcpy(file_name, line);
+    }
+    success = BuildDataFile(file_name);
+    printf("\n%s", error_msg[success]);
+    printf("\n\nOK? ");
+    fgets(line, sizeof line, stdin);
+    return success;
+}
+/***********************   Build Data File
+
+This function prepares a the Data file from a number of source data files. If one of the files
+cannot be opened, the program stops there and returns a number indicating the failure.
+
+RETURN VALUE:   EXIT_SUCCESS or Error Code
+
+PARAMETERS:     name of DST file and resultant Data File
+
+*/
+int BuildDataFile(char *file_name)
+{
+    int success;
+    char data_filename[32];
+    char dst_filename[32];
+
+    strcpy(data_filename, DATA_PATH);
+    strcat(data_filename, file_name);
+    strcat(data_filename, DATA_EXT);
+    strcpy(dst_filename, DST_PATH);
+    strcat(dst_filename, file_name);
+    strcat(dst_filename, DST_EXT);
+
+    success = 0;
+    if (success == EXIT_SUCCESS) success = GetSunData();
+    if (success == EXIT_SUCCESS) success = GetMoonData();
+    if (success == EXIT_SUCCESS) success = GetDateData();
+    if (success == EXIT_SUCCESS) success = GetDstData(dst_filename);
+    if (success == EXIT_SUCCESS) success = GetIllumData();
+    if (success == EXIT_SUCCESS) success = GetPhaseData();
+    if (success == EXIT_SUCCESS) success = SaveDataFile(data_filename);
+    return success;
+}
+
+/***********************   Display Summary Test
+
+This function exercises Summary(). It is used for testing.
+
+RETURN VALUE:   EXIT_SUCCESS or Error Code
+
+PARAMETERS:     none
+*/
+int TestSummary(void)
+{
+    int dst_time;
+    int am_pm;
+    char date_str[100];
+    char file_name[100];
+    char line[1024];
+    double lat;
+    double lon;
+    int gmt_offset;
+    int success;
+
+    printf("Enter Data File name: ");
+    fgets(line, sizeof line, stdin);
+    if (line[0] == '\n')    strcpy(file_name, DATA_NAME);
+    else
+    {
+        line[strlen(line) - 1] = '\0';
+        strcpy(file_name, line);
+    }
+
+    printf("Enter latitude (+N/-S, dd.dddd): ");
+    fgets(line, sizeof line, stdin);
+    if (line[0] == '\n')    lat = 34.5082;
+    else                    sscanf(line, "%lf", &lat);
+
+    printf("Enter longitude (+W/-E, dd.dddd): ");
+    fgets(line, sizeof line, stdin);
+    if (line[0] == '\n')    lon = 82.6500;
+    else                    sscanf(line, "%lf", &lon);
+
+    printf("Enter offset minutes from GMT (+W/-E): ");
+    fgets(line, sizeof line, stdin);
+    if (line[0] == '\n')    gmt_offset = 5 * 60;
+    else                    sscanf(line, "%i", &gmt_offset);
+
+    printf("Enter DST time in minutes: ");
+    fgets(line, sizeof line, stdin);
+    if (line[0] == '\n')    dst_time = 60;
+    else                    sscanf(line, "%i", &dst_time);
+
+    printf("Enter Date - YYYY/MM/DD: ");
+    fgets(line, sizeof line, stdin);
+    if (line[0] == '\n')    strcpy(date_str, "2016/07/04");
+    else
+    {
+        line[strlen(line) - 1] = '\0';
+        strcpy(date_str, line);
+    }
+    printf("24 Hour Format (YES/NO): ");
+    fgets(line, sizeof line, stdin);
+    am_pm = ((line[0] == 'Y') || (line[0] == 'y')) ? NO : YES;
+
+    success = Summary(date_str, lat, lon, gmt_offset, dst_time, am_pm, file_name);
+
+    printf("\n%s", error_msg[success]);
+
+    printf("\n\nOK? ");
+
+    fgets(line, sizeof line, stdin);
+    return success;
+}
+/***********************   Display Summary
+
+This function displays all data for the parameters specified.
+
+RETURN VALUE:   EXIT_SUCCESS or Error Code
+
+PARAMETERS:     date (string)
+                latitude (+ is north)
+                longitude (+ is west)
+                offset from GMT in minutes (+ is west)
+                daylight savings time change in minutes
+                time format desired
+                name of the data file
+*/
+int Summary(char *date_str, double lat, double lon, int gmt_offset, int dst_time,
+            int am_pm, char *data_file)
+{
+    sol_type solunar;
+    time_type temp;
+    double jdate;
+    int n;
+    int success;
+    char s_ris[10];
+    char s_trn[10];
+    char s_set[10];
+    char s_tru[10];
+    char m_ris[10];
+    char m_trn[10];
+    char m_set[10];
+    char m_tru[10];
+    char p_tim[10];
+    char filename[100];
+    const char phase[9][16] =
+    {   "*** ERROR ***  ",
+        "NEW_MOON       ",
+        "Waxing Crescent",
+        "FIRST QUARTER  ",
+        "Waxing Gibbous ",
+        "FULL MOON      ",
+        "Waning Gibbous ",
+        "LAST QUARTER   ",
+        "Waning Cescent " };
+
+    lat *= D2R;
+    lon *= D2R;
+
+    strcpy(filename, DATA_PATH);
+    strcat(filename, data_file);
+    strcat(filename, DATA_EXT);
+    jdate = ConvertDate(date_str);
+
+    success = Solunar(&solunar, jdate, lat, lon, gmt_offset, dst_time, filename);
+    if (success == EXIT_SUCCESS)
+    {
+        FmtTimeStr(s_ris, solunar.sun.ris, am_pm);
+        FmtTimeStr(s_trn, solunar.sun.trn, am_pm);
+        FmtTimeStr(s_set, solunar.sun.set, am_pm);
+        FmtTimeStr(s_tru, solunar.sun.tru, am_pm);
+        FmtTimeStr(m_ris, solunar.moon.ris, am_pm);
+        FmtTimeStr(m_trn, solunar.moon.trn, am_pm);
+        FmtTimeStr(m_set, solunar.moon.set, am_pm);
+        FmtTimeStr(m_tru, solunar.moon.tru, am_pm);
+
+        printf("\n%s  SUN    local times (GMT - %i)\n", solunar.date, solunar.gmt_offset);
+        printf("   Rise =          %s\n", s_ris);
+        printf("   Transit =       %s\n", s_trn);
+        printf("   Set =           %s\n", s_set);
+        printf("   Tran Under =    %s\n", s_tru);
+        printf("\n%s  MOON   local times (GMT - %i)\n", solunar.date, solunar.gmt_offset);
+        printf("   Rise =          %s\n", m_ris);
+        printf("   Transit =       %s\n", m_trn);
+        printf("   Set =           %s\n", m_set);
+        printf("   Tran Under =    %s\n", m_tru);
+
+        for (n = 0; n < 8; n++)
+        {
+            p_tim[n] = ' ';
+        }
+        p_tim[n] = '\0';
+        if (solunar.phase_time != 0)
+        {
+            temp.minute = solunar.phase_time;
+            temp.second = 0;
+            temp.exception = 0;
+            FmtTimeStr(p_tim, temp, am_pm);
+        }
+        printf( "   %s %s\n   %d%% Illuminated\n",
+                phase[solunar.moon_phase], p_tim, solunar.moon_illum);
+    }
+    return success;
+}
+
+/***********************   Club File Test
+
+This function exercises ClubFile(). It is used for testing.
+
+RETURN VALUE:   EXIT_SUCCESS or Error Code
+
+PARAMETERS:     none
+*/
+int TestClubFile(void)
+{
+    int success;
+    int dst_time;
+    int am_pm;
+    char club_name[100];
+    char data_name[100];
+    char start_date[100];
+    char line[1024];
+    double lat;
+    double lon;
+    int count;
+    int gmt_offset;
+
+    printf("Enter Club Name: ");
+    fgets(line, sizeof line, stdin);
+    if (line[0] == '\n')    strcpy(club_name, CLUB_NAME);
+    else
+    {
+        line[strlen(line) - 1] = '\0';
+        strcpy(club_name, line);
+    }
+    printf("Enter Data File Name: ");
+    fgets(line, sizeof line, stdin);
+    if (line[0] == '\n')    strcpy(data_name, DATA_NAME);
+    else
+    {
+        line[strlen(line) - 1] = '\0';
+        strcpy(data_name, line);
+    }
+    printf("Enter latitude (+N/-S, dd.dddd): ");
+    fgets(line, sizeof line, stdin);
+    if (line[0] == '\n')    lat = 34.5082;
+    else                    sscanf(line, "%lf", &lat);
+
+    printf("Enter longitude (+W/-E, dd.dddd): ");
+    fgets(line, sizeof line, stdin);
+    if (line[0] == '\n')    lon = 82.6500;
+    else                    sscanf(line, "%lf", &lon);
+
+    printf("Enter offset minutes from GMT (+W/-E): ");
+    fgets(line, sizeof line, stdin);
+    if (line[0] == '\n')    gmt_offset = 5 * 60;
+    else                    sscanf(line, "%i", &gmt_offset);
+
+    printf("Enter DST time in minutes: ");
+    fgets(line, sizeof line, stdin);
+    if (line[0] == '\n')    dst_time = 60;
+    else                    sscanf(line, "%i", &dst_time);
+
+    printf("Enter Starting Date - YYYY/MM/DD: ");
+    fgets(line, sizeof line, stdin);
+    if (line[0] == '\n')    strcpy(start_date, "2016/07/04");
+    else
+    {
+        line[strlen(line) - 1] = '\0';
+        strcpy(start_date, line);
+    }
+
+    printf("Enter number of days to be listed: ");
+    fgets(line, sizeof line, stdin);
+    if (line[0] == '\n')    count = 1;
+    else                    sscanf(line, "%i", &count);
+
+    printf("24 Hour Format (YES/NO): ");
+    fgets(line, sizeof line, stdin);
+    am_pm = ((line[0] == 'Y') || (line[0] == 'y')) ? NO : YES;
+
+    //success = ClubFile(club_name, start_date, count, lat, lon, gmt_offset, dst_time, am_pm, data_name);
+
+    printf("\n%s", error_msg[success]);
+    printf("\n\nOK? ");
+    fgets(line, sizeof line, stdin);
+
+    return success;
+}
+/***********************   Prepare Club Data File
+
+This function prepares a text file with a list of values for the date range specified. 
+
+RETURN VALUE:   EXIT_SUCCESS or Error Code
+
+PARAMETERS:     name of Club File
+                starting date (string)
+                number of days to be listed
+                latitude (+ is north)
+                longitude (+ is weast)
+                offset from GMT in minutes (+ is west)
+                daylight savings time change in minutes
+                name of Data File
+*/
+char* ClubFile(char *club_name, char *start_date, int count, double lat, double lon,
+                int gmt_offset, int dst_time, int am_pm, char *data_name, char *output)
+{
+    FILE *file;
+    int i;
+    int n;
+    int success;
+    double jdate;
+    time_type temp;
+    sol_type solunar;
+    char s_ris[10];
+    char s_trn[10];
+    char s_set[10];
+    char s_tru[10];
+    char m_ris[10];
+    char m_trn[10];
+    char m_set[10];
+    char m_tru[10];
+    char p_tim[10];
+    char data_filename[100];
+    char club_filename[100];
+    const char phase[9][16] =
+    { "*** ERROR ***  ",
+        "New Moon       ",
+        "Waxing Crescent",
+        "First Quarter  ",
+        "Waxing Gibbous ",
+        "Full Moon      ",
+        "Waning Gibbous ",
+        "Last Quarter   ",
+        "Waning Crescent" };
+
+    lat *= D2R;
+    lon *= D2R;
+
+    strcpy(club_filename, CLUB_PATH);
+    strcat(club_filename, club_name);
+    strcat(club_filename, CLUB_EXT);
+    strcpy(data_filename, DATA_PATH);
+    strcat(data_filename, data_name);
+    strcat(data_filename, DATA_EXT);
+    jdate = ConvertDate(start_date);
+
+    for (i = 0; i < count; i++)
+    {
+        success = Solunar(&solunar, jdate + i, lat, lon, gmt_offset, dst_time, data_filename);
+        if (success == EXIT_SUCCESS)
+        {
+            FmtTimeStr(s_ris, solunar.sun.ris, am_pm);
+            FmtTimeStr(s_trn, solunar.sun.trn, am_pm);
+            FmtTimeStr(s_set, solunar.sun.set, am_pm);
+            FmtTimeStr(s_tru, solunar.sun.tru, am_pm);
+            FmtTimeStr(m_ris, solunar.moon.ris, am_pm);
+            FmtTimeStr(m_trn, solunar.moon.trn, am_pm);
+            FmtTimeStr(m_set, solunar.moon.set, am_pm);
+            FmtTimeStr(m_tru, solunar.moon.tru, am_pm);
+
+            for (n = 0; n < 8; n ++)
+            {
+                p_tim[n] = ' ';
+            }
+            p_tim[n] = '\0';
+            if (solunar.phase_time != 0)
+            {
+                temp.minute = solunar.phase_time;
+                temp.second = 0;
+                temp.exception = 0;
+
+                FmtTimeStr(p_tim, temp, am_pm);
+            }
+            char charout[250];
+            sprintf(charout,"%s, %s, %s, %s, %s, %s, %s, %s, %s, %i, %s, %s, %i%%\n",
+                solunar.date, s_ris, s_trn, s_set, s_tru, m_ris, m_trn, m_set, m_tru,
+                solunar.gmt_offset, phase[solunar.moon_phase], p_tim, solunar.moon_illum);
+            if(strlen(output) == 0){
+                strcpy(output,charout);
+            }
+            else{
+                strcat(output,";");
+                strcat(output,charout);
+            }
+        }
+    }
+
+    return output;
+
+}
+/***********************   Convert Date
+
+This function returns the jdate from a string containing the desired date in a YYYY-MM-DD format.
+
+RETURN VALUE:   jdate
+                0.0 if text date is not valid
+
+PARAMETERS:     pointer to date string (yyyy/mm/dd
+*/
+double ConvertDate(char* string)
+{
+    int m[] = {31,28,31,30,31,30,31,31,30,31,30,31};
+    int l[] = {31,29,31,30,31,30,31,31,30,31,30,31};
+    int year;
+    int month;
+    int day;
+    int error;
+    double result;
+    
+    error = NO;
+    year = atoi(string);
+    month = atoi(string + 5);
+    day = atoi(string + 8);
+    if ((year < 2016)   ||  (year > 2026))                              error = YES;
+    if ((month < 1)     ||  (month > 12))                               error = YES;
+    if ((day < 1)       ||  ((year % 4 == 0) && (day > l[month - 1])))  error = YES;
+    if ((day < 1)       ||  ((year % 4 != 0) && (day > m[month - 1])))  error = YES;
+    if (error == NO)
+    {
+        result =  JDATE_BASE;
+        result += year_days[year - 2016];
+        result += year % 4 == 0? leap_days[month - 1]: month_days[month - 1];
+        result += day - 1;
+    }
+    else
+    {
+        result = 0.0;
+    }
+    return result;
+}
+/***********************   Get Sun Data
+
+This function gets the sun's JPL values for right ascension and declination values from the JPL
+data in sun.txt and puts them into jpl_temp[].
+
+RETURN VALUE:   EXIT_SUCCESS or Error Code
+
+PARAMETERS:     none
+*/
+int GetSunData(void)
+{
+    FILE *file;
+    int n;
+    int success;
+    char buffer[100];
+
+    file = fopen(SUN_FILE, "r");
+    if (file != NULL)
+    {
+        for (n = 0; n < DATA_FILE_SIZE; n++)
+        {
+            fgets(buffer, 100, file);
+            jpl_temp[n].sun.ra = atof(buffer + RA);
+            jpl_temp[n].sun.dec = atof(buffer + DEC);
+        }
+        fclose(file);
+        success = EXIT_SUCCESS;
+    }
+    else
+    {
+        success = SUN_FAIL;
+    }
+    return success;
+}
+
+/***********************   Get Moon Data
+
+This function gets the moon's JPL values for right ascension and declination values from the JPL
+data in sun.txt and puts them into jpl_temp[].
+
+RETURN VALUE:   EXIT_SUCCESS or Error Code
+
+PARAMETERS:     none
+*/
+int GetMoonData(void)
+{
+    FILE* file;
+    int n;
+    int success;
+    char buffer[100];
+
+    file = fopen(MOON_FILE, "r");
+    if (file != NULL)
+    {
+        for (n = 0; n < DATA_FILE_SIZE; n++)
+        {
+            fgets(buffer, 100, file);
+            jpl_temp[n].moon.ra = atof(buffer + RA);
+            jpl_temp[n].moon.dec = atof(buffer + DEC);
+        }
+        fclose(file);
+        success = EXIT_SUCCESS;
+    }
+    else
+    {
+        success = MOON_FAIL;
+    }
+    return success;
+}
+
+/***********************   Get Date String
+
+This function gets the date string from the JPL data in moon.txt and puts it into jpl_temp[].
+This operation could have been done as part of GetMoonData() or GetSunData(), but is separated
+for clarity.
+
+RETURN VALUE:   EXIT_SUCCESS or Error Code
+
+PARAMETERS:     none
+*/
+int GetDateData(void)
+{
+    FILE* file;
+    int n;
+    int i;
+    int success;
+    char buffer[100];
+
+    file = fopen(MOON_FILE, "r");
+    if (file != NULL)
+    {
+        for (n = 0; n < DATA_FILE_SIZE; n++)
+        {
+            fgets(buffer, 100, file);
+            for (i = 0; i < JPL_DATE_SIZE - 1; i++)
+            {
+                jpl_temp[n].date[i] = buffer[i + 1];
+            }
+            jpl_temp[n].date[i] = '\0';
+        }
+        fclose(file);
+        success = EXIT_SUCCESS;
+    }
+    else
+    {
+        success = MOON_FAIL;
+    }
+    return success;
+}
+
+/***********************   Get Daylight Savings Time Data
+
+For every element of the jpl_temp[] array, this function determines whether or not the associated
+date is subject to daylight savinhgs time and the dst member is updated.
+
+RETURN VALUE:   EXIT_SUCCESS or Error Code
+
+PARAMETERS:     none
+*/
+int GetDstData(char *filename)
+{
+    FILE* file;
+    char buffer[100];
+    int n;
+    int y;
+    int success;
+    double jdate;
+
+    file = fopen(filename, "r");
+    if (file != NULL)
+    {
+        for (y = 0; y < DST_FILE_SIZE; y++)
+        {
+            fgets(buffer, 100, file);
+            dst[y].start = ConvertDate(buffer);
+            dst[y].stop = ConvertDate(buffer + 12);
+        }
+        for (n = 0; n < DATA_FILE_SIZE; n++)
+        {
+            jdate = JDATE_BASE + n;
+            jpl_temp[n].dst = NO;
+            for (y = 0; y < (sizeof dst / sizeof(dst_type)); y++)
+            {
+                if (jdate < dst[y].stop)
+                {
+                    if (jdate >= dst[y].start)
+                    {
+                        jpl_temp[n].dst = YES;
+                    }
+                    break;
+                }
+            }
+        }
+        fclose(file);
+        success = EXIT_SUCCESS;
+    }
+    else
+    {
+        success = DTS_FAIL;
+    }
+    return success;
+}
+/***********************   Get Moon Phase Data
+
+This function gets the moon's phase data from the phase.txt file and puts it into jpl_temp[].
+
+RETURN VALUE:   EXIT_SUCCESS or Error Code
+
+PARAMETERS:     none
+*/
+int GetPhaseData(void)
+{
+    FILE* file;
+    bool match;
+    int c;
+    int j;
+    int i;
+    int n;
+    int phase;
+    int success;
+    char date[11];
+    int minute;
+    char buffer[100];
+
+    j = 0;
+    for (n = 0; n < DATA_FILE_SIZE; n++)
+    {
+        jpl_temp[n].phase = 0;
+        jpl_temp[n].phase_time = 0;
+    }
+    file = fopen(PHASE_FILE, "r");
+    if (file != NULL)
+    {
+        for (n = 0; n < PHASE_FILE_SIZE; n++)
+        {
+            fgets(buffer, 100, file);
+            i = 0;
+            while (buffer[i++] != '\t');
+            for (c = 0; c < 11; c++)
+            {
+                date[c] = buffer[i] == ' ' ? '-' : buffer[i];
+                i++;
+            }
+            i ++;
+            minute  = atoi(buffer + i) * 60;
+            minute += atoi(buffer + i + 3);
+            if (minute == 0)
+            {
+                minute = 24 * 60;
+            }
+            match = NO;
+            while (match == NO)
+            {
+                for (c = 0; c < 11; c++)
+                {
+                    if (date[c] != jpl_temp[j].date[c])
+                    {
+                        break;
+                    }
+                }
+                if (c == 11)
+                {
+                    match = YES;
+                }
+                else
+                {
+                    j++;
+                }
+            }
+            if      (buffer[2] == 'w')  jpl_temp[j].phase = NEW_MOON;
+            else if (buffer[2] == 'r')  jpl_temp[j].phase = FIRST_QTR;
+            else if (buffer[2] == 'l')  jpl_temp[j].phase = FULL_MOON;
+            else                        jpl_temp[j].phase = LAST_QTR;
+            jpl_temp[j].phase_time = minute;
+        }
+        fclose(file);
+        success = EXIT_SUCCESS;
+
+        // for each element of the jpl array:
+        //      record the phase based on the last major phases
+        //      record the the time of the last major phase
+        phase = FULL_MOON;              // 12/25/2015 phase 
+        minute = (11 * 60)+ 11;         // 12/25/2015 Full Moon time
+        for (n = 0; n < DATA_FILE_SIZE; n++)
+        {
+            if (jpl_temp[n].phase == 0)
+            {
+                jpl_temp[n].phase = phase + 1;
+            }
+            else
+            {
+                phase = jpl_temp[n].phase;
+            }
+        }
+    }
+    else
+    {
+        success = PHASE_FAIL;
+    }
+    return success;
+}
+
+/***********************   Get Moon Illumination Percentage Data
+
+This function gets the moon's percent illumination data from Ilum 20xx.txt files and puts it
+into jpl_temp[].
+
+RETURN VALUE:   EXIT_SUCCESS or Error Code
+
+PARAMETERS:     none
+*/
+int GetIllumData(void)
+{
+    int index;
+    int success;
+
+    index = 0;
+    success = EXIT_SUCCESS;
+    if (success == EXIT_SUCCESS) success = GetIllumYear(ILLUM_16_FILE, &index);
+    if (success == EXIT_SUCCESS) success = GetIllumYear(ILLUM_17_FILE, &index);
+    if (success == EXIT_SUCCESS) success = GetIllumYear(ILLUM_18_FILE, &index);
+    if (success == EXIT_SUCCESS) success = GetIllumYear(ILLUM_19_FILE, &index);
+    if (success == EXIT_SUCCESS) success = GetIllumYear(ILLUM_20_FILE, &index);
+    if (success == EXIT_SUCCESS) success = GetIllumYear(ILLUM_21_FILE, &index);
+    if (success == EXIT_SUCCESS) success = GetIllumYear(ILLUM_22_FILE, &index);
+    if (success == EXIT_SUCCESS) success = GetIllumYear(ILLUM_23_FILE, &index);
+    if (success == EXIT_SUCCESS) success = GetIllumYear(ILLUM_24_FILE, &index);
+    if (success == EXIT_SUCCESS) success = GetIllumYear(ILLUM_25_FILE, &index);
+    if (success == EXIT_SUCCESS) success = GetIllumYear(ILLUM_26_FILE, &index);
+    return success;
+}
+
+/***********************   Save Data File
+
+After the daylight savings data, date string and the right ascension and declination values for
+the sun and moon plus mone phase and illumination have been placed in jpl.temp[], this function
+writes the jpl data to the Data File.
+
+RETURN VALUE:   EXIT_SUCCESS or Error Code
+
+PARAMETERS:     filepath of Data File
+*/
+int SaveDataFile(char *filename)
+{
+    FILE *file;
+    int success;
+
+    file = fopen(filename, "wb");
+    if (file != NULL)
+    {
+        fwrite(jpl_temp, sizeof(jpl_type), DATA_FILE_SIZE, file);
+        fclose(file);
+        success = EXIT_SUCCESS;
+    }
+    else
+    {
+        success = DATA_FAIL;
+    }
+    return success;
+}
+
+/***********************   Solunar
+
+This function returns all the informatin required by the Knockdown program.
+
+As to the phases of the moon:
+
+The JPL file stores all data by GMT date. Unless the GMT offset time is 0, the local date
+overlaps parts of two GMT dates:
+
+East of Greenwich, the local date overlaps that part of the previous GMT date where the
+GMT time is within [gmt_offset] minutes before midnight; the local date overlaps the current
+GMT date the rest of the day.
+
+West of Greenwich, the local date overlaps that part of the following GMT date where the
+GMT time is within [gmt_offset] minutes after midnight; the local date overlaps the current 
+GMT date the rest of the day.
+
+The Primary moon phases are reported in local time and date. Use the GMT date where the
+time of the moon phase overlaps the current local date.
+
+
+RETURN VALUE:   EXIT_SUCCESS or Error Code
+
+PARAMETERS:     sol_type structure with sun, moon, date, and DST adjusted GME offset information
+                julian date
+                latitude (+ is north)
+                longitude (+ is west)
+                minutes easr or west of GMT (+ is west)
+                DST time in minutes
+                filepath of Data File
+*/
+int Solunar(sol_type *result, double jdate, double lat, double lon,
+            int gmt_offset, int dst_time, char *filename)
+{
+    enum {p_day, c_day, f_day};
+    int n;
+    int index;
+    int success;
+    FILE *file;
+    jpl_type jpl[3];
+    rst_type times_p;
+    rst_type times;
+    rst_type times_f;
+    int phase_time;
+    int months[13][5] = {
+        { 'J', 'a', 'n', '0', '1' },
+        { 'F', 'e', 'b', '0', '2' },
+        { 'M', 'a', 'r', '0', '3' },
+        { 'A', 'p', 'r', '0', '4' },
+        { 'M', 'a', 'y', '0', '5' },
+        { 'J', 'u', 'n', '0', '6' },
+        { 'J', 'u', 'l', '0', '7' },
+        { 'A', 'u', 'g', '0', '8' },
+        { 'S', 'e', 'p', '0', '9' },
+        { 'O', 'c', 't', '1', '0' },
+        { 'N', 'o', 'v', '1', '1' },
+        { 'D', 'e', 'c', '1', '2' },
+        { 0,   0,   0,   '?', '?' } };
+
+    //lon = -lon;
+
+    // get date
+    index = (int)(floor(jdate) - floor(JDATE_BASE));
+    file = fopen(filename, "rb");
+    if (file != NULL)
+    {
+        fseek(file, ((index - 1) * sizeof(jpl_type)), SEEK_SET);
+        fread(&jpl[0], sizeof(jpl_type), 3, file);
+        for (n = 0; n < 12; n++)
+        {
+            if (    (jpl[c_day].date[5] == months[n][0])
+                &&  (jpl[c_day].date[6] == months[n][1])
+                &&  (jpl[c_day].date[7] == months[n][2]) )
+            {
+                break;
+            }
+        }
+        result->date[0] = jpl[c_day].date[0];
+        result->date[1] = jpl[c_day].date[1];
+        result->date[2] = jpl[c_day].date[2];
+        result->date[3] = jpl[c_day].date[3];
+        result->date[4] = '-';
+        result->date[5] = months[n][3];
+        result->date[6] = months[n][4];
+        result->date[7] = '-';
+        result->date[8] = jpl[c_day].date[9];
+        result->date[9] = jpl[c_day].date[10];
+        result->date[10] = '\0';
+
+        // adjust gmt offset for dst
+        if ((dst_time != 0) && (jpl[c_day].dst == YES))
+        {
+            gmt_offset -= dst_time;
+        }
+        result->gmt_offset = gmt_offset;
+
+        // get values for the sun
+        times_p = RST(file, SUN, jdate - 1, lat, lon);
+        times   = RST(file, SUN, jdate, lat, lon);
+        times_f = RST(file, SUN, jdate + 1, lat, lon);
+        result->sun.ris = AdjustTimes(times_p.ris, times.ris, times_f.ris, gmt_offset);
+        result->sun.trn = AdjustTimes(times_p.trn, times.trn, times_f.trn, gmt_offset);
+        result->sun.set = AdjustTimes(times_p.set, times.set, times_f.set, gmt_offset);
+
+        // get values for the moon  
+        times_p = RST(file, MOON, jdate - 1, lat, lon);
+        times   = RST(file, MOON, jdate, lat, lon);
+        times_f = RST(file, MOON, jdate + 1, lat, lon);
+        result->moon.ris = AdjustTimes(times_p.ris, times.ris, times_f.ris, gmt_offset);
+        result->moon.trn = AdjustTimes(times_p.trn, times.trn, times_f.trn, gmt_offset);
+        result->moon.set = AdjustTimes(times_p.set, times.set, times_f.set, gmt_offset);
+
+        // get value for sun and moon transit underfoot ...
+        if (lon < 0)    lon += PI;
+        else            lon -= PI;
+
+        // ... sun
+        times_p = RST(file, SUN, jdate - 1, lat, lon);
+        times   = RST(file, SUN, jdate, lat, lon);
+        times_f = RST(file, SUN, jdate + 1, lat, lon);
+        result->sun.tru = AdjustTimes(times_p.trn, times.trn, times_f.trn, gmt_offset);
+
+        // ... moon
+        times_p = RST(file, MOON, jdate - 1, lat, lon);
+        times   = RST(file, MOON, jdate, lat, lon);
+        times_f = RST(file, MOON, jdate + 1, lat, lon);
+        result->moon.tru = AdjustTimes(times_p.trn, times.trn, times_f.trn, gmt_offset);
+
+        fclose(file);
+
+        // if western hemisphere or Britian Summer Time
+        if (gmt_offset > 0)
+        {
+            // if the following Greenwich day has a primary phase at a time that is during the
+            // current local day, use the phase from the following Greenwich day
+            if  (   (jpl[f_day].phase_time != 0)
+                    &&  (jpl[f_day].phase_time <= abs(gmt_offset)) )
+            {
+                result->moon_phase = jpl[f_day].phase;
+                phase_time = jpl[f_day].phase_time;
+            }
+            // if the current Greenwich day has a primary phase at a time that is not during the
+            // current local day, use the phase from the following Greenwich day 
+            else if (   (jpl[c_day].phase_time != 0)
+                    &&  (jpl[c_day].phase_time <= abs(gmt_offset)) )
+            {
+                result->moon_phase = jpl[f_day].phase;
+                phase_time = jpl[f_day].phase_time;
+            }
+            // if it is not necessary to use the phase from the following GMT day, use the phase
+            // from the current GMT day
+            else
+            {
+                result->moon_phase = jpl[c_day].phase;
+                phase_time = jpl[c_day].phase_time;
+            }
+            if (phase_time != 0.0)
+            {
+                phase_time += 24 * 60;
+                phase_time -= abs(gmt_offset);
+                if (phase_time > MINUTES_PER_DAY)
+                {
+                    phase_time -= 24 * 60;
+                }
+            }
+            result->phase_time = phase_time;
+        }
+        // if eastern hemisphere
+        else if (gmt_offset < 0)
+        {
+            // if the previous Greenwich day has a primary phase at a time that is during the
+            // current local day, use the phase from the following Greenwich day
+            if  (   (jpl[p_day].phase_time != 0)
+                &&  ((MINUTES_PER_DAY - jpl[p_day].phase_time) <= abs(gmt_offset)))
+            {
+                result->moon_phase = jpl[p_day].phase;
+                phase_time = jpl[p_day].phase_time;
+            }
+            // if the current Greenwich day has a primary phase at a time that is not during the
+            // current local day, use the hase from the previous Greenwich day 
+            else if (   (jpl[c_day].phase_time != 0)
+                    &&  ((MINUTES_PER_DAY - jpl[c_day].phase_time) <= abs(gmt_offset)))
+            {
+                result->moon_phase = jpl[p_day].phase;
+                phase_time = jpl[p_day].phase_time;
+            }
+            // if it is not necessary to use the phase from the previous GMT day, use the phase
+            // from the current GMT day
+            else
+            {
+                result->moon_phase = jpl[c_day].phase;
+                phase_time = jpl[c_day].phase_time;
+            }
+            if (phase_time != 0.0)
+            {
+                phase_time += abs(gmt_offset);
+                {
+                    if (phase_time > MINUTES_PER_DAY)
+                    {
+                        phase_time -= MINUTES_PER_DAY;
+                    }
+                }
+            }
+            result->phase_time = phase_time;
+        }
+        // if the gmt offset is 0, use the phase from the current Greenwich day
+        else
+        {
+            result->moon_phase = jpl[c_day].phase;
+            phase_time = jpl[c_day].phase_time;
+            result->phase_time = phase_time;
+        }
+        result->moon_illum = jpl[c_day].illum;
+        success = EXIT_SUCCESS;
+    }
+    else
+    {
+        //rb_eval_string("puts 'No file found at: '+`pwd`");
+        success = DATA_FAIL;
+    }
+    return success;
+}
+
+/***********************   Get Moon Illumination Percentage Data for One Year
+
+This function processes the moon's percent illumination data from the specified file and places
+it into jpl_temp[] for one year. Parameter index is kept up to date as this function is called 
+multiple times - one for each year.
+
+RETURN VALUE:   EXIT_SUCCESS or Error Code
+
+PARAMETERS:     current file
+                index into jpl_temp[]
+*/
+int GetIllumYear(const char *filename, int *index)
+{
+    FILE* file;
+    char buffer[31][102];
+    int col[] = { 8, 16, 24, 32, 40, 48, 56, 64, 72, 80, 88, 96 };
+    int m;
+    int d;
+    int n;
+    int success;
+
+    file = fopen(filename, "r");
+    if (file != NULL)
+    {
+        for (n = 0; n < 31; n++)
+        {
+            fgets(buffer[n], 102, file);
+        }
+        fclose(file);
+        for (m = 0; m < 12; m++)
+        {
+            for (d = 0; d < 31; d++)
+            {
+                if (buffer[d][col[m]] == '*')
+                {
+                    break;
+                }
+                else
+                {
+                    jpl_temp[*index].illum = atoi(buffer[d] + col[m]);
+                    (*index) ++;
+                }
+            }
+        }
+        success = EXIT_SUCCESS;
+    }
+    else
+    {
+        success = EXIT_FAILURE;
+    }
+    return success;
+}
+
+/***********************   Format the Time Structure
+
+This function formats a decimal time (H.hhhh) into minutes and seconds. Internal to the 
+program, time of day is kept in interger munites. To avoid floating point, seconds are a
+separate field and is used only for development and desting.
+
+RETURN VALUE:   formated time structure
+
+PARAMETERS:     decimal time
+*/
+time_type FmtTime(double d_time)
+{
+    time_type result;
+    double d_minute;
+    double d_second;
+    double i_minute;
+    double i_second;
+    double temp;
+
+    d_minute = d_time * 60;
+    i_minute = floor(d_minute);
+    d_second = (d_minute - i_minute) * 60;
+    i_second = floor(d_second);
+    temp = (d_second - i_second);
+    if (temp >= 0.5)
+    {
+        i_second += 1.0;
+    }
+    if (i_second == 60)
+    {
+        i_second = 0;
+        i_minute += 1;
+    }
+    result.minute = (int)d_minute;
+    result.second = (int)d_second;
+    result.exception = NULL;
+
+    return result;
+}
+
+/***********************   Format a Time String
+
+This function formats a string in the format hh:mm:ss from a time_type structure.
+
+RETURN VALUE:   none
+
+PARAMETERS:     pointer to destination string
+                time-type structure to be formatted
+                flag indicating whether format should 24 hour (with seconds) or am/pm
+*/
+void FmtTimeStr(char *string, time_type times, int am_pm)
+{
+    int n;
+    int hour;
+    int min;
+    char a_p;
+    const char exception[9][9] = {  
+        "        ",
+        "        ",
+        "  NONE  ",
+        "        ",
+        "  DARK  ",
+        " BRIGHT ",
+        "        ",
+        "ERROR  1",
+        "ERROR  2" };
+
+    if (times.exception >= NONE_TODAY)
+    {
+        sprintf(string, "%s", exception[times.exception - 1]);
+    }
+    else
+    {
+        if (am_pm == YES)
+        {
+            if (times.second >= 30) times.minute += 1;
+            if (times.minute >= MINUTES_PER_DAY) times.minute = MINUTES_PER_DAY - 1;
+            hour = times.minute / 60;
+            a_p = hour >= 12? 'p': 'a';
+            if (hour > 12) hour -= 12;
+            if (hour == 0) hour = 12;
+            min = times.minute % 60;
+            sprintf(string, "%2d:%2d %cm", hour, min, a_p);
+            if (string[3] == ' ') string[3] = '0';
+        }
+        else
+        {
+            hour = times.minute / 60;
+            min = times.minute % 60;
+            sprintf(string, "%2d:%2d:%2d", hour, min, times.second);
+            for (n = 0; n < 8; n++)
+            {
+                if (string[n] == ' ') string[n] = '0';
+            }
+        }
+    }
+}
+
+/***********************   Adjust Times
+
+For an explanation of this function,see the Adjust Times files in the project folder.
+
+RETURN VALUE:   adjusted time structure
+
+PARAMETERS:     time sStructure for the previous day
+                time structure for the Current Day
+                time structure for the Following Day
+                offset from GMT (hours west)
+*/
+time_type AdjustTimes(  time_type previous_day, time_type current_day,
+                        time_type following_day, int gmt_offset)
+{
+    #define TIME_BEFORE_MIDNIGHT(x) (MINUTES_PER_DAY - x)
+    #define TIME_AFTER_MIDNIGHT(x)  x
+    time_type result;
+    int special;
+    int temp_1;
+    int temp_2;
+
+    // if in the western hemisphere or Britan Summer Time
+    if (gmt_offset > 0)
+    {
+        special = abs(current_day.minute - following_day.minute) > (MINUTES_PER_DAY / 2) ? YES : NO;
+        if ((current_day.exception > ROUTINE) || (following_day.exception > ROUTINE))
+        {
+            if (current_day.exception > ERROR) result = following_day;
+            else result = current_day;
+            result.minute += MINUTES_PER_DAY;
+            result.minute -= gmt_offset;
+            result.minute %= MINUTES_PER_DAY;
+        }
+        else if (TIME_AFTER_MIDNIGHT(current_day.minute) >= gmt_offset)
+        {
+            result = current_day;
+            result.minute -= gmt_offset;
+        }
+        else if (TIME_AFTER_MIDNIGHT(following_day.minute) < gmt_offset)
+        {
+            result = following_day;
+            result.minute += MINUTES_PER_DAY;
+            result.minute -= gmt_offset;
+        }
+        else if (special == YES)
+        {
+            result = current_day;
+            temp_1 = (current_day.minute + MINUTES_PER_DAY - gmt_offset) % MINUTES_PER_DAY;
+            temp_2 = (following_day.minute + MINUTES_PER_DAY - gmt_offset) % MINUTES_PER_DAY;
+            result.minute = (temp_1 + temp_2) / 2;
+        }
+        else
+        {
+            result.exception = NONE_TODAY;
+        }
+    }
+    //if in eastern hemisphere
+    else if (gmt_offset < 0)
+    {
+        gmt_offset = abs(gmt_offset);
+        special = abs(previous_day.minute - current_day.minute) > (MINUTES_PER_DAY / 2)? YES: NO;
+        if ((current_day.exception >    ROUTINE) || (previous_day.exception > ROUTINE))
+        {
+            if (previous_day.exception > ERROR) result = current_day;
+            else result = previous_day;
+            result.minute += gmt_offset;
+            result.minute %= MINUTES_PER_DAY;
+        }
+        else if (TIME_BEFORE_MIDNIGHT(previous_day.minute) <= gmt_offset)
+        {
+            result = previous_day;
+            result.minute += gmt_offset;
+            result.minute %= MINUTES_PER_DAY;
+        }
+        else if (   (TIME_BEFORE_MIDNIGHT(previous_day.minute) > gmt_offset)
+                &&  (TIME_BEFORE_MIDNIGHT(current_day.minute) > gmt_offset) )
+        {
+            result = current_day;
+            result.minute += gmt_offset;
+        }
+        else if (special == YES)
+        {
+            result = current_day;
+            temp_1 = (previous_day.minute + gmt_offset) % MINUTES_PER_DAY;
+            temp_2 = (current_day.minute + gmt_offset) % MINUTES_PER_DAY;
+            result.minute = (temp_1 + temp_2) / 2;
+        }
+        else
+        {
+            result.exception = NONE_TODAY;
+        }
+    }
+    else
+    {
+        result = current_day;
+    }
+    return result;
+}
+
+/***********************   Rise Set Transit Transit Underfoot
+
+This function is the heart of the original Heafner code. It has been substantially changed as
+follows:
+
+1) The original function got latitude and longitude data from file scope variables obser_lat and
+obser_lon. Those have been replaced by parameters lat and lon.
+
+2) The original function returned results as text strings. These have been replaced by a singgle
+rst_type structure which is comprised of time type structures. Each time type strucuture
+includes exception codes.
+
+3) The original function reported exceptions (object never rises or sets, event occurs previous
+or following day) as text strings. These have been replaced by the exceptions member of the
+structure.
+
+4) The rsflag has been repurposed to show the exception.
+
+5) The original function got the ra[] and dec[] arrays as parameters. These are now determined
+from the JPL file.
+
+6) The original function had delta t as a parameter. This is now a fixed value of 69 which is
+average between the 2016 value of 68.5 and the 2020 value of 69.5.
+
+7) Added a fudge factor to z0 to make moon rise and set times agree with published data.
+
+RETURN VALUE:   RST structure
+
+PARAMETERS:     handle to the cata file - already opened.
+                object - SUN or MOON
+                julian date
+                latitude
+                longitude
+*/
+rst_type RST(FILE *file, int object, double jed, double lat, double lon)
+{
+    int rsflag, c;
+    double h0, cosh0, newm, oldm, m, m0, m1, m2;
+    double ristime, settime, trntime, gast0;
+    double d1, d2, d3, r1, r2, r3;
+    double deltat;
+    double ra[3];
+    double dec[3];
+    double z0;
+    double hp;
+    double sd;
+    int index;
+    int rst_tries;
+    rst_type result;
+    jpl_type jpl[3];
+
+    deltat = 69;
+    index = (int)(floor(jed) - floor(JDATE_BASE));
+    fseek(file, ((index - 1) * sizeof(jpl_type)), SEEK_SET);
+    fread(&jpl[0], sizeof(jpl_type), 3, file);
+    if (object == SUN)
+    {
+        ra[0] = D2R * jpl[0].sun.ra;
+        dec[0] = D2R * jpl[0].sun.dec;
+        ra[1] = D2R * jpl[1].sun.ra;
+        dec[1] = D2R * jpl[1].sun.dec;
+        ra[2] = D2R * jpl[2].sun.ra;
+        dec[2] = D2R * jpl[2].sun.dec;
+        z0 = D2R * deg(90.34 + 0.16);
+    }
+    else
+    {
+        ra[0] = D2R * jpl[0].moon.ra;
+        dec[0] = D2R * jpl[0].moon.dec;
+        ra[1] = D2R * jpl[1].moon.ra;
+        dec[1] = D2R * jpl[1].moon.dec;
+        ra[2] = D2R * jpl[2].moon.ra;
+        dec[2] = D2R * jpl[2].moon.dec;
+        hp = D2R * deg(0.444156);
+        sd = asin(0.272493 * sin(hp));
+        z0 = D2R * deg(90.34) + sd - hp;
+        z0 -= 0.00275;          // fudge factor
+    }
+    /* Make sure the ra[]'s are in continuous order */
+
+    if ((ra[1] < ra[0]) && (ra[2] > ra[1])) {
+        ra[1] = ra[1] + TWOPI;
+        ra[2] = ra[2] + TWOPI;
+    }
+    else if ((ra[1] > ra[0]) && (ra[2] < ra[1])) {
+        ra[2] = ra[2] + TWOPI;
+    }
+
+    r1 = ra[1] - ra[0];
+    r2 = ra[2] - ra[1];
+    r3 = r2 - r1;
+    d1 = dec[1] - dec[0];
+    d2 = dec[2] - dec[1];
+    d3 = d2 - d1;
+
+    rsflag = 0;
+    cosh0 = (cos(z0) - sin(lat) * sin(dec[1])) / (cos(lat) * cos(dec[1]));
+    if (cosh0 < -1.0)
+    {
+        // Object - never sets
+        rsflag = NEVER_SET;
+    }
+    else if (cosh0 > 1.0)
+    {
+        // Object never rises 
+        rsflag = NEVER_RISE;
+    }
+
+    GetGST(jed, 1, &gast0);
+
+    m0 = (ra[1] - lon - gast0) / TWOPI;
+    m0 = amodulo(m0, 1.0);
+
+    if (rsflag == 0)
+    {
+        h0 = acos(cosh0);
+        h0 = amodulo(h0, PI);
+        m1 = m0 - h0 / TWOPI;
+        m1 = amodulo(m1, 1.0);
+        m2 = m0 + h0 / TWOPI;
+        m2 = amodulo(m2, 1.0);
+
+        // Rising 
+        oldm = m1;
+        c = 1;
+        rst_tries = RST_Interpolate(c, z0, oldm, gast0, deltat, ra, dec,
+                                    r1, r2, r3, d1, d2, d3, lat, lon, &newm);
+        if (rst_tries == RST_MAX_TRIES)
+        {
+            result.ris.exception = RST_ERROR;
+        }
+        else if (rst_tries > RST_MAX_TRIES)
+        {
+            result.ris.exception = RST_FAIL;
+        }
+        else
+        {
+            m = newm;
+            ristime = 24.0 * m;
+
+            if (ristime > 24.0) {
+                ristime = ristime - 24.0;
+                // Event occurs the following day 
+                result.ris = FmtTime(ristime);
+                result.ris.exception = NEXT_DAY;
+            }
+            else if (ristime < 0.0) {
+                ristime = ristime + 24.0;
+                // Event occurs the previous day 
+                result.ris = FmtTime(ristime);
+                result.ris.exception = PREV_DAY;
+            }
+            else {
+                result.ris = FmtTime(ristime);
+            }
+        }
+        // Setting 
+        oldm = m2;
+        c = 1;
+        rst_tries = RST_Interpolate(c, z0, oldm, gast0, deltat, ra, dec,
+                                    r1, r2, r3, d1, d2, d3, lat, lon, &newm);
+        if (rst_tries == RST_MAX_TRIES)
+        {
+            result.set.exception = RST_ERROR;
+        }
+        else if (rst_tries > RST_MAX_TRIES)
+        {
+            result.set.exception = RST_FAIL;
+        }
+        else
+        {
+            m = newm;
+            settime = 24.0 * m;
+            if (settime > 24.0)
+            {
+                settime = settime - 24.0;
+                result.set = FmtTime(settime);
+                result.set.exception = NEXT_DAY;
+            }
+            else if (settime < 0.0) {
+                settime = settime + 24.0;
+                result.set = FmtTime(settime);
+                result.set.exception = PREV_DAY;
+            }
+            else {
+                result.set = FmtTime(settime);
+            }
+        }
+    }
+
+    else
+    {
+        result.set = FmtTime(0);
+        result.ris = FmtTime(0);
+        result.set.exception = rsflag;
+        result.ris.exception = rsflag;
+    }
+    // Transiting 
+    oldm = m0;
+    c = 0;
+    rst_tries = RST_Interpolate(c, z0, oldm, gast0, deltat, ra, dec,
+                                r1, r2, r3, d1, d2, d3, lat, lon, &newm);
+    if (rst_tries == RST_MAX_TRIES)
+    {
+        result.trn.exception = RST_ERROR;
+    }
+    if (rst_tries > RST_MAX_TRIES)
+    {
+        result.trn.exception = RST_FAIL;
+    }
+    else
+    {
+        m = newm;
+        trntime = 24.0 * m;
+        if (trntime > 24.0) {
+            trntime = trntime - 24.0;
+            result.trn = FmtTime(trntime);
+            result.trn.exception = NEXT_DAY;
+        }
+        else if (trntime < 0.0) {
+            trntime = trntime + 24.0;
+            result.trn = FmtTime(trntime);
+            result.trn.exception = PREV_DAY;
+        }
+        else {
+            result.trn = FmtTime(trntime);
+        }
+    }
+    return result;
+}
+
+/***********************   Interpolation required by RST()
+
+This  is original Heafner code. For explanation, see the originalfunction in astrolib.c.
+The only modification is that the original function got latitude and longitude data from
+file scope variables obser_lat and obser_lon. Those have been replaced by parameters lat
+and lon.
+
+RETURN VALUE:   count of inerations in do loop
+
+PARAMETERS:     lat     latitude
+                lon     longitude
+                (see original function in astrolib to describe others)
+*/
+static int RST_Interpolate(int c, double z0, double oldm, double gast0,
+    double deltat, double *ra, double *dec, double r1, double r2, double r3,
+    double d1, double d2, double d3, double lat, double lon, double *newm) {
+
+    double alpha, dm, h, gast, delta, alt, n;
+    int count;
+
+    count = 0;
+    *newm = oldm;
+    do {
+        count ++;
+        if (count > RST_MAX_TRIES)
+        {
+            break;
+        }
+        gast = gast0 + 6.300388093 * (*newm);
+        gast = amodulo(gast, TWOPI);
+        n = *newm + deltat / 86400.0;
+        alpha = ra[1] + 0.5 * n * (r1 + r2 + n * r3);
+        alpha = amodulo(alpha, TWOPI);
+        delta = dec[1] + 0.5 * n * (d1 + d2 + n * d3);
+        h = gast + lon - alpha;
+        alt = asin(sin(delta) * sin(lat) + cos(delta) * cos(lat) * cos(h));
+        if (c == 0) {
+            /* h must satisfy -PI <= h <= PI */
+            h = amodulo(h, TWOPI);
+            if (h > PI) {
+                h = h - TWOPI;
+            }
+            dm = -h / TWOPI;
+        }
+        else {
+            dm = (alt - PIDIV2 + z0) / (TWOPI * cos(delta) * cos(lat) * sin(h));
+        }
+        *newm = (*newm) + dm;
+
+
+    } while (fabs(dm) >= 1e-15);
+    if ((*newm >= 2.0) || (*newm <= -1.0))
+    {
+        count = RST_MAX_TRIES;
+    }
+    return count;
+}
+
+/***********************   Convert Degrees
+
+This function cnverts degrees in the format dd.mmss to decimal degrees.
+It is original Heafner code with no changes
+
+RETURN VALUE:   decimal degrees
+
+PARAMETERS:     degrees in format dD.MMSS
+*/
+double deg(double x) {
+
+    double dd, d, fixdd, ddfixdd;
+
+    if (x == 0.0) return (0.0);
+
+    dd = fabs(x);
+    fixdd = floor(dd);
+    ddfixdd = dd - fixdd + 5.0e-10;  /* fudge factor */
+    d = fixdd + floor(100.0 * ddfixdd) / 60.0;
+    d = d + (10000.0 * ddfixdd - 100.0 * floor(100.0 * ddfixdd)) / 3600.0;
+
+    return ((x / dd) * d);
+}
+
+/***********************   Get Grenwich Sidereal Time
+
+This function computes Sidereal time (in radians) from the Julian date.It is original Heafner
+code excdpt:
+
+1) The original was siginicantly more complicated in that it computed apparent sidereal time.
+We don't require that kind of (sub-minute) accuracy, so we will use mean sidereal time. All
+code required to calculate apparent sidereal time has been removed.
+
+2) The parameter that specified mean or apparent sideereal time has been removed.
+
+3) The original had logic such that saved the time and apparent flag. If the call was the
+same as the previous call, the function would simply return with no changes. That would force
+the calling function to save the result for use if it happened to call this function twice in
+a row with the same date. That may have been useful when being called by some functions not
+used in our application, but where it is called in RST, the result (gast0) is not saved. The
+result was that an unitialized value was sent to RST_Interpolate() which caused it to fail.
+That logic has been removed.
+
+RETURN VALUE:   none
+
+PARAMETERS:     Juilian date
+                address of result
+*/
+void GetGST(double jed, int s, double *gst) {
+
+    double T;
+
+    T = (jed - J2000) / JulCty;
+
+    /* compute GMST in seconds */
+    *gst = 67310.54841 + T * ((876600.0 * 3600.0 + 8640184.812866)
+        + T * (0.093104 + T * (-0.0000062)));
+
+    /* convert to radians */
+    *gst = amodulo(*gst / 3600.0, 24.0) * H2R;
+    *gst = amodulo(*gst, TWOPI);
+}
+
+/***********************   Calculate the modulo of an angle
+
+This function calculates the module of an angle to the specified base. It us used with values in
+radians with either PI or TWOPI
+
+RETURN VALUE:   modulo of the angle
+
+PARAMETERS:     the angle
+                the base
+*/
+double amodulo(double a, double b) {
+
+    double x;
+
+    x = a - b * floor(a / b);
+    return (x);
+}
+
+/***************************  Ruby interface code *******************************************************/
+
+static VALUE
+test_function(VALUE self, VALUE number) {
+    VALUE v;
+    long i;
+    i = FIX2LONG(number);
+    i = i*2;
+    v = LONG2FIX(i);
+    return v;
+}
+
+/* This function initializes the new Solunar object - the names should match, and capitalization seems to come from Ruby magic.
+*  A "Value" is C/Ruby.h/C++ speak for a Ruby object. In this case, with the rb_intern stuff, that object is of the class "Solunar" and is registered as such.
+*  Registration is pure ruby magic. rb_define_method uses this, of the format (root_object - always the thing declared before, name to be registered as, function name, number of arguements to pass)
+*  Caveat to the above: Functions that will return to Ruby always are of type "Value", and always have a first object, of type value, that does something likely important - but exactly what, I couldn't tell you...
+*/
+
+void
+Init_solunar(void) {
+    VALUE cSolunar;
+
+    cSolunar = rb_const_get(rb_cObject, rb_intern("Solunar"));
+
+    rb_define_method(cSolunar, "multi", test_function, 1);
+    rb_define_method(cSolunar, "generate", generate, 7);
+}
+