2 Module : Gargantext.Text.Metrics.Occurrences
4 Copyright : (c) CNRS, 2017-Present
5 License : AGPL + CECILL v3
6 Maintainer : team@gargantext.org
7 Stability : experimental
12 An occurrence is not necessarily a token. Considering the sentence:
13 "A rose is a rose is a rose". We may equally correctly state that there
14 are eight or three words in the sentence. There are, in fact, three word
15 types in the sentence: "rose", "is" and "a". There are eight word tokens
16 in a token copy of the line. The line itself is a type. There are not
17 eight word types in the line. It contains (as stated) only the three
18 word types, 'a', 'is' and 'rose', each of which is unique. So what do we
19 call what there are eight of? They are occurrences of words. There are
20 three occurrences of the word type 'a', two of 'is' and three of 'rose'.
21 Source : https://en.wikipedia.org/wiki/Type%E2%80%93token_distinction#Occurrences
25 {-# LANGUAGE NoImplicitPrelude #-}
26 {-# LANGUAGE OverloadedStrings #-}
28 module Gargantext.Text.Metrics.Occurrences
32 import Data.Map.Strict (Map
34 , insertWith, insertWithKey, unionWith
38 import qualified Data.Map.Strict as DMS
39 import Control.Monad ((>>),(>>=))
40 import Data.String (String())
41 import Data.Attoparsec.Text
43 ------------------------------------------------------------------------
44 import Gargantext.Prelude
45 import Gargantext.Core.Types
47 ------------------------------------------------------------------------
49 type Occ a = Map a Int
50 type Cooc a = Map (a, a) Int
51 type FIS a = Map (Set a) Int
53 data Group = ByStem | ByOntology
58 -- >> let testData = ["blue lagoon", "blues lagoon", "red lagoon"]
59 -- >> map occurrences <$> Prelude.mapM (terms Mono EN)
60 -- [fromList [(fromList ["blue"],1),(fromList ["lagoon"],1)],fromList [(fromList ["blue"],1),(fromList ["lagoon"],1)],fromList [(fromList ["lagoon"],1),(fromList ["red"],1)]]
61 --λ: cooc <$> Prelude.map occurrences <$> Prelude.mapM (terms Mono EN) ["blue lagoon", "blues lagoon", "red lagoon"]
62 --fromList [((fromList ["blue"],fromList ["lagoon"]),2),((fromList ["lagoon"],fromList ["red"]),1)]
63 --λ: cooc <$> Prelude.map occurrences <$> Prelude.mapM (terms Mono EN) ["blue lagoon", "blues lagoon", "red lagoon", "red lagoon"]
64 --fromList [((fromList ["blue"],fromList ["lagoon"]),2),((fromList ["lagoon"],fromList ["red"]),2)]
65 --λ: cooc <$> Prelude.map occurrences <$> Prelude.mapM (terms Mono EN) ["blue lagoon", "blues lagoon", "red lagoon red lagoon", "red lagoon"]
66 --fromList [((fromList ["blue"],fromList ["lagoon"]),2),((fromList ["lagoon"],fromList ["red"]),2)]
67 --λ: cooc <$> Prelude.map occurrences <$> Prelude.mapM (terms Mono EN) ["blue lagoon", "blues lagoon blues lagoon", "red lagoon red lagoon", "red lagoon"]
68 --fromList [((fromList ["blue"],fromList ["lagoon"]),2),((fromList ["lagoon"],fromList ["red"]),2)]
72 cooc :: (Ord b, Num a) => [Map b a] -> Map (b, b) a
73 cooc ts = cooc' $ map cooc'' ts
75 cooc' :: (Ord b, Num a) => [Map (b, b) a] -> Map (b,b) a
76 cooc' = foldl' (\x y -> unionWith (+) x y) empty
78 cooc'' :: (Ord b, Num a) => Map b a -> Map (b, b) a
79 cooc'' m = foldl' (\x (y,c) -> insertWith (+) y c x) empty xs
81 xs =[ ((x'',y''), c') | x' <- toList m
87 --, let c' = snd x' + snd y'
91 -- | Compute the grouped occurrences (occ)
92 occurrences :: [Terms] -> Map Grouped Int
93 occurrences = occurrences' _terms_stem
95 occurrences' :: Ord b => (a -> b) -> [a] -> Occ b
96 occurrences' f xs = foldl' (\x y -> insertWith (+) (f y) 1 x) empty xs
99 -- TODO add groups and filter stops
100 sumOcc :: Ord a => [Occ a] -> Occ a
101 sumOcc xs = foldl' (unionWith (+)) empty xs