@itwin/core-geometry 4.10.0-dev.3 → 4.10.0-dev.6

package/lib/esm/geometry3d/AngleSweep.d.ts

@@ -116,6 +116,7 @@ export declare class AngleSweep implements BeJSONFunctions {
     /**
      * Return 2PI divided by the sweep radians (i.e. 360 degrees divided by sweep angle).
      * * This is the number of fractional intervals required to cover a whole circle.
+     * @returns period of the sweep, or 1 if sweep is empty.
      */
     fractionPeriod(): number;
     /**
@@ -129,39 +130,70 @@ export declare class AngleSweep implements BeJSONFunctions {
      * *  fraction larger than one for angles "before" the start angle if start > end
      * *  negative fraction for angles "after" the end angle if start > end
      * *  does not allow period shift
+     * @returns unbounded fraction, or 1 if sweep is empty.
      */
     angleToUnboundedFraction(theta: Angle): number;
+    /**
+     * Convert a sweep fraction to the equivalent period-shifted fraction inside the sweep, or within one period of zero
+     * on the desired side.
+     * @param fraction fraction of the sweep.
+     * @param radians0 start angle of sweep (in radians).
+     * @param radians1 end angle of sweep (in radians).
+     * @param toNegativeFraction return an exterior fraction period-shifted to within one period of the start (true) or
+     * end (false) of the sweep.
+     * @returns period-shifted fraction. If `fraction` is already in [0,1], or the sweep is empty, then `fraction` is
+     * returned unchanged.
+     */
+    static fractionToSignedPeriodicFractionStartEnd(fraction: number, radians0: number, radians1: number, toNegativeFraction: boolean): number;
+    /**
+     * Convert a sweep fraction to the equivalent period-shifted fraction inside this sweep, or within one period of
+     * zero on the desired side.
+     * @param fraction fraction of the sweep.
+     * @param toNegativeFraction return an exterior fraction period-shifted to within one period of the start (true) or
+     * end (false) of the sweep.
+     * @returns period-shifted fraction. If `fraction` is already in [0,1], or the sweep is empty, then `fraction` is
+     * returned unchanged.
+     */
+    fractionToSignedPeriodicFraction(fraction: number, toNegativeFraction: boolean): number;
     /**
      * Return the fractionalized position of the given angle (as radians), computed with consideration of 2PI period.
      * *  consider radians0 as `start` angle of the sweep and radians1 as `end` angle of the sweep
-     * *  fraction is always positive
      * *  the start angle is at fraction 0
      * *  the end angle is at fraction 1
      * *  interior angles are between 0 and 1
      * *  all exterior angles are at fractions greater than 1
      * *  allows period shift
+     * @param radians input angle (in radians)
+     * @param radians0 start angle of sweep (in radians)
+     * @param radians1 end angle of sweep (in radians)
+     * @param zeroSweepDefault return value when the sweep is empty (default 0)
+     * @returns nonnegative fraction, or `zeroSweepDefault` if the sweep is empty.
      */
     static radiansToPositivePeriodicFractionStartEnd(radians: number, radians0: number, radians1: number, zeroSweepDefault?: number): number;
     /**
      * Return the fractionalized position of the given angle (as radians), computed with consideration of 2PI period.
-     * *  fraction is always positive
      * *  the start angle is at fraction 0
      * *  the end angle is at fraction 1
      * *  interior angles are between 0 and 1
      * *  all exterior angles are at fractions greater than 1
      * *  allows period shift
+     * @param radians input angle (in radians)
+     * @param zeroSweepDefault return value when this sweep is empty (default 0)
+     * @returns nonnegative fraction, or `zeroSweepDefault` if the sweep is empty.
      */
     radiansToPositivePeriodicFraction(radians: number, zeroSweepDefault?: number): number;
     /**
      * Return the fractionalized position of the given angle (as Angle), computed with consideration of 2PI period.
-     * *  fraction is always positive
      * *  the start angle is at fraction 0
      * *  the end angle is at fraction 1
      * *  interior angles are between 0 and 1
      * *  all exterior angles are at fractions greater than 1
      * *  allows period shift
+     * @param theta input angle
+     * @param zeroSweepDefault return value when this sweep is empty (default 0)
+     * @returns nonnegative fraction, or `zeroSweepDefault` if the sweep is empty.
      */
-    angleToPositivePeriodicFraction(theta: Angle): number;
+    angleToPositivePeriodicFraction(theta: Angle, zeroSweepDefault?: number): number;
     /**
      * Return the fractionalized position of the given array of angles (as radian), computed with consideration of 2PI period.
      * *  fraction is always positive
@@ -181,8 +213,13 @@ export declare class AngleSweep implements BeJSONFunctions {
      * *  negative fraction for angles "before" the start angle
      * *  fraction larger than one for angles "after" the end angle
      * *  allows period shift
+     * @param radians input angle (in radians)
+     * @param radians0 start angle of sweep (in radians)
+     * @param radians1 end angle of sweep (in radians)
+     * @param zeroSweepDefault return value when the sweep is empty (default 0)
+     * @returns fraction, or `zeroSweepDefault` if the sweep is empty.
      */
-    static radiansToSignedPeriodicFractionStartEnd(radians: number, radians0: number, radians1: number): number;
+    static radiansToSignedPeriodicFractionStartEnd(radians: number, radians0: number, radians1: number, zeroSweepDefault?: number): number;
     /**
      * Return the fractionalized position of the given angle (as radians) computed with consideration of
      * 2PI period and with consideration of angle sweep direction (CW or CCW).
@@ -192,8 +229,11 @@ export declare class AngleSweep implements BeJSONFunctions {
      * *  negative fraction for angles "before" the start angle
      * *  fraction larger than one for angles "after" the end angle
      * *  allows period shift
+     * @param radians input angle (in radians)
+     * @param zeroSweepDefault return value when this sweep is empty (default 0)
+     * @returns fraction, or `zeroSweepDefault` if this sweep is empty.
      */
-    radiansToSignedPeriodicFraction(radians: number): number;
+    radiansToSignedPeriodicFraction(radians: number, zeroSweepDefault?: number): number;
     /**
      * Return the fractionalized position of the given angle (as Angle) computed with consideration of
      * 2PI period and with consideration of angle sweep direction (CW or CCW).
@@ -203,8 +243,52 @@ export declare class AngleSweep implements BeJSONFunctions {
      * *  negative fraction for angles "before" the start angle
      * *  fraction larger than one for angles "after" the end angle
      * *  allows period shift
+     * @param theta input angle
+     * @param zeroSweepDefault return value when this sweep is empty (default 0)
+     * @returns fraction, or `zeroSweepDefault` if this sweep is empty.
+     */
+    angleToSignedPeriodicFraction(theta: Angle, zeroSweepDefault?: number): number;
+    /**
+     * Return the fractionalized position of the given radian angle with respect to the sweep.
+     * * The start angle returns fraction 0
+     * * The end angle returns fraction 1
+     * * Interior angles (and their multiples of 2PI) return fractions in [0,1].
+     * * Exterior angles return fractions outside [0,1] according to `toNegativeFraction`.
+     * @param radians input angle (in radians)
+     * @param radians0 start angle of sweep (in radians)
+     * @param radians1 end angle of sweep (in radians)
+     * @param toNegativeFraction convert an exterior angle to a negative number (true), or to
+     * a number greater than one (false, default). If false, this is just [[radiansToPositivePeriodicFractionStartEnd]].
+     * @param zeroSweepDefault return value when the sweep is empty (default 0).
+     * @returns fraction, or `zeroSweepDefault` if the sweep is empty
+     */
+    static radiansToSignedFractionStartEnd(radians: number, radians0: number, radians1: number, toNegativeFraction?: boolean, zeroSweepDefault?: number): number;
+    /**
+     * Return the fractionalized position of the given radian angle with respect to this sweep.
+     * * The start angle returns fraction 0
+     * * The end angle returns fraction 1
+     * * Interior angles (and their multiples of 2PI) return fractions in [0,1].
+     * * Exterior angles return fractions outside [0,1] according to `toNegativeFraction`.
+     * @param radians input angle (in radians)
+     * @param toNegativeFraction convert an exterior angle to a negative number (true), or to
+     * a number greater than one (false, default). If false, this is just [[radiansToPositivePeriodicFraction]].
+     * @param zeroSweepDefault return value when this sweep is empty (default 0).
+     * @returns fraction, or `zeroSweepDefault` if this sweep is empty
+     */
+    radiansToSignedFraction(radians: number, toNegativeFraction?: boolean, zeroSweepDefault?: number): number;
+    /**
+     * Return the fractionalized position of the given angle with respect to this sweep.
+     * * The start angle returns fraction 0
+     * * The end angle returns fraction 1
+     * * Interior angles (and their multiples of 2PI) return fractions in [0,1].
+     * * Exterior angles return fractions outside [0,1] according to `toNegativeFraction`.
+     * @param theta input angle
+     * @param toNegativeFraction convert an exterior angle to a negative number (true), or to
+     * a number greater than one (false, default). If false, this is just [[angleToPositivePeriodicFraction]].
+     * @param zeroSweepDefault return value when this sweep is empty (default 0).
+     * @returns fraction, or `zeroSweepDefault` if this sweep is empty
      */
-    angleToSignedPeriodicFraction(theta: Angle): number;
+    angleToSignedFraction(theta: Angle, toNegativeFraction?: boolean, zeroSweepDefault?: number): number;
     /** Test if the given angle (as radians) is within sweep (between radians0 and radians1)   */
     static isRadiansInStartEnd(radians: number, radians0: number, radians1: number, allowPeriodShift?: boolean): boolean;
     /** Test if the given angle (as radians) is within sweep  */

package/lib/esm/geometry3d/AngleSweep.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AngleSweep.d.ts","sourceRoot":"","sources":["../../../src/geometry3d/AngleSweep.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"AngleSweep.d.ts","sourceRoot":"","sources":["../../../src/geometry3d/AngleSweep.ts"],"names":[],"mappings":"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"}

