more C# styled

oldrev · oldrev · commit ae85aa6ecd26 · 2018-02-13T00:52:53.000+08:00
diff --git a/GeographicLib/GeoMath.cs b/GeographicLib/GeoMath.cs
@@ -310,8 +310,19 @@ public static double Atan2d(double y, double x)
             // converting it to degrees and mapping the result to the correct
             // quadrant.
             int q = 0;
-            if (Math.Abs(y) > Math.Abs(x)) { double t; t = x; x = y; y = t; q = 2; }
-            if (x < 0) { x = -x; ++q; }
+            if (Math.Abs(y) > Math.Abs(x))
+            {
+                double t;
+                t = x;
+                x = y;
+                y = t;
+                q = 2;
+            }
+            if (x < 0)
+            {
+                x = -x;
+                ++q;
+            }
             // here x >= 0 and x >= abs(y), so angle is in [-pi/4, pi/4]
             double ang = ToDegrees(Math.Atan2(y, x));
             switch (q)
@@ -336,7 +347,7 @@ public static double Atan2d(double y, double x)
          * @return true if number is finite, false if NaN or infinite.
          **********************************************************************/
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static bool isfinite(double x) =>
+        public static bool IsFinite(double x) =>
             Math.Abs(x) <= Double.MaxValue;
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
diff --git a/GeographicLib/Geodesic.cs b/GeographicLib/Geodesic.cs
@@ -280,9 +280,9 @@ public Geodesic(double a, double f)
             _etol2 = 0.1 * tol2_ /
                       Math.Sqrt(Math.Max(0.001, Math.Abs(_f)) *
                                  Math.Min(1.0, 1 - _f / 2) / 2);
-            if (!(GeoMath.isfinite(_a) && _a > 0))
+            if (!(GeoMath.IsFinite(_a) && _a > 0))
                 throw new GeographicErr("Equatorial radius is not positive");
-            if (!(GeoMath.isfinite(_b) && _b > 0))
+            if (!(GeoMath.IsFinite(_b) && _b > 0))
                 throw new GeographicErr("Polar semi-axis is not positive");
             _A3x = new double[nA3x_];
             _C3x = new double[nC3x_];
@@ -641,13 +641,14 @@ internal struct InverseData
             internal GeodesicData g;
             internal double salp1, calp1, salp2, calp2;
 
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
             private void Init()
             {
                 g = new GeodesicData();
                 salp1 = calp1 = salp2 = calp2 = Double.NaN;
             }
 
