{-# LANGUAGE NoImplicitPrelude #-}
-- |
-- Module : Phladiprelio.PermutationsArr
-- Copyright : (c) OleksandrZhabenko 2020-2024
-- License : MIT
-- Stability : Experimental
-- Maintainer : oleksandr.zhabenko@yahoo.com
--
-- Permutations and universal set functions for the phonetic-languages series and phladiprelio of packages
-- (PhLADiPreLiO-related). This module uses no vectors, but instead uses arrays.
module Phladiprelio.PermutationsArr (
universalSetGL
, genPermutations
, genPermutationsArr
, genPermutationsL
, genPermutationsArrL
) where
import GHC.Enum
import GHC.List
import GHC.Num (Num,(*), (-))
import GHC.Base
import GHC.Arr
import qualified Data.List as L (permutations,product)
import Data.InsertLeft
import qualified Data.Foldable as F (Foldable,concat,foldr',foldl')
import Data.Monoid
-- | A key point of the evaluation -- the universal set of the task represented as a @[[a]]@.
universalSetGL ::
(Eq a, F.Foldable t, InsertLeft t a, Monoid (t a), Monoid (t (t a))) => t a
-> t (t a)
-> (t a -> [a]) -- ^ The function that is used internally to convert to the @[a]@ so that the function can process further the permutations
-> ((t (t a)) -> [[a]]) -- ^ The function that is used internally to convert to the needed representation so that the function can process further
-> [Array Int Int] -- ^ The list of permutations of 'Int' indices starting from 0 and up to n (n is probably less than 7).
-> Array Int [a]
-> [[a]]
universalSetGL ts uss f1 f2 permsL baseArr = map (F.concat . F.foldr' (:) [] . (f1 ts:) . (`mappend` f2 uss) . elems . amap (unsafeAt baseArr)) permsL
{-# INLINE universalSetGL #-}
{-# SPECIALIZE universalSetGL :: String -> [String] -> (String -> String) -> ([String] -> [String]) -> [Array Int Int] -> Array Int String -> [String] #-}
genPermutations :: (Ord a, Enum a, Num a) => Int -> Array Int [a]
genPermutations n = listArray (0,L.product [1..(n - 1)]) . L.permutations . take n $ [0..]
{-# INLINE genPermutations #-}
{-# SPECIALIZE genPermutations :: Int -> Array Int [Int] #-}
genPermutationsArr :: (Ord a, Enum a, Num a) => Array Int (Array Int [a])
genPermutationsArr = amap genPermutations . listArray (0,5) $ [2..7]
{-# INLINE genPermutationsArr #-}
{-# SPECIALIZE genPermutationsArr :: Array Int (Array Int [Int]) #-}
genPermutationsL :: (Ord a, Enum a, Num a) => Int -> [Array Int a]
genPermutationsL n = map (\xs -> listArray (0,n - 1) xs) . L.permutations . take n $ [0..]
{-# INLINE genPermutationsL #-}
{-# SPECIALIZE genPermutationsL :: Int -> [Array Int Int] #-}
genPermutationsArrL :: (Ord a, Enum a, Num a) => Array Int [Array Int a]
genPermutationsArrL = amap genPermutationsL . listArray (0,5) $ [2..7]
{-# INLINE genPermutationsArrL #-}
{-# SPECIALIZE genPermutationsArrL :: Array Int [Array Int Int] #-}