interpolation: code style

Signed-off-by: Christoph Ruegg <git@cdrnet.ch>

src/Managed/Interpolation/Algorithms/BarycentricInterpolation.cs

@@ -42,17 +42,17 @@ namespace MathNet.Numerics.Interpolation.Algorithms
         /// <summary>
         /// Sample Points t.
         /// </summary>
-        private IList<double> points;
+        private IList<double> _points;
 
         /// <summary>
         /// Sample Values x(t).
         /// </summary>
-        private IList<double> values;
+        private IList<double> _values;
 
         /// <summary>
         /// Barycentric Weights w(t).
         /// </summary>
-        private IList<double> weights;
+        private IList<double> _weights;
 
         /// <summary>
         /// Initializes a new instance of the BarycentricInterpolation class.
@@ -72,7 +72,7 @@ namespace MathNet.Numerics.Interpolation.Algorithms
             IList<double> sampleValues,
             IList<double> barycentricWeights)
         {
-            this.Initialize(samplePoints, sampleValues, barycentricWeights);
+            Initialize(samplePoints, sampleValues, barycentricWeights);
         }
 
         /// <summary>
@@ -135,9 +135,9 @@ namespace MathNet.Numerics.Interpolation.Algorithms
                 throw new ArgumentException(Properties.Resources.ArgumentVectorsSameLengths);
             }
 
-            this.points = samplePoints;
-            this.values = sampleValues;
-            this.weights = barycentricWeights;
+            _points = samplePoints;
+            _values = sampleValues;
+            _weights = barycentricWeights;
         }
 
         /// <summary>
@@ -148,19 +148,19 @@ namespace MathNet.Numerics.Interpolation.Algorithms
         public double Interpolate(double t)
         {
             // trivial case: only one sample?
-            if (this.points.Count == 1)
+            if (_points.Count == 1)
             {
-                return this.values[0];
+                return _values[0];
             }
 
             // evaluate closest point and offset from that point (no sorting assumed)
             int closestPoint = 0;
-            double offset = t - this.points[0];
-            for (int i = 1; i < this.points.Count; i++)
+            double offset = t - _points[0];
+            for (int i = 1; i < _points.Count; i++)
             {
-                if (Math.Abs(t - this.points[i]) < Math.Abs(offset))
+                if (Math.Abs(t - _points[i]) < Math.Abs(offset))
                 {
-                    offset = t - this.points[i];
+                    offset = t - _points[i];
                     closestPoint = i;
                 }
             }
@@ -168,7 +168,7 @@ namespace MathNet.Numerics.Interpolation.Algorithms
             // trivial case: on a known sample point?
             if (offset.AlmostZero())
             {
-                return this.values[closestPoint];
+                return _values[closestPoint];
             }
 
             if (Math.Abs(offset) > 1e-150)
@@ -180,18 +180,18 @@ namespace MathNet.Numerics.Interpolation.Algorithms
 
             double s1 = 0.0;
             double s2 = 0.0;
-            for (int i = 0; i < this.points.Count; i++)
+            for (int i = 0; i < _points.Count; i++)
             {
                 if (i != closestPoint)
                 {
-                    double v = offset * this.weights[i] / (t - this.points[i]);
-                    s1 = s1 + (v * this.values[i]);
+                    double v = offset * _weights[i] / (t - _points[i]);
+                    s1 = s1 + (v * _values[i]);
                     s2 = s2 + v;
                 }
                 else
                 {
-                    double v = this.weights[i];
-                    s1 = s1 + (v * this.values[i]);
+                    double v = _weights[i];
+                    s1 = s1 + (v * _values[i]);
                     s2 = s2 + v;
                 }
             }
@@ -239,4 +239,4 @@ namespace MathNet.Numerics.Interpolation.Algorithms
             throw new NotSupportedException();
         }
     }
-}
+}

src/Managed/Interpolation/Algorithms/LinearSplineInterpolation.cs

