fix: remove redundant parameter

from optimised split methods

Author: klausbrunner

.github/workflows/maven-package.yml

@@ -13,7 +13,7 @@ jobs:
     steps:
     - uses: actions/checkout@v5
     - name: Set up JDK
-      uses: actions/setup-java@v4
+      uses: actions/setup-java@v5
       with:
         java-version: '17'
         distribution: 'temurin'

.github/workflows/release-dry-run.yml

@@ -21,50 +21,88 @@ jobs:
         token: ${{ secrets.GITHUB_TOKEN }}
 
     - name: Set up JDK 17
-      uses: actions/setup-java@v4
+      uses: actions/setup-java@v5
       with:
         java-version: '17'
         distribution: 'temurin'
         cache: maven
         gpg-private-key: ${{ secrets.GPG_PRIVATE_KEY }}
         gpg-passphrase: GPG_PASSPHRASE
-        
-    - name: Test version bump
+
+    - name: Configure Git
+      run: |
+        git config user.name "github-actions[bot]"
+        git config user.email "github-actions[bot]@users.noreply.github.com"
+
+    - name: Set release version (dry-run)
       run: |
         echo "Current version: $(mvn -B help:evaluate -Dexpression=project.version -q -DforceStdout)"
         if [ -n "${{ github.event.inputs.version }}" ]; then
+          echo "Would set version to ${{ github.event.inputs.version }}"
           mvn -B versions:set -DnewVersion=${{ github.event.inputs.version }}
-          echo "Would set version to: ${{ github.event.inputs.version }}"
+          echo "RELEASE_VERSION=${{ github.event.inputs.version }}" >> $GITHUB_ENV
         else
-          mvn -B build-helper:parse-version versions:set -DnewVersion=\${parsedVersion.majorVersion}.\${parsedVersion.minorVersion}.\${parsedVersion.nextIncrementalVersion}
-          echo "Would bump to: $(mvn -B help:evaluate -Dexpression=project.version -q -DforceStdout)"
+          echo "Would remove -SNAPSHOT suffix for release"
+          mvn -B versions:set -DremoveSnapshot=true
+          RELEASE_VERSION=$(mvn help:evaluate -Dexpression=project.version -q -DforceStdout)
+          echo "RELEASE_VERSION=$RELEASE_VERSION" >> $GITHUB_ENV
+          echo "Would release version: $RELEASE_VERSION"
         fi
         mvn -B versions:commit
-        
-    - name: Test build and verify
+
+    - name: Commit release version (dry-run)
+      run: |
+        git add pom.xml
+        git commit -m "release: prepare release v${{ env.RELEASE_VERSION }}"
+        echo "Committed release version locally (not pushed)"
+
+    - name: Build and verify
       run: mvn -B clean verify
-        
-    - name: Test full release process (dry-run)
+
+    - name: Stage artifacts
       run: |
-        echo "Staging artifacts..."
         mkdir -p target/staging-deploy
         mvn -B deploy -DaltDeploymentRepository=local::file:./target/staging-deploy -DskipTests
-        echo "Testing full JReleaser release process..."
-        mvn -B jreleaser:full-release
+
+    - name: Test full release process (dry-run)
+      run: mvn -B jreleaser:full-release
       env:
         JRELEASER_GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         JRELEASER_GPG_PASSPHRASE: ${{ secrets.GPG_PASSPHRASE }}
         JRELEASER_GPG_PUBLIC_KEY: ${{ secrets.GPG_PUBLIC_KEY }}
         JRELEASER_GPG_SECRET_KEY: ${{ secrets.GPG_PRIVATE_KEY }}
         JRELEASER_MAVENCENTRAL_USERNAME: ${{ secrets.SONATYPE_USERNAME }}
         JRELEASER_MAVENCENTRAL_TOKEN: ${{ secrets.SONATYPE_TOKEN }}
+        GPG_PASSPHRASE: ${{ secrets.GPG_PASSPHRASE }}
         JRELEASER_DRY_RUN: true
 
     - name: Show what would be released
       run: |