package/lib/esm/geometry3d/AngleSweep.js

@@ -213,9 +213,10 @@ export class AngleSweep {
     /**
      * Return 2PI divided by the sweep radians (i.e. 360 degrees divided by sweep angle).
      * * This is the number of fractional intervals required to cover a whole circle.
+     * @returns period of the sweep, or 1 if sweep is empty.
      */
     fractionPeriod() {
-        return Geometry.safeDivideFraction(Math.PI * 2.0, Math.abs(this._radians1 - this._radians0), 1.0);
+        return this.isEmpty ? 1.0 : Angle.pi2Radians / Math.abs(this._radians1 - this._radians0);
     }
     /**
      * Return the fractionalized position of the given angle (as Angle) computed without consideration of
@@ -228,68 +229,100 @@ export class AngleSweep {
      * *  fraction larger than one for angles "before" the start angle if start > end
      * *  negative fraction for angles "after" the end angle if start > end
      * *  does not allow period shift
+     * @returns unbounded fraction, or 1 if sweep is empty.
      */
     angleToUnboundedFraction(theta) {
-        return Geometry.safeDivideFraction(theta.radians - this._radians0, this._radians1 - this._radians0, 1.0);
+        return this.isEmpty ? 1.0 : (theta.radians - this._radians0) / (this._radians1 - this._radians0);
+    }
+    /**
+     * Convert a sweep fraction to the equivalent period-shifted fraction inside the sweep, or within one period of zero
+     * on the desired side.
+     * @param fraction fraction of the sweep.
+     * @param radians0 start angle of sweep (in radians).
+     * @param radians1 end angle of sweep (in radians).
+     * @param toNegativeFraction return an exterior fraction period-shifted to within one period of the start (true) or
+     * end (false) of the sweep.
+     * @returns period-shifted fraction. If `fraction` is already in [0,1], or the sweep is empty, then `fraction` is
+     * returned unchanged.
+     */
+    static fractionToSignedPeriodicFractionStartEnd(fraction, radians0, radians1, toNegativeFraction) {
+        const sweep = radians1 - radians0;
+        if (Angle.isAlmostEqualRadiansNoPeriodShift(0, sweep))
+            return fraction; // empty sweep
+        if (Geometry.isIn01(fraction))
+            return fraction;
+        const period = Angle.pi2Radians / Math.abs(sweep);
+        fraction = fraction % period; // period-shifted equivalent fraction closest to 0 with same sign as fraction
+        if (fraction + period < 1)
+            fraction += period; // it's really an interior fraction
+        if (Geometry.isIn01(fraction) || (toNegativeFraction && fraction < 0) || (!toNegativeFraction && fraction > 1))
+            return fraction;
+        return toNegativeFraction ? fraction - period : fraction + period; // shift to other side of sweep
+    }
+    /**
+     * Convert a sweep fraction to the equivalent period-shifted fraction inside this sweep, or within one period of
+     * zero on the desired side.
+     * @param fraction fraction of the sweep.
+     * @param toNegativeFraction return an exterior fraction period-shifted to within one period of the start (true) or
+     * end (false) of the sweep.
+     * @returns period-shifted fraction. If `fraction` is already in [0,1], or the sweep is empty, then `fraction` is
+     * returned unchanged.
+     */
+    fractionToSignedPeriodicFraction(fraction, toNegativeFraction) {
+        return AngleSweep.fractionToSignedPeriodicFractionStartEnd(fraction, this._radians0, this._radians1, toNegativeFraction);
     }
     /**
      * Return the fractionalized position of the given angle (as radians), computed with consideration of 2PI period.
      * *  consider radians0 as `start` angle of the sweep and radians1 as `end` angle of the sweep
-     * *  fraction is always positive
      * *  the start angle is at fraction 0
      * *  the end angle is at fraction 1
      * *  interior angles are between 0 and 1
      * *  all exterior angles are at fractions greater than 1
      * *  allows period shift
+     * @param radians input angle (in radians)
+     * @param radians0 start angle of sweep (in radians)
+     * @param radians1 end angle of sweep (in radians)
+     * @param zeroSweepDefault return value when the sweep is empty (default 0)
+     * @returns nonnegative fraction, or `zeroSweepDefault` if the sweep is empty.
      */
     static radiansToPositivePeriodicFractionStartEnd(radians, radians0, radians1, zeroSweepDefault = 0.0) {
-        if (Angle.isAlmostEqualRadiansAllowPeriodShift(radians0, radians1)) {
-            // for 2nPi sweep, allow matching without period shift, else we never return 1.0
-            if (Angle.isAlmostEqualRadiansNoPeriodShift(radians, radians0))
-                return 0.0;
-            if (Angle.isAlmostEqualRadiansNoPeriodShift(radians, radians1))
-                return 1.0;
-        }
-        else {
-            if (Angle.isAlmostEqualRadiansAllowPeriodShift(radians, radians0))
-                return 0.0;
-            if (Angle.isAlmostEqualRadiansAllowPeriodShift(radians, radians1))
-                return 1.0;
+        const zeroSweepMarker = Geometry.largeCoordinateResult;
+        let fraction = this.radiansToSignedPeriodicFractionStartEnd(radians, radians0, radians1, zeroSweepMarker);
+        if (fraction === zeroSweepMarker)
+            return zeroSweepDefault;
+        if (fraction < 0) {
+            const period = Angle.pi2Radians / Math.abs(radians1 - radians0);
+            fraction += period;
         }
-        const sweep = radians1 - radians0;
-        const delta = radians - radians0;
-        if (sweep > 0) {
-            const delta1 = Angle.adjustRadians0To2Pi(delta);
-            const fraction1 = Geometry.safeDivideFraction(delta1, sweep, zeroSweepDefault);
-            return fraction1;
-        }
-        const delta2 = Angle.adjustRadians0To2Pi(-delta);
-        const fraction2 = Geometry.safeDivideFraction(delta2, -sweep, zeroSweepDefault);
-        return fraction2;
+        return fraction;
     }
     /**
      * Return the fractionalized position of the given angle (as radians), computed with consideration of 2PI period.
-     * *  fraction is always positive
      * *  the start angle is at fraction 0
      * *  the end angle is at fraction 1
      * *  interior angles are between 0 and 1
      * *  all exterior angles are at fractions greater than 1
      * *  allows period shift
+     * @param radians input angle (in radians)
+     * @param zeroSweepDefault return value when this sweep is empty (default 0)
+     * @returns nonnegative fraction, or `zeroSweepDefault` if the sweep is empty.
      */
     radiansToPositivePeriodicFraction(radians, zeroSweepDefault = 0.0) {
         return AngleSweep.radiansToPositivePeriodicFractionStartEnd(radians, this._radians0, this._radians1, zeroSweepDefault);
     }
     /**
      * Return the fractionalized position of the given angle (as Angle), computed with consideration of 2PI period.
-     * *  fraction is always positive
      * *  the start angle is at fraction 0
      * *  the end angle is at fraction 1
      * *  interior angles are between 0 and 1
      * *  all exterior angles are at fractions greater than 1
      * *  allows period shift
+     * @param theta input angle
+     * @param zeroSweepDefault return value when this sweep is empty (default 0)
+     * @returns nonnegative fraction, or `zeroSweepDefault` if the sweep is empty.
      */
-    angleToPositivePeriodicFraction(theta) {
-        return this.radiansToPositivePeriodicFraction(theta.radians);
+    angleToPositivePeriodicFraction(theta, zeroSweepDefault = 0.0) {
+        return this.radiansToPositivePeriodicFraction(theta.radians, zeroSweepDefault);
     }
     /**
      * Return the fractionalized position of the given array of angles (as radian), computed with consideration of 2PI period.
@@ -315,10 +348,18 @@ export class AngleSweep {
      * *  negative fraction for angles "before" the start angle
      * *  fraction larger than one for angles "after" the end angle
      * *  allows period shift
+     * @param radians input angle (in radians)
+     * @param radians0 start angle of sweep (in radians)
+     * @param radians1 end angle of sweep (in radians)
+     * @param zeroSweepDefault return value when the sweep is empty (default 0)
+     * @returns fraction, or `zeroSweepDefault` if the sweep is empty.
      */
-    static radiansToSignedPeriodicFractionStartEnd(radians, radians0, radians1) {
+    static radiansToSignedPeriodicFractionStartEnd(radians, radians0, radians1, zeroSweepDefault = 0.0) {
+        const sweep = radians1 - radians0;
+        if (Angle.isAlmostEqualRadiansNoPeriodShift(0, sweep))
+            return zeroSweepDefault;
         if (Angle.isAlmostEqualRadiansAllowPeriodShift(radians0, radians1)) {
-            // for 2nPi sweep, allow matching without period shift, else we never return 1.0
+            // for sweep = 2nPi !== 0, allow matching without period shift, else we never return 1.0
             if (Angle.isAlmostEqualRadiansNoPeriodShift(radians, radians0))
                 return 0.0;
             if (Angle.isAlmostEqualRadiansNoPeriodShift(radians, radians1))
@@ -330,16 +371,8 @@ export class AngleSweep {
             if (Angle.isAlmostEqualRadiansAllowPeriodShift(radians, radians1))
                 return 1.0;
         }
-        const sweep = radians1 - radians0;
-        const delta = radians - radians0 - 0.5 * sweep; // measure from middle of interval
-        if (sweep > 0) {
-            const delta1 = Angle.adjustRadiansMinusPiPlusPi(delta);
-            const fraction1 = 0.5 + Geometry.safeDivideFraction(delta1, sweep, 0.0);
-            return fraction1;
-        }
-        const delta2 = Angle.adjustRadiansMinusPiPlusPi(-delta);
-        const fraction = 0.5 + Geometry.safeDivideFraction(delta2, -sweep, 0.0);
-        return fraction;
+        const fraction = (radians - radians0) / sweep;
+        return this.fractionToSignedPeriodicFractionStartEnd(fraction, radians0, radians1, fraction < 0);
     }
     /**
      * Return the fractionalized position of the given angle (as radians) computed with consideration of
@@ -350,9 +383,12 @@ export class AngleSweep {
      * *  negative fraction for angles "before" the start angle
      * *  fraction larger than one for angles "after" the end angle
      * *  allows period shift
+     * @param radians input angle (in radians)
+     * @param zeroSweepDefault return value when this sweep is empty (default 0)
+     * @returns fraction, or `zeroSweepDefault` if this sweep is empty.
      */
-    radiansToSignedPeriodicFraction(radians) {
-        return AngleSweep.radiansToSignedPeriodicFractionStartEnd(radians, this._radians0, this._radians1);
+    radiansToSignedPeriodicFraction(radians, zeroSweepDefault = 0.0) {
+        return AngleSweep.radiansToSignedPeriodicFractionStartEnd(radians, this._radians0, this._radians1, zeroSweepDefault);
     }
     /**
      * Return the fractionalized position of the given angle (as Angle) computed with consideration of
@@ -363,9 +399,69 @@ export class AngleSweep {
      * *  negative fraction for angles "before" the start angle
      * *  fraction larger than one for angles "after" the end angle
      * *  allows period shift
+     * @param theta input angle
+     * @param zeroSweepDefault return value when this sweep is empty (default 0)
+     * @returns fraction, or `zeroSweepDefault` if this sweep is empty.
+     */
+    angleToSignedPeriodicFraction(theta, zeroSweepDefault = 0.0) {
+        return this.radiansToSignedPeriodicFraction(theta.radians, zeroSweepDefault);
+    }
+    /**
+     * Return the fractionalized position of the given radian angle with respect to the sweep.
+     * * The start angle returns fraction 0
+     * * The end angle returns fraction 1
+     * * Interior angles (and their multiples of 2PI) return fractions in [0,1].
+     * * Exterior angles return fractions outside [0,1] according to `toNegativeFraction`.
+     * @param radians input angle (in radians)
+     * @param radians0 start angle of sweep (in radians)
+     * @param radians1 end angle of sweep (in radians)
+     * @param toNegativeFraction convert an exterior angle to a negative number (true), or to
+     * a number greater than one (false, default). If false, this is just [[radiansToPositivePeriodicFractionStartEnd]].
+     * @param zeroSweepDefault return value when the sweep is empty (default 0).
+     * @returns fraction, or `zeroSweepDefault` if the sweep is empty
+     */
+    static radiansToSignedFractionStartEnd(radians, radians0, radians1, toNegativeFraction = false, zeroSweepDefault = 0.0) {
+        const zeroSweepMarker = Geometry.largeCoordinateResult;
+        let fraction = this.radiansToSignedPeriodicFractionStartEnd(radians, radians0, radians1, zeroSweepMarker);
+        if (fraction === zeroSweepMarker)
+            return zeroSweepDefault;
+        if ((toNegativeFraction && fraction > 1) || (!toNegativeFraction && fraction < 0)) {
+            let period = Angle.pi2Radians / Math.abs(radians1 - radians0);
+            if (toNegativeFraction)
+                period = -period;
+            fraction += period;
+        }
+        return fraction;
+    }
+    /**
+     * Return the fractionalized position of the given radian angle with respect to this sweep.
+     * * The start angle returns fraction 0
+     * * The end angle returns fraction 1
+     * * Interior angles (and their multiples of 2PI) return fractions in [0,1].
+     * * Exterior angles return fractions outside [0,1] according to `toNegativeFraction`.
+     * @param radians input angle (in radians)
+     * @param toNegativeFraction convert an exterior angle to a negative number (true), or to
+     * a number greater than one (false, default). If false, this is just [[radiansToPositivePeriodicFraction]].
+     * @param zeroSweepDefault return value when this sweep is empty (default 0).
+     * @returns fraction, or `zeroSweepDefault` if this sweep is empty
+     */
+    radiansToSignedFraction(radians, toNegativeFraction = false, zeroSweepDefault = 0.0) {
+        return AngleSweep.radiansToSignedFractionStartEnd(radians, this._radians0, this._radians1, toNegativeFraction, zeroSweepDefault);
+    }
+    /**
+     * Return the fractionalized position of the given angle with respect to this sweep.
+     * * The start angle returns fraction 0
+     * * The end angle returns fraction 1
+     * * Interior angles (and their multiples of 2PI) return fractions in [0,1].
+     * * Exterior angles return fractions outside [0,1] according to `toNegativeFraction`.
+     * @param theta input angle
+     * @param toNegativeFraction convert an exterior angle to a negative number (true), or to
+     * a number greater than one (false, default). If false, this is just [[angleToPositivePeriodicFraction]].
+     * @param zeroSweepDefault return value when this sweep is empty (default 0).
+     * @returns fraction, or `zeroSweepDefault` if this sweep is empty
      */
-    angleToSignedPeriodicFraction(theta) {
-        return this.radiansToSignedPeriodicFraction(theta.radians);
+    angleToSignedFraction(theta, toNegativeFraction = false, zeroSweepDefault = 0.0) {
+        return this.radiansToSignedFraction(theta.radians, toNegativeFraction, zeroSweepDefault);
     }
     /** Test if the given angle (as radians) is within sweep (between radians0 and radians1)   */
     static isRadiansInStartEnd(radians, radians0, radians1, allowPeriodShift = true) {