@@ -42,14 +42,14 @@ namespace MathNet.Numerics.Interpolation.Algorithms
         /// <summary>
         /// Internal Spline Interpolation
         /// </summary>
-        private readonly SplineInterpolation spline;
+        private readonly SplineInterpolation _spline;
 
         /// <summary>
         /// Initializes a new instance of the LinearSplineInterpolation class.
         /// </summary>
         public LinearSplineInterpolation()
         {
-            this.spline = new SplineInterpolation();
+            _spline = new SplineInterpolation();
         }
 
         /// <summary>
@@ -61,8 +61,8 @@ namespace MathNet.Numerics.Interpolation.Algorithms
             IList<double> samplePoints,
             IList<double> sampleValues)
         {
-            this.spline = new SplineInterpolation();
-            this.Initialize(samplePoints, sampleValues);
+            _spline = new SplineInterpolation();
+            Initialize(samplePoints, sampleValues);
         }
 
         /// <summary>
@@ -123,7 +123,7 @@ namespace MathNet.Numerics.Interpolation.Algorithms
                 coefficients[j + 3] = 0;
             }
 
-            this.spline.Initialize(samplePoints, coefficients);
+            _spline.Initialize(samplePoints, coefficients);
         }
 
         /// <summary>
@@ -133,7 +133,7 @@ namespace MathNet.Numerics.Interpolation.Algorithms
         /// <returns>Interpolated value x(t).</returns>
         public double Interpolate(double t)
         {
-            return this.spline.Interpolate(t);
+            return _spline.Interpolate(t);
         }
 
         /// <summary>
@@ -145,7 +145,7 @@ namespace MathNet.Numerics.Interpolation.Algorithms
         /// <seealso cref="Differentiate(double, out double, out double)"/>
         public double Differentiate(double t)
         {
-            return this.spline.Differentiate(t);
+            return _spline.Differentiate(t);
         }
 
         /// <summary>
@@ -162,7 +162,7 @@ namespace MathNet.Numerics.Interpolation.Algorithms
             out double interpolatedValue,
             out double secondDerivative)
         {
-            return this.spline.Differentiate(t, out interpolatedValue, out secondDerivative);
+            return _spline.Differentiate(t, out interpolatedValue, out secondDerivative);
         }
 
         /// <summary>
@@ -173,7 +173,7 @@ namespace MathNet.Numerics.Interpolation.Algorithms
         /// <seealso cref="IInterpolation.SupportsIntegration"/>
         public double Integrate(double t)
         {
-            return this.spline.Integrate(t);
+            return _spline.Integrate(t);
         }
     }
-}
+}

src/Managed/Interpolation/Algorithms/NevillePolynomialInterpolation.cs

@@ -49,12 +49,12 @@ namespace MathNet.Numerics.Interpolation.Algorithms
         /// <summary>
         /// Sample Points t.
         /// </summary>
-        private IList<double> points;
+        private IList<double> _points;
 
         /// <summary>
         /// Spline Values x(t).
         /// </summary>
-        private IList<double> values;
+        private IList<double> _values;
 
         /// <summary>
         /// Initializes a new instance of the NevillePolynomialInterpolation class.
@@ -72,7 +72,7 @@ namespace MathNet.Numerics.Interpolation.Algorithms
             IList<double> samplePoints,
             IList<double> sampleValues)
         {
-            this.Initialize(samplePoints, sampleValues);
+            Initialize(samplePoints, sampleValues);
         }
 
         /// <summary>
@@ -118,8 +118,8 @@ namespace MathNet.Numerics.Interpolation.Algorithms
                 throw new ArgumentException(Properties.Resources.ArgumentVectorsSameLengths);
             }
 
-            this.points = samplePoints;
-            this.values = sampleValues;
+            _points = samplePoints;
+            _values = sampleValues;
         }
 
         /// <summary>
