Switch to file-scoped namespaces (#432)

Algorithms/Sequences/BinaryPrimeConstantSequence.cs

@@ -1,41 +1,40 @@
 using System.Collections.Generic;
 using System.Numerics;
 
-namespace Algorithms.Sequences
+namespace Algorithms.Sequences;
+
+/// <summary>
+///     <para>
+///         Sequence of binary prime constant
+///         (Characteristic function of primes: 1 if n is prime, else 0).
+///     </para>
+///     <para>
+///         Wikipedia: https://wikipedia.org/wiki/Prime_constant.
+///     </para>
+///     <para>
+///         OEIS: https://oeis.org/A010051.
+///     </para>
+/// </summary>
+public class BinaryPrimeConstantSequence : ISequence
 {
     /// <summary>
-    ///     <para>
-    ///         Sequence of binary prime constant
-    ///         (Characteristic function of primes: 1 if n is prime, else 0).
-    ///     </para>
-    ///     <para>
-    ///         Wikipedia: https://wikipedia.org/wiki/Prime_constant.
-    ///     </para>
-    ///     <para>
-    ///         OEIS: https://oeis.org/A010051.
-    ///     </para>
+    /// Gets sequence of binary prime constant.
     /// </summary>
-    public class BinaryPrimeConstantSequence : ISequence
+    public IEnumerable<BigInteger> Sequence
     {
-        /// <summary>
-        /// Gets sequence of binary prime constant.
-        /// </summary>
-        public IEnumerable<BigInteger> Sequence
+        get
         {
-            get
-            {
-                ISequence primes = new PrimesSequence();
-                var n = new BigInteger(0);
+            ISequence primes = new PrimesSequence();
+            var n = new BigInteger(0);
 
-                foreach (var p in primes.Sequence)
+            foreach (var p in primes.Sequence)
+            {
+                for (n++; n < p; n++)
                 {
-                    for (n++; n < p; n++)
-                    {
-                        yield return 0;
-                    }
-
-                    yield return 1;
+                    yield return 0;
                 }
+
+                yield return 1;
             }
         }
     }

Algorithms/Sequences/BinomialSequence.cs

@@ -1,67 +1,66 @@
-using System.Collections.Generic;
+using System.Collections.Generic;
 using System.Numerics;
 
-namespace Algorithms.Sequences
+namespace Algorithms.Sequences;
+
+/// <summary>
+///     <para>
+///         Sequence of binomial coefficients.
+///     </para>
+///     <para>
+///         Wikipedia: https://en.wikipedia.org/wiki/Binomial_coefficient.
+///     </para>
+///     <para>
+///         OEIS: http://oeis.org/A007318.
+///     </para>
+/// </summary>
+public class BinomialSequence : ISequence
 {
     /// <summary>
-    ///     <para>
-    ///         Sequence of binomial coefficients.
-    ///     </para>
-    ///     <para>
-    ///         Wikipedia: https://en.wikipedia.org/wiki/Binomial_coefficient.
-    ///     </para>
-    ///     <para>
-    ///         OEIS: http://oeis.org/A007318.
-    ///     </para>
+    ///     Gets sequence of binomial coefficients.
     /// </summary>
-    public class BinomialSequence : ISequence
+    public IEnumerable<BigInteger> Sequence
     {
-        /// <summary>
-        ///     Gets sequence of binomial coefficients.
-        /// </summary>
-        public IEnumerable<BigInteger> Sequence
+        get
         {
-            get
-            {
-                var i = 0;
+            var i = 0;
 
-                while (true)
+            while (true)
+            {
+                var row = GenerateRow(i);
+                foreach (var coefficient in row)
                 {
-                    var row = GenerateRow(i);
-                    foreach (var coefficient in row)
-                    {
-                        yield return coefficient;
-                    }
-
-                    i++;
+                    yield return coefficient;
                 }
+
+                i++;
             }
         }
+    }
 
-        private static BigInteger BinomialCoefficient(long n, long k)
+    private static BigInteger BinomialCoefficient(long n, long k)
+    {
+        if (k == 0 || k == n)
         {
-            if (k == 0 || k == n)
-            {
-                return new BigInteger(1);
-            }
-
-            if (n < 0)
-            {
-                return new BigInteger(0);
-            }
-
-            return BinomialCoefficient(n - 1, k) + BinomialCoefficient(n - 1, k - 1);
+            return new BigInteger(1);
         }
 
-        private static IEnumerable<BigInteger> GenerateRow(long n)
+        if (n < 0)
         {
-            long k = 0;
+            return new BigInteger(0);
+        }
 
-            while (k <= n)
-            {
-                yield return BinomialCoefficient(n, k);
-                k++;
-            }
+        return BinomialCoefficient(n - 1, k) + BinomialCoefficient(n - 1, k - 1);
+    }
+
+    private static IEnumerable<BigInteger> GenerateRow(long n)
+    {
+        long k = 0;
+
+        while (k <= n)
+        {
+            yield return BinomialCoefficient(n, k);
+            k++;
         }
     }
 }

Algorithms/Sequences/CatalanSequence.cs

@@ -1,37 +1,36 @@
 using System.Collections.Generic;
 using System.Numerics;
 
-namespace Algorithms.Sequences
+namespace Algorithms.Sequences;
+
+/// <summary>
+///     <para>
+///         Catalan numbers: C[n+1] = (2*(2*n+1)*C[n])/(n+2).
+///     </para>
+///     <para>
+///         Wikipedia: https://en.wikipedia.org/wiki/Catalan_number.
+///     </para>
+///     <para>
+///         OEIS:http://oeis.org/A000108.
+///     </para>
+/// </summary>
+public class CatalanSequence : ISequence
 {
     /// <summary>
-    ///     <para>
-    ///         Catalan numbers: C[n+1] = (2*(2*n+1)*C[n])/(n+2).
-    ///     </para>
-    ///     <para>
-    ///         Wikipedia: https://en.wikipedia.org/wiki/Catalan_number.
-    ///     </para>
-    ///     <para>
-    ///         OEIS:http://oeis.org/A000108.
-    ///     </para>
+    ///     Gets sequence of Catalan numbers.
     /// </summary>
-    public class CatalanSequence : ISequence
+    public IEnumerable<BigInteger> Sequence
     {
-        /// <summary>
-        ///     Gets sequence of Catalan numbers.
-        /// </summary>
-        public IEnumerable<BigInteger> Sequence
+        get
         {
-            get
+            // initialize the first element (1) and define it's enumerator (0)
+            var catalan = new BigInteger(1);
+            var n = 0;
+            while (true)
             {
-                // initialize the first element (1) and define it's enumerator (0)
-                var catalan = new BigInteger(1);
-                var n = 0;
-                while (true)
-                {
-                    yield return catalan;
-                    catalan = (2 * (2 * n + 1) * catalan) / (n + 2);
-                    n++;
-                }
+                yield return catalan;
+                catalan = (2 * (2 * n + 1) * catalan) / (n + 2);
+                n++;
             }
         }
     }

Algorithms/Sequences/CubesSequence.cs

@@ -1,35 +1,34 @@
 using System.Collections.Generic;
 using System.Numerics;
 
-namespace Algorithms.Sequences
+namespace Algorithms.Sequences;
+
+/// <summary>
+///     <para>
+///         Sequence of cube numbers.
+///     </para>
+///     <para>
+///         Wikipedia: https://en.wikipedia.org/wiki/Cube_(algebra).
+///     </para>
+///     <para>
+///         OEIS: https://oeis.org/A000578.
+///     </para>
+/// </summary>
+public class CubesSequence : ISequence
 {
     /// <summary>
-    ///     <para>
-    ///         Sequence of cube numbers.
-    ///     </para>
-    ///     <para>
-    ///         Wikipedia: https://en.wikipedia.org/wiki/Cube_(algebra).
-    ///     </para>
-    ///     <para>
-    ///         OEIS: https://oeis.org/A000578.
-    ///     </para>
+    /// Gets sequence of cube numbers.
     /// </summary>
-    public class CubesSequence : ISequence
+    public IEnumerable<BigInteger> Sequence
     {
-        /// <summary>
-        /// Gets sequence of cube numbers.
-        /// </summary>
-        public IEnumerable<BigInteger> Sequence
+        get
         {
-            get
-            {
-                var n = BigInteger.Zero;
+            var n = BigInteger.Zero;
 
-                while (true)
-                {
-                    yield return n * n * n;
-                    n++;
-                }
+            while (true)
+            {
+                yield return n * n * n;
+                n++;
             }
         }
     }

Algorithms/Sequences/DivisorsCountSequence.cs

@@ -1,40 +1,39 @@
 using System.Collections.Generic;
 using System.Numerics;
 
-namespace Algorithms.Sequences
+namespace Algorithms.Sequences;
+
+/// <summary>
+///     <para>
+///         Sequence of the number of divisors of n, starting with 1.
+///     </para>
+///     <para>
+///         OEIS: https://oeis.org/A000005.
+///     </para>
+/// </summary>
+public class DivisorsCountSequence : ISequence
 {
     /// <summary>
-    ///     <para>
-    ///         Sequence of the number of divisors of n, starting with 1.
-    ///     </para>
-    ///     <para>
-    ///         OEIS: https://oeis.org/A000005.
-    ///     </para>
+    ///     Gets sequence of number of divisors for n, starting at 1.
     /// </summary>
-    public class DivisorsCountSequence : ISequence
+    public IEnumerable<BigInteger> Sequence
     {
-        /// <summary>
-        ///     Gets sequence of number of divisors for n, starting at 1.
-        /// </summary>
-        public IEnumerable<BigInteger> Sequence
+        get
         {
-            get
+            yield return BigInteger.One;
+            for (var n = new BigInteger(2); ; n++)
             {
-                yield return BigInteger.One;
-                for (var n = new BigInteger(2); ; n++)
+                var count = 2;
+                for (var k = 2; k < n; k++)
                 {
-                    var count = 2;
-                    for (var k = 2; k < n; k++)
+                    BigInteger.DivRem(n, k, out var remainder);
+                    if (remainder == 0)
                     {
-                        BigInteger.DivRem(n, k, out var remainder);
-                        if (remainder == 0)
-                        {
-                            count++;
-                        }
+                        count++;
                     }
-
-                    yield return count;
                 }
+
+                yield return count;
             }
         }
     }