public IList <Book> Recommend(Preference preference, int limit)
        {
            IList <Book>       books             = new List <Book>(limit);
            DataLoaderFactory  dataLoaderFactory = DataLoaderFactory.getInstance();
            IDataLoader        loader            = dataLoaderFactory.GetLoader();
            IRecommender       recommender       = new PearsonRecommender();
            IRatingsAggregator aggregator        = new RatingsAggregator();

            BookDetail bookDetail = loader.Load();
            Dictionary <string, List <int> > bookRatings = aggregator.Aggregate(bookDetail, preference);

            List <int> Base = bookRatings[preference.ISBN];

            bookRatings.Remove(preference.ISBN);

            Dictionary <string, double> coefficients = new Dictionary <string, double>();

            foreach (var item in bookRatings)
            {
                coefficients.Add(item.Key, recommender.GetCorrelation(Base, bookRatings[item.Key]));
            }

            coefficients = coefficients.OrderByDescending(x => x.Value).ToDictionary(a => a.Key, b => b.Value);
            coefficients = coefficients.Take(limit).ToDictionary(a => a.Key, b => b.Value);

            books.Add(bookDetail.Books.Find(b => b.ISBN == preference.ISBN));
            foreach (var isbn in coefficients.Keys)
            {
                books.Add(bookDetail.Books.Find(b => b.ISBN == isbn));
            }

            return(books);
        }
        public void GetCorrelation_ForValidInput_GetsValidResult()
        {
            List <int> baseArray = new List <int> {
                1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
            };
            List <int> dataArray = new List <int> {
                1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
            };
            double       actual;
            IRecommender target = new PearsonRecommender();

            actual = target.GetCorrelation(baseArray, dataArray);
            Assert.AreEqual(actual, 1);
        }
        public List <Book> Recommend(Preference preference, int limit)
        {
            BooksDataService            dataService = new BooksDataService();
            Dictionary <string, double> pairs       = new Dictionary <string, double>();
            List <Book> books       = new List <Book>();
            IDataLoader dataLoader  = new CSVDataLoader();
            BookDetails bookDetails = new BookDetails();

            bookDetails = dataService.GetBookDetails();
            Dictionary <string, List <long> > keyValuePairs = new Dictionary <string, List <long> >();
            IRatingAggregator aggregator = new RatingAggregatorClass();

            keyValuePairs = aggregator.Aggregate(bookDetails, preference);
            IRecommender recommender = new PearsonRecommender();
            List <long>  baseData    = new List <long>();

            foreach (BookUserRating rating in bookDetails.bookUserRatings)
            {
                if (string.Compare(rating.ISBN, preference.ISBN) == 0)
                {
                    baseData.Add(rating.BookRating);
                }
            }
            foreach (var keyValue in keyValuePairs)
            {
                double corValue = recommender.GetCorrelation(baseData, keyValue.Value);
                pairs.Add(keyValue.Key, corValue);
            }
            pairs = pairs.OrderByDescending(pair => pair.Value).ToDictionary(pair => pair.Key, pair => pair.Value);
            int count = 0;

            foreach (var item in pairs)
            {
                if (count == limit)
                {
                    break;
                }
                count++;
                books.Add(bookDetails.books.Find(b => b.ISBN == item.Key));
            }
            return(books);
        }