@@ -129,16 +129,16 @@ namespace MathNet.Numerics.Interpolation.Algorithms
         /// <returns>Interpolated value x(t).</returns>
         public double Interpolate(double t)
         {
-            double[] x = new double[this.values.Count];
-            this.values.CopyTo(x, 0);
+            double[] x = new double[_values.Count];
+            _values.CopyTo(x, 0);
 
             for (int level = 1; level < x.Length; level++)
             {
                 for (int i = 0; i < x.Length - level; i++)
                 {
-                    double hp = t - this.points[i + level];
-                    double ho = this.points[i] - t;
-                    double den = this.points[i] - this.points[i + level];
+                    double hp = t - _points[i + level];
+                    double ho = _points[i] - t;
+                    double den = _points[i] - _points[i + level];
                     x[i] = ((hp * x[i]) + (ho * x[i + 1])) / den;
                 }
             }
@@ -155,17 +155,17 @@ namespace MathNet.Numerics.Interpolation.Algorithms
         /// <seealso cref="Differentiate(double, out double, out double)"/>
         public double Differentiate(double t)
         {
-            double[] x = new double[this.values.Count];
-            double[] dx = new double[this.values.Count];
-            this.values.CopyTo(x, 0);
+            double[] x = new double[_values.Count];
+            double[] dx = new double[_values.Count];
+            _values.CopyTo(x, 0);
 
             for (int level = 1; level < x.Length; level++)
             {
                 for (int i = 0; i < x.Length - level; i++)
                 {
-                    double hp = t - this.points[i + level];
-                    double ho = this.points[i] - t;
-                    double den = this.points[i] - this.points[i + level];
+                    double hp = t - _points[i + level];
+                    double ho = _points[i] - t;
+                    double den = _points[i] - _points[i + level];
                     dx[i] = ((hp * dx[i]) + x[i] + (ho * dx[i + 1]) - x[i + 1]) / den;
                     x[i] = ((hp * x[i]) + (ho * x[i + 1])) / den;
                 }
@@ -188,26 +188,26 @@ namespace MathNet.Numerics.Interpolation.Algorithms
             out double interpolatedValue,
             out double secondDerivative)
         {
-            double[] x = new double[this.values.Count];
-            double[] dx = new double[this.values.Count];
-            double[] d2x = new double[this.values.Count];
-            this.values.CopyTo(x, 0);
+            double[] x = new double[_values.Count];
+            double[] dx = new double[_values.Count];
+            double[] ddx = new double[_values.Count];
+            _values.CopyTo(x, 0);
 
             for (int level = 1; level < x.Length; level++)
             {
                 for (int i = 0; i < x.Length - level; i++)
                 {
-                    double hp = t - this.points[i + level];
-                    double ho = this.points[i] - t;
-                    double den = this.points[i] - this.points[i + level];
-                    d2x[i] = ((hp * d2x[i]) + (ho * d2x[i + 1]) + (2 * dx[i]) - (2 * dx[i + 1])) / den;
+                    double hp = t - _points[i + level];
+                    double ho = _points[i] - t;
+                    double den = _points[i] - _points[i + level];
+                    ddx[i] = ((hp * ddx[i]) + (ho * ddx[i + 1]) + (2 * dx[i]) - (2 * dx[i + 1])) / den;
                     dx[i] = ((hp * dx[i]) + x[i] + (ho * dx[i + 1]) - x[i + 1]) / den;
                     x[i] = ((hp * x[i]) + (ho * x[i + 1])) / den;
                 }
             }
 
             interpolatedValue = x[0];
-            secondDerivative = d2x[0];
+            secondDerivative = ddx[0];
             return dx[0];
         }
 
@@ -222,4 +222,4 @@ namespace MathNet.Numerics.Interpolation.Algorithms
             throw new NotSupportedException();
         }
     }
-}
+}

src/Managed/Interpolation/Algorithms/RationalPoleFreeInterpolation.cs

@@ -42,14 +42,14 @@ namespace MathNet.Numerics.Interpolation.Algorithms
         /// <summary>
         /// Internal Barycentric Interpolation
         /// </summary>
