0

OH noo, please not that again! Yeah, primes sigh. But they play a minor role here as a perfect victim to explain some other things. Would not advise to use the algorithm here to calculate them in real life. There are languages like Python, F#, Haskell etc. who have list comprehension on board. I was wondering how to do it in C#. Looked up some examples on the net and concoct my own here. See the factors method on line 84 and the primes method on line 109. What I like about this code is that it is so concise yet easy to comprehend.( That is I think it is :) )
PLINQ joins in as I use the AsParallel() extension on line 111. You might as well add the AsOrdered() extension. Parallel processors don't always deliver their tasks in order! Working parallel is not always advisable. Think of numbers less than 1000 or so. Calculate primes from 2 to 100000 and you're in business. Calculating all the primes up to 1234567 on my i7 four core machine in parallel, still takes about half an hour, while taking up 96% of total processor time(seen in Task Manager). Leave .AsParallel().AsOrdered()out if you want to see the time difference. Enjoy. Any comments are always welcome.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Diagnostics;

namespace PrimeLister
{
    /// <summary>
    /// Visual Studio Community 2017
    /// 
    /// Listing primes using list comprehensions with the aid of PLINQ
    /// </summary>
    class Program
    {
        static void Main(string[] args)
        {
            int cNumber = InputInteger();

            Console.WriteLine("The number {0} has following factors:", cNumber);
            List<int> facs = factors(cNumber);
            PrintOut(facs);

            if (prime(cNumber))
                Console.WriteLine("It is a prime number");
            else
                Console.WriteLine("It is not a prime number");

            Console.WriteLine("The primes up to this number are:");
            var STW = Stopwatch.StartNew();                
                List <int> prims = primes(cNumber); 
            STW.Stop();
            PrintOut(prims);

            Console.WriteLine("Total number of primes up to {0} is: {1}", cNumber, prims.Count());
            Console.WriteLine("Total time calculating: {0}", STW.Elapsed.ToString(@"mm\:ss\.fff"));

            Console.ReadKey();
        }

        /// <summary>
        /// Some way where it is only possible to input numbers
        /// </summary>
        /// <returns>on success, the inputted number</returns>
        static int InputInteger()
        {
            string intStr;
            int numb;
            do
            {
                Console.Write("Input an integer: ");
                intStr = string.Empty;
                intStr = Console.ReadLine();
            } while (!Int32.TryParse(intStr, out numb));
            return numb;
        }

        /// <summary>
        /// Print out a formatted list of integers on the console
        /// </summary>
        /// <param name="aList">here a list of integers</param>
        static void PrintOut(List<int> aList)
        {
            const int cNumbersOnaLine = 15;

            int Counter = 0;
            foreach (var result in aList)
            {
                Console.Write("{0,6} ", result);
                Counter++;
                if (Counter > cNumbersOnaLine)
                {
                    Counter = 0;
                    Console.WriteLine();
                }
            }
            Console.WriteLine();
        }

        /// <summary>
        /// Get a list of factors from a number
        /// </summary>
        /// <param name="number">The number to handle</param>
        /// <returns>The list of factors</returns>
        static List<int> factors(int number)
        {
            return new List<int>(from x in Enumerable.Range(1, number)
                                 where number % x == 0
                                 select x);
        }

        /// <summary>
        /// Test if a number is prime
        /// </summary>
        /// <param name="number"></param>
        /// <returns>true or false</returns>
        static bool prime(int number)
        {
            //return factors(number).Count() == 2; or
            return factors(number).SequenceEqual(new List<int>() { 1, number });
        }

        /// <summary>
        /// Get a list of primes up to a certain number.
        /// Leaving AsParallel out it's 4 times slower on my system
        /// but depending on how may numbers you choose!
        /// </summary>
        /// <param name="upto">the maximum</param>
        /// <returns>A list of primes in the range 2 until upto</returns>
        static List<int> primes(int upto)
        {
            return new List<int>(from x in Enumerable.Range(2, upto).AsParallel().AsOrdered()
                                 where prime(x)
                                 select x);
        }
    }
}
2
Contributors
2
Replies
15
Views
7 Months
Discussion Span
Last Post by ddanbe
0

It was not my intention to speed things up as I wanted to test the parallel feature. Thanks anyway.

Have something to contribute to this discussion? Please be thoughtful, detailed and courteous, and be sure to adhere to our posting rules.