コード例 #1
0
        public List <UsersSimilarity> CreateUserSimilarities(ISettings settings,
                                                             int userId,
                                                             List <int> comparedUserId,
                                                             BookScore[] userBooks,
                                                             List <BookScore[]> comparedUserBooks,
                                                             List <double?> similarity = null)
        {
            var userSimilarities = new List <UsersSimilarity>();
            var comparer         = new BookScoreEqualityComparer();

            for (int i = 0; i < comparedUserId.Count; i++)
            {
                var comparedUserRatesForMutualBooks = comparedUserBooks[i].Intersect(userBooks, comparer).ToArray();
                var userRatesForMutualBooks         = userBooks.Intersect(comparedUserBooks[i], comparer).ToArray();
                var booksUniqueForComparedUser      = comparedUserBooks[i].Except(userBooks, comparer).ToArray();
                var temp = new UsersSimilarity
                {
                    AverageScoreForComparedUser = RandomNumber(3),
                    ComparedUserId = comparedUserId[i],
                    UserId         = userId,
                    Similarity     = similarity?[i],
                    SimilarityType = (int)settings.SimilarityDistance,
                    ComparedUserRatesForMutualBooks = comparedUserRatesForMutualBooks,
                    BooksUniqueForComparedUser      = booksUniqueForComparedUser,
                    UserRatesForMutualBooks         = userRatesForMutualBooks
                };
                userSimilarities.Add(temp);
            }

            return(userSimilarities);
        }
コード例 #2
0
        public void GetNearestNeighbors_WhenSimilarityIsNotNull_ShouldNotReturnNull()
        {
            var similarity = new UsersSimilarity
            {
                ComparedUserRatesForMutualBooks = _helpers.CreateBookScores(2, new[] { "1", "2", "3" }, new short[] { 1, 2, 3 }),
                UserRatesForMutualBooks         = _helpers.CreateBookScores(2, new[] { "1", "2", "3" }, new short[] { 1, 2, 3 }),
            };

            _usersSelector.SelectMutualAndUniqueBooksForUsers(1, 2).Returns(similarity);

            var actual = _sut.GetNearestNeighbors(1, new List <int>()
            {
                2
            }, _settings);

            actual.ShouldNotBeNull();
        }
コード例 #3
0
        public void testAddDuplicateValues()
        {
            UsersSimilarity usersSimilarity = new UsersSimilarity(2);

            usersSimilarity.add(new User("first"), 1.1);
            usersSimilarity.add(new User("second"), 1.1);

            List <KeyValuePair <User, double> > expected = new List <KeyValuePair <User, double> >()
            {
                new KeyValuePair <User, double>(new User("first"), 1.1),
                new KeyValuePair <User, double>(new User("second"), 1.1)
            };


            List <KeyValuePair <User, double> > actual = usersSimilarity.AsList();

            CollectionAssert.AreEqual(expected, actual);
        }
コード例 #4
0
        public void GetNearestNeighbors_WhenBooksAreTheSAme_ShouldReturnMaxSimilarity(DistanceSimilarityEnum distance)
        {
            _settings.SimilarityDistance = distance;
            var similarity = new UsersSimilarity
            {
                ComparedUserRatesForMutualBooks = _helpers.CreateBookScores(2, new[] { "1", "2", "3" }, new short[] { 1, 2, 3 }),
                UserRatesForMutualBooks         = _helpers.CreateBookScores(2, new[] { "1", "2", "3" }, new short[] { 1, 2, 3 }),
            };

            _usersSelector.SelectMutualAndUniqueBooksForUsers(1, 2).Returns(similarity);

            var actual = _sut.GetNearestNeighbors(1, new List <int>()
            {
                2
            }, _settings).FirstOrDefault();

            actual.ShouldNotBeNull();
            actual.Similarity.Value.ShouldBe(1, 2);
        }
コード例 #5
0
        public void Compare_ShouldReturnLower(int userId, int comparedUserId, int mutualBooksLenth, double similarity)
        {
            var x = new UsersSimilarity
            {
                UserId         = userId,
                ComparedUserId = comparedUserId,
                ComparedUserRatesForMutualBooks = new BookScore[mutualBooksLenth],
                Similarity = similarity
            };

            var y = new UsersSimilarity
            {
                UserId         = 1,
                ComparedUserId = 2,
                ComparedUserRatesForMutualBooks = new BookScore[10],
                Similarity = 1.2
            };

            _sut.Compare(x, y).ShouldBe(1);
        }
コード例 #6
0
        public void GetNearestNeighbors_ShouldReturnTwoMostSimilarUsers(DistanceSimilarityEnum distance)
        {
            _settings.SimilarityDistance = distance;
            var similarity_1 = new UsersSimilarity
            {
                ComparedUserRatesForMutualBooks = _helpers.CreateBookScores(2, new[] { "1", "2", "3" }, new short[] { 1, 2, 2 }),
                UserRatesForMutualBooks         = _helpers.CreateBookScores(1, new[] { "1", "2", "3" }, new short[] { 1, 2, 2 }),
                ComparedUserId = 2
            };

            var similarity_2 = new UsersSimilarity
            {
                ComparedUserRatesForMutualBooks = _helpers.CreateBookScores(3, new[] { "1", "2", "3" }, new short[] { 1, 2, 2 }),
                UserRatesForMutualBooks         = _helpers.CreateBookScores(1, new[] { "1", "2", "3" }, new short[] { 1, 4, 2 }),
                ComparedUserId = 3
            };

            var similarity_3 = new UsersSimilarity
            {
                ComparedUserRatesForMutualBooks = _helpers.CreateBookScores(4, new[] { "1", "2", "3" }, new short[] { 1, 2, 2 }),
                UserRatesForMutualBooks         = _helpers.CreateBookScores(1, new[] { "1", "2", "3" }, new short[] { 10, 5, 3 }),
                ComparedUserId = 4
            };

            _usersSelector.SelectMutualAndUniqueBooksForUsers(1, 2).Returns(similarity_1);
            _usersSelector.SelectMutualAndUniqueBooksForUsers(1, 3).Returns(similarity_2);
            _usersSelector.SelectMutualAndUniqueBooksForUsers(1, 4).Returns(similarity_3);

            var actual = _sut.GetNearestNeighbors(1, new List <int>()
            {
                2, 3, 4
            }, _settings);

            actual.ShouldNotBeNull();
            actual.Select(x => x.ComparedUserId).ShouldBe(new[] { 2, 3 });
            actual.Count.ShouldBe(2);
        }