-        private readonly BarycentricInterpolation barycentric;
+        private readonly BarycentricInterpolation _barycentric;
 
         /// <summary>
         /// Initializes a new instance of the RationalPoleFreeInterpolation class.
         /// </summary>
         public RationalPoleFreeInterpolation()
         {
-            this.barycentric = new BarycentricInterpolation();
+            _barycentric = new BarycentricInterpolation();
         }
 
         /// <summary>
@@ -61,8 +61,8 @@ namespace MathNet.Numerics.Interpolation.Algorithms
             IList<double> samplePoints,
             IList<double> sampleValues)
         {
-            this.barycentric = new BarycentricInterpolation();
-            this.Initialize(samplePoints, sampleValues);
+            _barycentric = new BarycentricInterpolation();
+            Initialize(samplePoints, sampleValues);
         }
 
         /// <summary>
@@ -96,7 +96,7 @@ namespace MathNet.Numerics.Interpolation.Algorithms
             IList<double> samplePoints,
             IList<double> sampleValues)
         {
-            this.Initialize(samplePoints, sampleValues, Math.Min(3, samplePoints.Count - 1));
+            Initialize(samplePoints, sampleValues, Math.Min(3, samplePoints.Count - 1));
         }
 
         /// <summary>
@@ -198,7 +198,7 @@ namespace MathNet.Numerics.Interpolation.Algorithms
                 weights[perm[i]] = sortedWeights[i];
             }
 
-            this.barycentric.Initialize(samplePoints, sampleValues, weights);
+            _barycentric.Initialize(samplePoints, sampleValues, weights);
         }
 
         /// <summary>
@@ -208,7 +208,7 @@ namespace MathNet.Numerics.Interpolation.Algorithms
         /// <returns>Interpolated value x(t).</returns>
         public double Interpolate(double t)
         {
-            return this.barycentric.Interpolate(t);
+            return _barycentric.Interpolate(t);
         }
 
         /// <summary>
@@ -251,4 +251,4 @@ namespace MathNet.Numerics.Interpolation.Algorithms
             throw new NotSupportedException();
         }
     }
-}
+}

src/Managed/Interpolation/Algorithms/SplineInterpolation.cs

@@ -42,17 +42,17 @@ namespace MathNet.Numerics.Interpolation.Algorithms
         /// <summary>
         /// Sample Points t.
         /// </summary>
-        private IList<double> points;
+        private IList<double> _points;
 
         /// <summary>
         /// Spline Coefficients c(t).
         /// </summary>
-        private IList<double> coefficients;
+        private IList<double> _coefficients;
 
         /// <summary>
         /// Number of samples.
         /// </summary>
-        private int sampleCount;
+        private int _sampleCount;
 
         /// <summary>
         /// Initializes a new instance of the SplineInterpolation class.
@@ -70,7 +70,7 @@ namespace MathNet.Numerics.Interpolation.Algorithms
             IList<double> samplePoints,
             IList<double> splineCoefficients)
         {
-            this.Initialize(samplePoints, splineCoefficients);
+            Initialize(samplePoints, splineCoefficients);
         }
 
         /// <summary>
@@ -121,9 +121,9 @@ namespace MathNet.Numerics.Interpolation.Algorithms
                 throw new ArgumentOutOfRangeException("splineCoefficients");
             }
 
-            this.points = samplePoints;
-            this.coefficients = splineCoefficients;
-            this.sampleCount = samplePoints.Count;
+            _points = samplePoints;
+            _coefficients = splineCoefficients;
+            _sampleCount = samplePoints.Count;
         }
 
         /// <summary>
@@ -136,13 +136,13 @@ namespace MathNet.Numerics.Interpolation.Algorithms
             int closestLeftIndex = IndexOfClosestPointLeftOf(t);
 
             // Interpolation
-            double offset = t - this.points[closestLeftIndex];
+            double offset = t - _points[closestLeftIndex];
             int k = closestLeftIndex << 2;
 