+        echo "=== Release Summary ==="
+        echo "Release version: ${{ env.RELEASE_VERSION }}"
+        echo ""
         echo "=== Generated changelog ==="
         if [ -f target/jreleaser/release/CHANGELOG.md ]; then
           cat target/jreleaser/release/CHANGELOG.md
         else
           echo "No changelog found"
-        fi
+        fi
+        echo ""
+        echo "=== Next development version ==="
+        mvn -B build-helper:parse-version versions:set -DnewVersion=\${parsedVersion.majorVersion}.\${parsedVersion.minorVersion}.\${parsedVersion.nextIncrementalVersion}-SNAPSHOT
+        mvn -B versions:commit
+        NEXT_VERSION=$(mvn help:evaluate -Dexpression=project.version -q -DforceStdout)
+        echo "Bumped to next development version: $NEXT_VERSION"
+
+    - name: Commit development version (dry-run)
+      run: |
+        git add pom.xml
+        git commit -m "release: prepare for next development iteration"
+        echo "Committed development version locally (not pushed)"
+
+    - name: Show final git status
+      run: |
+        echo "=== Local Git Status ==="
+        git log --oneline -3
+        echo ""
+        echo "These commits were made locally but NOT pushed to the repository"

.github/workflows/release.yml

@@ -21,7 +21,7 @@ jobs:
         token: ${{ secrets.GITHUB_TOKEN }}
 
     - name: Set up JDK 17
-      uses: actions/setup-java@v4
+      uses: actions/setup-java@v5
       with:
         java-version: '17'
         distribution: 'temurin'
@@ -87,5 +87,4 @@ jobs:
 
     - name: Push changes
       run: |
-        git push origin master
-        git push origin --tags
+        git push origin master

README.md

@@ -17,7 +17,7 @@ included to validate against the reference code and other sources.
 <dependency>
     <groupId>net.e175.klaus</groupId>
     <artifactId>solarpositioning</artifactId>
-    <version>2.0.8</version>
+    <version>2.0.9</version>
 </dependency>
 ```
 
@@ -83,7 +83,7 @@ final var timeDependent = SPA.calculateSpaTimeDependentParts(dateTime, deltaT);
 // Reuse for multiple coordinates (up to 10x faster)
 for(var coordinate: coordinates) {
     var position = SPA.calculateSolarPositionWithTimeDependentParts(
-        dateTime, coordinate.lat, coordinate.lon, coordinate.elevation, timeDependent);
+        coordinate.lat, coordinate.lon, coordinate.elevation, timeDependent);
 }
 ```
 See the Javadoc for more methods.

pom.xml

@@ -118,6 +118,9 @@
                                 <changelog>
                                     <formatted>ALWAYS</formatted>
                                     <preset>conventional-commits</preset>
+                                    <contributors>
+                                        <enabled>false</enabled>
+                                    </contributors>
                                 </changelog>
                             </github>
                         </release>

src/main/java/net/e175/klaus/solarpositioning/SPA.java