-            internal static InverseData Empty
+            internal static InverseData NaN
             {
                 get
                 {
@@ -661,7 +662,7 @@ internal static InverseData Empty
         private InverseData InverseInt(double lat1, double lon1,
                                        double lat2, double lon2, int outmask)
         {
-            InverseData result = InverseData.Empty;
+            InverseData result = InverseData.NaN;
             GeodesicData r = result.g;
             // Compute longitude difference (AngDiff does this carefully).  Result is
             // in [-180, 180] but -180 is only for west-going geodesics.  180 is for
@@ -1269,13 +1270,13 @@ public GeodesicLine Line(double lat1, double lon1, double azi1, int caps)
          * @return <i>a</i> the equatorial radius of the ellipsoid (meters).  This is
          *   the value used in the constructor.
          **********************************************************************/
-        public double MajorRadius() { return _a; }
+        public double MajorRadius => _a;
 
         /**
          * @return <i>f</i> the  flattening of the ellipsoid.  This is the
          *   value used in the constructor.
          **********************************************************************/
-        public double Flattening() { return _f; }
+        public double Flattening => _f;
 
         /**
          * @return total area of ellipsoid in meters<sup>2</sup>.  The area of a
@@ -1288,8 +1289,9 @@ public GeodesicLine Line(double lat1, double lon1, double azi1, int caps)
          * A global instantiation of Geodesic with the parameters for the WGS84
          * ellipsoid.
          **********************************************************************/
-        public static readonly Geodesic WGS84 =
-    new Geodesic(Constants.WGS84_a, Constants.WGS84_f);
+        private static readonly Lazy<Geodesic> _wgs84 = new Lazy<Geodesic>(() => new Geodesic(Constants.WGS84_a, Constants.WGS84_f), true);
+
+        public static Geodesic WGS84 => _wgs84.Value;
 
         // This is a reformulation of the geodesic problem.  The notation is as
         // follows:
@@ -1341,11 +1343,14 @@ internal static double SinCosSeries(bool sinp,
         internal struct LengthsV
         {
             internal double s12b, m12b, m0, M12, M21;
+
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
             private void Init()
             {
                 s12b = m12b = m0 = M12 = M21 = Double.NaN;
             }
-            internal static LengthsV Empty
+
+            internal static LengthsV NaN
             {
                 get
                 {
@@ -1367,7 +1372,7 @@ private LengthsV Lengths(double eps, double sig12,
             // Return m12b = (reduced length)/_b; also calculate s12b = distance/_b,
             // and m0 = coefficient of secular term in expression for reduced length.
             outmask &= GeodesicMask.OUT_MASK;
-            LengthsV v = LengthsV.Empty; // To hold s12b, m12b, m0, M12, M21;
+            LengthsV v = LengthsV.NaN; // To hold s12b, m12b, m0, M12, M21;
 
             double m0x = 0, J12 = 0, A1 = 0, A2 = 0;
             if ((outmask & (GeodesicMask.DISTANCE | GeodesicMask.REDUCEDLENGTH |
@@ -1494,12 +1499,13 @@ internal struct InverseStartV
               // Only updated for short lines
               dnm;
 
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
             private void Init()
             {
                 sig12 = salp1 = calp1 = salp2 = calp2 = dnm = Double.NaN;
             }
 
-            internal static InverseStartV Empty
+            internal static InverseStartV NaN
             {
                 get
                 {
@@ -1522,7 +1528,7 @@ private InverseStartV InverseStart(double sbet1, double cbet1, double dn1,
             // salp2 and calp2 and function value is sig12.
 
             // To hold sig12, salp1, calp1, salp2, calp2, dnm.
-            InverseStartV w = InverseStartV.Empty;
+            InverseStartV w = InverseStartV.NaN;
             w.sig12 = -1;               // Return value
             double
               // bet12 = bet2 - bet1 in [0, pi); bet12a = bet2 + bet1 in (-pi, 0]
@@ -1697,13 +1703,15 @@ internal struct Lambda12V
         {
             internal double lam12, salp2, calp2, sig12, ssig1, csig1, ssig2, csig2,
               eps, domg12, dlam12;
+
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
             private void Init()
             {
                 lam12 = salp2 = calp2 = sig12 = ssig1 = csig1 = ssig2 = csig2
                   = eps = domg12 = dlam12 = Double.NaN;
             }
 
-            internal static Lambda12V Empty
+            internal static Lambda12V NaN
             {
                 get
                 {
@@ -1725,7 +1733,7 @@ private Lambda12V Lambda12(double sbet1, double cbet1, double dn1,
             // Object to hold lam12, salp2, calp2, sig12, ssig1, csig1, ssig2, csig2,
             // eps, domg12, dlam12;
 
-            Lambda12V w = Lambda12V.Empty;
+            Lambda12V w = Lambda12V.NaN;
 
             if (sbet1 == 0 && calp1 == 0)
                 // Break degeneracy of equatorial line.  This case has already been
diff --git a/GeographicLib/GeodesicLine.cs b/GeographicLib/GeodesicLine.cs
@@ -452,12 +452,11 @@ public GeodesicData Position(bool arcmode, double s12_a12,
         {
             outmask &= _caps & GeodesicMask.OUT_MASK;
             GeodesicData r = new GeodesicData();
-            if (!(Init() &&
-                   (arcmode ||
-                    (_caps & (GeodesicMask.OUT_MASK & GeodesicMask.DISTANCE_IN)) != 0)
-                   ))
+            if (!(Init && (arcmode || (_caps & (GeodesicMask.OUT_MASK & GeodesicMask.DISTANCE_IN)) != 0)))
+            {
                 // Uninitialized or impossible distance calculation requested
                 return r;
+            }
             r.lat1 = _lat1; r.azi1 = _azi1;
             r.lon1 = ((outmask & GeodesicMask.LONG_UNROLL) != 0) ? _lon1 :
               GeoMath.AngNormalize(_lon1);
@@ -637,6 +636,7 @@ public GeodesicData Position(bool arcmode, double s12_a12,
          * This is only useful if the GeodesicLine object has been constructed
          * with <i>caps</i> |= {@link GeodesicMask#DISTANCE_IN}.
          **********************************************************************/
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void SetDistance(double s13)
         {
             _s13 = s13;
@@ -653,6 +653,7 @@ public void SetDistance(double s13)
          * The distance <i>s13</i> is only set if the GeodesicLine object has been
          * constructed with <i>caps</i> |= {@link GeodesicMask#DISTANCE}.
          **********************************************************************/
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         void SetArc(double a13)
         {
             _a13 = a13;
@@ -671,6 +672,7 @@ void SetArc(double a13)
          *   point 1 to point 3 (meters); otherwise it is the arc length from
          *   point 1 to point 3 (degrees); it can be negative.
          **********************************************************************/
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void GenSetDistance(bool arcmode, double s13_a13)
         {
             if (arcmode)
@@ -682,90 +684,82 @@ public void GenSetDistance(bool arcmode, double s13_a13)
         /**
          * @return true if the object has been initialized.
          **********************************************************************/
-        private bool Init() { return _caps != 0; }
+        private bool Init => _caps != 0;
 
         /**
          * @return <i>lat1</i> the latitude of point 1 (degrees).
          **********************************************************************/
-        public double Latitude()
-        { return Init() ? _lat1 : Double.NaN; }
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double Latitude() => Init ? _lat1 : double.NaN;
 
         /**
          * @return <i>lon1</i> the longitude of point 1 (degrees).
          **********************************************************************/
-        public double Longitude()
-        { return Init() ? _lon1 : Double.NaN; }
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double Longitude() => Init ? _lon1 : double.NaN;
 
         /**
          * @return <i>azi1</i> the azimuth (degrees) of the geodesic line at point 1.
          **********************************************************************/
-        public double Azimuth()
-        { return Init() ? _azi1 : Double.NaN; }
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double Azimuth() => Init ? _azi1 : double.NaN;
 
         /**
          * @return pair of sine and cosine of <i>azi1</i> the azimuth (degrees) of
          *   the geodesic line at point 1.
          **********************************************************************/
-        public Pair AzimuthCosines()
-        {
-            return new Pair(Init() ? _salp1 : Double.NaN,
-                            Init() ? _calp1 : Double.NaN);
-        }
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public Pair AzimuthCosines() =>
+            new Pair(Init ? _salp1 : Double.NaN, Init ? _calp1 : Double.NaN);
 
         /**
          * @return <i>azi0</i> the azimuth (degrees) of the geodesic line as it
          *   crosses the equator in a northward direction.
          **********************************************************************/
-        public double EquatorialAzimuth()
-        {
-            return Init() ?
-              GeoMath.Atan2d(_salp0, _calp0) : Double.NaN;
-        }
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double EquatorialAzimuth() =>
+            Init ? GeoMath.Atan2d(_salp0, _calp0) : Double.NaN;
 
         /**
          * @return pair of sine and cosine of <i>azi0</i> the azimuth of the geodesic
          *   line as it crosses the equator in a northward direction.
          **********************************************************************/
-        public Pair EquatorialAzimuthCosines()
-        {
-            return new Pair(Init() ? _salp0 : Double.NaN,
-                            Init() ? _calp0 : Double.NaN);
-        }
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public Pair EquatorialAzimuthCosines() =>
+            new Pair(Init ? _salp0 : Double.NaN, Init ? _calp0 : Double.NaN);
 
         /**
          * @return <i>a1</i> the arc length (degrees) between the northward
          *   equatorial crossing and point 1.
          **********************************************************************/
-        public double EquatorialArc()
-        {
-            return Init() ?
-              GeoMath.Atan2d(_ssig1, _csig1) : Double.NaN;
-        }
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double EquatorialArc() =>
+            Init ? GeoMath.Atan2d(_ssig1, _csig1) : double.NaN;
 
         /**
          * @return <i>a</i> the equatorial radius of the ellipsoid (meters).  This is
          *   the value inherited from the Geodesic object used in the constructor.
          **********************************************************************/
-        public double MajorRadius()
-        { return Init() ? _a : Double.NaN; }
+        public double MajorRadius => Init ? _a : double.NaN;
 
         /**
          * @return <i>f</i> the flattening of the ellipsoid.  This is the value
          *   inherited from the Geodesic object used in the constructor.
          **********************************************************************/
-        public double Flattening()
-        { return Init() ? _f : Double.NaN; }
+        public double Flattening => Init ? _f : double.NaN;
 
         /**
          * @return <i>caps</i> the computational capabilities that this object was
          *   constructed with.  LATITUDE and AZIMUTH are always included.
          **********************************************************************/
-        public int Capabilities() { return _caps; }
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public int Capabilities() => _caps;
 
         /**
          * @param testcaps a set of bitor'ed {@link GeodesicMask} values.
          * @return true if the GeodesicLine object has all these capabilities.
          **********************************************************************/
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public bool Capabilities(int testcaps)
         {
             testcaps &= GeodesicMask.OUT_ALL;
@@ -780,18 +774,20 @@ public bool Capabilities(int testcaps)
          * @return <i>s13</i> if <i>arcmode</i> is false; <i>a13</i> if
          *   <i>arcmode</i> is true.
          **********************************************************************/
-        public double GenDistance(bool arcmode)
-        { return Init() ? (arcmode ? _a13 : _s13) : Double.NaN; }
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double GenDistance(bool arcmode) => Init ? (arcmode ? _a13 : _s13) : double.NaN;
 
         /**
          * @return <i>s13</i>, the distance to point 3 (meters).
          **********************************************************************/
-        public double Distance() { return GenDistance(false); }
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double Distance() => GenDistance(false);
 
         /**
          * @return <i>a13</i>, the arc length to point 3 (degrees).
          **********************************************************************/
-        public double Arc() { return GenDistance(true); }
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double Arc() => GenDistance(true);
 
     }
 
diff --git a/GeographicLib/Gnomonic.cs b/GeographicLib/Gnomonic.cs
@@ -153,8 +153,8 @@ public readonly struct Gnomonic
         public Gnomonic(Geodesic earth)
         {
             _earth = earth;
-            _a = _earth.MajorRadius();
-            _f = _earth.Flattening();
+            _a = _earth.MajorRadius;
+            _f = _earth.Flattening;
         }
 
         /**
diff --git a/GeographicLib/PolygonArea.cs b/GeographicLib/PolygonArea.cs
@@ -404,13 +404,13 @@ public PolygonResult TestEdge(double azi, double s,
          *   the value inherited from the Geodesic object used in the constructor.
          **********************************************************************/
 
-        public double MajorRadius() { return _earth.MajorRadius(); }
+        public double MajorRadius => _earth.MajorRadius;
 
         /**
          * @return <i>f</i> the flattening of the ellipsoid.  This is the value
          *   inherited from the Geodesic object used in the constructor.
          **********************************************************************/
-        public double Flattening() { return _earth.Flattening(); }
+        public double Flattening => _earth.Flattening;
 
         /**
          * Report the previous vertex added to the polygon or polyline.

Original file line number	Diff line number	Diff line change
`@@ -153,8 +153,8 @@ public readonly struct Gnomonic`
`153`	`153`	`public Gnomonic(Geodesic earth)`
`154`	`154`	`{`
`155`	`155`	`_earth = earth;`
`156`		`- _a = _earth.MajorRadius();`
`157`		`- _f = _earth.Flattening();`
	`156`	`+ _a = _earth.MajorRadius;`
	`157`	`+ _f = _earth.Flattening;`
`158`	`158`	`}`
`159`	`159`
`160`	`160`	`/**`