-            return this.coefficients[k]
-                + (offset * (this.coefficients[k + 1]
-                + (offset * (this.coefficients[k + 2]
-                + (offset * this.coefficients[k + 3])))));
+            return _coefficients[k]
+                   + (offset * (_coefficients[k + 1]
+                                + (offset * (_coefficients[k + 2]
+                                             + (offset * _coefficients[k + 3])))));
         }
 
         /// <summary>
@@ -157,12 +157,12 @@ namespace MathNet.Numerics.Interpolation.Algorithms
             int closestLeftIndex = IndexOfClosestPointLeftOf(t);
 
             // Differentiation
-            double offset = t - this.points[closestLeftIndex];
+            double offset = t - _points[closestLeftIndex];
             int k = closestLeftIndex << 2;
 
-            return this.coefficients[k + 1]
-                + (2 * offset * this.coefficients[k + 2])
-                + (3 * offset * offset * this.coefficients[k + 3]);
+            return _coefficients[k + 1]
+                   + (2 * offset * _coefficients[k + 2])
+                   + (3 * offset * offset * _coefficients[k + 3]);
         }
 
         /// <summary>
@@ -182,20 +182,20 @@ namespace MathNet.Numerics.Interpolation.Algorithms
             int closestLeftIndex = IndexOfClosestPointLeftOf(t);
 
             // Differentiation
-            double offset = t - this.points[closestLeftIndex];
+            double offset = t - _points[closestLeftIndex];
             int k = closestLeftIndex << 2;
 
-            interpolatedValue = this.coefficients[k]
-                + (offset * (this.coefficients[k + 1]
-                + (offset * (this.coefficients[k + 2]
-                + (offset * this.coefficients[k + 3])))));
+            interpolatedValue = _coefficients[k]
+                                + (offset * (_coefficients[k + 1]
+                                             + (offset * (_coefficients[k + 2]
+                                                          + (offset * _coefficients[k + 3])))));
 
-            secondDerivative = (2 * this.coefficients[k + 2])
-                + (6 * offset * this.coefficients[k + 3]);
+            secondDerivative = (2 * _coefficients[k + 2])
+                               + (6 * offset * _coefficients[k + 3]);
 
-            return this.coefficients[k + 1]
-                + (2 * offset * this.coefficients[k + 2])
-                + (3 * offset * offset * this.coefficients[k + 3]);
+            return _coefficients[k + 1]
+                   + (2 * offset * _coefficients[k + 2])
+                   + (3 * offset * offset * _coefficients[k + 3]);
         }
 
         /// <summary>
@@ -212,21 +212,20 @@ namespace MathNet.Numerics.Interpolation.Algorithms
             double result = 0;
             for (int i = 0, j = 0; i < closestLeftIndex; i++, j += 4)
             {
-                double w = this.points[i + 1] - this.points[i];
-                result += w * (this.coefficients[j]
-                    + ((w * (this.coefficients[j + 1] * 0.5))
-                    + (w * ((this.coefficients[j + 2] / 3)
-                    + (w * this.coefficients[j + 3] * 0.25)))));
+                double w = _points[i + 1] - _points[i];
+                result += w * (_coefficients[j]
+                               + ((w * _coefficients[j + 1] * 0.5)
+                                  + (w * ((_coefficients[j + 2] / 3)
+                                          + (w * _coefficients[j + 3] * 0.25)))));
             }
 
-            double offset = t - this.points[closestLeftIndex];
+            double offset = t - _points[closestLeftIndex];
             int k = closestLeftIndex << 2;
 
-            return result
-                + (offset * (this.coefficients[k]
-                + ((offset * (this.coefficients[k + 1] * 0.5))
-                + (offset * (this.coefficients[k + 2] / 3))
-                + (offset * this.coefficients[k + 3] * 0.25))));
+            return result + (offset * (_coefficients[k]
+                                       + (offset * _coefficients[k + 1] * 0.5)
+                                       + (offset * _coefficients[k + 2] / 3)
+                                       + (offset * _coefficients[k + 3] * 0.25)));
         }
 
         /// <summary>