@@ -67,7 +67,8 @@ public double elevation() {
   /**
    * Calculate time-dependent parts of the SPA algorithm (steps 1-11). These calculations depend
    * only on the date/time and can be computed once for bulk processing at a fixed time with varying
-   * coordinates.
+   * coordinates. Use with {@link #calculateSolarPositionWithTimeDependentParts} for significant
+   * performance improvements when calculating positions for multiple coordinates at the same time.
    *
    * @param date Observer's local date and time.
    * @param deltaT Difference between earth rotation time and terrestrial time (or Universal Time
@@ -85,19 +86,19 @@ public static SpaTimeDependent calculateSpaTimeDependentParts(
 
     // calculate Earth heliocentric longitude, L
     final double[] lTerms = calculateLBRTerms(jme, TERMS_L);
-    final double lDegrees = limitDegreesTo360(toDegrees(calculateLBRPolynomial(jme, lTerms)));
+    final double lDegrees = limitTo(toDegrees(calculateLBRPolynomial(jme, lTerms)), 360);
 
     // calculate Earth heliocentric latitude, B
     final double[] bTerms = calculateLBRTerms(jme, TERMS_B);
-    final double bDegrees = limitDegreesTo360(toDegrees(calculateLBRPolynomial(jme, bTerms)));
+    final double bDegrees = limitTo(toDegrees(calculateLBRPolynomial(jme, bTerms)), 360);
 
     // calculate Earth radius vector, R
     final double[] rTerms = calculateLBRTerms(jme, TERMS_R);
     final double r = calculateLBRPolynomial(jme, rTerms);
     assert r != 0;
 
     // calculate geocentric longitude, theta
-    final double thetaDegrees = limitDegreesTo360(lDegrees + 180);
+    final double thetaDegrees = limitTo(lDegrees + 180, 360);
     // calculate geocentric latitude, beta
     final double betaDegrees = -bDegrees;
     final double beta = toRadians(betaDegrees);
@@ -146,7 +147,6 @@ public static SpaTimeDependent calculateSpaTimeDependentParts(
    * #calculateSpaTimeDependentParts}. Used together, these provide significant speedup for
    * coordinate sweeps at fixed time.
    *
-   * @param date Observer's local date and time (must match the date used for timeDependent).
    * @param latitude Observer's latitude, in degrees (negative south of equator).
    * @param longitude Observer's longitude, in degrees (negative west of Greenwich).
    * @param elevation Observer's elevation, in meters.
@@ -161,7 +161,6 @@ public static SpaTimeDependent calculateSpaTimeDependentParts(
    * @see SolarPosition
    */
   public static SolarPosition calculateSolarPositionWithTimeDependentParts(
-      final ZonedDateTime date,
       final double latitude,
       final double longitude,
       final double elevation,
@@ -176,7 +175,7 @@ public static SolarPosition calculateSolarPositionWithTimeDependentParts(
     final double deltaDegrees = timeDependent.deltaDegrees;
 
     // Calculate observer local hour angle
-    final double hDegrees = limitDegreesTo360(timeDependent.nuDegrees + longitude - alphaDegrees);
+    final double hDegrees = limitTo(timeDependent.nuDegrees + longitude - alphaDegrees, 360);
     final double h = toRadians(hDegrees);
 
     // Calculate the topocentric sun right ascension and sun declination
@@ -234,14 +233,13 @@ public static SolarPosition calculateSolarPosition(
       final double temperature) {
     final SpaTimeDependent timeDependent = calculateSpaTimeDependentParts(date, deltaT);
     return calculateSolarPositionWithTimeDependentParts(
-        date, latitude, longitude, elevation, pressure, temperature, timeDependent);
+        latitude, longitude, elevation, pressure, temperature, timeDependent);
   }
 
   /**
    * Calculate topocentric solar position using pre-computed time-dependent parts. This method does
    * not perform refraction correction.
    *
-   * @param date Observer's local date and time (must match the date used for timeDependent).
    * @param latitude Observer's latitude, in degrees (negative south of equator).
    * @param longitude Observer's longitude, in degrees (negative west of Greenwich).
    * @param elevation Observer's elevation, in meters.
@@ -252,13 +250,12 @@ public static SolarPosition calculateSolarPosition(
    * @see SolarPosition
    */
   public static SolarPosition calculateSolarPositionWithTimeDependentParts(
-      final ZonedDateTime date,
       final double latitude,
       final double longitude,
       final double elevation,
       final SpaTimeDependent timeDependent) {
     return calculateSolarPositionWithTimeDependentParts(
-        date, latitude, longitude, elevation, Double.NaN, Double.NaN, timeDependent);
+        latitude, longitude, elevation, Double.NaN, Double.NaN, timeDependent);
   }
 
   /**
@@ -647,7 +644,7 @@ private static AlphaDelta calculateAlphaDelta(
       double jme, double deltaPsi, double epsilonDegrees) {
     // calculate Earth heliocentric latitude, B
     final double[] bTerms = calculateLBRTerms(jme, TERMS_B);
-    final double bDegrees = limitDegreesTo360(toDegrees(calculateLBRPolynomial(jme, bTerms)));
+    final double bDegrees = limitTo(toDegrees(calculateLBRPolynomial(jme, bTerms)), 360);
 
     // calculate Earth radius vector, R
     final double[] rTerms = calculateLBRTerms(jme, TERMS_R);
@@ -656,10 +653,10 @@ private static AlphaDelta calculateAlphaDelta(
 
     // calculate Earth heliocentric longitude, L
     final double[] lTerms = calculateLBRTerms(jme, TERMS_L);
-    final double lDegrees = limitDegreesTo360(toDegrees(calculateLBRPolynomial(jme, lTerms)));
+    final double lDegrees = limitTo(toDegrees(calculateLBRPolynomial(jme, lTerms)), 360);
 
     // calculate geocentric longitude, theta
-    final double thetaDegrees = limitDegreesTo360(lDegrees + 180);
+    final double thetaDegrees = limitTo(lDegrees + 180, 360);
 
     // calculate geocentric latitude, beta
     final double betaDegrees = -bDegrees;
@@ -701,8 +698,8 @@ private static SolarPosition calculateTopocentricSolarPosition(
 
     // Calculate the topocentric azimuth angle
     final double gamma = atan2(sin(hPrime), cosHPrime * sinPhi - tan(deltaPrime) * cosPhi);
-    final double gammaDegrees = limitDegreesTo360(toDegrees(gamma));
-    final double topocentricAzimuthAngle = limitDegreesTo360(gammaDegrees + 180);
+    final double gammaDegrees = limitTo(toDegrees(gamma), 360);
+    final double topocentricAzimuthAngle = limitTo(gammaDegrees + 180, 360);
 
     return new SolarPosition(topocentricAzimuthAngle, topocentricZenithAngle);
   }
@@ -737,7 +734,7 @@ private static double calculateGeocentricSunRightAscension(
     final double alpha =
         atan2(sin(lambdaRad) * cos(epsilonRad) - tan(betaRad) * sin(epsilonRad), cos(lambdaRad));
 
-    return limitDegreesTo360(toDegrees(alpha));
+    return limitTo(toDegrees(alpha), 360);
   }
 
   private static double calculateTrueObliquityOfEcliptic(
@@ -749,10 +746,11 @@ private static double calculateTrueObliquityOfEcliptic(
   private static double calculateApparentSiderealTimeAtGreenwich(
       final JulianDate jd, final double deltaPsi, final double epsilonDegrees) {
     final double nu0degrees =
-        limitDegreesTo360(
+        limitTo(
             280.46061837
                 + 360.98564736629 * (jd.julianDate() - 2451545)
-                + pow(jd.julianCentury(), 2) * (0.000387933 - jd.julianCentury() / 38710000));
+                + pow(jd.julianCentury(), 2) * (0.000387933 - jd.julianCentury() / 38710000),
+            360);
 
     return nu0degrees + deltaPsi * cos(toRadians(epsilonDegrees));
   }
@@ -790,10 +788,6 @@ private static double[] calculateNutationTerms(final double jce) {
     return x;
   }
 
-  private static double limitDegreesTo360(final double degrees) {
-    return limitTo(degrees, 360.0);
-  }
-
   private static double calculateLBRPolynomial(final double jme, final double[] terms) {
     return polynomial(jme, terms) / 1e8;
   }

src/test/java/net/e175/klaus/solarpositioning/test/SPABulkProcessingTest.java

@@ -37,7 +37,7 @@ void timeDependentPartsProduceIdenticalResults() {
     SPA.SpaTimeDependent timeDependent = SPA.calculateSpaTimeDependentParts(dateTime, deltaT);
     SolarPosition optimized =
         SPA.calculateSolarPositionWithTimeDependentParts(
-            dateTime, latitude, longitude, elevation, pressure, temperature, timeDependent);
+            latitude, longitude, elevation, pressure, temperature, timeDependent);
 
     assertThat(optimized.azimuth()).isCloseTo(traditional.azimuth(), within(TOLERANCE));
     assertThat(optimized.zenithAngle()).isCloseTo(traditional.zenithAngle(), within(TOLERANCE));
@@ -60,7 +60,7 @@ void timeDependentPartsProduceIdenticalResultsWithoutRefraction() {
     SPA.SpaTimeDependent timeDependent = SPA.calculateSpaTimeDependentParts(dateTime, deltaT);
     SolarPosition optimized =
         SPA.calculateSolarPositionWithTimeDependentParts(
-            dateTime, latitude, longitude, elevation, timeDependent);
+            latitude, longitude, elevation, timeDependent);
 
     assertThat(optimized.azimuth()).isCloseTo(traditional.azimuth(), within(TOLERANCE));
     assertThat(optimized.zenithAngle()).isCloseTo(traditional.zenithAngle(), within(TOLERANCE));
@@ -95,7 +95,7 @@ void bulkProcessingWithFixedTime() {
       // Calculate optimized way
       SolarPosition optimized =
           SPA.calculateSolarPositionWithTimeDependentParts(
-              dateTime, coord.latitude, coord.longitude, coord.elevation, timeDependent);
+              coord.latitude, coord.longitude, coord.elevation, timeDependent);
 
       assertThat(optimized.azimuth())
           .as("Azimuth for lat=%f, lon=%f", coord.latitude, coord.longitude)
@@ -131,7 +131,7 @@ void bulkProcessingWithRandomCoordinates() {
       // Calculate optimized way
       SolarPosition optimized =
           SPA.calculateSolarPositionWithTimeDependentParts(
-              dateTime, latitude, longitude, elevation, pressure, temperature, timeDependent);
+              latitude, longitude, elevation, pressure, temperature, timeDependent);
 
       assertThat(optimized.azimuth())
           .as("Azimuth for random coordinate #%d", i)
@@ -168,8 +168,7 @@ void recycleTimeDependentPartsForMultipleCoordinates() {
 
       // Calculate using recycled time-dependent parts
       SolarPosition optimized =
-          SPA.calculateSolarPositionWithTimeDependentParts(
-              dateTime, lat, lon, elevation, timeDependent);
+          SPA.calculateSolarPositionWithTimeDependentParts(lat, lon, elevation, timeDependent);
 
       assertThat(optimized.azimuth())
           .as("Azimuth for coordinate lat=%f, lon=%f", lat, lon)
@@ -215,7 +214,7 @@ void performanceBenefitOfBulkProcessing() {
     SPA.SpaTimeDependent timeDependent = SPA.calculateSpaTimeDependentParts(dateTime, deltaT);
     for (Coordinate coord : coordinates) {
       SPA.calculateSolarPositionWithTimeDependentParts(
-          dateTime, coord.latitude, coord.longitude, coord.elevation, timeDependent);
+          coord.latitude, coord.longitude, coord.elevation, timeDependent);
     }
     long optimizedTime = System.nanoTime() - startOptimized;
 
@@ -246,7 +245,7 @@ void timeDependentPartsWithExtremeValues() {
         SPA.calculateSolarPosition(dateTime, latitude, longitude, elevation, deltaT);
     SolarPosition optimized =
         SPA.calculateSolarPositionWithTimeDependentParts(
-            dateTime, latitude, longitude, elevation, timeDependent);
+            latitude, longitude, elevation, timeDependent);
 
     assertThat(optimized.azimuth()).isCloseTo(traditional.azimuth(), within(TOLERANCE));
     assertThat(optimized.zenithAngle()).isCloseTo(traditional.zenithAngle(), within(TOLERANCE));
@@ -256,7 +255,7 @@ void timeDependentPartsWithExtremeValues() {
     traditional = SPA.calculateSolarPosition(dateTime, latitude, longitude, elevation, deltaT);
     optimized =
         SPA.calculateSolarPositionWithTimeDependentParts(
-            dateTime, latitude, longitude, elevation, timeDependent);
+            latitude, longitude, elevation, timeDependent);
 
     assertThat(optimized.azimuth()).isCloseTo(traditional.azimuth(), within(TOLERANCE));
     assertThat(optimized.zenithAngle()).isCloseTo(traditional.zenithAngle(), within(TOLERANCE));