src/Gargantext/Viz/Graph/Index.hs

   1 {-|
   2 Module      : Gargantext.Graph.Distances.Utils
   3 Description : Tools to compute distances from Cooccurrences
   4 Copyright   : (c) CNRS, 2017-Present
   5 License     : AGPL + CECILL v3
   6 Maintainer  : team@gargantext.org
   7 Stability   : experimental
   8 Portability : POSIX
   9
  10 Basically @compute@ takes an accelerate function as first input, a Map
  11 of coccurrences as second input and outputs a Map automatically using
  12 indexes.
  13
  14 TODO:
  15 --cooc2fgl :: Ord t, Integral n => Map (t, t) n -> Graph
  16 --fgl2json
  17
  18 -}
  19
  20 {-# LANGUAGE BangPatterns      #-}
  21 {-# LANGUAGE FlexibleContexts  #-}
  22 {-# LANGUAGE NoImplicitPrelude #-}
  23 {-# LANGUAGE TypeOperators     #-}
  24
  25
  26 module Gargantext.Viz.Graph.Index
  27   where
  28
  29 import qualified Data.Array.Accelerate as A
  30 import qualified Data.Array.Accelerate.Interpreter as A
  31 import Data.Array.Accelerate (Matrix, Elt, Shape, (:.)(..), Z(..))
  32
  33 import qualified Data.Vector.Unboxed as DVU
  34 import Data.Maybe (fromMaybe)
  35
  36 import Data.Set (Set)
  37 import qualified Data.Set as S
  38
  39 import Data.Map (Map)
  40 import qualified Data.Map.Strict    as M
  41
  42 import Gargantext.Prelude
  43
  44 type Index    = Int
  45
  46
  47 -------------------------------------------------------------------------------
  48 {-
  49 map'' :: (Ord t) => (A.Matrix Int -> A.Matrix Double)
  50                 -> Map (t, t) Int
  51                 -> Map (t, t) Double
  52 map'' f m = back . f' . from m
  53   where
  54     from (fs, m') = unzip $ M.toAscList m
  55     f'  = f $ A.fromList shape m'
  56     shape = (A.Z A.:. n A.:. n)
  57     back = M.fromAscList . zip fs . A.toList
  58 -}
  59 -------------------------------------------------------------------------------
  60 map' :: (Ord t) => (A.Matrix Int -> A.Matrix Double)
  61                 -> Map (t, t) Int
  62                 -> Map (t, t) Double
  63 map' f m = fromIndex fromI . mat2cooc . f $ cooc2mat toI m
  64   where
  65     (toI, fromI) = createIndexes m
  66
  67 map'' m = cooc2mat toI m
  68   where
  69     (toI, fromI) = createIndexes m
  70
  71 -------------------------------------------------------------------------------
  72 -------------------------------------------------------------------------------
  73 cooc2mat :: Ord t => Map t Index -> Map (t, t) Int -> Matrix Int
  74 cooc2mat ti m = map2mat 0 n idx
  75   where
  76     n = M.size ti
  77     idx = toIndex ti m -- it is important to make sure that toIndex is ran only once.
  78
  79 map2mat :: Elt a => a -> Int -> Map (Index, Index) a -> Matrix a
  80 map2mat def n m = A.fromFunction shape (\(Z :. x :. y) -> fromMaybe def $ M.lookup (x, y) m)
  81   where
  82     shape = (Z :. n :. n)
  83
  84 -- TODO rename mat2map
  85 mat2cooc :: (Elt a, Shape (Z :. Index)) =>
  86             A.Array (Z :. Index :. Index) a -> Map (Index, Index) a
  87 mat2cooc m = M.fromList . map f . A.toList . A.run . A.indexed $ A.use m
  88   where
  89     Z :. _ :. n = A.arrayShape m
  90     f ((Z :. i :. j), x) = ((i, j), x)
  91
  92 -------------------------------------------------------------------------------
  93 -------------------------------------------------------------------------------
  94 toIndex :: Ord t => Map t Index -> Map (t,t) a -> Map (Index,Index) a
  95 toIndex ni ns = indexConversion ni ns
  96
  97 fromIndex :: Ord t => Map Index t -> Map (Index, Index) a -> Map (t,t) a
  98 fromIndex ni ns = indexConversion ni ns
  99 ---------------------------------------------------------------------------------
 100 indexConversion :: (Ord b, Ord k) => Map k b -> Map (k,k) a -> Map (b, b) a
 101 indexConversion index ms = M.fromList $ map (\((k1,k2),c) -> ( ((M.!) index k1, (M.!) index k2), c)) (M.toList ms)
 102 -------------------------------------------------------------------------------
 103 -------------------------------------------------------------------------------
 104 createIndexes :: Ord t => Map (t, t) b -> (Map t Index, Map Index t)
 105 createIndexes = set2indexes . cooc2set
 106   where
 107     cooc2set :: Ord t => Map (t, t) a -> Set t
 108     cooc2set cs' = foldl' (\s ((t1,t2),_) -> insert [t1,t2] s ) S.empty (M.toList cs')
 109       where
 110         insert as s = foldl' (\s' t -> S.insert t s') s as
 111
 112     set2indexes :: Ord t => Set t -> (Map t Index, Map Index t)
 113     set2indexes s = (M.fromList toIndex', M.fromList fromIndex')
 114       where
 115         fromIndex' = zip [0..] xs
 116         toIndex'   = zip xs [0..]
 117         xs         = S.toList s
 118
 119