@@ -238,11 +237,11 @@ namespace MathNet.Numerics.Interpolation.Algorithms
         {
             // Binary search in the [ t[0], ..., t[n-2] ] (t[n-1] is not included)
             int low = 0;
-            int high = this.sampleCount - 1;
+            int high = _sampleCount - 1;
             while (low != high - 1)
             {
                 int middle = (low + high) / 2;
-                if (this.points[middle] > t)
+                if (_points[middle] > t)
                 {
                     high = middle;
                 }
@@ -255,4 +254,4 @@ namespace MathNet.Numerics.Interpolation.Algorithms
             return low;
         }
     }
-}
+}

src/Managed/Interpolation/IInterpolation.cs

@@ -84,4 +84,4 @@ namespace MathNet.Numerics.Interpolation
         /// <seealso cref="SupportsIntegration"/>
         double Integrate(double t);
     }
-}
+}

src/Managed/Interpolation/Interpolation.cs

@@ -91,4 +91,4 @@ namespace MathNet.Numerics.Interpolation
             return method;
         }
     }
-}
+}

src/Settings.Resharper.xml

@@ -0,0 +1,79 @@
+<CodeStyleSettings>
+  <CSharp>
+    <FormatSettings>
+      <ANONYMOUS_METHOD_DECLARATION_BRACES>NEXT_LINE</ANONYMOUS_METHOD_DECLARATION_BRACES>
+      <CASE_BLOCK_BRACES>NEXT_LINE</CASE_BLOCK_BRACES>
+      <FORCE_FIXED_BRACES_STYLE>ALWAYS_ADD</FORCE_FIXED_BRACES_STYLE>
+      <FORCE_FOR_BRACES_STYLE>ALWAYS_ADD</FORCE_FOR_BRACES_STYLE>
+      <FORCE_FOREACH_BRACES_STYLE>ALWAYS_ADD</FORCE_FOREACH_BRACES_STYLE>
+      <FORCE_IFELSE_BRACES_STYLE>ALWAYS_ADD</FORCE_IFELSE_BRACES_STYLE>
+      <FORCE_USING_BRACES_STYLE>ALWAYS_ADD</FORCE_USING_BRACES_STYLE>
+      <FORCE_WHILE_BRACES_STYLE>ALWAYS_ADD</FORCE_WHILE_BRACES_STYLE>
+      <INDENT_SIZE>4</INDENT_SIZE>
+      <INITIALIZER_BRACES>NEXT_LINE</INITIALIZER_BRACES>
+      <MODIFIERS_ORDER IsNull="False">
+        <Item>public</Item>
+        <Item>protected</Item>
+        <Item>internal</Item>
+        <Item>private</Item>
+        <Item>new</Item>
+        <Item>abstract</Item>
+        <Item>virtual</Item>
+        <Item>override</Item>
+        <Item>sealed</Item>
+        <Item>static</Item>
+        <Item>readonly</Item>
+        <Item>extern</Item>
+        <Item>unsafe</Item>
+        <Item>volatile</Item>
+      </MODIFIERS_ORDER>
+      <SPACE_AROUND_MULTIPLICATIVE_OP>True</SPACE_AROUND_MULTIPLICATIVE_OP>
+      <SPACE_WITHIN_SINGLE_LINE_ARRAY_INITIALIZER_BRACES>True</SPACE_WITHIN_SINGLE_LINE_ARRAY_INITIALIZER_BRACES>
+    </FormatSettings>
+    <UsingsSettings />
+    <Naming2>
+      <ExceptionName IsNull="False">
+      </ExceptionName>
+      <PredefinedRule Inspect="True" Prefix="" Suffix="" Style="AaBb" ElementKind="TypesAndNamespaces" />
+      <PredefinedRule Inspect="True" Prefix="I" Suffix="" Style="AaBb" ElementKind="Interfaces" />
+      <PredefinedRule Inspect="True" Prefix="T" Suffix="" Style="AaBb" ElementKind="TypeParameters" />
+      <PredefinedRule Inspect="True" Prefix="" Suffix="" Style="AaBb" ElementKind="MethodPropertyEvent" />
+      <PredefinedRule Inspect="True" Prefix="" Suffix="" Style="aaBb" ElementKind="Locals" />
+      <PredefinedRule Inspect="True" Prefix="" Suffix="" Style="aaBb" ElementKind="LocalConstants" />
+      <PredefinedRule Inspect="True" Prefix="" Suffix="" Style="aaBb" ElementKind="Parameters" />
+      <PredefinedRule Inspect="True" Prefix="" Suffix="" Style="AaBb" ElementKind="PublicFields" />
+      <PredefinedRule Inspect="True" Prefix="" Suffix="" Style="AaBb" ElementKind="Constants" />
+      <PredefinedRule Inspect="True" Prefix="" Suffix="" Style="AaBb" ElementKind="StaticReadonly" />
+      <PredefinedRule Inspect="True" Prefix="_" Suffix="" Style="aaBb" ElementKind="NotPublicStaticFields" />
+      <PredefinedRule Inspect="True" Prefix="_" Suffix="" Style="aaBb" ElementKind="NotPublicInstanceFields" />
+      <PredefinedRule Inspect="True" Prefix="" Suffix="" Style="AaBb" ElementKind="EnumMember" />
+      <PredefinedRule Inspect="True" Prefix="" Suffix="" Style="AaBb" ElementKind="Other" />
+    </Naming2>
+  </CSharp>
+  <VB>
+    <FormatSettings>
+      <INDENT_SIZE>4</INDENT_SIZE>
+    </FormatSettings>
+    <ImportsSettings />
+    <Naming2 />
+  </VB>
+  <GenerateMemberBody />
+  <Naming2>
+    <ExceptionName IsNull="False">
+    </ExceptionName>
+    <PredefinedRule Inspect="True" Prefix="" Suffix="" Style="AaBb" ElementKind="StaticReadonly" />
+    <PredefinedRule Inspect="True" Prefix="" Suffix="" Style="AaBb" ElementKind="TypesAndNamespaces" />
+    <PredefinedRule Inspect="True" Prefix="I" Suffix="" Style="AaBb" ElementKind="Interfaces" />
+    <PredefinedRule Inspect="True" Prefix="T" Suffix="" Style="AaBb" ElementKind="TypeParameters" />
+    <PredefinedRule Inspect="True" Prefix="" Suffix="" Style="AaBb" ElementKind="MethodPropertyEvent" />
+    <PredefinedRule Inspect="True" Prefix="" Suffix="" Style="aaBb" ElementKind="Locals" />
+    <PredefinedRule Inspect="True" Prefix="" Suffix="" Style="aaBb" ElementKind="LocalConstants" />
+    <PredefinedRule Inspect="True" Prefix="" Suffix="" Style="aaBb" ElementKind="Parameters" />
+    <PredefinedRule Inspect="True" Prefix="" Suffix="" Style="AaBb" ElementKind="PublicFields" />
+    <PredefinedRule Inspect="True" Prefix="" Suffix="" Style="AaBb" ElementKind="Constants" />
+    <PredefinedRule Inspect="True" Prefix="_" Suffix="" Style="aaBb" ElementKind="NotPublicStaticFields" />
+    <PredefinedRule Inspect="True" Prefix="_" Suffix="" Style="aaBb" ElementKind="NotPublicInstanceFields" />
+    <PredefinedRule Inspect="True" Prefix="" Suffix="" Style="AaBb" ElementKind="EnumMember" />
+    <PredefinedRule Inspect="True" Prefix="" Suffix="" Style="AaBb" ElementKind="Other" />
+  </Naming2>
+</CodeStyleSettings>