{"text": "{-# LANGUAGE DataKinds #-}\n{-# LANGUAGE DeriveAnyClass #-}\n{-# LANGUAGE DeriveGeneric #-}\n{-# LANGUAGE FlexibleInstances #-}\n{-# LANGUAGE MultiParamTypeClasses #-}\n{-# LANGUAGE RankNTypes #-}\n{-# LANGUAGE ScopedTypeVariables #-}\n{-# LANGUAGE Strict #-}\n{-# LANGUAGE TypeFamilies #-}\n{-# LANGUAGE TypeOperators #-}\n{-|\nModule : Grenade.Layers.Tanh\nDescription : Hyperbolic tangent nonlinear layer\nCopyright : (c) Huw Campbell, 2016-2017\nLicense : BSD2\nStability : experimental\n-}\nmodule Grenade.Layers.Tanh\n ( Tanh(..)\n , SpecTanh (..)\n , specTanh1D\n , specTanh2D\n , specTanh3D\n , specTanh\n , tanhLayer\n ) where\n\nimport Control.DeepSeq (NFData (..))\nimport Data.Constraint (Dict (..))\nimport Data.Reflection (reifyNat)\nimport Data.Serialize\nimport Data.Singletons\nimport GHC.Generics (Generic)\nimport GHC.TypeLits\nimport qualified Numeric.LinearAlgebra.Static as LAS\nimport Unsafe.Coerce (unsafeCoerce)\n\nimport Grenade.Core\nimport Grenade.Dynamic\nimport Grenade.Dynamic.Internal.Build\nimport Grenade.Utils.Conversion\nimport Grenade.Utils.Vector\n\n-- | A Tanh layer.\n-- A layer which can act between any shape of the same dimension, performing a tanh function.\ndata Tanh = Tanh\n deriving (Generic,NFData,Show)\n\ninstance UpdateLayer Tanh where\n type Gradient Tanh = ()\n runUpdate _ _ _ = Tanh\n\ninstance RandomLayer Tanh where\n createRandomWith _ _ = return Tanh\n\ninstance Serialize Tanh where\n put _ = return ()\n get = return Tanh\n\ninstance (a ~ b, SingI a) => Layer Tanh a b where\n type Tape Tanh a b = S a\n -- runForwards _ (S1DV v) = (S1DV v, S1DV $ mapVectorInPlace tanh v) -- This is inplace replacement!\n -- runForwards _ (S2DV v) = (S2DV v, S2DV $ mapVectorInPlace tanh v) -- This is inplace replacement!\n runForwards _ a = (a, tanh a)\n runBackwards _ (S1DV v) (S1DV gs) = ((), S1DV $ zipWithVector (\\t g -> max 0.005 (1 - (tanh t) ^ (2 :: Int)) * g) v gs)\n runBackwards _ (S2DV v) (S2DV gs) = ((), S2DV $ zipWithVector (\\t g -> max 0.005 (1 - (tanh t) ^ (2 :: Int)) * g) v gs)\n runBackwards _ (S1D a) (S1D g)= ((), S1D $ LAS.dvmap (max 0.005) (tanh' a) * g)\n runBackwards _ (S2D a) (S2D g)= ((), S2D $ LAS.dmmap (max 0.005) (tanh' a) * g)\n runBackwards _ (S3D a) (S3D g)= ((), S3D $ LAS.dmmap (max 0.005) (tanh' a) * g)\n runBackwards l x y = runBackwards l x (toLayerShape x y)\n -- runBackwards _ a g = ((), tanh' a * g)\n\ntanh' :: (Floating a) => a -> a\ntanh' t = 1 - s ^ (2 :: Int) where s = tanh t\n\n-------------------- DynamicNetwork instance --------------------\n\ninstance FromDynamicLayer Tanh where\n fromDynamicLayer inp _ _ = SpecNetLayer $ SpecTanh (tripleFromSomeShape inp)\n\ninstance ToDynamicLayer SpecTanh where\n toDynamicLayer _ _ (SpecTanh (rows, cols, depth)) =\n reifyNat rows $ \\(_ :: (KnownNat rows) => Proxy rows) ->\n reifyNat cols $ \\(_ :: (KnownNat cols) => Proxy cols) ->\n reifyNat depth $ \\(_ :: (KnownNat depth) => Proxy depth) ->\n case (rows, cols, depth) of\n (_, 1, 1) -> return $ SpecLayer Tanh (sing :: Sing ('D1 rows)) (sing :: Sing ('D1 rows))\n (_, _, 1) -> return $ SpecLayer Tanh (sing :: Sing ('D2 rows cols)) (sing :: Sing ('D2 rows cols))\n _ -> case (unsafeCoerce (Dict :: Dict()) :: Dict (KnownNat (rows GHC.TypeLits.* depth))) of\n Dict -> return $ SpecLayer Tanh (sing :: Sing ('D3 rows cols depth)) (sing :: Sing ('D3 rows cols depth))\n\n\n-- | Create a specification for a Tanh layer.\nspecTanh1D :: Integer -> SpecNet\nspecTanh1D i = specTanh3D (i, 1, 1)\n\n-- | Create a specification for a Tanh layer.\nspecTanh2D :: (Integer, Integer) -> SpecNet\nspecTanh2D (i, j) = specTanh3D (i, j, 1)\n\n-- | Create a specification for a Tanh layer.\nspecTanh3D :: (Integer, Integer, Integer) -> SpecNet\nspecTanh3D = SpecNetLayer . SpecTanh\n\n-- | Create a specification for a Tanh layer.\nspecTanh :: (Integer, Integer, Integer) -> SpecNet\nspecTanh = SpecNetLayer . SpecTanh\n\n-- | Add a Tanh layer to your build.\ntanhLayer :: BuildM ()\ntanhLayer = buildGetLastLayerOut >>= buildAddSpec . SpecNetLayer . SpecTanh\n\n\n-------------------- GNum instances --------------------\n\ninstance GNum Tanh where\n _ |* Tanh = Tanh\n _ |+ Tanh = Tanh\n sumG _ = Tanh\n", "meta": {"hexsha": "b3217d1082e146276ff8bad98ead41aa11207ed1", "size": 4465, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/Grenade/Layers/Tanh.hs", "max_stars_repo_name": "schnecki/grenade", "max_stars_repo_head_hexsha": "027e9c16899e2ca3685e89338a047488ac834249", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-01-11T15:05:38.000Z", "max_stars_repo_stars_event_max_datetime": "2021-01-11T15:05:38.000Z", "max_issues_repo_path": "src/Grenade/Layers/Tanh.hs", "max_issues_repo_name": "schnecki/grenade", "max_issues_repo_head_hexsha": "027e9c16899e2ca3685e89338a047488ac834249", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/Grenade/Layers/Tanh.hs", "max_forks_repo_name": "schnecki/grenade", "max_forks_repo_head_hexsha": "027e9c16899e2ca3685e89338a047488ac834249", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2018-07-02T01:04:29.000Z", "max_forks_repo_forks_event_max_datetime": "2021-01-08T13:08:47.000Z", "avg_line_length": 37.2083333333, "max_line_length": 121, "alphanum_fraction": 0.6091825308, "num_tokens": 1349, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.7341195385342971, "lm_q2_score": 0.47657965106367595, "lm_q1q2_score": 0.3498664335137021}} {"text": "{-# LANGUAGE BangPatterns #-}\n{-# LANGUAGE DataKinds #-}\n{-# LANGUAGE FlexibleContexts #-}\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE LambdaCase #-}\n{-# LANGUAGE ScopedTypeVariables #-}\n{-# LANGUAGE TupleSections #-}\n{-# LANGUAGE TypeApplications #-}\n{-# LANGUAGE TypeFamilyDependencies #-}\n\nmodule Backprop.Learn.Model (\n module M, Backprop(..)\n , runLearn_, runLearnStoch_, runLearnStateless_, runLearnStochStateless_\n , gradLearn, gradLearnStoch\n -- * Work with parameters\n , initParam, initParamMaybe, initParamNormal, initParamNormalMaybe\n , encodeParam, decodeParam, decodeParamOrFail, saveParam, loadParam, loadParamOrFail\n -- * Iterated runners\n , iterateLearn, iterateLearnM, iterateLearnStoch\n , scanLearn, scanLearnStoch\n -- * No final state\n , iterateLearn_, iterateLearnM_, iterateLearnStoch_\n , scanLearn_, scanLearnStoch_\n -- * \"Prime\" runners\n , primeLearn, primeLearnStoch, selfPrime, selfPrimeM\n ) where\n\nimport Backprop.Learn.Initialize\nimport Backprop.Learn.Model.Class as M\nimport Backprop.Learn.Model.Combinator as M\nimport Backprop.Learn.Model.Function as M\nimport Backprop.Learn.Model.Neural as M\nimport Backprop.Learn.Model.Neural.LSTM as M\nimport Backprop.Learn.Model.Parameter as M\nimport Backprop.Learn.Model.Regression as M\nimport Backprop.Learn.Model.State as M\nimport Backprop.Learn.Model.Stochastic as M\nimport Control.Monad.Primitive\nimport Control.Monad.ST\nimport Control.Monad.Trans.State\nimport Data.Bifunctor\nimport Data.Foldable\nimport Data.Functor.Identity\nimport Data.Type.Mayb\nimport Data.Word\nimport Numeric.Backprop\nimport Statistics.Distribution\nimport qualified Data.Binary as Bi\nimport qualified Data.ByteString.Lazy as BSL\nimport qualified Data.Vector.Unboxed as VU\nimport qualified System.Random.MWC as MWC\n\n-- TODO: this can be more efficient by breaking out into separate functions\nrunLearn_\n :: (Learn a b l, MaybeC Backprop (LStateMaybe l), Backprop b)\n => l\n -> LParam_ I l\n -> a\n -> LState_ I l\n -> (b, LState_ I l)\nrunLearn_ l mp x ms = case mp of\n N_ -> case ms of\n N_ -> (evalBP (runLearnStateless l N_) x, N_)\n J_ (I s) -> second (J_ . I)\n . evalBP2 (\\x' s' -> uncurry T2\n . second fromJ_\n $ runLearn l N_ x' (J_ s')\n ) x\n $ s\n J_ (I p) -> case ms of\n N_ -> (evalBP2 (runLearnStateless l . J_) p x, N_)\n J_ (I s) -> second (J_ . I)\n . evalBPN (\\(p' :< x' :< s' :< \u00d8) ->\n uncurry T2\n . second fromJ_\n $ runLearn l (J_ p') x' (J_ s')\n )\n $ (p ::< x ::< s ::< \u00d8)\n\nrunLearnStoch_\n :: (Learn a b l, MaybeC Backprop (LStateMaybe l), Backprop b, PrimMonad m)\n => l\n -> MWC.Gen (PrimState m)\n -> LParam_ I l\n -> a\n -> LState_ I l\n -> m (b, LState_ I l)\nrunLearnStoch_ l g mp x ms = do\n -- TODO: is this the best way to handle this?\n seed <- MWC.uniformVector @_ @Word32 @VU.Vector g 2\n pure $ case mp of\n N_ -> case ms of\n N_ -> (, N_) $ evalBP (\\x' -> runST $ do\n g' <- MWC.initialize seed\n runLearnStochStateless l g' N_ x'\n ) x\n J_ (I s) -> second (J_ . I) $ evalBP2 (\\x' s' -> runST $ do\n g' <- MWC.initialize seed\n uncurry T2 . second fromJ_\n <$> runLearnStoch l g' N_ x' (J_ s')\n ) x s\n J_ (I p) -> case ms of\n N_ -> (, N_) $ evalBP2 (\\p' x' -> runST $ do\n g' <- MWC.initialize seed\n runLearnStochStateless l g' (J_ p') x'\n ) p x\n J_ (I s) -> second (J_ . I) $ evalBPN (\\(p' :< x' :< s' :< \u00d8) -> runST $ do\n g' <- MWC.initialize seed\n uncurry T2 . second fromJ_\n <$> runLearnStoch l g' (J_ p') x' (J_ s')\n ) (p ::< x ::< s ::< \u00d8)\n\nrunLearnStateless_\n :: (Learn a b l, NoState l)\n => l\n -> LParam_ I l\n -> a\n -> b\nrunLearnStateless_ l = \\case\n N_ -> evalBP (runLearnStateless l N_ )\n J_ (I p) -> evalBP2 (runLearnStateless l . J_) p\n\nrunLearnStochStateless_\n :: (Learn a b l, NoState l, PrimMonad m)\n => l\n -> MWC.Gen (PrimState m)\n -> LParam_ I l\n -> a\n -> m b\nrunLearnStochStateless_ l g mp x = do\n seed <- MWC.uniformVector @_ @Word32 @VU.Vector g 2\n pure $ case mp of\n N_ -> evalBP (\\x' -> runST $ do\n g' <- MWC.initialize seed\n runLearnStochStateless l g' N_ x'\n ) x\n J_ (I p) -> evalBP2 (\\p' x' -> runST $ do\n g' <- MWC.initialize seed\n runLearnStochStateless l g' (J_ p') x'\n ) p x\n\ngradLearn\n :: (Learn a b l, NoState l, Backprop a, Backprop b, MaybeC Backprop (LParamMaybe l))\n => l\n -> LParam_ I l\n -> a\n -> (LParam_ I l, a)\ngradLearn l = \\case\n N_ -> (N_,) . gradBP (runLearnStateless l N_)\n J_ (I p) -> first (J_ . I) . gradBP2 (runLearnStateless l . J_) p\n\ngradLearnStoch\n :: (Learn a b l, NoState l, Backprop a, Backprop b, MaybeC Backprop (LParamMaybe l), PrimMonad m)\n => l\n -> MWC.Gen (PrimState m)\n -> LParam_ I l\n -> a\n -> m (LParam_ I l, a)\ngradLearnStoch l g mp x = do\n seed <- MWC.uniformVector @_ @Word32 @VU.Vector g 2\n pure $ case mp of\n N_ -> (N_,) $ gradBP (\\x' -> runST $ do\n g' <- MWC.initialize seed\n runLearnStochStateless l g' N_ x'\n ) x\n J_ (I p) -> first (J_ . I) $ gradBP2 (\\p' x' -> runST $ do\n g' <- MWC.initialize seed\n runLearnStochStateless l g' (J_ p') x'\n ) p x\n\niterateLearn\n :: (Learn a b l, Backprop b, MaybeC Backprop (LStateMaybe l))\n => (b -> a) -- ^ loop\n -> Int -- ^ num times\n -> l\n -> LParam_ I l\n -> a\n -> LState_ I l\n -> ([b], LState_ I l)\niterateLearn f n l p x = runIdentity . iterateLearnM (Identity . f) n l p x\n\niterateLearn_\n :: (Learn a b l, Backprop b, MaybeC Backprop (LStateMaybe l))\n => (b -> a) -- ^ loop\n -> l\n -> LParam_ I l\n -> a\n -> LState_ I l\n -> [b]\niterateLearn_ f l p = go\n where\n go !x !s = y : go (f y) s'\n where\n (y, s') = runLearn_ l p x s\n\nselfPrime\n :: (Learn a b l, Backprop b, MaybeC Backprop (LStateMaybe l))\n => (b -> a) -- ^ loop\n -> l\n -> LParam_ I l\n -> a\n -> LState_ I l\n -> [LState_ I l]\nselfPrime f l p = go\n where\n go !x !s = s' : go (f y) s'\n where\n (y, s') = runLearn_ l p x s\n\niterateLearnM\n :: (Learn a b l, Backprop b, MaybeC Backprop (LStateMaybe l), Monad m)\n => (b -> m a) -- ^ loop\n -> Int -- ^ num times\n -> l\n -> LParam_ I l\n -> a\n -> LState_ I l\n -> m ([b], LState_ I l)\niterateLearnM f n l p = go 0\n where\n go !i !x !s\n | i <= n = do\n let (y, s') = runLearn_ l p x s\n (ys, s'') <- flip (go (i + 1)) s' =<< f y\n pure (y : ys, s'')\n | otherwise = pure ([], s)\n\niterateLearnM_\n :: (Learn a b l, Backprop b, MaybeC Backprop (LStateMaybe l), Monad m)\n => (b -> m a) -- ^ loop\n -> Int -- ^ num times\n -> l\n -> LParam_ I l\n -> a\n -> LState_ I l\n -> m [b]\niterateLearnM_ f n l p x = fmap fst . iterateLearnM f n l p x\n\nselfPrimeM\n :: (Learn a b l, Backprop b, MaybeC Backprop (LStateMaybe l), Monad m)\n => (b -> m a) -- ^ loop\n -> Int -- ^ num times\n -> l\n -> LParam_ I l\n -> a\n -> LState_ I l\n -> m (LState_ I l)\nselfPrimeM f n l p x = fmap snd . iterateLearnM f n l p x\n\niterateLearnStoch\n :: (Learn a b l, Backprop b, MaybeC Backprop (LStateMaybe l), PrimMonad m)\n => (b -> m a) -- ^ loop\n -> Int -- ^ num times\n -> l\n -> MWC.Gen (PrimState m)\n -> LParam_ I l\n -> a\n -> LState_ I l\n -> m ([b], LState_ I l)\niterateLearnStoch f n l g p = go 0\n where\n go !i !x !s\n | i <= n = do\n (y , s' ) <- runLearnStoch_ l g p x s\n (ys, s'') <- flip (go (i + 1)) s' =<< f y\n pure (y : ys, s'')\n | otherwise = pure ([], s)\n\niterateLearnStoch_\n :: (Learn a b l, Backprop b, MaybeC Backprop (LStateMaybe l), PrimMonad m)\n => (b -> m a) -- ^ loop\n -> Int -- ^ num times\n -> l\n -> MWC.Gen (PrimState m)\n -> LParam_ I l\n -> a\n -> LState_ I l\n -> m [b]\niterateLearnStoch_ f n l g p x = fmap fst . iterateLearnStoch f n l g p x\n\nscanLearn\n :: (Learn a b l, Backprop b, MaybeC Backprop (LStateMaybe l), Traversable t)\n => l\n -> LParam_ I l\n -> t a\n -> LState_ I l\n -> (t b, LState_ I l)\nscanLearn l p = runState . traverse (state . runLearn_ l p)\n\nscanLearn_\n :: (Learn a b l, Backprop b, MaybeC Backprop (LStateMaybe l), Traversable t)\n => l\n -> LParam_ I l\n -> t a\n -> LState_ I l\n -> t b\nscanLearn_ l p xs = fst . scanLearn l p xs\n\nprimeLearn\n :: (Learn a b l, Backprop b, MaybeC Backprop (LStateMaybe l), Foldable t)\n => l\n -> LParam_ I l\n -> t a\n -> LState_ I l\n -> LState_ I l\nprimeLearn l p = execState . traverse_ (state . runLearn_ l p)\n\nscanLearnStoch\n :: (Learn a b l, Backprop b, MaybeC Backprop (LStateMaybe l), PrimMonad m, Traversable t)\n => l\n -> MWC.Gen (PrimState m)\n -> LParam_ I l\n -> t a\n -> LState_ I l\n -> m (t b, LState_ I l)\nscanLearnStoch l g p = runStateT . traverse (StateT . runLearnStoch_ l g p)\n\nscanLearnStoch_\n :: (Learn a b l, Backprop b, MaybeC Backprop (LStateMaybe l), PrimMonad m, Traversable t)\n => l\n -> MWC.Gen (PrimState m)\n -> LParam_ I l\n -> t a\n -> LState_ I l\n -> m (t b)\nscanLearnStoch_ l g p xs = fmap fst . scanLearnStoch l g p xs\n\nprimeLearnStoch\n :: (Learn a b l, Backprop b, MaybeC Backprop (LStateMaybe l), PrimMonad m, Foldable t)\n => l\n -> MWC.Gen (PrimState m)\n -> LParam_ I l\n -> t a\n -> LState_ I l\n -> m (LState_ I l)\nprimeLearnStoch l g p = execStateT . traverse_ (StateT . runLearnStoch_ l g p)\n\ninitParamMaybe\n :: forall l m d proxy.\n ( MaybeC Initialize (LParamMaybe l)\n , ContGen d\n , PrimMonad m\n , KnownMayb (LParamMaybe l)\n )\n => proxy l -- ^ ignored\n -> d\n -> MWC.Gen (PrimState m)\n -> LParam_ m l\ninitParamMaybe _ d g = case knownMayb @(LParamMaybe l) of\n N_ -> N_\n J_ (_ :: P p) -> J_ $ initialize @p d g\n\ninitParam\n :: forall l m d proxy.\n ( Initialize (LParam l)\n , ContGen d\n , PrimMonad m\n )\n => proxy l -- ^ ignored\n -> d\n -> MWC.Gen (PrimState m)\n -> m (LParam l)\ninitParam _ = initialize\n\ninitParamNormalMaybe\n :: forall l m proxy.\n ( MaybeC Initialize (LParamMaybe l)\n , PrimMonad m\n , KnownMayb (LParamMaybe l)\n )\n => proxy l -- ^ ignored\n -> Double\n -> MWC.Gen (PrimState m)\n -> LParam_ m l\ninitParamNormalMaybe _ d g = case knownMayb @(LParamMaybe l) of\n N_ -> N_\n J_ (_ :: P p) -> J_ $ initializeNormal @p d g\n\n\ninitParamNormal\n :: forall l m proxy.\n ( Initialize (LParam l)\n , PrimMonad m\n )\n => proxy l -- ^ ignored\n -> Double\n -> MWC.Gen (PrimState m)\n -> m (LParam l)\ninitParamNormal _ = initializeNormal\n\nencodeParam\n :: Bi.Binary (LParam l)\n => proxy l -- ^ ignored\n -> LParam l\n -> BSL.ByteString\nencodeParam _ = Bi.encode\n\ndecodeParam\n :: Bi.Binary (LParam l)\n => proxy l -- ^ ignored\n -> BSL.ByteString\n -> LParam l\ndecodeParam _ = Bi.decode\n\ndecodeParamOrFail\n :: Bi.Binary (LParam l)\n => proxy l -- ^ ignored\n -> BSL.ByteString\n -> Either String (LParam l)\ndecodeParamOrFail _ = bimap thrd thrd . Bi.decodeOrFail\n\nsaveParam\n :: Bi.Binary (LParam l)\n => proxy l\n -> FilePath\n -> LParam l\n -> IO ()\nsaveParam p fp = BSL.writeFile fp . encodeParam p\n\nloadParam\n :: Bi.Binary (LParam l)\n => proxy l\n -> FilePath\n -> IO (LParam l)\nloadParam p fp = decodeParam p <$> BSL.readFile fp\n\nloadParamOrFail\n :: Bi.Binary (LParam l)\n => proxy l\n -> FilePath\n -> IO (Either String (LParam l))\nloadParamOrFail p fp = decodeParamOrFail p <$> BSL.readFile fp\n\n\nthrd :: (a,b,c) -> c\nthrd (_,_,z) = z\n", "meta": {"hexsha": "554d10b686dafbd021d20c60124581d39ee529b3", "size": 12858, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "old2/src/Backprop/Learn/Model.hs", "max_stars_repo_name": "mstksg/backprop-learn", "max_stars_repo_head_hexsha": "59aea530a0fad45de6d18b9a723914d1d66dc222", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 31, "max_stars_repo_stars_event_min_datetime": "2017-03-14T08:39:46.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-11T13:41:33.000Z", "max_issues_repo_path": "old2/src/Backprop/Learn/Model.hs", "max_issues_repo_name": "mstksg/backprop-learn", "max_issues_repo_head_hexsha": "59aea530a0fad45de6d18b9a723914d1d66dc222", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2018-05-06T01:01:46.000Z", "max_issues_repo_issues_event_max_datetime": "2018-05-06T01:01:46.000Z", "max_forks_repo_path": "old2/src/Backprop/Learn/Model.hs", "max_forks_repo_name": "mstksg/backprop-learn", "max_forks_repo_head_hexsha": "59aea530a0fad45de6d18b9a723914d1d66dc222", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2017-05-23T22:01:21.000Z", "max_forks_repo_forks_event_max_datetime": "2020-12-14T01:54:18.000Z", "avg_line_length": 29.4233409611, "max_line_length": 101, "alphanum_fraction": 0.5253538653, "num_tokens": 4074, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.7279754371026367, "lm_q2_score": 0.48047867804790706, "lm_q1q2_score": 0.3497766756704222}} {"text": "{-# LANGUAGE ForeignFunctionInterface #-}\n{-|\nModule : Grenade.Layers.Internal.Activations\nDescription : Fast activation functions that call efficient C function\nMaintainer : Theo Charalambous\nLicense : BSD2\nStability : experimental\n-}\nmodule Grenade.Layers.Internal.Activations \n ( relu\n , relu1d\n , leakyRelu\n , leakyRelu1d \n ) where\n\nimport qualified Data.Vector.Storable as U (unsafeFromForeignPtr0,\n unsafeToForeignPtr0)\n\nimport Foreign (mallocForeignPtrArray, withForeignPtr)\nimport Foreign.Ptr (Ptr)\nimport Numeric.LinearAlgebra (Matrix, Vector, flatten)\nimport qualified Numeric.LinearAlgebra.Devel as U\nimport System.IO.Unsafe (unsafePerformIO)\n\nimport Grenade.Types\n\n-- | Apply ReLU on a matrix\nrelu :: Int -> Int -> Int -> Matrix RealNum -> Matrix RealNum\nrelu channels rows cols = leakyRelu channels rows cols 0\n{-# INLINE relu #-}\n\n-- | Apply ReLU on a vector\nrelu1d :: Int -> Vector RealNum -> Vector RealNum\nrelu1d size = leakyRelu1d size 0\n{-# INLINE relu1d #-}\n\n-- | Apply LeakyReLU on a matrix\nleakyRelu :: Int -> Int -> Int -> RealNum -> Matrix RealNum -> Matrix RealNum\nleakyRelu channels rows cols alpha m \n = let vec = flatten m\n out = leakyRelu1d (channels * rows * cols) alpha vec\n in U.matrixFromVector U.RowMajor (rows * channels) cols out\n{-# INLINE leakyRelu #-}\n\n-- | Apply LeakyReLU on a vector\nleakyRelu1d :: Int -> RealNum -> Vector RealNum -> Vector RealNum\nleakyRelu1d size alpha vec\n = unsafePerformIO $ do\n outPtr <- mallocForeignPtrArray size\n let (inPtr, _) = U.unsafeToForeignPtr0 vec\n\n withForeignPtr inPtr $ \\inPtr' ->\n withForeignPtr outPtr $ \\outPtr' ->\n leaky_relu_forward inPtr' size alpha outPtr'\n \n return $ U.unsafeFromForeignPtr0 outPtr size\n{-# INLINE leakyRelu1d #-}\n\nforeign import ccall unsafe\n leaky_relu_forward\n :: Ptr RealNum -> Int -> RealNum -> Ptr RealNum -> IO ()\n", "meta": {"hexsha": "2b2faa5c05c56be860c9bd17e46d7792d9b8a9a8", "size": 2065, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/Grenade/Layers/Internal/Activations.hs", "max_stars_repo_name": "th-char/grenade", "max_stars_repo_head_hexsha": "0be658e7cf07562cd5e4170ed1e8875ccec14cdb", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-06-09T06:06:26.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-09T06:06:26.000Z", "max_issues_repo_path": "src/Grenade/Layers/Internal/Activations.hs", "max_issues_repo_name": "th-char/grenade", "max_issues_repo_head_hexsha": "0be658e7cf07562cd5e4170ed1e8875ccec14cdb", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/Grenade/Layers/Internal/Activations.hs", "max_forks_repo_name": "th-char/grenade", "max_forks_repo_head_hexsha": "0be658e7cf07562cd5e4170ed1e8875ccec14cdb", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 33.3064516129, "max_line_length": 84, "alphanum_fraction": 0.6576271186, "num_tokens": 531, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO\n\n", "lm_q1_score": 0.7217431943271999, "lm_q2_score": 0.48438008427698437, "lm_q1q2_score": 0.349598029294549}} {"text": "{-# LANGUAGE FlexibleContexts #-}\n{-# LANGUAGE ScopedTypeVariables #-}\n\nmodule FinancialTimeseries.Report.Standard where\n\nimport Data.Time (UTCTime)\n\nimport Data.Bifunctor (bimap)\nimport Data.Distributive (Distributive, distribute)\n\nimport qualified Data.Vector as Vec\nimport Data.Vector (Vector)\n\nimport qualified System.Random as R\n\nimport qualified Text.Blaze.Html5 as H5\n\nimport qualified Graphics.Rendering.Chart.Easy as E\n\nimport qualified Statistics.Sample.Histogram as Histo\n\nimport qualified FinancialTimeseries.Algorithm.MonteCarlo as AMC\nimport FinancialTimeseries.Algorithm.Evaluate (Profit, long, evaluate, evaluateFraction)\nimport FinancialTimeseries.Render.Chart (chartWithEquity)\nimport qualified FinancialTimeseries.Render.HtmlReader as HtmlReader -- (Config, runHtmlReader)\nimport FinancialTimeseries.Render.Render (display)\nimport FinancialTimeseries.Render.Statement (statement, currentTime)\nimport FinancialTimeseries.Statistics.Statistics (yield, tradeStatistics, stats2cdfChart, stats2list)\nimport FinancialTimeseries.Test (check_timeseries_prop)\nimport FinancialTimeseries.Type.Fraction (Fraction(..))\nimport FinancialTimeseries.Type.Histogram (Histogram(..))\nimport FinancialTimeseries.Type.Labeled (Labeled(..))\nimport FinancialTimeseries.Type.MonteCarlo (Broom(..))\nimport FinancialTimeseries.Type.Strategy (Strategy(..))\nimport FinancialTimeseries.Type.Timeseries (TimeseriesRaw, first, slice)\nimport qualified FinancialTimeseries.Type.Timeseries as TS\nimport FinancialTimeseries.Type.Types (StripPrice, stripPrice, Equity(..), partitionInvested)\n\nimport FinancialTimeseries.Util.DistributivePair (distributePair)\nimport FinancialTimeseries.Util.Pretty (Pretty, pretty)\n\n\n\ndata Config params gen price a = Config {\n now :: UTCTime\n , reportConfig :: HtmlReader.Config\n , monteCarloConfig :: AMC.Config gen a\n , strategy :: Strategy params price a\n }\n\nreport ::\n (Profit price, Distributive price, StripPrice price, Pretty params, R.RandomGen gen, Num a, Fractional a, Real a, E.PlotValue a, Show a, Pretty a, TS.Length (TimeseriesRaw price a)) =>\n Config params gen price a -> TimeseriesRaw price a -> H5.Html\nreport cfg ts =\n let t = (freeStrategy (strategy cfg)) (parameters (strategy cfg)) ts\n lg = long (partitionInvested (slice t))\n\n mteCrlo = AMC.mc (monteCarloConfig cfg) lg\n\n yields =\n let k = fmap (Vec.fromList . map (yield . Vec.map snd))\n in fmap (fmap (bimap k k)) lg\n\n tradeYields =\n let j zs = (fmap stats2cdfChart zs, fmap stats2list zs)\n k = j . fmap ((:[]) . Labeled \"Trade Yields\" . tradeStatistics)\n in fmap (fmap (snd . fmap k)) yields\n\n tsCharts =\n let convert = Equity . snd . stripPrice\n k = fmap (flip chartWithEquity [t]) . distribute\n in fmap (bimap k k . distributePair) (evaluate (convert (first ts)) lg)\n\n histogram =\n let histo zs =\n let n = round (fromIntegral (Vec.length zs) / fromIntegral (5 :: Integer) :: Double)\n in Histogram (Histo.histogram n (Vec.map realToFrac zs) :: (Vector Double, Vector Int))\n in fmap (fmap (fmap histo . snd)) yields\n\n ms = map (\\f -> mteCrlo f (evaluateFraction f)) (AMC.fractions (monteCarloConfig cfg))\n ys = fmap (fmap (fmap snd)) (AMC.timeseriesYields ms)\n rdds = fmap (fmap (fmap snd)) (AMC.relativeDrawdowns ms)\n\n broom = fmap (fmap (fmap (bimap (fmap Broom) (fmap Broom)))) (mteCrlo (Fraction 1.0) evaluate)\n \n html = HtmlReader.runHtmlReader (reportConfig cfg) $ mconcat $\n currentTime (now cfg)\n : statement (\"Timeseries is well formed: \" ++ show (check_timeseries_prop t))\n : statement (\"Parameters: \" ++ pretty (parameters (strategy cfg)))\n : display tsCharts\n : display tradeYields\n : display histogram\n : display broom\n : display ys\n : display rdds\n : []\n \n in html\n", "meta": {"hexsha": "1a31010f8a9e1c6dc6e950521dcbf66df50ed3cc", "size": 3924, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/FinancialTimeseries/Report/Standard.hs", "max_stars_repo_name": "fphh/financial-timeseries", "max_stars_repo_head_hexsha": "9be9b8e83108889a7527dbd15df8ac9f2cf6093e", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/FinancialTimeseries/Report/Standard.hs", "max_issues_repo_name": "fphh/financial-timeseries", "max_issues_repo_head_hexsha": "9be9b8e83108889a7527dbd15df8ac9f2cf6093e", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/FinancialTimeseries/Report/Standard.hs", "max_forks_repo_name": "fphh/financial-timeseries", "max_forks_repo_head_hexsha": "9be9b8e83108889a7527dbd15df8ac9f2cf6093e", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 39.6363636364, "max_line_length": 186, "alphanum_fraction": 0.7112640163, "num_tokens": 961, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO\n\n", "lm_q1_score": 0.7905303186696747, "lm_q2_score": 0.4416730056646256, "lm_q1q2_score": 0.3491559019158495}} {"text": "{-# LANGUAGE Rank2Types #-}\n{-# LANGUAGE TypeFamilies #-}\n\nmodule Plotting where\n\nimport Data.List (sort)\nimport qualified Data.Vector as Vector\nimport Graphics.Rendering.Chart.Easy\nimport Statistics.Sample (meanVariance)\n\n{-# ANN module \"HLint: ignore Reduce duplication\" #-}\n\nerrBars :: Double -> Vector.Vector Double -> (Double, Double)\nerrBars k xs = (mean, k * stdDev)\n where\n (mean, var) = meanVariance xs\n stdDev = sqrt var\n\nanytimeEval :: ([(a, Double)] -> Double) -> [(a, Double)] -> [Int] -> [Double]\nanytimeEval f xs ns = map eval (filter (<= length xs) ns)\n where\n eval n = f (take n xs)\n\nanytimePlot :: String -> String -> [Int] -> [(String, [Double])] -> EC (Layout LogValue LogValue) ()\nanytimePlot x_title y_title ns inputs = do\n let xLabelShow = map (show . ceiling)\n let yLabelShow = map show\n let generatePlot (algName, ys) = plot $ line algName [zip (map fromIntegral ns) (map LogValue ys)]\n mapM_ generatePlot inputs\n layout_x_axis . laxis_generate .= autoScaledLogAxis (loga_labelf .~ xLabelShow $ def)\n layout_y_axis . laxis_generate .= autoScaledLogAxis (loga_labelf .~ yLabelShow $ def)\n layout_x_axis . laxis_title .= x_title\n layout_y_axis . laxis_title .= y_title\n\noneShotPlot :: String -> String -> [(String, [(Double, (Double, Double))])] -> EC (Layout LogValue LogValue) ()\noneShotPlot x_title y_title inputs = do\n let xLabelShow = map (show . ceiling)\n let yLabelShow = map show\n let processPoint (x, (y, dy)) = symErrPoint (LogValue x) (LogValue y) 0 (LogValue dy)\n let generatePlot (algName, ps) = do\n plot $ points algName $ map (\\(x, (y, _)) -> (LogValue x, LogValue y)) ps\n plot $ return (def & plot_errbars_values .~ map processPoint ps)\n mapM_ generatePlot inputs\n layout_x_axis . laxis_generate .= autoScaledLogAxis (loga_labelf .~ xLabelShow $ def)\n layout_y_axis . laxis_generate .= autoScaledLogAxis (loga_labelf .~ yLabelShow $ def)\n layout_x_axis . laxis_title .= x_title\n layout_y_axis . laxis_title .= y_title\n\nerrorbarPlot ::\n String ->\n String ->\n [(String, [(Double, [Double])])] ->\n EC (Layout LogValue LogValue) ()\nerrorbarPlot x_title y_title inputs = do\n let xLabelShow = map (show . ceiling)\n let yLabelShow = map show\n let makeBars (x, ys) = ErrPoint (ErrValue x' x' x') (ErrValue ymin y ymax)\n where\n x' = LogValue x\n y = LogValue $ sum ys / fromIntegral (length ys)\n sorted = sort ys\n n = length ys\n ymin = LogValue $ sorted !! (n `div` 4)\n ymax = LogValue $ sorted !! (n * 3 `div` 4)\n let generatePlot (algName, ps) = do\n plot $ liftEC $ do\n -- ensure error bars are the same color as the points\n (color : _) <- liftCState $ use colors\n plot_errbars_values .= map makeBars ps\n plot_errbars_line_style . line_color .= color\n plot $ points algName $\n map (\\(x, ys) -> (LogValue x, LogValue (sum ys / fromIntegral (length ys)))) ps\n mapM_ generatePlot inputs\n layout_x_axis . laxis_generate .= autoScaledLogAxis (loga_labelf .~ xLabelShow $ def)\n layout_y_axis . laxis_generate .= autoScaledLogAxis (loga_labelf .~ yLabelShow $ def)\n layout_x_axis . laxis_title .= x_title\n layout_y_axis . laxis_title .= y_title\n", "meta": {"hexsha": "098a255fdc5f3a36536d80f095fde29601d7267c", "size": 3244, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "models/Plotting.hs", "max_stars_repo_name": "saeedhadikhanloo/monad-bayes", "max_stars_repo_head_hexsha": "9b764c952551a5d62bdbdeac1cd13921f4cf9f27", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-02-27T02:59:08.000Z", "max_stars_repo_stars_event_max_datetime": "2020-02-27T02:59:08.000Z", "max_issues_repo_path": "models/Plotting.hs", "max_issues_repo_name": "saeedhadikhanloo/monad-bayes", "max_issues_repo_head_hexsha": "9b764c952551a5d62bdbdeac1cd13921f4cf9f27", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "models/Plotting.hs", "max_forks_repo_name": "saeedhadikhanloo/monad-bayes", "max_forks_repo_head_hexsha": "9b764c952551a5d62bdbdeac1cd13921f4cf9f27", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 41.5897435897, "max_line_length": 111, "alphanum_fraction": 0.6698520345, "num_tokens": 932, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.6619228758499942, "lm_q2_score": 0.5273165233795671, "lm_q1q2_score": 0.3490428696386238}} {"text": "{-# LANGUAGE FlexibleContexts #-} {- Container (Vector a) => ..., etc. -}\n{-# LANGUAGE RankNTypes #-} {- For type traces w/ ST -}\n{-# LANGUAGE Strict #-} {- Lazy evaluation is no good here -}\n{-# LANGUAGE TemplateHaskell #-} {- Since we're using lenses aplenty -}\n\n{-\n TODO LIST:\n * Make sure basic functionality works, write some tests.\n * Use Numeric.LinearAlgebra.Devel to guarantee that ALL matrix operations\n are zero-copy or low allocation overhead.\n * Leverage chunk-based parallelism (lots of embarassing parallelism!)\n-}\n\nmodule Optimization.NelderMead\n ( nelderMeadAt\n , nelderMeadFull\n , nelderMead\n ) where\n\nimport Control.Applicative\nimport Control.Lens\nimport Control.Monad\nimport Control.Monad.ST\n\nimport Data.Maybe\nimport Data.Ord ( comparing )\nimport Data.STRef ( STRef\n , modifySTRef\n , newSTRef\n , readSTRef\n , writeSTRef )\n \nimport Data.Vector.Storable as VS hiding ( take\n , forM_\n , (!) )\nimport Data.Vector.Algorithms.Intro ( sortBy )\nimport Data.Vector.Mutable as VM hiding ( take )\nimport Data.Vector.Storable.Mutable as VSM hiding ( take )\n\nimport Numeric.LinearAlgebra.Data as LA\nimport Numeric.LinearAlgebra.HMatrix as HM\nimport Numeric.LinearAlgebra.Devel as MutM\n\nimport Optimization.Types\n\n-- One point of the simplex and its associated score.\ndata Vertex s = Vertex {\n which :: Int,\n score :: s\n }\n\n-- Ranked vertices for NM search.\ndata VertexRank a b = VertexRank {\n bestOf :: Vertex b,\n nextBestOf :: Vertex b,\n worstOf :: Vertex b,\n goodCentroidOf :: Vector a\n }\n\n-- Create a VertexRank from the available data.\npickBestAndWorstVerts ::\n (Numeric a, Fractional a, Ord b) =>\n --(Container Vector a, Element a, Ord b, Transposable (Simplex a) (Simplex a)) =>\n (Vector a -> b) -> -- A function from a point on the simplex to some orderable type.\n Simplex a -> -- The simplex to consider.\n VertexRank a b -- Vertex rank.\npickBestAndWorstVerts f s = runST $ do\n let\n nDims = rows s\n points = tr s\n\n scores <- VM.new nDims\n forM_ [0..(nDims - 1)] (\\i -> VM.unsafeWrite scores i (i, f $ points ! i))\n sortBy (comparing snd) scores\n let\n mvertex j = liftM (uncurry Vertex) (VM.unsafeRead scores j)\n h <- mvertex 0\n sh <- mvertex 1\n l <- mvertex (nDims - 1)\n \n return $ VertexRank h sh l (center $ allButIth (which l) s)\n\n-- Increment a termination criterion by one iteration.\nincrement :: TerminationCriterion a -> TerminationCriterion a\nincrement p\n | isJust (view maxit p) = over maxit (fmap pred) p\n | otherwise = p\n\n-- Compute the center of the NM Simplex.\ncenter ::\n (Numeric a, Fractional a) =>\n Simplex a ->\n Vector a\ncenter s = runST $ do \n centroid <- VSM.new (rows s)\n \n forM_ [0..((rows s) - 1)] (\\i -> do\n forM_ [0..((cols s) - 1)] (\\j -> do\n let\n u = fromIntegral (cols s)\n VSM.unsafeWrite centroid i ((s `atIndex` (i,j)) / u) ))\n\n freeze centroid\n\n-- Create a simplex with all points but the i-th.\nallButIth :: (Numeric a) => Int -> Simplex a -> Simplex a\nallButIth l s\n | l == 0 = subMatrix (0,1) (nDims, nDims) s\n | l == (cols s) = subMatrix (0,0) (nDims, nDims) s\n | otherwise = ls ||| rs where\n nDims = rows s\n ls = subMatrix (0, l - 1) (nDims, l - 1) s\n rs = subMatrix (0, l + 1) (nDims, nDims - l) s\n\n-- The centroid of all points except whichever is worst.\ngoodCentroid :: (Numeric a, Fractional a, Ord b) =>\n VertexRank a b ->\n Simplex a ->\n Vector a\ngoodCentroid r splx = center $ allButIth ((which . worstOf) r) splx\n\n-- Get the i-th point of a simplex.\nnthPoint :: (Numeric a, Element a) => Int -> Simplex a -> Vector a\nnthPoint i s = flatten $ subMatrix (0, i) (rows s, 1) s\n\n-- Get an estimate of simplex size by computing the sum of all\n-- elements in the simplex, translated so that its centroid\n-- lies at zero.\nsimplexSize :: (Numeric a, Fractional a) =>\n Simplex a ->\n a\nsimplexSize s = fastSimplexL1 (moveToOrigin s) where\n fastSimplexL1 m = runST $ do\n acc <- newSTRef 0\n mut <- unsafeThawMatrix m\n forM_ [0..((rows m) - 1)] $ \\i -> do\n forM_ [0..((cols m) - 1)] $ \\j -> do\n elem <- unsafeReadMatrix mut i j\n modifySTRef acc (+ elem)\n readSTRef acc\n\nmoveToOrigin :: (Numeric a, Fractional a) =>\n Simplex a ->\n Simplex a\nmoveToOrigin s = runSTMatrix $ do\n sm <- thawMatrix s\n ctr <- unsafeThawVector (center s)\n\n forM_ [0..((rows s) - 1)] $ \\i -> do\n c_entry <- unsafeReadVector ctr i\n forM_ [0..((cols s) - 1)] $ \\j -> do\n m_entry <- unsafeReadMatrix sm i j\n unsafeWriteMatrix sm i j (m_entry - c_entry)\n\n return sm\n\n-- Check if current simplex state and termination criterion indicate that we should\n-- be finished.\nisDone tc simplex = noMoreIters || closeEnough || neitherValid where\n noMoreIters = (fromMaybe 1 (view maxit tc)) == 0\n thresh = view threshold tc\n closeEnough = fromMaybe False (fmap ((simplexSize simplex) <) thresh)\n neitherValid = (isNothing (view maxit tc)) && (isNothing (view threshold tc))\n\n-- Update the i-th point of simplex sx with vector p.\nupdateSimplex :: (Numeric a) => Int -> Vector a -> Simplex a -> Simplex a\nupdateSimplex i v sx = runSTMatrix $ do\n sxm <- thawMatrix sx\n vm <- unsafeThawVector v\n forM_ [0..((cols sx) - 1)] $ \\d -> do\n updated <- unsafeReadVector vm d\n unsafeWriteMatrix sxm d i updated\n return sxm\n\n-- Reflect the simplex's \"worst\" point around the hyperplane defined by the \n-- other points. If this constitutes a significant improvement, then consider\n-- \"expanding\" even farther in the same direction. Otherwise, give up.\nreflectAndExpand :: forall a b s. (Num a, Numeric a, Fractional a, Ord b) =>\n NMStepParameters a ->\n (Vector a -> b) ->\n STRef s (Simplex a) ->\n STRef s (VertexRank a b) ->\n ST s Bool\nreflectAndExpand params f s vrank = do\n r <- readSTRef vrank\n sx <- readSTRef s\n \n let\n x0 = goodCentroid r sx\n x_best = nthPoint ((which . bestOf) r) sx\n sx_best = (score . bestOf) r -- Score of best x\n sx_next = (score . nextBestOf) r -- Score of next best x\n \n a = view alpha params\n xr = x0 + ((x0 - x_best) `scaleBy` a) -- x reflected\n sxr = f xr -- score of x reflected\n\n -- How does the reflected point fare?\n if (sxr < sx_next && sxr > sx_best)\n then do\n modifySTRef s (updateSimplex ((which . worstOf) r) xr)\n return True\n else do\n\n -- Consider expansion.\n if (sxr < sx_best)\n then do\n let\n g = view gamma params\n xe = x0 + ((xr - x0) `scaleBy` g)\n sxe = f xe\n\n -- Is expansion better?\n if (sxe < sxr)\n then do\n modifySTRef s (updateSimplex ((which . worstOf) r) xe)\n return True\n else do\n modifySTRef s (updateSimplex ((which . worstOf) r) xr)\n return True\n else do\n return False\n\n-- Move the worst point of the simplex inward toward the centroid of all the\n-- better points. If this doesn't result in an improvement, don't do anything.\ncontract :: forall a b s. (Numeric a, Fractional a, Ord b) =>\n NMStepParameters a ->\n (Vector a -> b) ->\n STRef s (Simplex a) ->\n STRef s (VertexRank a b) ->\n ST s Bool\ncontract params f s vrank = do\n r <- readSTRef vrank\n sx <- readSTRef s\n let\n x0 = goodCentroid r sx\n x_worst = nthPoint ((which . worstOf) r) sx\n sx_worst = (score . worstOf) r\n \n rh = view rho params\n xc = x0 + ((x_worst - x0) `scaleBy` rh)\n sxc = f xc\n\n if (sxc < sx_worst)\n then do\n modifySTRef s (updateSimplex ((which . worstOf) r) xc)\n return True\n else do\n return False \n\n\n-- Move all points of a simplex slightly towards the best point.\nshrink :: forall a b s. (Num a, Fractional a, Storable a, Ord b) =>\n NMStepParameters a ->\n (Vector a -> b) ->\n STRef s (Simplex a) ->\n STRef s (VertexRank a b) ->\n ST s Bool\nshrink params f s vrank = do\n sx <- readSTRef s\n r <- readSTRef vrank\n let\n sig = view sigma r\n x_best = nthPoint ((which . bestOf) r) sx\n\n forM_ (\\i -> do\n modifySTRef s (\\simplex ->\n if (i == ((which . bestOf) r))\n then\n simplex\n else\n let\n xi = nthPoint i simplex\n xi' = x_best + (sig * (xi - x_best)) in\n updateSimplex i xi' simplex\n )\n ) [0..((cols sx) - 1)]\n return True\n\n \n-- |Predict the location of a minimum of an objective function using the Nelder-Mead simplex\n-- search. This function permits tuning of all parameters, including the starting simplex.\nnelderMeadFull :: (Num a, Fractional a, Storable a, Ord b) =>\n NMStepParameters a -> -- ^Nelder-Mead step parameters\n TerminationCriterion a -> -- ^Reason we would terminate\n (Vector a -> b) -> -- ^Objective function\n Simplex a -> -- ^Starting simplex\n Vector a -- ^Predicted minimum\nnelderMeadFull params term_conditions func initial = (center . runST) $ do\n \n simplex <- newSTRef initial\n vtx_rank <- newSTRef (pickBestAndWorstVerts simplex)\n\n nelderMeadStep params term_conditions func simplex vtx_rank where\n \n nelderMeadStep p tc f s vrank = do\n -- Update rank and see if we're done.\n modifySTRef vrank (pickBestAndWorstVerts func)\n finished <- isDone <$> readSTRef s\n\n if (finished)\n then do\n rnk <- readSTRef vrank\n sx <- readSTRef s\n return $ nthPoint ((which . bestOf) rnk) sx\n\n -- Attempt to improve simplex.\n else do\n reflected <- reflectAndExpand p f s vrank\n unless reflected $ do\n contracted <- contract p f s vrank\n unless contracted $ do\n shrink p f s vrank\n \n nelderMeadStep p (iterate tc) f s vrank\n \n-- |Predict the location of a minimum of an objective function using the\n-- Nelder-Mead simplex search. This version is like nelderMeadFull, but accepts\n-- a starting point rather than an entire simplex.\nnelderMeadAt :: (Num a, Fractional a, Storable a, Ord b) =>\n NMStepParameters a -> -- ^Nelder-Mead step parameters\n TerminationCriterion a -> -- ^Reason we would terminate\n (Vector a -> b) -> -- ^Objective function\n Vector a -> -- ^Starting point.\n Vector a -- ^Predicted minimum.\nnelderMeadAt p t f i = nelderMeadFull p t f (makeSimplexAround i e) where\n e = view epsilon p\n\n-- |Minimize an objective function using the Nelder-Mead simplex search. This\n-- invokation uses \"default\" step parameters.\nnelderMead :: (Num a, Fractional a, Storable a, Ord b) =>\n TerminationCriterion a -> -- ^Reason we would terminate\n (Vector a -> b) -> -- ^Objective function\n Vector a -- ^Initial guess\nnelderMead tc f x = nelderMeadAt defaultStep tc f x\n\n{-\n Construct a simplex around a point by creating another vertex epsilon away from the initial\n guess along each vector of the canonical basis.\n-}\nmakeSimplexAround :: (Element a) =>\n Vector a -> -- One vertex of the simplex\n a -> -- Epsilon used to expand the simplex along the canonical basis\n Simplex a -- Resultant simplex.\nmakeSimplexAround initial = fromBlocks [[asColumn initial, cloned + identity]]\n where\n dimension = size initial\n cloned = asColumns (take dimension $ repeat initial)\n identity = ident dimension\n\nscaleBy :: (Num a) => Vector a -> a -> Vector a\nscaleBy v a = runST $ do\n vm <- thawVector\n forM_ [0..((VS.length v) - 1)] $ \\i -> do\n e <- unsafeReadVector vm i\n unsafeWriteVector vm i (e * a)\n freezeVector vm\n", "meta": {"hexsha": "1dfb6a6ff899e1ad09455296279d25ae9304ff38", "size": 12079, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/Optimization/NelderMead.hs", "max_stars_repo_name": "agbrooks/buzzwords", "max_stars_repo_head_hexsha": "89fa4ef0dc5a2317b6f19bd05f1d44a5b7aa9763", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2017-10-10T07:11:28.000Z", "max_stars_repo_stars_event_max_datetime": "2017-10-10T07:11:28.000Z", "max_issues_repo_path": "src/Optimization/NelderMead.hs", "max_issues_repo_name": "agbrooks/buzzwords", "max_issues_repo_head_hexsha": "89fa4ef0dc5a2317b6f19bd05f1d44a5b7aa9763", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/Optimization/NelderMead.hs", "max_forks_repo_name": "agbrooks/buzzwords", "max_forks_repo_head_hexsha": "89fa4ef0dc5a2317b6f19bd05f1d44a5b7aa9763", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 33.7402234637, "max_line_length": 94, "alphanum_fraction": 0.6081629274, "num_tokens": 3400, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.7310585903489891, "lm_q2_score": 0.476579651063676, "lm_q1q2_score": 0.3484076478956241}} {"text": "{-# LANGUAGE TypeSynonymInstances #-}\n{-# LANGUAGE FlexibleInstances #-}\nmodule Marvin.Test.TestUtils (\n isAround\n , nestedFromList\n , trainMatrix\n , equals\n , (+-)\n) where\n\nimport Marvin.Test.Metric\nimport Marvin.API as Marvin\n\nimport Test.QuickCheck hiding (vector)\nimport qualified Test.QuickCheck as QC (vector)\nimport Numeric.LinearAlgebra.Data as LA\nimport Foreign.Storable\n\nimport qualified Data.Vector as Vec\n\nnestedFromList = Vec.fromList . Prelude.map Vec.fromList\n\ngenVectorOfSize :: (Storable a, Arbitrary a) => Int -> Gen (Vector a)\ngenVectorOfSize n = do\n xs <- vectorOf n arbitrary\n return $ LA.fromList xs\n\ninstance (Storable a, Arbitrary a) => Arbitrary (Vector a) where\n arbitrary = sized genVectorOfSize\n\ninstance (Arbitrary a) => Arbitrary (Vec.Vector a) where\n arbitrary = Vec.fromList <$> arbitrary\n\ninstance Arbitrary NumericColumn where\n arbitrary = do\n t <- arbitrary\n h <- arbitrary\n let Right col = Marvin.fromList (h:t)\n return col\n\ninstance Arbitrary Error where\n arbitrary = do\n msg <- arbitrary\n return $ Marvin.Failure msg\n\nisAround :: Metric a => a -> a -> Bool\nisAround a x = dist a x <= threshold\n\ninfix 7 `equals`\nequals :: Metric a => a -> a -> FloatPrecision -> Bool\nequals x y (P e) = dist x y < e\n\nnewtype FloatPrecision = P Double\n\ninfix 8 +-\n(+-) :: Double -> FloatPrecision\n(+-) = P\n\nthreshold = 0.00001\n\ntrainMatrix = [\n [2,6,2,3,2,2,1,3,2,2,2,15.0],\n [1,6,1,3,3,1,1,2,2,4,2,14.5],\n [2,6,3,1,4,2,3,3,1,3,1,14.0],\n [2,6,1,4,4,2,2,3,2,4,2,16.0],\n [1,1,2,2,2,1,1,4,1,3,1,14.0],\n [1,3,2,1,1,1,2,2,1,2,1,16.5],\n [1,4,1,1,3,1,3,1,1,3,1,14.0],\n [1,3,2,3,2,1,2,3,1,3,1,16.5],\n [2,4,1,2,1,2,3,2,1,4,1,15.0],\n [2,4,1,1,2,2,3,3,1,3,1,16.0],\n [2,2,1,2,3,2,1,2,1,3,1,16.5],\n [2,5,2,2,1,2,3,1,2,1,2,15.0],\n [2,5,2,2,3,2,3,1,2,1,2,15.5],\n [2,6,1,4,3,2,2,3,2,4,2,15.5],\n [2,3,2,3,1,2,1,2,1,3,1,15.0],\n [1,1,2,4,3,1,1,1,1,2,1,15.0],\n [1,1,3,2,2,1,2,2,2,2,2,14.5],\n [1,2,1,1,2,1,2,1,1,4,1,16.0],\n [2,1,2,4,4,2,2,2,1,1,1,15.5],\n [2,2,2,2,3,2,3,4,1,2,1,14.5],\n [1,5,2,3,3,1,3,2,1,1,1,13.5],\n [2,5,3,4,4,2,2,4,2,3,2,16.0],\n [1,2,2,3,4,1,3,3,1,2,1,15.0],\n [2,3,1,2,2,2,2,2,1,1,1,14.5],\n [2,2,1,3,1,2,1,1,2,4,2,15.0],\n [1,1,2,3,4,1,1,2,1,4,1,14.5],\n [2,1,3,4,2,2,1,4,1,1,1,14.5],\n [1,3,3,4,3,1,3,4,2,4,2,15.5],\n [2,2,3,1,3,2,2,1,2,2,2,15.5],\n [1,5,1,2,4,1,2,1,2,4,2,15.5],\n [2,2,2,3,1,2,3,2,2,4,2,14.0],\n [1,2,3,4,2,1,1,4,1,3,1,17.0],\n [1,1,3,4,2,1,2,3,2,3,2,15.0],\n [1,2,1,2,1,1,2,3,1,3,1,16.0],\n [2,3,2,3,3,2,1,2,2,3,2,15.0],\n [2,5,1,1,4,2,1,4,2,1,2,16.0],\n [1,4,3,3,3,1,2,3,1,3,1,15.5],\n [1,2,3,3,3,1,1,3,2,1,2,16.5],\n [2,6,1,3,1,2,2,2,1,1,1,15.5],\n [1,6,2,1,1,1,2,3,2,3,2,15.0],\n [2,6,1,2,3,2,2,1,1,2,1,15.0],\n [2,2,1,4,2,2,1,4,2,1,2,15.0],\n [2,5,1,4,4,2,1,3,2,2,2,14.5],\n [1,5,1,3,1,1,2,2,2,2,2,14.5],\n [2,4,1,4,1,2,3,4,1,2,1,16.0],\n [1,6,1,4,2,1,1,4,2,3,2,14.5],\n [1,6,1,2,4,1,1,1,2,2,2,13.5],\n [2,6,1,1,2,2,2,4,1,3,1,15.0],\n [1,4,1,1,1,1,3,1,2,3,2,14.5],\n [2,1,1,4,3,2,3,3,2,3,2,15.0],\n [1,3,2,1,2,1,2,2,2,2,2,14.5],\n [2,5,1,2,2,2,1,1,1,4,1,15.5],\n [1,3,3,1,3,1,3,2,1,1,1,15.0],\n [1,2,3,4,3,1,1,4,2,3,2,16.5],\n [1,1,2,3,1,1,1,2,1,4,1,15.0],\n [1,5,3,1,2,1,1,1,1,2,1,14.0],\n [1,6,3,2,3,1,3,2,1,1,1,15.0],\n [2,5,3,1,3,2,2,3,1,4,1,14.0],\n [1,2,2,2,4,1,3,1,1,3,1,16.5],\n [2,1,2,3,4,2,2,3,1,4,1,16.0],\n [2,6,2,3,3,2,1,3,1,2,1,14.0],\n [1,3,3,1,1,1,3,2,2,1,2,15.5],\n [2,3,2,4,2,2,1,3,2,2,2,14.0],\n [1,5,2,2,1,1,3,4,1,4,1,14.5],\n [2,6,2,2,1,2,1,1,1,4,1,15.0],\n [1,2,3,1,4,1,1,2,2,4,2,16.0],\n [1,4,3,1,3,1,2,2,1,2,1,14.5],\n [2,5,3,4,3,2,2,4,2,3,2,15.0],\n [1,6,2,3,1,1,2,2,2,2,2,13.5],\n [2,4,1,3,4,2,3,1,1,1,1,15.0],\n [2,4,3,4,1,2,1,2,2,3,2,14.0],\n [1,4,3,4,1,1,2,4,2,1,2,15.5],\n [1,3,2,2,3,1,2,1,1,4,1,16.0],\n [1,6,3,3,2,1,3,4,1,4,1,15.0],\n [1,3,3,2,2,1,3,1,1,3,1,15.5],\n [1,6,2,4,3,1,2,1,2,4,2,15.5],\n [2,2,3,1,1,2,2,1,2,2,2,14.5],\n [2,2,2,3,2,2,3,2,1,4,1,14.5],\n [2,2,1,2,2,2,1,2,1,3,1,15.0],\n [2,5,2,3,2,2,3,3,1,3,1,15.0]]\n\ntestMatrix = [\n [1,1,1,4,4,1,3,4,1,4,1,16.0],\n [1,4,3,3,1,1,2,3,1,3,1,15.5],\n [2,2,1,4,4,2,1,4,2,1,2,15.0],\n [1,5,2,4,3,1,3,1,1,3,1,15.0],\n [1,4,2,1,2,1,1,2,2,4,2,14.5],\n [1,1,2,1,4,1,1,3,2,1,2,15.0],\n [1,1,3,1,3,1,2,1,2,4,2,15.0],\n [1,4,2,1,1,1,1,2,1,4,1,14.5],\n [2,6,1,4,2,2,2,3,1,4,1,15.0],\n [2,5,1,3,2,2,1,2,2,3,2,15.5],\n [1,6,1,3,1,1,1,2,1,4,1,15.0],\n [2,3,2,1,3,2,1,1,1,4,1,15.5],\n [1,2,2,3,3,1,3,3,2,2,2,14.0],\n [1,4,1,1,2,1,3,1,2,3,2,14.0],\n [1,2,1,2,4,1,2,3,2,3,2,15.0],\n [1,2,2,2,1,1,3,1,2,3,2,16.0],\n [1,5,1,1,1,1,2,3,1,3,1,15.5],\n [1,3,2,4,3,1,2,4,2,1,2,17.0],\n [2,1,3,4,3,2,1,4,2,1,2,15.5],\n [2,5,2,3,1,2,3,3,2,3,2,15.0]]\n", "meta": {"hexsha": "9e3f4d05b1cd7b042caaacefbd6494a5cf919961", "size": 4617, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "test-suite/Marvin/Test/TestUtils.hs", "max_stars_repo_name": "gaborhermann/marvin", "max_stars_repo_head_hexsha": "5c616709f0645d4b1f13caa20820a39ee31774de", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2017-04-18T09:46:00.000Z", "max_stars_repo_stars_event_max_datetime": "2017-04-18T09:46:00.000Z", "max_issues_repo_path": "test-suite/Marvin/Test/TestUtils.hs", "max_issues_repo_name": "gaborhermann/marvin", "max_issues_repo_head_hexsha": "5c616709f0645d4b1f13caa20820a39ee31774de", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "test-suite/Marvin/Test/TestUtils.hs", "max_forks_repo_name": "gaborhermann/marvin", "max_forks_repo_head_hexsha": "5c616709f0645d4b1f13caa20820a39ee31774de", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-01-02T11:45:45.000Z", "max_forks_repo_forks_event_max_datetime": "2020-01-02T11:45:45.000Z", "avg_line_length": 28.1524390244, "max_line_length": 69, "alphanum_fraction": 0.5183019277, "num_tokens": 3166, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.6791786991753929, "lm_q2_score": 0.5117166047041654, "lm_q1q2_score": 0.3475470179294238}} {"text": "{-# LANGUAGE DataKinds #-}\n{-# LANGUAGE DeriveAnyClass #-}\n{-# LANGUAGE DeriveGeneric #-}\n{-# LANGUAGE MultiParamTypeClasses #-}\n{-# LANGUAGE RankNTypes #-}\n{-# LANGUAGE ScopedTypeVariables #-}\n{-# LANGUAGE TypeFamilies #-}\n{-# LANGUAGE TypeOperators #-}\n{-|\nModule : Grenade.Layers.LeakyRelu\nDescription : Rectifying linear unit layer\nCopyright : (c) Manuel Schneckenreither, 2020\nLicense : BSD2\nStability : experimental\n-}\nmodule Grenade.Layers.LeakyRelu (\n LeakyRelu (..)\n , SpecLeakyRelu (..)\n , specLeakyRelu1D\n , specLeakyRelu2D\n , specLeakyRelu3D\n , leakyRelu\n ) where\n\nimport Control.DeepSeq (NFData (..), force)\nimport Data.Constraint (Dict (..))\nimport Data.Reflection (reifyNat)\nimport Data.Serialize\nimport Data.Singletons\nimport GHC.Generics (Generic)\nimport GHC.TypeLits\nimport qualified Numeric.LinearAlgebra.Static as LAS\nimport Unsafe.Coerce (unsafeCoerce)\n\nimport Grenade.Core\nimport Grenade.Dynamic\nimport Grenade.Dynamic.Internal.Build\nimport Grenade.Types\nimport Grenade.Utils.Conversion (toLayerShape)\nimport Grenade.Utils.Vector\n\n\n-- | A rectifying linear unit.\n-- A layer which can act between any shape of the same dimension, acting as a\n-- diode on every neuron individually.\ndata LeakyRelu = LeakyRelu\n deriving (Generic, NFData, Show)\n\ninstance UpdateLayer LeakyRelu where\n type Gradient LeakyRelu = ()\n runUpdate _ _ _ = LeakyRelu\n\ninstance RandomLayer LeakyRelu where\n createRandomWith _ _ = return LeakyRelu\n\ninstance Serialize LeakyRelu where\n put _ = return ()\n get = return LeakyRelu\n\ninstance (KnownNat i) => Layer LeakyRelu ('D1 i) ('D1 i) where\n type Tape LeakyRelu ('D1 i) ('D1 i) = S ('D1 i)\n\n runForwards _ (S1D y) = (S1D y, S1D (relu y))\n where\n relu = LAS.dvmap (\\a -> if a < 0 then alpha * a else a)\n runForwards _ (S1DV y) = (S1DV y, S1DV (mapVectorInPlace relu y))\n where\n relu = (\\a -> if a < 0 then alpha * a else a) -- we do not change the sign, so we can use inPlace here\n runBackwards _ (S1D y) (S1D dEdy) = ((), S1D (relu' y * dEdy))\n where\n relu' = LAS.dvmap (\\a -> if a < 0 then alpha else 1)\n runBackwards _ (S1DV y) (S1DV dEdy) = ((), zipWithVectorInPlaceSnd reluDif y dEdy `seq` S1DV dEdy)\n runBackwards x y dEdy = runBackwards x y (toLayerShape y dEdy)\n\n\ninstance (KnownNat i, KnownNat j) => Layer LeakyRelu ('D2 i j) ('D2 i j) where\n type Tape LeakyRelu ('D2 i j) ('D2 i j) = S ('D2 i j)\n\n runForwards _ (S2D y) = (S2D y, S2D (relu y))\n where\n relu = LAS.dmmap (\\a -> if a < 0 then alpha * a else a)\n runForwards _ (S2DV y) = (S2DV y, S2DV (mapVectorInPlace relu y))\n where\n relu = (\\a -> if a < 0 then alpha * a else a)\n runBackwards _ (S2D y) (S2D dEdy) = ((), S2D (relu' y * dEdy))\n where\n relu' = LAS.dmmap (\\a -> if a < 0 then alpha else 1)\n runBackwards _ (S2DV y) (S2DV dEdy) = ((), zipWithVectorInPlaceSnd reluDif y dEdy `seq` S2DV dEdy)\n runBackwards x y dEdy = runBackwards x y (toLayerShape y dEdy)\n\ninstance (KnownNat i, KnownNat j, KnownNat k) => Layer LeakyRelu ('D3 i j k) ('D3 i j k) where\n\n type Tape LeakyRelu ('D3 i j k) ('D3 i j k) = S ('D3 i j k)\n\n runForwards _ (S3D y) = (S3D y, S3D (relu y))\n where\n relu = LAS.dmmap (\\a -> if a < 0 then alpha * a else a)\n runBackwards _ (S3D y) (S3D dEdy) = ((), S3D (relu' y * dEdy))\n where\n relu' = LAS.dmmap (\\a -> if a < 0 then alpha else 1)\n\nalpha :: RealNum\nalpha = 0.02\n\nreluDif :: RealNum -> RealNum -> RealNum\nreluDif a g\n | a < 0 = alpha * g\n | otherwise = g\n\n\n-------------------- DynamicNetwork instance --------------------\n\ninstance FromDynamicLayer LeakyRelu where\n fromDynamicLayer inp _ _ = SpecNetLayer $ SpecLeakyRelu (tripleFromSomeShape inp)\n\ninstance ToDynamicLayer SpecLeakyRelu where\n toDynamicLayer _ _ (SpecLeakyRelu (rows, cols, depth)) =\n reifyNat rows $ \\(_ :: (KnownNat rows) => Proxy rows) ->\n reifyNat cols $ \\(_ :: (KnownNat cols) => Proxy cols) ->\n reifyNat depth $ \\(_ :: (KnownNat depth) => Proxy depth) ->\n case (rows, cols, depth) of\n (_, 1, 1) -> return $ SpecLayer LeakyRelu (sing :: Sing ('D1 rows)) (sing :: Sing ('D1 rows))\n (_, _, 1) -> return $ SpecLayer LeakyRelu (sing :: Sing ('D2 rows cols)) (sing :: Sing ('D2 rows cols))\n _ -> case (unsafeCoerce (Dict :: Dict()) :: Dict (KnownNat (rows GHC.TypeLits.* depth))) of\n Dict -> return $ SpecLayer LeakyRelu (sing :: Sing ('D3 rows cols depth)) (sing :: Sing ('D3 rows cols depth))\n\n\n-- | Create a specification for a elu layer.\nspecLeakyRelu1D :: Integer -> SpecNet\nspecLeakyRelu1D i = specLeakyRelu3D (i, 1, 1)\n\n-- | Create a specification for a elu layer.\nspecLeakyRelu2D :: (Integer, Integer) -> SpecNet\nspecLeakyRelu2D (i, j) = specLeakyRelu3D (i, j, 1)\n\n-- | Create a specification for a elu layer.\nspecLeakyRelu3D :: (Integer, Integer, Integer) -> SpecNet\nspecLeakyRelu3D = SpecNetLayer . SpecLeakyRelu\n\n\n-- | Add a LeakyRelu layer to your build.\nleakyRelu :: BuildM ()\nleakyRelu = buildGetLastLayerOut >>= buildAddSpec . SpecNetLayer . SpecLeakyRelu\n\n\n-------------------- GNum instances --------------------\n\ninstance GNum LeakyRelu where\n _ |* LeakyRelu = LeakyRelu\n _ |+ LeakyRelu = LeakyRelu\n", "meta": {"hexsha": "685a0f29f3be8327c75ef4ffc37e756de1e30279", "size": 5474, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/Grenade/Layers/LeakyRelu.hs", "max_stars_repo_name": "schnecki/grenade", "max_stars_repo_head_hexsha": "027e9c16899e2ca3685e89338a047488ac834249", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-01-11T15:05:38.000Z", "max_stars_repo_stars_event_max_datetime": "2021-01-11T15:05:38.000Z", "max_issues_repo_path": "src/Grenade/Layers/LeakyRelu.hs", "max_issues_repo_name": "schnecki/grenade", "max_issues_repo_head_hexsha": "027e9c16899e2ca3685e89338a047488ac834249", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/Grenade/Layers/LeakyRelu.hs", "max_forks_repo_name": "schnecki/grenade", "max_forks_repo_head_hexsha": "027e9c16899e2ca3685e89338a047488ac834249", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2018-07-02T01:04:29.000Z", "max_forks_repo_forks_event_max_datetime": "2021-01-08T13:08:47.000Z", "avg_line_length": 36.2516556291, "max_line_length": 121, "alphanum_fraction": 0.624588966, "num_tokens": 1754, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.6224593312018546, "lm_q2_score": 0.5583269943353745, "lm_q1q2_score": 0.34753584748593885}} {"text": "{-# LANGUAGE BangPatterns #-}\n{-# LANGUAGE FlexibleInstances #-}\n{-# LANGUAGE LambdaCase #-}\n{-# LANGUAGE RecordWildCards #-}\n\nmodule Numeric.LinearAlgebra.Arnoldi\n ( Arpack, eig\n -- * Options\n , Options(..), Which(..)\n -- * Exceptions\n , MaxIterations(..)\n , NoShifts(..)\n , Reallocate(..)\n , XYAUPD(..)\n , XYEUPD(..)\n , Unimplemented(..)\n ) where\n\nimport Data.Vector.Storable (Vector)\nimport Data.Vector.Storable.Mutable (IOVector)\nimport Numeric.LinearAlgebra (Matrix)\nimport System.IO.Unsafe (unsafePerformIO)\n\nimport Arpack.Exceptions\nimport Arpack.Foreign\nimport Arpack.Options\n\neig :: Arpack t => Options t -> Int -> (IOVector t -> IOVector t -> IO ())\n -> (Vector t, Matrix t)\neig !options !dim !multiply = unsafePerformIO (arpack options dim multiply)\n", "meta": {"hexsha": "9b113dfe26b5e723baeb39e00383dc3bc9d6703d", "size": 834, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/Numeric/LinearAlgebra/Arnoldi.hs", "max_stars_repo_name": "ttuegel/arpack", "max_stars_repo_head_hexsha": "004b7b4444f2ab7b2b1c07ed6aecf279e330f9a5", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2019-12-17T01:05:40.000Z", "max_stars_repo_stars_event_max_datetime": "2019-12-17T01:05:40.000Z", "max_issues_repo_path": "src/Numeric/LinearAlgebra/Arnoldi.hs", "max_issues_repo_name": "ttuegel/arpack", "max_issues_repo_head_hexsha": "004b7b4444f2ab7b2b1c07ed6aecf279e330f9a5", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2016-09-30T09:59:48.000Z", "max_issues_repo_issues_event_max_datetime": "2016-09-30T19:56:06.000Z", "max_forks_repo_path": "src/Numeric/LinearAlgebra/Arnoldi.hs", "max_forks_repo_name": "ttuegel/arpack", "max_forks_repo_head_hexsha": "004b7b4444f2ab7b2b1c07ed6aecf279e330f9a5", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 26.9032258065, "max_line_length": 75, "alphanum_fraction": 0.6342925659, "num_tokens": 204, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES\n\n", "lm_q1_score": 0.6688802603710086, "lm_q2_score": 0.519521321952093, "lm_q1q2_score": 0.34749755709560654}} {"text": "{-# LANGUAGE BangPatterns #-}\n{-# LANGUAGE ConstrainedClassMethods #-}\n{-# LANGUAGE DeriveGeneric #-}\n{-# LANGUAGE FlexibleContexts #-}\n{-# LANGUAGE FlexibleInstances #-}\n{-# LANGUAGE ForeignFunctionInterface #-}\n{-# LANGUAGE TypeFamilies #-}\n{-# LANGUAGE TypeOperators #-}\n{-# LANGUAGE ViewPatterns #-}\n\n-- |\n-- Module : Internal.Matrix\n-- Copyright : (c) Alberto Ruiz 2007-15\n-- License : BSD3\n-- Maintainer : Alberto Ruiz\n-- Stability : provisional\n--\n-- Internal matrix representation\n--\n\nmodule Internal.Matrix where\n\nimport Control.DeepSeq (NFData (..))\nimport Data.Complex (Complex)\nimport Foreign.C.String (CString, newCString)\nimport Foreign.C.Types (CInt (..))\nimport Foreign.Marshal.Alloc (free)\nimport Foreign.Marshal.Array (newArray)\nimport Foreign.Ptr (Ptr)\nimport Foreign.Storable (Storable)\nimport Internal.Devel\nimport Internal.Vector\nimport Internal.Vectorized hiding (( # ), ( #! ))\nimport System.IO.Unsafe (unsafePerformIO)\nimport Text.Printf\n\n-----------------------------------------------------------------\n\ndata MatrixOrder = RowMajor | ColumnMajor deriving (Show,Eq)\n\n-- | Matrix representation suitable for BLAS\\/LAPACK computations.\n\ndata Matrix t = Matrix\n { irows :: {-# UNPACK #-} !Int\n , icols :: {-# UNPACK #-} !Int\n , xRow :: {-# UNPACK #-} !Int\n , xCol :: {-# UNPACK #-} !Int\n , xdat :: {-# UNPACK #-} !(Vector t)\n }\n\n\nrows :: Matrix t -> Int\nrows = irows\n{-# INLINE rows #-}\n\ncols :: Matrix t -> Int\ncols = icols\n{-# INLINE cols #-}\n\nsize :: Matrix t -> (Int, Int)\nsize m = (irows m, icols m)\n{-# INLINE size #-}\n\nrowOrder :: Matrix t -> Bool\nrowOrder m = xCol m == 1 || cols m == 1\n{-# INLINE rowOrder #-}\n\ncolOrder :: Matrix t -> Bool\ncolOrder m = xRow m == 1 || rows m == 1\n{-# INLINE colOrder #-}\n\nis1d :: Matrix t -> Bool\nis1d (size->(r,c)) = r==1 || c==1\n{-# INLINE is1d #-}\n\n-- data is not contiguous\nisSlice :: Storable t => Matrix t -> Bool\nisSlice m@(size->(r,c)) = r*c < dim (xdat m)\n{-# INLINE isSlice #-}\n\norderOf :: Matrix t -> MatrixOrder\norderOf m = if rowOrder m then RowMajor else ColumnMajor\n\n\nshowInternal :: Storable t => Matrix t -> IO ()\nshowInternal m = printf \"%dx%d %s %s %d:%d (%d)\\n\" r c slc ord xr xc dv\n where\n r = rows m\n c = cols m\n xr = xRow m\n xc = xCol m\n slc = if isSlice m then \"slice\" else \"full\"\n ord = if is1d m then \"1d\" else if rowOrder m then \"rows\" else \"cols\"\n dv = dim (xdat m)\n\n--------------------------------------------------------------------------------\n\n-- | Matrix transpose.\ntrans :: Matrix t -> Matrix t\ntrans m@Matrix { irows = r, icols = c, xRow = xr, xCol = xc } =\n m { irows = c, icols = r, xRow = xc, xCol = xr }\n\n\ncmat :: (Element t) => Matrix t -> Matrix t\ncmat m\n | rowOrder m = m\n | otherwise = extractAll RowMajor m\n\n\nfmat :: (Element t) => Matrix t -> Matrix t\nfmat m\n | colOrder m = m\n | otherwise = extractAll ColumnMajor m\n\n\n-- C-Haskell matrix adapters\n{-# INLINE amatr #-}\namatr :: Storable a => Matrix a -> (f -> IO r) -> (CInt -> CInt -> Ptr a -> f) -> IO r\namatr x f g = unsafeWith (xdat x) (f . g r c)\n where\n r = fi (rows x)\n c = fi (cols x)\n\n{-# INLINE amat #-}\namat :: Storable a => Matrix a -> (f -> IO r) -> (CInt -> CInt -> CInt -> CInt -> Ptr a -> f) -> IO r\namat x f g = unsafeWith (xdat x) (f . g r c sr sc)\n where\n r = fi (rows x)\n c = fi (cols x)\n sr = fi (xRow x)\n sc = fi (xCol x)\n\n\ninstance Storable t => TransArray (Matrix t)\n where\n type TransRaw (Matrix t) b = CInt -> CInt -> Ptr t -> b\n type Trans (Matrix t) b = CInt -> CInt -> CInt -> CInt -> Ptr t -> b\n apply = amat\n {-# INLINE apply #-}\n applyRaw = amatr\n {-# INLINE applyRaw #-}\n\ninfixr 1 #\n(#) :: TransArray c => c -> (b -> IO r) -> Trans c b -> IO r\na # b = apply a b\n{-# INLINE (#) #-}\n\n(#!) :: (TransArray c, TransArray c1) => c1 -> c -> Trans c1 (Trans c (IO r)) -> IO r\na #! b = a # b # id\n{-# INLINE (#!) #-}\n\n--------------------------------------------------------------------------------\n\ncopy :: Element t => MatrixOrder -> Matrix t -> IO (Matrix t)\ncopy ord m = extractR ord m 0 (idxs[0,rows m-1]) 0 (idxs[0,cols m-1])\n\nextractAll :: Element t => MatrixOrder -> Matrix t -> Matrix t\nextractAll ord m = unsafePerformIO (copy ord m)\n\n{- | Creates a vector by concatenation of rows. If the matrix is ColumnMajor, this operation requires a transpose.\n\n>>> flatten (ident 3)\n[1.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,1.0]\nit :: (Num t, Element t) => Vector t\n\n-}\nflatten :: Element t => Matrix t -> Vector t\nflatten m\n | isSlice m || not (rowOrder m) = xdat (extractAll RowMajor m)\n | otherwise = xdat m\n\n\n-- | the inverse of 'Data.Packed.Matrix.fromLists'\ntoLists :: (Element t) => Matrix t -> [[t]]\ntoLists = map toList . toRows\n\n\n-- | common value with \\\"adaptable\\\" 1\ncompatdim :: [Int] -> Maybe Int\ncompatdim [] = Nothing\ncompatdim [a] = Just a\ncompatdim (a:b:xs)\n | a==b = compatdim (b:xs)\n | a==1 = compatdim (b:xs)\n | b==1 = compatdim (a:xs)\n | otherwise = Nothing\n\n\n-- | Create a matrix from a list of vectors.\n-- All vectors must have the same dimension,\n-- or dimension 1, which is are automatically expanded.\nfromRows :: Element t => [Vector t] -> Matrix t\nfromRows [] = emptyM 0 0\nfromRows vs = case compatdim (map dim vs) of\n Nothing -> error $ \"fromRows expects vectors with equal sizes (or singletons), given: \" ++ show (map dim vs)\n Just 0 -> emptyM r 0\n Just c -> matrixFromVector RowMajor r c . vjoin . map (adapt c) $ vs\n where\n r = length vs\n adapt c v\n | c == 0 = fromList[]\n | dim v == c = v\n | otherwise = constantD (v@>0) c\n\n-- | extracts the rows of a matrix as a list of vectors\ntoRows :: Element t => Matrix t -> [Vector t]\ntoRows m\n | rowOrder m = map sub rowRange\n | otherwise = map ext rowRange\n where\n rowRange = [0..rows m-1]\n sub k = subVector (k*xRow m) (cols m) (xdat m)\n ext k = xdat $ unsafePerformIO $ extractR RowMajor m 1 (idxs[k]) 0 (idxs[0,cols m-1])\n\n\n-- | Creates a matrix from a list of vectors, as columns\nfromColumns :: Element t => [Vector t] -> Matrix t\nfromColumns m = trans . fromRows $ m\n\n-- | Creates a list of vectors from the columns of a matrix\ntoColumns :: Element t => Matrix t -> [Vector t]\ntoColumns m = toRows . trans $ m\n\n-- | Reads a matrix position.\n(@@>) :: Storable t => Matrix t -> (Int,Int) -> t\ninfixl 9 @@>\nm@Matrix {irows = r, icols = c} @@> (i,j)\n | i<0 || i>=r || j<0 || j>=c = error \"matrix indexing out of range\"\n | otherwise = atM' m i j\n{-# INLINE (@@>) #-}\n\n-- Unsafe matrix access without range checking\natM' :: Storable t => Matrix t -> Int -> Int -> t\natM' m i j = xdat m `at'` (i * (xRow m) + j * (xCol m))\n{-# INLINE atM' #-}\n\n------------------------------------------------------------------\n\nmatrixFromVector :: Storable t => MatrixOrder -> Int -> Int -> Vector t -> Matrix t\nmatrixFromVector _ 1 _ v@(dim->d) = Matrix { irows = 1, icols = d, xdat = v, xRow = d, xCol = 1 }\nmatrixFromVector _ _ 1 v@(dim->d) = Matrix { irows = d, icols = 1, xdat = v, xRow = 1, xCol = d }\nmatrixFromVector o r c v\n | r * c == dim v = m\n | otherwise = error $ \"can't reshape vector dim = \"++ show (dim v)++\" to matrix \" ++ shSize m\n where\n m | o == RowMajor = Matrix { irows = r, icols = c, xdat = v, xRow = c, xCol = 1 }\n | otherwise = Matrix { irows = r, icols = c, xdat = v, xRow = 1, xCol = r }\n\n-- allocates memory for a new matrix\ncreateMatrix :: (Storable a) => MatrixOrder -> Int -> Int -> IO (Matrix a)\ncreateMatrix ord r c = do\n p <- createVector (r*c)\n return (matrixFromVector ord r c p)\n\n{- | Creates a matrix from a vector by grouping the elements in rows with the desired number of columns. (GNU-Octave groups by columns. To do it you can define @reshapeF r = tr' . reshape r@\nwhere r is the desired number of rows.)\n\n>>> reshape 4 (fromList [1..12])\n(3><4)\n [ 1.0, 2.0, 3.0, 4.0\n , 5.0, 6.0, 7.0, 8.0\n , 9.0, 10.0, 11.0, 12.0 ]\n\n-}\nreshape :: Storable t => Int -> Vector t -> Matrix t\nreshape 0 v = matrixFromVector RowMajor 0 0 v\nreshape c v = matrixFromVector RowMajor (dim v `div` c) c v\n\n\n-- | application of a vector function on the flattened matrix elements\nliftMatrix :: (Element a, Element b) => (Vector a -> Vector b) -> Matrix a -> Matrix b\nliftMatrix f m@Matrix { irows = r, icols = c, xdat = d}\n | isSlice m = matrixFromVector RowMajor r c (f (flatten m))\n | otherwise = matrixFromVector (orderOf m) r c (f d)\n\n-- | application of a vector function on the flattened matrices elements\nliftMatrix2 :: (Element t, Element a, Element b) => (Vector a -> Vector b -> Vector t) -> Matrix a -> Matrix b -> Matrix t\nliftMatrix2 f m1@(size->(r,c)) m2\n | (r,c)/=size m2 = error \"nonconformant matrices in liftMatrix2\"\n | rowOrder m1 = matrixFromVector RowMajor r c (f (flatten m1) (flatten m2))\n | otherwise = matrixFromVector ColumnMajor r c (f (flatten (trans m1)) (flatten (trans m2)))\n\n------------------------------------------------------------------\n\n-- | Supported matrix elements.\nclass (Storable a) => Element a where\n constantD :: a -> Int -> Vector a\n extractR :: MatrixOrder -> Matrix a -> CInt -> Vector CInt -> CInt -> Vector CInt -> IO (Matrix a)\n setRect :: Int -> Int -> Matrix a -> Matrix a -> IO ()\n sortI :: Ord a => Vector a -> Vector CInt\n sortV :: Ord a => Vector a -> Vector a\n compareV :: Ord a => Vector a -> Vector a -> Vector CInt\n selectV :: Vector CInt -> Vector a -> Vector a -> Vector a -> Vector a\n remapM :: Matrix CInt -> Matrix CInt -> Matrix a -> Matrix a\n rowOp :: Int -> a -> Int -> Int -> Int -> Int -> Matrix a -> IO ()\n gemm :: Vector a -> Matrix a -> Matrix a -> Matrix a -> IO ()\n reorderV :: Vector CInt-> Vector CInt-> Vector a -> Vector a -- see reorderVector for documentation\n\n\ninstance Element Float where\n constantD = constantAux cconstantF\n extractR = extractAux c_extractF\n setRect = setRectAux c_setRectF\n sortI = sortIdxF\n sortV = sortValF\n compareV = compareF\n selectV = selectF\n remapM = remapF\n rowOp = rowOpAux c_rowOpF\n gemm = gemmg c_gemmF\n reorderV = reorderAux c_reorderF\n\n-- instance Element Double where\n-- constantD = constantAux cconstantR\n-- extractR = extractAux c_extractD\n-- setRect = setRectAux c_setRectD\n-- sortI = sortIdxD\n-- sortV = sortValD\n-- compareV = compareD\n-- selectV = selectD\n-- remapM = remapD\n-- rowOp = rowOpAux c_rowOpD\n-- gemm = gemmg c_gemmD\n-- reorderV = reorderAux c_reorderD\n\ninstance Element (Complex Float) where\n constantD = constantAux cconstantQ\n extractR = extractAux c_extractQ\n setRect = setRectAux c_setRectQ\n sortI = undefined\n sortV = undefined\n compareV = undefined\n selectV = selectQ\n remapM = remapQ\n rowOp = rowOpAux c_rowOpQ\n gemm = gemmg c_gemmQ\n reorderV = reorderAux c_reorderQ\n\n-- instance Element (Complex Double) where\n-- constantD = constantAux cconstantC\n-- extractR = extractAux c_extractC\n-- setRect = setRectAux c_setRectC\n-- sortI = undefined\n-- sortV = undefined\n-- compareV = undefined\n-- selectV = selectC\n-- remapM = remapC\n-- rowOp = rowOpAux c_rowOpC\n-- gemm = gemmg c_gemmC\n-- reorderV = reorderAux c_reorderC\n\ninstance Element (CInt) where\n constantD = constantAux cconstantI\n extractR = extractAux c_extractI\n setRect = setRectAux c_setRectI\n sortI = sortIdxI\n sortV = sortValI\n compareV = compareI\n selectV = selectI\n remapM = remapI\n rowOp = rowOpAux c_rowOpI\n gemm = gemmg c_gemmI\n reorderV = reorderAux c_reorderI\n\ninstance Element Z where\n constantD = constantAux cconstantL\n extractR = extractAux c_extractL\n setRect = setRectAux c_setRectL\n sortI = sortIdxL\n sortV = sortValL\n compareV = compareL\n selectV = selectL\n remapM = remapL\n rowOp = rowOpAux c_rowOpL\n gemm = gemmg c_gemmL\n reorderV = reorderAux c_reorderL\n\n-------------------------------------------------------------------\n\n-- | reference to a rectangular slice of a matrix (no data copy)\nsubMatrix :: Element a\n => (Int,Int) -- ^ (r0,c0) starting position\n -> (Int,Int) -- ^ (rt,ct) dimensions of submatrix\n -> Matrix a -- ^ input matrix\n -> Matrix a -- ^ result\nsubMatrix (r0,c0) (rt,ct) m\n | rt <= 0 || ct <= 0 = matrixFromVector RowMajor (max 0 rt) (max 0 ct) (fromList [])\n | 0 <= r0 && 0 <= rt && r0+rt <= rows m &&\n 0 <= c0 && 0 <= ct && c0+ct <= cols m = res\n | otherwise = error $ \"wrong subMatrix \"++show ((r0,c0),(rt,ct))++\" of \"++shSize m\n where\n p = r0 * xRow m + c0 * xCol m\n tot | rowOrder m = ct + (rt-1) * xRow m\n | otherwise = rt + (ct-1) * xCol m\n res = m { irows = rt, icols = ct, xdat = subVector p tot (xdat m) }\n\n--------------------------------------------------------------------------\n\nmaxZ :: (Num t1, Ord t1, Foldable t) => t t1 -> t1\nmaxZ xs = if minimum xs == 0 then 0 else maximum xs\n\nconformMs :: Element t => [Matrix t] -> [Matrix t]\nconformMs ms = map (conformMTo (r,c)) ms\n where\n r = maxZ (map rows ms)\n c = maxZ (map cols ms)\n\nconformVs :: Element t => [Vector t] -> [Vector t]\nconformVs vs = map (conformVTo n) vs\n where\n n = maxZ (map dim vs)\n\nconformMTo :: Element t => (Int, Int) -> Matrix t -> Matrix t\nconformMTo (r,c) m\n | size m == (r,c) = m\n | size m == (1,1) = matrixFromVector RowMajor r c (constantD (m@@>(0,0)) (r*c))\n | size m == (r,1) = repCols c m\n | size m == (1,c) = repRows r m\n | otherwise = error $ \"matrix \" ++ shSize m ++ \" cannot be expanded to \" ++ shDim (r,c)\n\nconformVTo :: Element t => Int -> Vector t -> Vector t\nconformVTo n v\n | dim v == n = v\n | dim v == 1 = constantD (v@>0) n\n | otherwise = error $ \"vector of dim=\" ++ show (dim v) ++ \" cannot be expanded to dim=\" ++ show n\n\nrepRows :: Element t => Int -> Matrix t -> Matrix t\nrepRows n x = fromRows (replicate n (flatten x))\nrepCols :: Element t => Int -> Matrix t -> Matrix t\nrepCols n x = fromColumns (replicate n (flatten x))\n\nshSize :: Matrix t -> [Char]\nshSize = shDim . size\n\nshDim :: (Show a, Show a1) => (a1, a) -> [Char]\nshDim (r,c) = \"(\" ++ show r ++\"x\"++ show c ++\")\"\n\nemptyM :: Storable t => Int -> Int -> Matrix t\nemptyM r c = matrixFromVector RowMajor r c (fromList[])\n\n----------------------------------------------------------------------\n\ninstance (Storable t, NFData t) => NFData (Matrix t)\n where\n rnf m | d > 0 = rnf (v @> 0)\n | otherwise = ()\n where\n d = dim v\n v = xdat m\n\n---------------------------------------------------------------\n\nextractAux :: (Eq t3, Eq t2, TransArray c, Storable a, Storable t1,\n Storable t, Num t3, Num t2, Integral t1, Integral t)\n => (t3 -> t2 -> CInt -> Ptr t1 -> CInt -> Ptr t\n -> Trans c (CInt -> CInt -> CInt -> CInt -> Ptr a -> IO CInt))\n -> MatrixOrder -> c -> t3 -> Vector t1 -> t2 -> Vector t -> IO (Matrix a)\nextractAux f ord m moder vr modec vc = do\n let nr = if moder == 0 then fromIntegral $ vr@>1 - vr@>0 + 1 else dim vr\n nc = if modec == 0 then fromIntegral $ vc@>1 - vc@>0 + 1 else dim vc\n r <- createMatrix ord nr nc\n (vr # vc # m #! r) (f moder modec) #|\"extract\"\n\n return r\n\ntype Extr x = CInt -> CInt -> CIdxs (CIdxs (OM x (OM x (IO CInt))))\n\n-- foreign import ccall unsafe \"extractD\" c_extractD :: Extr Double\nforeign import ccall unsafe \"extractF\" c_extractF :: Extr Float\n-- foreign import ccall unsafe \"extractC\" c_extractC :: Extr (Complex Double)\nforeign import ccall unsafe \"extractQ\" c_extractQ :: Extr (Complex Float)\nforeign import ccall unsafe \"extractI\" c_extractI :: Extr CInt\nforeign import ccall unsafe \"extractL\" c_extractL :: Extr Z\n\n---------------------------------------------------------------\n\nsetRectAux :: (TransArray c1, TransArray c)\n => (CInt -> CInt -> Trans c1 (Trans c (IO CInt)))\n -> Int -> Int -> c1 -> c -> IO ()\nsetRectAux f i j m r = (m #! r) (f (fi i) (fi j)) #|\"setRect\"\n\ntype SetRect x = I -> I -> x ::> x::> Ok\n\n-- foreign import ccall unsafe \"setRectD\" c_setRectD :: SetRect Double\nforeign import ccall unsafe \"setRectF\" c_setRectF :: SetRect Float\n-- foreign import ccall unsafe \"setRectC\" c_setRectC :: SetRect (Complex Double)\nforeign import ccall unsafe \"setRectQ\" c_setRectQ :: SetRect (Complex Float)\nforeign import ccall unsafe \"setRectI\" c_setRectI :: SetRect I\nforeign import ccall unsafe \"setRectL\" c_setRectL :: SetRect Z\n\n--------------------------------------------------------------------------------\n\nsortG :: (Storable t, Storable a)\n => (CInt -> Ptr t -> CInt -> Ptr a -> IO CInt) -> Vector t -> Vector a\nsortG f v = unsafePerformIO $ do\n r <- createVector (dim v)\n (v #! r) f #|\"sortG\"\n return r\n\n-- sortIdxD :: Vector Double -> Vector CInt\n-- sortIdxD = sortG c_sort_indexD\nsortIdxF :: Vector Float -> Vector CInt\nsortIdxF = sortG c_sort_indexF\nsortIdxI :: Vector CInt -> Vector CInt\nsortIdxI = sortG c_sort_indexI\nsortIdxL :: Vector Z -> Vector I\nsortIdxL = sortG c_sort_indexL\n\n-- sortValD :: Vector Double -> Vector Double\n-- sortValD = sortG c_sort_valD\nsortValF :: Vector Float -> Vector Float\nsortValF = sortG c_sort_valF\nsortValI :: Vector CInt -> Vector CInt\nsortValI = sortG c_sort_valI\nsortValL :: Vector Z -> Vector Z\nsortValL = sortG c_sort_valL\n\n-- foreign import ccall unsafe \"sort_indexD\" c_sort_indexD :: CV Double (CV CInt (IO CInt))\nforeign import ccall unsafe \"sort_indexF\" c_sort_indexF :: CV Float (CV CInt (IO CInt))\nforeign import ccall unsafe \"sort_indexI\" c_sort_indexI :: CV CInt (CV CInt (IO CInt))\nforeign import ccall unsafe \"sort_indexL\" c_sort_indexL :: Z :> I :> Ok\n\n-- foreign import ccall unsafe \"sort_valuesD\" c_sort_valD :: CV Double (CV Double (IO CInt))\nforeign import ccall unsafe \"sort_valuesF\" c_sort_valF :: CV Float (CV Float (IO CInt))\nforeign import ccall unsafe \"sort_valuesI\" c_sort_valI :: CV CInt (CV CInt (IO CInt))\nforeign import ccall unsafe \"sort_valuesL\" c_sort_valL :: Z :> Z :> Ok\n\n--------------------------------------------------------------------------------\n\ncompareG :: (TransArray c, Storable t, Storable a)\n => Trans c (CInt -> Ptr t -> CInt -> Ptr a -> IO CInt)\n -> c -> Vector t -> Vector a\ncompareG f u v = unsafePerformIO $ do\n r <- createVector (dim v)\n (u # v #! r) f #|\"compareG\"\n return r\n\n-- compareD :: Vector Double -> Vector Double -> Vector CInt\n-- compareD = compareG c_compareD\ncompareF :: Vector Float -> Vector Float -> Vector CInt\ncompareF = compareG c_compareF\ncompareI :: Vector CInt -> Vector CInt -> Vector CInt\ncompareI = compareG c_compareI\ncompareL :: Vector Z -> Vector Z -> Vector CInt\ncompareL = compareG c_compareL\n\n-- foreign import ccall unsafe \"compareD\" c_compareD :: CV Double (CV Double (CV CInt (IO CInt)))\nforeign import ccall unsafe \"compareF\" c_compareF :: CV Float (CV Float (CV CInt (IO CInt)))\nforeign import ccall unsafe \"compareI\" c_compareI :: CV CInt (CV CInt (CV CInt (IO CInt)))\nforeign import ccall unsafe \"compareL\" c_compareL :: Z :> Z :> I :> Ok\n\n--------------------------------------------------------------------------------\n\nselectG :: (TransArray c, TransArray c1, TransArray c2, Storable t, Storable a)\n => Trans c2 (Trans c1 (CInt -> Ptr t -> Trans c (CInt -> Ptr a -> IO CInt)))\n -> c2 -> c1 -> Vector t -> c -> Vector a\nselectG f c u v w = unsafePerformIO $ do\n r <- createVector (dim v)\n (c # u # v # w #! r) f #|\"selectG\"\n return r\n\n-- selectD :: Vector CInt -> Vector Double -> Vector Double -> Vector Double -> Vector Double\n-- selectD = selectG c_selectD\nselectF :: Vector CInt -> Vector Float -> Vector Float -> Vector Float -> Vector Float\nselectF = selectG c_selectF\nselectI :: Vector CInt -> Vector CInt -> Vector CInt -> Vector CInt -> Vector CInt\nselectI = selectG c_selectI\nselectL :: Vector CInt -> Vector Z -> Vector Z -> Vector Z -> Vector Z\nselectL = selectG c_selectL\n-- selectC :: Vector CInt\n-- -> Vector (Complex Double)\n-- -> Vector (Complex Double)\n-- -> Vector (Complex Double)\n-- -> Vector (Complex Double)\n-- selectC = selectG c_selectC\nselectQ :: Vector CInt\n -> Vector (Complex Float)\n -> Vector (Complex Float)\n -> Vector (Complex Float)\n -> Vector (Complex Float)\nselectQ = selectG c_selectQ\n\ntype Sel x = CV CInt (CV x (CV x (CV x (CV x (IO CInt)))))\n\n-- foreign import ccall unsafe \"chooseD\" c_selectD :: Sel Double\nforeign import ccall unsafe \"chooseF\" c_selectF :: Sel Float\nforeign import ccall unsafe \"chooseI\" c_selectI :: Sel CInt\n-- foreign import ccall unsafe \"chooseC\" c_selectC :: Sel (Complex Double)\nforeign import ccall unsafe \"chooseQ\" c_selectQ :: Sel (Complex Float)\nforeign import ccall unsafe \"chooseL\" c_selectL :: Sel Z\n\n---------------------------------------------------------------------------\n\nremapG :: (TransArray c, TransArray c1, Storable t, Storable a)\n => (CInt -> CInt -> CInt -> CInt -> Ptr t\n -> Trans c1 (Trans c (CInt -> CInt -> CInt -> CInt -> Ptr a -> IO CInt)))\n -> Matrix t -> c1 -> c -> Matrix a\nremapG f i j m = unsafePerformIO $ do\n r <- createMatrix RowMajor (rows i) (cols i)\n (i # j # m #! r) f #|\"remapG\"\n return r\n\n-- remapD :: Matrix CInt -> Matrix CInt -> Matrix Double -> Matrix Double\n-- remapD = remapG c_remapD\nremapF :: Matrix CInt -> Matrix CInt -> Matrix Float -> Matrix Float\nremapF = remapG c_remapF\nremapI :: Matrix CInt -> Matrix CInt -> Matrix CInt -> Matrix CInt\nremapI = remapG c_remapI\nremapL :: Matrix CInt -> Matrix CInt -> Matrix Z -> Matrix Z\nremapL = remapG c_remapL\n-- remapC :: Matrix CInt\n-- -> Matrix CInt\n-- -> Matrix (Complex Double)\n-- -> Matrix (Complex Double)\n-- remapC = remapG c_remapC\nremapQ :: Matrix CInt -> Matrix CInt -> Matrix (Complex Float) -> Matrix (Complex Float)\nremapQ = remapG c_remapQ\n\ntype Rem x = OM CInt (OM CInt (OM x (OM x (IO CInt))))\n\n-- foreign import ccall unsafe \"remapD\" c_remapD :: Rem Double\nforeign import ccall unsafe \"remapF\" c_remapF :: Rem Float\nforeign import ccall unsafe \"remapI\" c_remapI :: Rem CInt\n-- foreign import ccall unsafe \"remapC\" c_remapC :: Rem (Complex Double)\nforeign import ccall unsafe \"remapQ\" c_remapQ :: Rem (Complex Float)\nforeign import ccall unsafe \"remapL\" c_remapL :: Rem Z\n\n--------------------------------------------------------------------------------\n\nrowOpAux :: (TransArray c, Storable a) =>\n (CInt -> Ptr a -> CInt -> CInt -> CInt -> CInt -> Trans c (IO CInt))\n -> Int -> a -> Int -> Int -> Int -> Int -> c -> IO ()\nrowOpAux f c x i1 i2 j1 j2 m = do\n px <- newArray [x]\n (m # id) (f (fi c) px (fi i1) (fi i2) (fi j1) (fi j2)) #|\"rowOp\"\n free px\n\ntype RowOp x = CInt -> Ptr x -> CInt -> CInt -> CInt -> CInt -> x ::> Ok\n\n-- foreign import ccall unsafe \"rowop_double\" c_rowOpD :: RowOp R\nforeign import ccall unsafe \"rowop_float\" c_rowOpF :: RowOp Float\n-- foreign import ccall unsafe \"rowop_TCD\" c_rowOpC :: RowOp C\nforeign import ccall unsafe \"rowop_TCS\" c_rowOpQ :: RowOp (Complex Float)\nforeign import ccall unsafe \"rowop_int32_t\" c_rowOpI :: RowOp I\nforeign import ccall unsafe \"rowop_int64_t\" c_rowOpL :: RowOp Z\nforeign import ccall unsafe \"rowop_mod_int32_t\" c_rowOpMI :: I -> RowOp I\nforeign import ccall unsafe \"rowop_mod_int64_t\" c_rowOpML :: Z -> RowOp Z\n\n--------------------------------------------------------------------------------\n\ngemmg :: (TransArray c1, TransArray c, TransArray c2, TransArray c3)\n => Trans c3 (Trans c2 (Trans c1 (Trans c (IO CInt))))\n -> c3 -> c2 -> c1 -> c -> IO ()\ngemmg f v m1 m2 m3 = (v # m1 # m2 #! m3) f #|\"gemmg\"\n\ntype Tgemm x = x :> x ::> x ::> x ::> Ok\n\n-- foreign import ccall unsafe \"gemm_double\" c_gemmD :: Tgemm R\nforeign import ccall unsafe \"gemm_float\" c_gemmF :: Tgemm Float\n-- foreign import ccall unsafe \"gemm_TCD\" c_gemmC :: Tgemm C\nforeign import ccall unsafe \"gemm_TCS\" c_gemmQ :: Tgemm (Complex Float)\nforeign import ccall unsafe \"gemm_int32_t\" c_gemmI :: Tgemm I\nforeign import ccall unsafe \"gemm_int64_t\" c_gemmL :: Tgemm Z\nforeign import ccall unsafe \"gemm_mod_int32_t\" c_gemmMI :: I -> Tgemm I\nforeign import ccall unsafe \"gemm_mod_int64_t\" c_gemmML :: Z -> Tgemm Z\n\n--------------------------------------------------------------------------------\n\nreorderAux :: (TransArray c, Storable t, Storable a1, Storable t1, Storable a) =>\n (CInt -> Ptr a -> CInt -> Ptr t1\n -> Trans c (CInt -> Ptr t -> CInt -> Ptr a1 -> IO CInt))\n -> Vector t1 -> c -> Vector t -> Vector a1\nreorderAux f s d v = unsafePerformIO $ do\n k <- createVector (dim s)\n r <- createVector (dim v)\n (k # s # d # v #! r) f #| \"reorderV\"\n return r\n\ntype Reorder x = CV CInt (CV CInt (CV CInt (CV x (CV x (IO CInt)))))\n\n-- foreign import ccall unsafe \"reorderD\" c_reorderD :: Reorder Double\nforeign import ccall unsafe \"reorderF\" c_reorderF :: Reorder Float\nforeign import ccall unsafe \"reorderI\" c_reorderI :: Reorder CInt\n-- foreign import ccall unsafe \"reorderC\" c_reorderC :: Reorder (Complex Double)\nforeign import ccall unsafe \"reorderQ\" c_reorderQ :: Reorder (Complex Float)\nforeign import ccall unsafe \"reorderL\" c_reorderL :: Reorder Z\n\n-- | Transpose an array with dimensions @dims@ by making a copy using @strides@. For example, for an array with 3 indices,\n-- @(reorderVector strides dims v) ! ((i * dims ! 1 + j) * dims ! 2 + k) == v ! (i * strides ! 0 + j * strides ! 1 + k * strides ! 2)@\n-- This function is intended to be used internally by tensor libraries.\nreorderVector :: Element a\n => Vector CInt -- ^ @strides@: array strides\n -> Vector CInt -- ^ @dims@: array dimensions of new array @v@\n -> Vector a -- ^ @v@: flattened input array\n -> Vector a -- ^ @v'@: flattened output array\nreorderVector = reorderV\n\n--------------------------------------------------------------------------------\n\nforeign import ccall unsafe \"saveMatrix\" c_saveMatrix\n :: CString -> CString -> Double ::> Ok\n\n{- | save a matrix as a 2D ASCII table\n-}\nsaveMatrix\n :: FilePath\n -> String -- ^ \\\"printf\\\" format (e.g. \\\"%.2f\\\", \\\"%g\\\", etc.)\n -> Matrix Double\n -> IO ()\nsaveMatrix name format m = do\n cname <- newCString name\n cformat <- newCString format\n (m # id) (c_saveMatrix cname cformat) #|\"saveMatrix\"\n free cname\n free cformat\n return ()\n\n--------------------------------------------------------------------------------\n", "meta": {"hexsha": "aaf12f885877145485afefd1fb132d4c9c1d0aa2", "size": 27088, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/Internal/Matrix.hs", "max_stars_repo_name": "schnecki/hmatrix-float", "max_stars_repo_head_hexsha": "20ad30db8edb97ce735d8218937f9ded878e3217", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/Internal/Matrix.hs", "max_issues_repo_name": "schnecki/hmatrix-float", "max_issues_repo_head_hexsha": "20ad30db8edb97ce735d8218937f9ded878e3217", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/Internal/Matrix.hs", "max_forks_repo_name": "schnecki/hmatrix-float", "max_forks_repo_head_hexsha": "20ad30db8edb97ce735d8218937f9ded878e3217", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-01-12T02:51:35.000Z", "max_forks_repo_forks_event_max_datetime": "2021-01-12T02:51:35.000Z", "avg_line_length": 37.6745479833, "max_line_length": 190, "alphanum_fraction": 0.5831733609, "num_tokens": 8125, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.658417487156366, "lm_q2_score": 0.5273165233795671, "lm_q1q2_score": 0.34719442025960573}} {"text": "{-# LANGUAGE OverloadedStrings #-}\nmodule Lisp.PrintSpec (spec) where\n\nimport Data.Complex\nimport Data.Ratio\nimport Data.Text\nimport Test.Hspec\nimport Test.QuickCheck\n\nimport Lisp\n\nspec :: Spec\n\nspec = do\n let foo = Symbol \"foo\"\n let bar = Symbol \"bar\"\n \n describe \"LispVal.pp\" $ do\n it \"prints symbols as its own value\" $ \n pp foo `shouldBe` \"foo\"\n\n it \"QuickCheck symbols print as their own value\" $ \n property $ \\s -> let t = pack s in pp (Symbol t) == t\n\n it \"prints integers as their own value\" $ \n pp (Int 5) `shouldBe` \"5\"\n\n it \"prints decimals as thier own value\" $ \n pp (Real 3.14) `shouldBe` \"3.14\"\n\n it \"prints rationals as their own value, lisp-style\" $\n pp (Rational (3%4)) `shouldBe` \"3/4\"\n\n it \"prints rationals reduced\" $\n pp (Rational (4%8)) `shouldBe` \"1/2\"\n\n it \"prints complex number as their own value, lisp-style\" $\n pp (Complex (3:+4)) `shouldBe` \"3.0+4.0i\"\n\n it \"prints strings in quotes\" $ \n pp (String \"foo\") `shouldBe` \"\\\"foo\\\"\"\n \n it \"prints true as #t\" $ \n pp (Bool True) `shouldBe` \"#t\"\n\n it \"prints false as #f\" $ \n pp (Bool False) `shouldBe` \"#f\"\n\n it \"prints nils/empty lists as ()\" $ \n pp Nil `shouldBe` \"()\"\n\n it \"prints pairs as dotted pairs\" $ \n pp (Pair foo bar) `shouldBe` \"(foo . bar)\"\n\n it \"prints pairs with Nil cdr as singleton lists\" $\n pp (Pair foo Nil) `shouldBe` \"(foo)\"\n \n it \"prints lists as lists\" $ \n pp (Pair foo\n (Pair bar\n (Pair (Int 5)\n (Pair (Bool False) Nil)))) `shouldBe` \"(foo bar 5 #f)\"\n \n it \"prints dotted lists with dots\" $ \n pp (Pair foo\n (Pair bar\n (Pair (Int 5)\n (Pair (Bool False) (Bool True))))) `shouldBe` \"(foo bar 5 #f . #t)\"\n \n", "meta": {"hexsha": "ffc2a7d8dc3373e743f850e9c5ed80be6c362725", "size": 1802, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "tests/Lisp/PrintSpec.hs", "max_stars_repo_name": "blaisepascal/Haskell-LiSP", "max_stars_repo_head_hexsha": "a9478b521f6488b0c557bbcee88cf0d3b38aef6a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-12-15T09:43:08.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-15T09:43:08.000Z", "max_issues_repo_path": "tests/Lisp/PrintSpec.hs", "max_issues_repo_name": "blaisepascal/Haskell-LiSP", "max_issues_repo_head_hexsha": "a9478b521f6488b0c557bbcee88cf0d3b38aef6a", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "tests/Lisp/PrintSpec.hs", "max_forks_repo_name": "blaisepascal/Haskell-LiSP", "max_forks_repo_head_hexsha": "a9478b521f6488b0c557bbcee88cf0d3b38aef6a", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 25.7428571429, "max_line_length": 80, "alphanum_fraction": 0.5693673696, "num_tokens": 541, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.588889130767832, "lm_q2_score": 0.588889130767832, "lm_q1q2_score": 0.3467904083364927}} {"text": "module STCPinwheelCorner where\n\nimport Control.Monad as M\nimport Control.Monad.Parallel as MP\nimport qualified Data.Array.Accelerate as A\nimport Data.Array.Accelerate.LLVM.PTX\nimport Data.Array.IArray as IA\nimport Data.Array.Repa as R\nimport Data.Binary\nimport Data.Complex\nimport Data.List as L\nimport Data.Vector.Storable as VS\nimport Data.Vector.Unboxed as VU\nimport Filter.Utils\nimport FokkerPlanck\nimport Foreign.CUDA.Driver as CUDA\nimport FourierMethod.BlockMatrixAcc\nimport FourierMethod.FourierSeries2D\nimport FourierPinwheel\nimport Image.IO\nimport Pinwheel.FourierSeries2D\nimport STC hiding (convolve)\nimport System.Directory\nimport System.Environment\nimport System.FilePath\nimport Text.Printf\nimport Utils.Array\nimport Utils.Time\n\nmain = do\n args@(deviceIDsStr:numPointsStr:deltaStr:thresholdStr:numPointsReconStr:deltaReconStr:numOrientationStr:numScaleStr:thetaSigmaStr:scaleSigmaStr:tauStr:numR2FreqStr:periodR2Str:phiFreqsStr:rhoFreqsStr:thetaFreqsStr:scaleFreqsStr:initDistStr:initScaleStr:histFilePath:stdR2Str:stdStr:numBatchR2Str:numBatchR2FreqsStr:numBatchOriStr:batchSizeStr:sStr:radiusStr:deltaTStr:weightStr:posStr:numThreadStr:_) <-\n getArgs\n let deviceIDs = read deviceIDsStr :: [Int]\n numPoints = read numPointsStr :: Int\n delta = read deltaStr :: Double\n threshold = read thresholdStr :: Double\n numPointsRecon = read numPointsReconStr :: Int\n deltaRecon = read deltaReconStr :: Double\n numOrientation = read numOrientationStr :: Int\n numScale = read numScaleStr :: Int\n thetaSigma = read thetaSigmaStr :: Double\n scaleSigma = read scaleSigmaStr :: Double\n tau = read tauStr :: Double\n numR2Freq = read numR2FreqStr :: Int\n periodR2 = read periodR2Str :: Double\n phiFreq = read phiFreqsStr :: Int\n phiFreqs = L.map fromIntegral [-phiFreq .. phiFreq]\n rhoFreq = read rhoFreqsStr :: Int\n rhoFreqs = L.map fromIntegral [-rhoFreq .. rhoFreq]\n thetaFreq = read thetaFreqsStr :: Int\n thetaFreqs = L.map fromIntegral [-thetaFreq .. thetaFreq]\n scaleFreq = read scaleFreqsStr :: Int\n scaleFreqs = L.map fromIntegral [-scaleFreq .. scaleFreq]\n initScale = read initScaleStr :: Double\n initDist = read initDistStr :: [(Double, Double, Double, Double)]\n initPoints = L.map (\\(x, y, t, s) -> Point x y t s) initDist\n initSource = [L.head initPoints]\n initSink = [L.last initPoints]\n numThread = read numThreadStr :: Int\n folderPath = \"output/test/STCPinwheelCorner\"\n stdR2 = read stdR2Str :: Double\n std = read stdStr :: Double\n numBatchR2 = read numBatchR2Str :: Int\n numBatchR2Freqs = read numBatchR2FreqsStr :: Int\n numBatchOri = read numBatchOriStr :: Int\n batchSize = read batchSizeStr :: Int\n s = read sStr :: Double\n radius = read radiusStr :: Double\n deltaT = read deltaTStr :: Double\n weight = read weightStr :: Double\n pos = read posStr :: (Int, Int)\n periodEnv = periodR2 ^ 2 / 4\n -- removePathForcibly folderPath\n createDirectoryIfMissing True folderPath\n -- let deltaTheta = 2 * pi / fromIntegral numOrientation\n -- cornerDist =\n -- cornerDistribution\n -- delta\n -- initScale\n -- thetaSigma\n -- tau\n -- threshold\n -- [fromIntegral i * deltaTheta | i <- [0 .. numOrientation - 1]]\n -- weight\n -- pos\n -- idx = [(i, j) | i <- [-10 .. 10], j <- [-10 .. 10]]\n -- xs =\n -- L.map\n -- (\\(i, j) ->\n -- let x = i * delta\n -- y = j * delta\n -- in ( (x, y)\n -- , L.sum $\n -- cornerDistribution\n -- delta\n -- initScale\n -- thetaSigma\n -- tau\n -- threshold\n -- [ fromIntegral o * deltaTheta\n -- | o <- [0 .. numOrientation - 1]\n -- ]\n -- weight\n -- (x, y)))\n -- idx\n -- print . L.sortOn snd $ xs\n -- printf \"%f\\n\" (L.sum cornerDist)\n -- print .\n -- L.sortOn snd .\n -- L.zip\n -- [fromIntegral i * deltaTheta / pi * 180 | i <- [0 .. numOrientation - 1]] $\n -- cornerDist\n -- plotImageRepa (folderPath \"test.png\") .\n -- ImageRepa 8 .\n -- fromListUnboxed (Z :. (1 :: Int) :. (21 :: Int) :. (21 :: Int)) .\n -- snd . L.unzip $\n -- xs\n -- let maxIdx =\n -- fst .\n -- L.maximumBy (\\(_, a) (_, b) -> compare a b) .\n -- L.zip\n -- [ fromIntegral i * deltaTheta / pi * 180\n -- | i <- [0 .. numOrientation - 1]\n -- ] $\n -- cornerDist\n -- maxDist <- cornerDistribution' delta initScale thetaSigma tau threshold [fromIntegral i * deltaTheta | i <- [0 .. numOrientation - 1]] weight pos (maxIdx / 180 * pi)\n -- print maxIdx\n -- print maxDist\n flag <- doesFileExist histFilePath \n initialise []\n devs <- M.mapM device deviceIDs\n ctxs <- M.mapM (\\dev -> CUDA.create dev []) devs\n ptxs <- M.mapM createTargetFromContext ctxs\n hist <-\n if flag\n then do\n printCurrentTime \"read from files...\"\n decodeFile histFilePath\n else sampleCartesianCorner\n histFilePath\n folderPath\n ptxs\n numPoints\n periodEnv\n delta\n numOrientation\n initScale\n thetaSigma\n tau\n threshold\n s\n phiFreq\n rhoFreq\n thetaFreq\n scaleFreq\n stdR2\n weight\n printCurrentTime \"Done\"\n printCurrentTime \"Start Convloution..\"\n plan <-\n makePlan\n folderPath\n emptyPlan\n numPointsRecon\n numPointsRecon\n numR2Freq\n (2 * thetaFreq + 1)\n (2 * scaleFreq + 1)\n (2 * phiFreq + 1)\n (2 * rhoFreq + 1)\n printCurrentTime \"Compute DFT Plan done.\"\n let coefficients = getNormalizedHistogramArr hist\n harmonicsArray <-\n createHarmonics\n numR2Freq\n phiFreq\n rhoFreq\n thetaFreq\n scaleFreq\n (-s)\n periodR2\n periodEnv\n coefficients\n let initDistSource =\n computeInitialDistributionFourierPinwheel\n numR2Freq\n periodR2\n periodEnv\n phiFreq\n rhoFreq\n thetaFreq\n scaleFreq\n initSource\n initDistSink =\n computeInitialDistributionFourierPinwheel\n numR2Freq\n periodR2\n periodEnv\n phiFreq\n rhoFreq\n thetaFreq\n scaleFreq\n initSink\n source <- convolve harmonicsArray initDistSource\n sink <- convolve harmonicsArray initDistSink\n sourceR2 <- plotFPArray plan (folderPath \"Source.png\") source\n sinkR2 <- plotFPArray plan (folderPath \"Sink.png\") sink\n plotRThetaDist\n (folderPath \"Source_Theta.png\")\n (folderPath \"Source_R.png\")\n numPointsRecon\n 360\n 90\n periodEnv\n pos\n sourceR2\n plotRThetaDist\n (folderPath \"Sink_Theta.png\")\n (folderPath \"Sink_R.png\")\n numPointsRecon\n 360\n 90\n periodEnv\n pos\n sinkR2\n sinkR2TR <-\n computeUnboxedP .\n timeReversalRepa [fromIntegral (-thetaFreq) .. fromIntegral thetaFreq] $\n sinkR2\n completionR2 <- completionFieldRepa plan sourceR2 sinkR2TR\n (sumP . sumS . R.map (\\x -> magnitude x ** 2) . rotate4D2 $ completionR2) >>=\n plotImageRepa (folderPath \"Completion.png\") .\n ImageRepa 8 .\n computeS .\n extend (Z :. (1 :: Int) :. All :. All) -- . R.map (\\x -> log (x + 1))\n", "meta": {"hexsha": "8572ef7db1371027eca62f6012d903aaf44cb9df", "size": 8023, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "test/STCPinwheelCorner/STCPinwheelCorner.hs", "max_stars_repo_name": "XinhuaZhang/Stochastic-Completion-Field", "max_stars_repo_head_hexsha": "494a49356e17288ce09864c64ba09d11a3e9e0a8", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "test/STCPinwheelCorner/STCPinwheelCorner.hs", "max_issues_repo_name": "XinhuaZhang/Stochastic-Completion-Field", "max_issues_repo_head_hexsha": "494a49356e17288ce09864c64ba09d11a3e9e0a8", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 4, "max_issues_repo_issues_event_min_datetime": "2019-07-25T20:48:32.000Z", "max_issues_repo_issues_event_max_datetime": "2019-09-04T20:46:48.000Z", "max_forks_repo_path": "test/STCPinwheelCorner/STCPinwheelCorner.hs", "max_forks_repo_name": "XinhuaZhang/Stochastic-Completion-Field", "max_forks_repo_head_hexsha": "494a49356e17288ce09864c64ba09d11a3e9e0a8", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2019-07-29T15:55:46.000Z", "max_forks_repo_forks_event_max_datetime": "2019-07-29T15:55:46.000Z", "avg_line_length": 33.9957627119, "max_line_length": 405, "alphanum_fraction": 0.5692384395, "num_tokens": 2153, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.7217432062975979, "lm_q2_score": 0.48047867804790706, "lm_q1q2_score": 0.34678222165192774}} {"text": "{-# LANGUAGE FlexibleContexts #-}\n-- |\n-- Module : System.Random.MWC.CondensedTable\n-- Copyright : (c) 2012 Aleksey Khudyakov\n-- License : BSD3\n--\n-- Maintainer : bos@serpentine.com\n-- Stability : experimental\n-- Portability : portable\n--\n-- Table-driven generation of random variates. This approach can\n-- generate random variates in /O(1)/ time for the supported\n-- distributions, at a modest cost in initialization time.\nmodule System.Random.MWC.CondensedTable (\n -- * Condensed tables\n CondensedTable\n , CondensedTableV\n , CondensedTableU\n , genFromTable\n -- * Constructors for tables\n , tableFromProbabilities\n , tableFromWeights\n , tableFromIntWeights\n -- ** Disrete distributions\n , tablePoisson\n , tableBinomial\n -- * References\n -- $references\n ) where\n\nimport Control.Arrow (second,(***))\n\nimport Data.Word\nimport Data.Int\nimport Data.Bits\nimport qualified Data.Vector.Generic as G\nimport Data.Vector.Generic ((++))\nimport qualified Data.Vector.Generic.Mutable as M\nimport qualified Data.Vector.Unboxed as U\nimport qualified Data.Vector as V\nimport Data.Vector.Generic (Vector)\nimport Numeric.SpecFunctions (logFactorial)\nimport System.Random.Stateful\n\nimport Prelude hiding ((++))\n\n\n\n-- | A lookup table for arbitrary discrete distributions. It allows\n-- the generation of random variates in /O(1)/. Note that probability\n-- is quantized in units of @1/2^32@, and all distributions with\n-- infinite support (e.g. Poisson) should be truncated.\ndata CondensedTable v a =\n CondensedTable\n {-# UNPACK #-} !Word64 !(v a) -- Lookup limit and first table\n {-# UNPACK #-} !Word64 !(v a) -- Second table\n {-# UNPACK #-} !Word64 !(v a) -- Third table\n !(v a) -- Last table\n\n-- Implementation note. We have to store lookup limit in Word64 since\n-- we need to accomodate two cases. First is when we have no values in\n-- lookup table, second is when all elements are there\n--\n-- Both are pretty easy to realize. For first one probability of every\n-- outcome should be less then 1/256, latter arise when probabilities\n-- of two outcomes are [0.5,0.5]\n\n-- | A 'CondensedTable' that uses unboxed vectors.\ntype CondensedTableU = CondensedTable U.Vector\n\n-- | A 'CondensedTable' that uses boxed vectors, and is able to hold\n-- any type of element.\ntype CondensedTableV = CondensedTable V.Vector\n\n\n\n-- | Generate a random value using a condensed table.\ngenFromTable :: (StatefulGen g m, Vector v a) => CondensedTable v a -> g -> m a\n{-# INLINE genFromTable #-}\ngenFromTable table gen = do\n w <- uniformM gen\n return $ lookupTable table $ fromIntegral (w :: Word32)\n\nlookupTable :: Vector v a => CondensedTable v a -> Word64 -> a\n{-# INLINE lookupTable #-}\nlookupTable (CondensedTable na aa nb bb nc cc dd) i\n | i < na = aa `at` ( i `shiftR` 24)\n | i < nb = bb `at` ((i - na) `shiftR` 16)\n | i < nc = cc `at` ((i - nb) `shiftR` 8 )\n | otherwise = dd `at` ( i - nc)\n where\n at arr j = G.unsafeIndex arr (fromIntegral j)\n\n\n----------------------------------------------------------------\n-- Table generation\n----------------------------------------------------------------\n\n-- | Generate a condensed lookup table from a list of outcomes with\n-- given probabilities. The vector should be non-empty and the\n-- probabilites should be non-negative and sum to 1. If this is not\n-- the case, this algorithm will construct a table for some\n-- distribution that may bear no resemblance to what you intended.\ntableFromProbabilities\n :: (Vector v (a,Word32), Vector v (a,Double), Vector v a, Vector v Word32)\n => v (a, Double) -> CondensedTable v a\n{-# INLINE tableFromProbabilities #-}\ntableFromProbabilities v\n | G.null tbl = pkgError \"tableFromProbabilities\" \"empty vector of outcomes\"\n | otherwise = tableFromIntWeights $ G.map (second $ toWeight . (* mlt)) tbl\n where\n -- 2^32. N.B. This number is exatly representable.\n mlt = 4.294967296e9\n -- Drop non-positive probabilities\n tbl = G.filter ((> 0) . snd) v\n -- Convert Double weight to Word32 and avoid overflow at the same\n -- time. It's especially dangerous if one probability is\n -- approximately 1 and others are 0.\n toWeight w | w > mlt - 1 = 2^(32::Int) - 1\n | otherwise = round w\n\n\n-- | Same as 'tableFromProbabilities' but treats number as weights not\n-- probilities. Non-positive weights are discarded, and those\n-- remaining are normalized to 1.\ntableFromWeights\n :: (Vector v (a,Word32), Vector v (a,Double), Vector v a, Vector v Word32)\n => v (a, Double) -> CondensedTable v a\n{-# INLINE tableFromWeights #-}\ntableFromWeights = tableFromProbabilities . normalize . G.filter ((> 0) . snd)\n where\n normalize v\n | G.null v = pkgError \"tableFromWeights\" \"no positive weights\"\n | otherwise = G.map (second (/ s)) v\n where\n -- Explicit fold is to avoid 'Vector v Double' constraint\n s = G.foldl' (flip $ (+) . snd) 0 v\n\n\n-- | Generate a condensed lookup table from integer weights. Weights\n-- should sum to @2^32@ at least approximately. This function will\n-- correct small deviations from @2^32@ such as arising from rounding\n-- errors. But for large deviations it's likely to product incorrect\n-- result with terrible performance.\ntableFromIntWeights :: (Vector v (a,Word32), Vector v a, Vector v Word32)\n => v (a, Word32)\n -> CondensedTable v a\n{-# INLINE tableFromIntWeights #-}\ntableFromIntWeights v\n | n == 0 = pkgError \"tableFromIntWeights\" \"empty table\"\n -- Single element tables should be treated sepately. Otherwise\n -- they will confuse correctWeights\n | n == 1 = let m = 2^(32::Int) - 1 -- Works for both Word32 & Word64\n in CondensedTable\n m (G.replicate 256 $ fst $ G.head tbl)\n m G.empty\n m G.empty\n G.empty\n | otherwise = CondensedTable\n na aa\n nb bb\n nc cc\n dd\n where\n -- We must filter out zero-probability outcomes because they may\n -- confuse weight correction algorithm\n tbl = G.filter ((/=0) . snd) v\n n = G.length tbl\n -- Corrected table\n table = uncurry G.zip $ id *** correctWeights $ G.unzip tbl\n -- Make condensed table\n mkTable d =\n G.concatMap (\\(x,w) -> G.replicate (fromIntegral $ digit d w) x) table\n len = fromIntegral . G.length\n -- Tables\n aa = mkTable 0\n bb = mkTable 1\n cc = mkTable 2\n dd = mkTable 3\n -- Offsets\n na = len aa `shiftL` 24\n nb = na + (len bb `shiftL` 16)\n nc = nb + (len cc `shiftL` 8)\n\n\n-- Calculate N'th digit base 256\ndigit :: Int -> Word32 -> Word32\ndigit 0 x = x `shiftR` 24\ndigit 1 x = (x `shiftR` 16) .&. 0xff\ndigit 2 x = (x `shiftR` 8 ) .&. 0xff\ndigit 3 x = x .&. 0xff\ndigit _ _ = pkgError \"digit\" \"the impossible happened!?\"\n{-# INLINE digit #-}\n\n-- Correct integer weights so they sum up to 2^32. Array of weight\n-- should contain at least 2 elements.\ncorrectWeights :: G.Vector v Word32 => v Word32 -> v Word32\n{-# INLINE correctWeights #-}\ncorrectWeights v = G.create $ do\n let\n -- Sum of weights\n s = G.foldl' (flip $ (+) . fromIntegral) 0 v :: Int64\n -- Array size\n n = G.length v\n arr <- G.thaw v\n -- On first pass over array adjust only entries which are larger\n -- than `lim'. On second and subsequent passes `lim' is set to 1.\n --\n -- It's possibly to make this algorithm loop endlessly if all\n -- weights are 1 or 0.\n let loop lim i delta\n | delta == 0 = return ()\n | i >= n = loop 1 0 delta\n | otherwise = do\n w <- M.read arr i\n case () of\n _| w < lim -> loop lim (i+1) delta\n | delta < 0 -> M.write arr i (w + 1) >> loop lim (i+1) (delta + 1)\n | otherwise -> M.write arr i (w - 1) >> loop lim (i+1) (delta - 1)\n loop 255 0 (s - 2^(32::Int))\n return arr\n\n\n-- | Create a lookup table for the Poisson distibution. Note that\n-- table construction may have significant cost. For λ < 100 it\n-- takes as much time to build table as generation of 1000-30000\n-- variates.\ntablePoisson :: Double -> CondensedTableU Int\ntablePoisson = tableFromProbabilities . make\n where\n make lam\n | lam < 0 = pkgError \"tablePoisson\" \"negative lambda\"\n | lam < 22.8 = U.unfoldr unfoldForward (exp (-lam), 0)\n | otherwise = U.unfoldr unfoldForward (pMax, nMax)\n ++ U.tail (U.unfoldr unfoldBackward (pMax, nMax))\n where\n -- Number with highest probability and its probability\n --\n -- FIXME: this is not ideal precision-wise. Check if code\n -- from statistics gives better precision.\n nMax = floor lam :: Int\n pMax = exp $ fromIntegral nMax * log lam - lam - logFactorial nMax\n -- Build probability list\n unfoldForward (p,i)\n | p < minP = Nothing\n | otherwise = Just ( (i,p)\n , (p * lam / fromIntegral (i+1), i+1)\n )\n -- Go down\n unfoldBackward (p,i)\n | p < minP = Nothing\n | otherwise = Just ( (i,p)\n , (p / lam * fromIntegral i, i-1)\n )\n -- Minimal representable probability for condensed tables\n minP = 1.1641532182693481e-10 -- 2**(-33)\n\n-- | Create a lookup table for the binomial distribution.\ntableBinomial :: Int -- ^ Number of tries\n -> Double -- ^ Probability of success\n -> CondensedTableU Int\ntableBinomial n p = tableFromProbabilities makeBinom\n where \n makeBinom\n | n <= 0 = pkgError \"tableBinomial\" \"non-positive number of tries\"\n | p == 0 = U.singleton (0,1)\n | p == 1 = U.singleton (n,1)\n | p > 0 && p < 1 = U.unfoldrN (n + 1) unfolder ((1-p)^n, 0)\n | otherwise = pkgError \"tableBinomial\" \"probability is out of range\"\n where\n h = p / (1 - p)\n unfolder (t,i) = Just ( (i,t)\n , (t * (fromIntegral $ n + 1 - i1) * h / fromIntegral i1, i1) )\n where i1 = i + 1\n\npkgError :: String -> String -> a\npkgError func err =\n error . concat $ [\"System.Random.MWC.CondensedTable.\", func, \": \", err]\n\n-- $references\n--\n-- * Wang, J.; Tsang, W. W.; G. Marsaglia (2004), Fast Generation of\n-- Discrete Random Variables, /Journal of Statistical Software,\n-- American Statistical Association/, vol. 11(i03).\n-- \n", "meta": {"hexsha": "9b9936fe92767bc09326423e7e6300ec38d856b7", "size": 10617, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "System/Random/MWC/CondensedTable.hs", "max_stars_repo_name": "Shimuuar/mwc-random", "max_stars_repo_head_hexsha": "225bf0b24a7c85e603e5c3464657e3fa1fdebf92", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-02-15T06:11:37.000Z", "max_stars_repo_stars_event_max_datetime": "2021-02-15T06:11:37.000Z", "max_issues_repo_path": "System/Random/MWC/CondensedTable.hs", "max_issues_repo_name": "Shimuuar/mwc-random", "max_issues_repo_head_hexsha": "225bf0b24a7c85e603e5c3464657e3fa1fdebf92", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": 3, "max_issues_repo_issues_event_min_datetime": "2021-02-15T17:55:19.000Z", "max_issues_repo_issues_event_max_datetime": "2021-08-15T14:45:03.000Z", "max_forks_repo_path": "System/Random/MWC/CondensedTable.hs", "max_forks_repo_name": "Shimuuar/mwc-random", "max_forks_repo_head_hexsha": "225bf0b24a7c85e603e5c3464657e3fa1fdebf92", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": 6, "max_forks_repo_forks_event_min_datetime": "2020-12-14T09:58:56.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-16T22:58:35.000Z", "avg_line_length": 37.1223776224, "max_line_length": 91, "alphanum_fraction": 0.611754733, "num_tokens": 2915, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.6513548646660542, "lm_q2_score": 0.5312093733737563, "lm_q1q2_score": 0.3460058095032025}} {"text": "{-# LANGUAGE CPP, DerivingVia, GADTs, InstanceSigs, KindSignatures #-}\n{-# LANGUAGE PatternSynonyms, RankNTypes, RoleAnnotations #-}\n{-# LANGUAGE ScopedTypeVariables, StandaloneDeriving, TemplateHaskell #-}\n{-# LANGUAGE TypeApplications, TypeFamilies, TypeOperators #-}\n{-# LANGUAGE UndecidableSuperClasses #-}\n{-# OPTIONS_GHC -Wno-orphans #-}\nmodule Control.Subcategory.Functor\n ( Constrained(..), Dom(), CFunctor (..),\n (<$:>),\n defaultCmapConst,\n WrapFunctor (..),\n WrapMono (WrapMono, unwrapMono),\n coerceToMono, withMonoCoercible,\n )\nwhere\nimport qualified Control.Applicative as App\nimport Control.Arrow (Arrow, ArrowMonad)\nimport Control.Exception (Handler)\nimport qualified Control.Monad.ST.Lazy as LST\nimport qualified Control.Monad.ST.Strict as SST\nimport Control.Subcategory.Wrapper.Internal\nimport Data.Coerce\nimport Data.Complex (Complex)\nimport qualified Data.Functor.Compose as SOP\nimport Data.Functor.Const (Const)\nimport Data.Functor.Identity (Identity)\nimport qualified Data.Functor.Product as SOP\nimport qualified Data.Functor.Sum as SOP\nimport Data.Hashable (Hashable)\nimport qualified Data.HashMap.Strict as HM\nimport qualified Data.HashSet as HS\nimport qualified Data.IntMap as IM\nimport Data.Kind (Constraint, Type)\nimport Data.List.NonEmpty (NonEmpty)\nimport qualified Data.Map as Map\nimport qualified Data.Monoid as Mon\nimport Data.MonoTraversable (Element,\n MonoFunctor (..))\n#if MIN_VERSION_mono_traversable(1,0,14)\nimport Data.MonoTraversable (WrappedMono)\n#endif\n\nimport qualified Data.IntSet as IS\nimport Data.Ord (Down (..))\nimport qualified Data.Primitive.Array as A\nimport qualified Data.Primitive.PrimArray as PA\nimport qualified Data.Primitive.SmallArray as SA\nimport Data.Proxy (Proxy)\nimport qualified Data.Semigroup as Sem\nimport qualified Data.Sequence as Seq\nimport qualified Data.Set as Set\nimport qualified Data.Tree as Tree\nimport qualified Data.Vector as V\nimport qualified Data.Vector.Primitive as P\nimport qualified Data.Vector.Storable as S\nimport qualified Data.Vector.Unboxed as U\nimport Foreign.Ptr (Ptr)\nimport GHC.Conc (STM)\nimport GHC.Generics ((:*:) (..), (:+:) (..),\n (:.:) (..), K1, M1, Par1,\n Rec1, U1, URec, V1)\nimport qualified System.Console.GetOpt as GetOpt\nimport Text.ParserCombinators.ReadP (ReadP)\nimport Text.ParserCombinators.ReadPrec (ReadPrec)\n\ninfixl 4 <$:\n\nclass Constrained (f :: Type -> Type) where\n type Dom f (a :: Type) :: Constraint\n type Dom f a = ()\n\nclass Constrained f => CFunctor f where\n cmap :: (Dom f a, Dom f b) => (a -> b) -> f a -> f b\n default cmap :: Functor f => (a -> b) -> f a -> f b\n cmap = fmap\n {-# INLINE cmap #-}\n (<$:) :: (Dom f a, Dom f b) => a -> f b -> f a\n (<$:) = cmap . const\n {-# INLINE (<$:) #-}\n\ndefaultCmapConst :: (CFunctor f, Dom f a, Dom f b) => a -> f b -> f a\ndefaultCmapConst = cmap . const\n{-# INLINE defaultCmapConst #-}\n\ninstance Constrained (WrapFunctor f) where\n type Dom (WrapFunctor f) a = ()\n\ninstance Functor f => CFunctor (WrapFunctor f) where\n cmap :: (a -> b) -> WrapFunctor f a -> WrapFunctor f b\n cmap = fmap\n {-# INLINE cmap #-}\n (<$:) :: a -> WrapFunctor f b -> WrapFunctor f a\n (<$:) = (<$)\n {-# INLINE (<$:) #-}\n\ninstance Constrained []\ninstance CFunctor []\ninstance Constrained Maybe\ninstance CFunctor Maybe\ninstance Constrained IO\ninstance CFunctor IO\ninstance Constrained Par1\ninstance CFunctor Par1\ninstance Constrained NonEmpty\ninstance CFunctor NonEmpty\ninstance Constrained ReadP\ninstance CFunctor ReadP\ninstance Constrained ReadPrec\ninstance CFunctor ReadPrec\n\n\ninstance Constrained Down\ninstance CFunctor Down\ninstance Constrained Mon.Product\ninstance CFunctor Mon.Product\n\ninstance Constrained Mon.Sum\ninstance CFunctor Mon.Sum\ninstance Constrained Mon.Dual\ninstance CFunctor Mon.Dual\n\ninstance Constrained Mon.Last\ninstance CFunctor Mon.Last\ninstance Constrained Mon.First\ninstance CFunctor Mon.First\n\ninstance Constrained STM\ninstance CFunctor STM\ninstance Constrained Handler\ninstance CFunctor Handler\n\ninstance Constrained Identity\ninstance CFunctor Identity\ninstance Constrained App.ZipList\ninstance CFunctor App.ZipList\ninstance Constrained GetOpt.ArgDescr\ninstance CFunctor GetOpt.ArgDescr\ninstance Constrained GetOpt.OptDescr\ninstance CFunctor GetOpt.OptDescr\ninstance Constrained GetOpt.ArgOrder\ninstance CFunctor GetOpt.ArgOrder\ninstance Constrained Sem.Option\ninstance CFunctor Sem.Option\n\ninstance Constrained Sem.Last\ninstance CFunctor Sem.Last\ninstance Constrained Sem.First\ninstance CFunctor Sem.First\n\ninstance Constrained Sem.Max\ninstance CFunctor Sem.Max\ninstance Constrained Sem.Min\ninstance CFunctor Sem.Min\n\ninstance Constrained Complex\ninstance CFunctor Complex\ninstance Constrained (Either a)\ninstance CFunctor (Either a)\n\ninstance Constrained V1\ninstance CFunctor V1\ninstance Constrained U1\ninstance CFunctor U1\n\ninstance Constrained ((,) a)\ninstance CFunctor ((,) a)\ninstance Constrained (SST.ST s)\ninstance CFunctor (SST.ST s)\n\ninstance Constrained (LST.ST s)\ninstance CFunctor (LST.ST s)\ninstance Constrained Proxy\ninstance CFunctor Proxy\n\ninstance Constrained (ArrowMonad a)\ninstance Arrow a => CFunctor (ArrowMonad a)\ninstance Constrained (App.WrappedMonad m)\ninstance Monad m => CFunctor (App.WrappedMonad m)\n\ninstance Constrained (Sem.Arg a)\ninstance CFunctor (Sem.Arg a)\ninstance Constrained (Rec1 f)\ninstance Functor f => CFunctor (Rec1 f)\n\ninstance Constrained (URec Char)\ninstance CFunctor (URec Char)\ninstance Constrained (URec Double)\ninstance CFunctor (URec Double)\n\ninstance Constrained (URec Float)\ninstance CFunctor (URec Float)\ninstance Constrained (URec Int)\ninstance CFunctor (URec Int)\n\ninstance Constrained (URec Word)\ninstance CFunctor (URec Word)\ninstance Constrained (URec (Ptr ()))\ninstance CFunctor (URec (Ptr ()))\n\ninstance Constrained f => Constrained (Mon.Ap f) where\n type Dom (Mon.Ap f) a = Dom f a\n\nderiving newtype instance CFunctor f => CFunctor (Mon.Ap f)\n\ninstance Constrained (Mon.Alt f) where\n type Dom (Mon.Alt f) a = Dom f a\nderiving newtype instance CFunctor f => CFunctor (Mon.Alt f)\n\ninstance Constrained (Const m)\ninstance CFunctor (Const m)\ninstance Constrained (App.WrappedArrow a b)\ninstance Arrow a => CFunctor (App.WrappedArrow a b)\n\ninstance Constrained ((->) r)\ninstance CFunctor ((->) r)\ninstance Constrained (K1 i c)\ninstance CFunctor (K1 i c)\n\ninstance Constrained (f :+: g) where\n type Dom (f :+: g) a = (Dom f a, Dom g a)\ninstance (CFunctor f, CFunctor g) => CFunctor (f :+: g) where\n cmap f (L1 xs) = L1 $ cmap f xs\n cmap f (R1 xs) = R1 $ cmap f xs\n {-# INLINE [1] cmap #-}\ninstance Constrained (f :*: g) where\n type Dom (f :*: g) a = (Dom f a, Dom g a)\ninstance (CFunctor f, CFunctor g) => CFunctor (f :*: g) where\n cmap f (l :*: r) = cmap f l :*: cmap f r\n {-# INLINE cmap #-}\n\ninstance Constrained (f :.: (g :: Type -> Type)) where\n type Dom (f :.: g) a = (Dom f (g a), Dom g a)\ninstance (CFunctor f, CFunctor g) => CFunctor (f :.: g) where\n cmap f gfa = Comp1 $ cmap (cmap f) $ unComp1 gfa\n {-# INLINE cmap #-}\ninstance (Constrained f, Constrained g) => Constrained (SOP.Sum f g) where\n type Dom (SOP.Sum f g) a = (Dom f a, Dom g a)\n\ninstance (CFunctor f, CFunctor g) => CFunctor (SOP.Sum f g) where\n cmap f (SOP.InL a) = SOP.InL $ cmap f a\n cmap f (SOP.InR b) = SOP.InR $ cmap f b\n {-# INLINE cmap #-}\n\n (<$:) = defaultCmapConst\n {-# INLINE (<$:) #-}\n\ninstance (Constrained f, Constrained g) => Constrained (SOP.Product f g) where\n type Dom (SOP.Product f g) a = (Dom f a, Dom g a)\n\ninstance (CFunctor f, CFunctor g) => CFunctor (SOP.Product f g) where\n cmap f (SOP.Pair a b) = SOP.Pair (cmap f a) (cmap f b)\n {-# INLINE cmap #-}\n\n (<$:) = defaultCmapConst\n {-# INLINE (<$:) #-}\n\ninstance (Constrained (f ::Type -> Type), Constrained (g :: Type -> Type))\n => Constrained (SOP.Compose f g) where\n type Dom (SOP.Compose f g) a = (Dom g a, Dom f (g a))\n\ninstance (CFunctor f, CFunctor g) => CFunctor (SOP.Compose f g) where\n cmap f (SOP.Compose a) = SOP.Compose $ cmap (cmap f) a\n (<$:) = defaultCmapConst\n\n {-# INLINE (<$:) #-}\n\ninstance Constrained (M1 i c f)\ninstance Functor f => CFunctor (M1 i c f)\n\ninstance Constrained Seq.Seq\ninstance CFunctor Seq.Seq\n\n#if MIN_VERSION_mono_traversable(1,0,14)\ninstance Constrained (WrappedMono mono) where\n type Dom (WrappedMono mono) a = a ~ Element mono\n\ninstance MonoFunctor IS.IntSet where\n omap = IS.map\n\ninstance MonoFunctor mono => CFunctor (WrappedMono mono) where\n cmap = omap\n (<$:) = omap . const\n#endif\n\ninstance Constrained (WrapMono mono) where\n type Dom (WrapMono mono) b = b ~ Element mono\n\ninstance {-# OVERLAPPABLE #-} MonoFunctor a\n => CFunctor (WrapMono a) where\n cmap = coerce @((Element a -> Element a) -> a -> a) omap\n {-# INLINE [1] cmap #-}\n\n (<$:) = defaultCmapConst\n {-# INLINE [1] (<$:) #-}\n\n\ninstance Constrained IM.IntMap\ninstance CFunctor IM.IntMap\n\ninstance Constrained (Map.Map k)\ninstance Ord k => CFunctor (Map.Map k)\n\ninstance Constrained Set.Set where\n type Dom Set.Set a = Ord a\n\ninstance CFunctor Set.Set where\n cmap = Set.map\n {-# INLINE [1] cmap #-}\n (<$:) = flip $ \\s ->\n if Set.null s\n then const Set.empty else Set.singleton\n {-# INLINE [1] (<$:) #-}\n\ninstance Constrained HS.HashSet where\n type Dom HS.HashSet a = (Hashable a, Eq a)\n\ninstance CFunctor HS.HashSet where\n cmap :: (Hashable b, Eq b) => (a -> b) -> HS.HashSet a -> HS.HashSet b\n cmap = HS.map\n {-# INLINE [1] cmap #-}\n (<$:) = flip $ \\s -> if HS.null s\n then const HS.empty else HS.singleton\n {-# INLINE (<$:) #-}\n\ninstance Constrained (HM.HashMap k)\ninstance CFunctor (HM.HashMap k)\ninstance Constrained Tree.Tree\ninstance CFunctor Tree.Tree\n\n\ninfixl 4 <$:>\n(<$:>) :: (CFunctor f, Dom f a, Dom f b) => (a -> b) -> f a -> f b\n(<$:>) = cmap\n{-# INLINE [1] (<$:>) #-}\n\ninstance Constrained V.Vector where\n type Dom V.Vector a = ()\n\ninstance CFunctor V.Vector where\n cmap = V.map\n {-# INLINE [1] cmap #-}\n\ninstance Constrained U.Vector where\n type Dom U.Vector a = U.Unbox a\ninstance CFunctor U.Vector where\n cmap = U.map\n {-# INLINE [1] cmap #-}\ninstance Constrained S.Vector where\n type Dom S.Vector a = S.Storable a\ninstance CFunctor S.Vector where\n cmap = S.map\n {-# INLINE [1] cmap #-}\n\ninstance Constrained P.Vector where\n type Dom P.Vector a = P.Prim a\ninstance CFunctor P.Vector where\n cmap = P.map\n {-# INLINE [1] cmap #-}\n\ninstance Constrained PA.PrimArray where\n type Dom PA.PrimArray a = P.Prim a\n\ninstance CFunctor PA.PrimArray where\n cmap = PA.mapPrimArray\n {-# INLINE [1] cmap #-}\n\nderiving via WrapFunctor SA.SmallArray\n instance Constrained SA.SmallArray\nderiving via WrapFunctor SA.SmallArray\n instance CFunctor SA.SmallArray\n\nderiving via WrapFunctor A.Array\n instance Constrained A.Array\nderiving via WrapFunctor A.Array\n instance CFunctor A.Array\n", "meta": {"hexsha": "b74af8fdbef18ad66d2a11a0a39a132ec84e36eb", "size": 11842, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/Control/Subcategory/Functor.hs", "max_stars_repo_name": "konn/subcategories", "max_stars_repo_head_hexsha": "2ad473e09bbf674bbe3825849bad3cca7b25f4ac", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 6, "max_stars_repo_stars_event_min_datetime": "2018-07-30T19:14:49.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-16T19:19:37.000Z", "max_issues_repo_path": "src/Control/Subcategory/Functor.hs", "max_issues_repo_name": "konn/subcategories", "max_issues_repo_head_hexsha": "2ad473e09bbf674bbe3825849bad3cca7b25f4ac", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/Control/Subcategory/Functor.hs", "max_forks_repo_name": "konn/subcategories", "max_forks_repo_head_hexsha": "2ad473e09bbf674bbe3825849bad3cca7b25f4ac", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 31.4946808511, "max_line_length": 78, "alphanum_fraction": 0.6501435568, "num_tokens": 3166, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.7690802264851919, "lm_q2_score": 0.44939263446475963, "lm_q1q2_score": 0.3456189890949344}} {"text": "{- |\nCopyright: (c) 2020 Thomas Tuegel\nSPDX-License-Identifier: BSD-3-Clause\nMaintainer: Thomas Tuegel \n\n-}\n\nmodule Injection\n ( Injection (..)\n , Retraction (..)\n ) where\n\nimport Data.Complex (Complex ((:+)))\nimport Data.Dynamic (Dynamic, Typeable, fromDynamic, toDyn)\nimport Data.Fixed (Fixed, HasResolution)\nimport Data.Functor.Const (Const (..))\nimport Data.Functor.Identity (Identity (..))\nimport Data.List.NonEmpty (NonEmpty (..))\nimport Data.Maybe (maybeToList)\nimport Data.Monoid (Dual (..))\nimport Data.Monoid (Product (..))\nimport Data.Monoid (Sum (..))\nimport Data.Monoid (Any (..))\nimport Data.Monoid (All (..))\nimport qualified Data.Monoid as Monoid (First (..), Last (..))\nimport Data.Ord (Down (..))\nimport Data.Ratio (Ratio)\nimport qualified Data.Ratio as Ratio\nimport Data.Semigroup (Max (..), Min (..))\nimport qualified Data.Semigroup as Semigroup (First (..), Last (..))\nimport Data.Text (Text)\nimport qualified Data.Text as Text\nimport qualified Data.Text.Lazy as Lazy (Text)\nimport qualified Data.Text.Lazy as Text.Lazy\nimport Data.Void (Void)\nimport Numeric.Natural (Natural)\n\n{- | @Injection@ describes a lossless conversion that includes one type in another.\n\nThe sole method of this class,\n\n> inject :: from -> into\n\ntakes a value @input :: from@ and returns a value @output :: into@ which preserves all the information contained in the input.\nSpecifically, each @input@ is mapped to a /unique/ @output@.\nIn mathematical terminology, @inject@ is /injective/:\n\n> inject a \u2261 inject b \u2192 a \u2261 b\n\nThe name of the class is derived from the mathematical term.\n\n@Injection@ models the \"is-a\" relationship used in languages with subtypes (such as in object-oriented programming),\nbut an explicit cast with @inject@ is required in Haskell.\n\nAlthough it is often possible to infer the type parameters of this class,\nit is advisable to specify one or both of the parameters to @inject@\nusing a type signature or the @TypeApplications@ language extension.\nSpecifying the type parameters will give clearer error messages from the type checker in any case.\n\n-}\nclass Injection from into where\n inject :: from -> into\n\n{- | @Retraction@ undoes an 'Injection'.\n\nBecause 'Injection' is a lossless conversion, we can define a @Retraction@ which undoes it.\nThe method\n\n> retract :: into -> Maybe from\n\nis the (left) inverse of 'inject':\n\n> retract (inject x) = Just x\n\n'retract' is partial (returns 'Maybe') because the type @into@ may be larger than the type @from@;\nthat is, there may be values in @into@ which are not 'inject'-ed from @from@,\nand in that case @retract@ may return 'Nothing'.\n\nAlthough it is often possible to infer the type parameters of this class,\nit is advisable to specify one or both of the parameters to @retract@\nusing a type signature or the @TypeApplications@ language extension.\nSpecifying the type parameters will give clearer error messages from the type checker in any case.\n\n-}\nclass Injection from into => Retraction from into where\n retract :: into -> Maybe from\n\ninstance Injection a a where\n inject = id\n {-# INLINE inject #-}\n\ninstance Retraction a a where\n retract = Just\n {-# INLINE retract #-}\n\ninstance Typeable a => Injection a Dynamic where\n inject = toDyn\n {-# INLINE inject #-}\n\ninstance Typeable a => Retraction a Dynamic where\n retract = fromDynamic\n {-# INLINE retract #-}\n\ninstance Injection a b => Injection a (Maybe b) where\n inject = Just . inject\n {-# INLINE inject #-}\n\ninstance Retraction a b => Retraction a (Maybe b) where\n retract = \\x -> x >>= retract @a @b\n {-# INLINE retract #-}\n\ninstance Injection a b => Injection (Maybe a) [b] where\n inject = maybeToList . fmap (inject @a @b)\n {-# INLINE inject #-}\n\ninstance Retraction a b => Retraction (Maybe a) [b] where\n retract [] = Just Nothing\n retract [b] = Just <$> retract @a @b b\n retract _ = Nothing\n\ninstance Injection Natural Integer where\n inject = toInteger\n {-# INLINE inject #-}\n\ninstance Retraction Natural Integer where\n retract x\n | x < 0 = Nothing\n | otherwise = Just (fromInteger x)\n {-# INLINE retract #-}\n\ninstance Injection Void any where\n inject = \\case {}\n {-# INLINE inject #-}\n\n-- | 'Text.unpack' is the canonical injection @'Text' -> 'String'@.\n-- There is no injection in the other direction because 'String' can represent\n-- invalid surrogate code points, but 'Text' cannot; for details, see\n-- \"Data.Text\".\ninstance Injection Text String where\n inject = Text.unpack\n {-# INLINE inject #-}\n\n-- | 'Text.Lazy.unpack' is the canonical injection @'Lazy.Text' -> 'String'@.\n-- There is no injection in the other direction because 'String' can represent\n-- invalid surrogate code points, but 'Lazy.Text' cannot; for details, see\n-- \"Data.Text.Lazy\".\ninstance Injection Lazy.Text String where\n inject = Text.Lazy.unpack\n {-# INLINE inject #-}\n\ninstance Injection Text Lazy.Text where\n inject = Text.Lazy.fromStrict\n {-# INLINE inject #-}\n\ninstance Injection Lazy.Text Text where\n inject = Text.Lazy.toStrict\n {-# INLINE inject #-}\n\ninstance HasResolution a => Injection Integer (Fixed a) where\n inject = fromInteger\n {-# INLINE inject #-}\n\ninstance HasResolution a => Retraction Integer (Fixed a) where\n retract x = retract @Integer (toRational x)\n {-# INLINE retract #-}\n\ninstance Injection a (Const a b) where\n inject = Const\n {-# INLINE inject #-}\n\ninstance Injection (Const a b) a where\n inject = getConst\n {-# INLINE inject #-}\n\ninstance Injection Integer (Ratio Integer) where\n inject = fromInteger\n {-# INLINE inject #-}\n\ninstance Retraction Integer (Ratio Integer) where\n retract x\n | Ratio.denominator x == 1 = Just (Ratio.numerator x)\n | otherwise = Nothing\n {-# INLINE retract #-}\n\ninstance Num a => Injection a (Complex a) where\n inject = (:+ 0)\n {-# INLINE inject #-}\n\ninstance (Eq a, Num a) => Retraction a (Complex a) where\n retract (x :+ y)\n | y == 0 = Just x\n | otherwise = Nothing\n {-# INLINE retract #-}\n\ninstance Injection a (Identity a) where\n inject = Identity\n {-# INLINE inject #-}\n\ninstance Injection (Identity a) a where\n inject = runIdentity\n {-# INLINE inject #-}\n\ninstance Injection (NonEmpty a) [a] where\n inject (x :| xs) = x : xs\n {-# INLINE inject #-}\n\ninstance Retraction (NonEmpty a) [a] where\n retract (x : xs) = Just (x :| xs)\n retract [] = Nothing\n {-# INLINE retract #-}\n\ninstance Injection a (Down a) where\n inject = pure\n {-# INLINE inject #-}\n\ninstance Injection (Down a) a where\n inject = \\(Down a) -> a\n {-# INLINE inject #-}\n\ninstance Injection a (Product a) where\n inject = pure\n {-# INLINE inject #-}\n\ninstance Injection (Product a) a where\n inject = getProduct\n {-# INLINE inject #-}\n\ninstance Injection a (Sum a) where\n inject = pure\n {-# INLINE inject #-}\n\ninstance Injection (Sum a) a where\n inject = getSum\n {-# INLINE inject #-}\n\ninstance Injection a (Dual a) where\n inject = pure\n {-# INLINE inject #-}\n\ninstance Injection (Dual a) a where\n inject = getDual\n {-# INLINE inject #-}\n\ninstance Injection a (Monoid.Last a) where\n inject = pure\n {-# INLINE inject #-}\n\ninstance Retraction a (Monoid.Last a) where\n retract = Monoid.getLast\n {-# INLINE retract #-}\n\ninstance Injection a (Monoid.First a) where\n inject = pure\n {-# INLINE inject #-}\n\ninstance Retraction a (Monoid.First a) where\n retract = Monoid.getFirst\n {-# INLINE retract #-}\n\ninstance Injection a (Semigroup.First a) where\n inject = pure\n {-# INLINE inject #-}\n\ninstance Injection (Semigroup.First a) a where\n inject = Semigroup.getFirst\n {-# INLINE inject #-}\n\ninstance Injection a (Semigroup.Last a) where\n inject = pure\n {-# INLINE inject #-}\n\ninstance Injection (Semigroup.Last a) a where\n inject = Semigroup.getLast\n {-# INLINE inject #-}\n\ninstance Injection a (Max a) where\n inject = pure\n {-# INLINE inject #-}\n\ninstance Injection (Max a) a where\n inject = getMax\n {-# INLINE inject #-}\n\ninstance Injection a (Min a) where\n inject = pure\n {-# INLINE inject #-}\n\ninstance Injection (Min a) a where\n inject = getMin\n {-# INLINE inject #-}\n\ninstance Injection a (r -> a) where\n inject = const\n {-# INLINE inject #-}\n\ninstance Injection Bool Any where\n inject = Any\n {-# INLINE inject #-}\n\ninstance Injection Any Bool where\n inject = getAny\n {-# INLINE inject #-}\n\ninstance Injection Bool All where\n inject = All\n {-# INLINE inject #-}\n\ninstance Injection All Bool where\n inject = getAll\n {-# INLINE inject #-}\n", "meta": {"hexsha": "864f8608c1008bc13bb9d1006b7e0d632e74ac38", "size": 8655, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/Injection.hs", "max_stars_repo_name": "ttuegel/injection", "max_stars_repo_head_hexsha": "e5741923a59c6e762ca776569a3008a13892f06e", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/Injection.hs", "max_issues_repo_name": "ttuegel/injection", "max_issues_repo_head_hexsha": "e5741923a59c6e762ca776569a3008a13892f06e", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/Injection.hs", "max_forks_repo_name": "ttuegel/injection", "max_forks_repo_head_hexsha": "e5741923a59c6e762ca776569a3008a13892f06e", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 27.8295819936, "max_line_length": 126, "alphanum_fraction": 0.6756787984, "num_tokens": 2109, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.6187804337438501, "lm_q2_score": 0.5583269943353745, "lm_q1q2_score": 0.34548181972574316}} {"text": "{-# LANGUAGE MultiParamTypeClasses, FlexibleInstances, ScopedTypeVariables, RecordWildCards #-}\n\nimport Control.Monad.Primitive \nimport Control.Monad\nimport Foreign.C.Types\nimport Foreign.Ptr\nimport Unsafe.Coerce\nimport Data.Complex\nimport Foreign.Marshal.Array\n\nimport qualified Data.Vector.Generic as VG\nimport qualified Data.Vector.Generic.Mutable as VGM\nimport qualified Data.Vector.Storable as VS\nimport qualified Data.Vector.Storable.Mutable as VSM\nimport qualified Data.Vector.Fusion.Stream as VFS\nimport qualified Data.Vector.Fusion.Stream.Monadic as VFSM\n\nimport Foreign.Storable.Complex\nimport Criterion.Main\nimport Test.QuickCheck\nimport Test.QuickCheck.Monadic\n\n-- | A class for things that can be multiplied by a scalar.\nclass Mult a b where\n mult :: a -> b -> a\n\ninstance (Num a) => Mult a a where\n mult = (*)\n\ninstance (Num a) => Mult (Complex a) a where\n mult (x :+ y) z = (x * z) :+ (y * z)\n\n-- | Fill a mutable vector from a monadic stream\n{-# INLINE fill #-}\nfill :: (PrimMonad m, Functor m, VGM.MVector vm a) => VFS.MStream m a -> vm (PrimState m) a -> m ()\nfill str outBuf = void $ VFSM.foldM' put 0 str\n where \n put i x = do\n VGM.unsafeWrite outBuf i x\n return $ i + 1\n \n{-# INLINE stride #-}\nstride :: VG.Vector v a => Int -> v a -> v a\nstride str inv = VG.unstream $ VFS.unfoldr func 0\n where\n len = VG.length inv\n func i | i >= len = Nothing\n | otherwise = Just (VG.unsafeIndex inv i, i + str)\n\n-- | The functions to be benchmarked\n\n-- | Filters\n\nfilterHighLevel :: (PrimMonad m, Functor m, Num a, Mult a b, VG.Vector v a, VG.Vector v b, VGM.MVector vm a) => Int -> v b -> v a -> vm (PrimState m) a -> m ()\nfilterHighLevel num coeffs inBuf outBuf = fill (VFSM.generate num dotProd) outBuf\n where\n dotProd offset = VG.sum $ VG.zipWith mult (VG.unsafeDrop offset inBuf) coeffs\n\ntype FilterCRR = CInt -> CInt -> Ptr CFloat -> Ptr CFloat -> Ptr CFloat -> IO ()\ntype FilterRR = Int -> VS.Vector Float -> VS.Vector Float -> VS.MVector RealWorld Float -> IO ()\ntype FilterRC = Int -> VS.Vector Float -> VS.Vector (Complex Float) -> VS.MVector RealWorld (Complex Float) -> IO ()\n\nfilterFFIR :: FilterCRR -> FilterRR \nfilterFFIR func num coeffs inBuf outBuf = \n VS.unsafeWith (unsafeCoerce coeffs) $ \\cPtr -> \n VS.unsafeWith (unsafeCoerce inBuf) $ \\iPtr -> \n VSM.unsafeWith (unsafeCoerce outBuf) $ \\oPtr -> \n func (fromIntegral num) (fromIntegral $ VG.length coeffs) cPtr iPtr oPtr\n\nfilterFFIC :: FilterCRR -> FilterRC \nfilterFFIC func num coeffs inBuf outBuf = \n VS.unsafeWith (unsafeCoerce coeffs) $ \\cPtr -> \n VS.unsafeWith (unsafeCoerce inBuf) $ \\iPtr -> \n VSM.unsafeWith (unsafeCoerce outBuf) $ \\oPtr -> \n func (fromIntegral num) (fromIntegral $ VG.length coeffs) cPtr iPtr oPtr\n\n-- | Decimation\n\ndecimateHighLevel :: (PrimMonad m, Functor m, Num a, Mult a b, VG.Vector v a, VG.Vector v b, VGM.MVector vm a) => Int -> Int -> v b -> v a -> vm (PrimState m) a -> m ()\ndecimateHighLevel num factor coeffs inBuf outBuf = fill x outBuf\n where \n x = VFSM.map dotProd (VFSM.iterateN num (+ factor) 0)\n dotProd offset = VG.sum $ VG.zipWith mult (VG.unsafeDrop offset inBuf) coeffs\n\ntype DecimateCRR = CInt -> CInt -> CInt -> Ptr CFloat -> Ptr CFloat -> Ptr CFloat -> IO ()\ntype DecimateRR = Int -> Int -> VS.Vector Float -> VS.Vector Float -> VS.MVector RealWorld Float -> IO ()\ntype DecimateRC = Int -> Int -> VS.Vector Float -> VS.Vector (Complex Float) -> VS.MVector RealWorld (Complex Float) -> IO ()\n\ndecimateFFIR :: DecimateCRR -> DecimateRR \ndecimateFFIR func num factor coeffs inBuf outBuf = \n VS.unsafeWith (unsafeCoerce coeffs) $ \\cPtr -> \n VS.unsafeWith (unsafeCoerce inBuf) $ \\iPtr -> \n VSM.unsafeWith (unsafeCoerce outBuf) $ \\oPtr -> \n func (fromIntegral num) (fromIntegral factor) (fromIntegral $ VG.length coeffs) cPtr iPtr oPtr\n\ndecimateFFIC :: DecimateCRR -> DecimateRC \ndecimateFFIC func num factor coeffs inBuf outBuf = \n VS.unsafeWith (unsafeCoerce coeffs) $ \\cPtr -> \n VS.unsafeWith (unsafeCoerce inBuf) $ \\iPtr -> \n VSM.unsafeWith (unsafeCoerce outBuf) $ \\oPtr -> \n func (fromIntegral num) (fromIntegral factor) (fromIntegral $ VG.length coeffs) cPtr iPtr oPtr\n\n-- | Rational downsampling\nresampleHighLevel :: (PrimMonad m, Num a, Mult a b, VG.Vector v a, VG.Vector v b, VGM.MVector vm a) => Int -> Int -> Int -> Int -> v b -> v a -> vm (PrimState m) a -> m Int\nresampleHighLevel count interpolation decimation filterOffset coeffs inBuf outBuf = fill 0 filterOffset 0\n where\n fill i filterOffset inputOffset\n | i < count = do\n let dp = dotProd filterOffset inputOffset\n VGM.unsafeWrite outBuf i dp\n let (q, r) = quotRem (decimation - filterOffset - 1) interpolation\n inputOffset' = inputOffset + q + 1\n filterOffset' = interpolation - 1 - r\n filterOffset' `seq` inputOffset' `seq` fill (i + 1) filterOffset' inputOffset'\n | otherwise = return filterOffset\n dotProd filterOffset offset = VG.sum $ VG.zipWith mult (VG.unsafeDrop offset inBuf) (stride interpolation (VG.unsafeDrop filterOffset coeffs))\n\npad :: a -> Int -> [a] -> [a]\npad with num list = list ++ replicate (num - length list) with \n\nstrideList :: Int -> [a] -> [a]\nstrideList s xs = go 0 xs\n where\n go _ [] = []\n go 0 (x:xs) = x : go (s-1) xs\n go n (x:xs) = go (n - 1) xs\n\nroundUp :: Int -> Int -> Int\nroundUp num div = ((num + div - 1) `quot` div) * div\n\ndata Coeffs = Coeffs {\n numCoeffs :: Int,\n numGroups :: Int,\n increments :: [Int],\n groups :: [[Float]]\n}\n\nprepareCoeffs :: Int -> Int -> Int -> [Float] -> Coeffs\nprepareCoeffs n interpolation decimation coeffs = Coeffs {..}\n where\n numCoeffs = maximum $ map (length . snd) dats\n numGroups = length groups\n increments = map fst dats\n\n groups :: [[Float]]\n groups = map (pad 0 (roundUp numCoeffs n)) $ map snd dats\n\n dats :: [(Int, [Float])]\n dats = func 0\n where\n\n func' 0 = []\n func' x = func x\n\n func :: Int -> [(Int, [Float])]\n func offset = (increment, strideList interpolation $ drop offset coeffs) : func' offset'\n where\n (q, r) = quotRem (decimation - offset - 1) interpolation\n increment = q + 1\n offset' = interpolation - 1 - r\n\nresampleFFIR :: (Ptr CFloat -> Ptr CFloat -> IO ()) -> VS.Vector Float -> VSM.MVector RealWorld Float -> IO ()\nresampleFFIR func inBuf outBuf = \n VS.unsafeWith (unsafeCoerce inBuf) $ \\iPtr -> \n VS.unsafeWith (unsafeCoerce outBuf) $ \\oPtr -> \n func iPtr oPtr\n\ntype ResampleR = CInt -> CInt -> CInt -> CInt -> Ptr CInt -> Ptr (Ptr CFloat) -> Ptr CFloat -> Ptr CFloat -> IO ()\n\nmkResampler :: ResampleR -> Int -> Int -> Int -> [Float] -> IO (Int -> Int -> VS.Vector Float -> VS.MVector RealWorld Float -> IO ())\nmkResampler func n interpolation decimation coeffs = do\n groupsP <- mapM newArray $ map (map realToFrac) groups\n groupsPP <- newArray groupsP\n incrementsP <- newArray $ map fromIntegral increments\n return $ \\num offset -> resampleFFIR $ func (fromIntegral num) (fromIntegral numCoeffs) (fromIntegral offset) (fromIntegral numGroups) incrementsP groupsPP\n where\n Coeffs {..} = prepareCoeffs n interpolation decimation coeffs\n\ntheBench :: IO ()\ntheBench = do\n --Setup\n let size = 16384\n numCoeffs = 128\n num = size - numCoeffs + 1\n decimation = 4\n interpolation = 3\n numCoeffsDiv2 = 64\n\n coeffsList :: [Float]\n coeffsList = take numCoeffs [0 ..]\n coeffs :: VS.Vector Float\n coeffs = VG.fromList $ take numCoeffs [0 ..]\n coeffsSym :: VS.Vector Float\n coeffsSym = VG.fromList $ take numCoeffsDiv2 [0 ..]\n inBuf :: VS.Vector Float\n inBuf = VG.fromList $ take size [0 ..]\n inBufComplex :: VS.Vector (Complex Float)\n inBufComplex = VG.fromList $ take size $ do\n i <- [0..]\n return $ i :+ i\n\n numConv = 16386\n inBufConv :: VS.Vector CUChar\n inBufConv = VG.fromList $ take size $ concat $ repeat [0 .. 255]\n\n duplicate :: [a] -> [a]\n duplicate = concatMap func\n where func x = [x, x]\n\n coeffs2 :: VS.Vector Float\n coeffs2 = VG.fromList $ duplicate $ take numCoeffs [0 ..]\n\n outBuf :: VS.MVector RealWorld Float <- VGM.new size\n outBufComplex :: VS.MVector RealWorld (Complex Float) <- VGM.new size\n\n --Benchmarks\n defaultMain [\n bgroup \"filter\" [\n bgroup \"real\" [\n bench \"highLevel\" $ nfIO $ filterHighLevel num coeffs inBuf outBuf\n ],\n bgroup \"complex\" [\n bench \"highLevel\" $ nfIO $ filterHighLevel num coeffs inBufComplex outBufComplex\n ]\n ],\n bgroup \"decimate\" [\n bgroup \"real\" [\n bench \"highLevel\" $ nfIO $ decimateHighLevel (num `quot` decimation) decimation coeffs inBuf outBuf\n ],\n bgroup \"complex\" [\n bench \"highLevel\" $ nfIO $ decimateHighLevel (num `quot` decimation) decimation coeffs inBufComplex outBufComplex\n ]\n ],\n bgroup \"resample\" [\n bgroup \"real\" [\n bench \"highLevel\" $ nfIO $ resampleHighLevel (num `quot` decimation) interpolation decimation 0 coeffs inBuf outBuf\n ],\n bgroup \"complex\" [\n bench \"highLevel\" $ nfIO $ resampleHighLevel (num `quot` decimation) interpolation decimation 0 coeffs inBufComplex outBufComplex\n ]\n ]\n ]\n\ntheTest = quickCheck $ conjoin [propFiltersComplex]\n where\n sizes = elements [1024, 2048, 4096, 8192, 16384, 32768, 65536]\n numCoeffs = elements [32, 64, 128, 256, 512]\n factors = elements [1, 2, 3, 4, 7, 9, 12, 15, 21]\n factors' = [1, 2, 3, 4, 7, 9, 12, 15, 21]\n propFiltersReal = forAll sizes $ \\size -> \n forAll (vectorOf size (choose (-10, 10))) $ \\inBuf -> \n forAll numCoeffs $ \\numCoeffs -> \n forAll (vectorOf numCoeffs (choose (-10, 10))) $ \\coeffs -> \n testFiltersReal size numCoeffs coeffs inBuf\n testFiltersReal :: Int -> Int -> [Float] -> [Float] -> Property\n testFiltersReal size numCoeffs coeffs inBuf = monadicIO $ do\n let vCoeffsHalf = VS.fromList coeffs\n vCoeffs = VS.fromList $ coeffs ++ reverse coeffs\n vInput = VS.fromList inBuf\n num = size - numCoeffs*2 + 1\n\n r1 <- run $ getResult num $ filterHighLevel num vCoeffs vInput\n\n propFiltersComplex = forAll sizes $ \\size -> \n forAll (vectorOf size (choose (-10, 10))) $ \\inBufR -> \n forAll (vectorOf size (choose (-10, 10))) $ \\inBufI -> \n forAll numCoeffs $ \\numCoeffs -> \n forAll (vectorOf numCoeffs (choose (-10, 10))) $ \\coeffs -> \n assert $ all (r1 `eqDelta`) [r1]\n testFiltersComplex size numCoeffs coeffs $ zipWith (:+) inBufR inBufI\n testFiltersComplex :: Int -> Int -> [Float] -> [Complex Float] -> Property\n testFiltersComplex size numCoeffs coeffs inBuf = monadicIO $ do\n let vCoeffsHalf = VS.fromList coeffs\n vCoeffs = VS.fromList $ coeffs ++ reverse coeffs\n vInput = VS.fromList inBuf\n num = size - numCoeffs*2 + 1\n --vCoeffs2 = VG.fromList $ duplicate $ coeffs ++ reverse coeffs\n\n r1 <- run $ getResult num $ filterHighLevel num vCoeffs vInput\n\n propDecimationReal = forAll sizes $ \\size -> \n forAll (vectorOf size (choose (-10, 10))) $ \\inBuf -> \n forAll numCoeffs $ \\numCoeffs -> \n forAll (vectorOf numCoeffs (choose (-10, 10))) $ \\coeffs -> \n forAll factors $ \\factor -> \n assert $ all (r1 `eqDeltaC`) [r1]\n testDecimationReal size numCoeffs factor coeffs inBuf\n testDecimationReal :: Int -> Int -> Int -> [Float] -> [Float] -> Property\n testDecimationReal size numCoeffs factor coeffs inBuf = monadicIO $ do\n let vCoeffsHalf = VS.fromList coeffs\n vCoeffs = VS.fromList $ coeffs ++ reverse coeffs\n vInput = VS.fromList inBuf\n num = (size - numCoeffs*2 + 1) `quot` factor\n\n r1 <- run $ getResult num $ decimateHighLevel num factor vCoeffs vInput\n\n propDecimationComplex = forAll sizes $ \\size -> \n forAll (vectorOf size (choose (-10, 10))) $ \\inBufR -> \n forAll (vectorOf size (choose (-10, 10))) $ \\inBufI -> \n forAll numCoeffs $ \\numCoeffs -> \n forAll (vectorOf numCoeffs (choose (-10, 10))) $ \\coeffs -> \n forAll factors $ \\factor -> \n assert $ all (r1 `eqDelta`) [r1]\n testDecimationComplex size numCoeffs factor coeffs $ zipWith (:+) inBufR inBufI\n testDecimationComplex :: Int -> Int -> Int -> [Float] -> [Complex Float] -> Property\n testDecimationComplex size numCoeffs factor coeffs inBuf = monadicIO $ do\n let vCoeffsHalf = VS.fromList coeffs\n vCoeffs = VS.fromList $ coeffs ++ reverse coeffs\n vInput = VS.fromList inBuf\n num = (size - numCoeffs*2 + 1) `quot` factor\n --vCoeffs2 = VG.fromList $ duplicate $ coeffs ++ reverse coeffs\n\n r1 <- run $ getResult num $ decimateHighLevel num factor vCoeffs vInput\n\n propResamplingReal = forAll sizes $ \\size -> \n forAll (vectorOf size (choose (-10, 10))) $ \\inBuf -> \n forAll numCoeffs $ \\numCoeffs -> \n forAll (vectorOf numCoeffs (choose (-10, 10))) $ \\coeffs -> \n forAll (elements $ tail factors') $ \\decimation -> \n forAll (elements $ filter (< decimation) factors') $ \\interpolation -> \n assert $ all (r1 `eqDeltaC`) [r1]\n testResamplingReal size numCoeffs interpolation decimation coeffs inBuf\n testResamplingReal :: Int -> Int -> Int -> Int -> [Float] -> [Float] -> Property\n testResamplingReal size numCoeffs interpolation decimation coeffs inBuf = monadicIO $ do\n let vCoeffsHalf = VS.fromList coeffs\n vCoeffs = VS.fromList $ coeffs ++ reverse coeffs\n vInput = VS.fromList inBuf\n num = (size - numCoeffs*2 + 1) `quot` decimation\n\n r1 <- run $ getResult num $ resampleHighLevel num interpolation decimation 0 vCoeffs vInput\n\n assert $ all (r1 `eqDelta`) [r1]\n getResult :: (VSM.Storable a) => Int -> (VS.MVector RealWorld a -> IO b) -> IO [a]\n getResult size func = do\n outBuf <- VGM.new size\n func outBuf\n out :: VS.Vector a <- VG.freeze outBuf\n return $ VG.toList out\n eqDelta x y = all (uncurry eqDelta') $ zip x y\n where\n eqDelta' x y = abs (x - y) < 0.01\n eqDeltaC x y = all (uncurry eqDelta') $ zip x y\n where\n eqDelta' x y = magnitude (x - y) < 0.01\n duplicate :: [a] -> [a]\n duplicate = concatMap func\n where func x = [x, x]\n\nmain = theBench\n", "meta": {"hexsha": "bb72e4d913b21e48a81a5486fe661cbb65721e17", "size": 16256, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "expts/Benchmark.hs", "max_stars_repo_name": "adamwalker/sdr", "max_stars_repo_head_hexsha": "c7d4d7dacb41039976e11df93adb10d3570cb8ce", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 94, "max_stars_repo_stars_event_min_datetime": "2015-05-10T02:13:53.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-27T16:32:22.000Z", "max_issues_repo_path": "expts/Benchmark.hs", "max_issues_repo_name": "peixian/sdr", "max_issues_repo_head_hexsha": "55bc865ea6c6df2d7e6e9fe6c4c3d02f76a5b2ab", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 4, "max_issues_repo_issues_event_min_datetime": "2015-05-05T19:20:46.000Z", "max_issues_repo_issues_event_max_datetime": "2016-08-02T04:19:15.000Z", "max_forks_repo_path": "expts/Benchmark.hs", "max_forks_repo_name": "adamwalker/sdr", "max_forks_repo_head_hexsha": "c7d4d7dacb41039976e11df93adb10d3570cb8ce", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 12, "max_forks_repo_forks_event_min_datetime": "2015-07-12T11:23:35.000Z", "max_forks_repo_forks_event_max_datetime": "2021-03-10T07:41:21.000Z", "avg_line_length": 46.4457142857, "max_line_length": 172, "alphanum_fraction": 0.5685285433, "num_tokens": 4343, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.7185943805178139, "lm_q2_score": 0.48047867804790706, "lm_q1q2_score": 0.34526927800385393}} {"text": "{-# LANGUAGE TypeFamilies #-}\n-- | Tools for implementing (and debugging the use of) gradient descent schemes.\nmodule HordeAd.Core.OptimizerTools\n ( updateWithGradient\n , gradientIsNil, minimumGradient, maximumGradient\n , ArgsAdam(..), defaultArgsAdam\n , StateAdam(..), initialStateAdam\n , liftMatrix43, updateWithGradientAdam\n ) where\n\nimport Prelude\n\nimport Control.Monad.ST.Strict (runST)\nimport qualified Data.Array.DynamicS as OT\nimport qualified Data.Vector.Generic as V\nimport qualified Data.Vector.Generic.Mutable as VM\nimport HordeAd.Internal.OrthotopeOrphanInstances (liftVT2)\nimport Numeric.LinearAlgebra (Element, Matrix, Numeric, Vector)\nimport qualified Numeric.LinearAlgebra as HM\nimport Numeric.LinearAlgebra.Data (flatten)\nimport Numeric.LinearAlgebra.Devel\n (MatrixOrder (..), liftMatrix, liftMatrix2, matrixFromVector, orderOf)\n\nimport HordeAd.Internal.Delta (Domains, isTensorDummy)\n\n{-\n60% of heap allocation in matrix- and vector-based MNIST\nwith simple gradient descent (no mini-batches) is performed\nby @updateWithGradient.updateVector@ below\n\n let updateVector i r = i - HM.scale gamma r\n\ndue to allocating once in @scale@ and again in @-@\n(and there seems to be one more allocation judging by the numbers).\nSomething like the following code would be needed to eliminate\none allocation, but it would requre the hmatrix maintainer to expose\ninternal modules.\n\nimport Internal.Vectorized\n ( FunCodeSV (Scale), FunCodeVV (Sub), applyRaw, c_vectorMapValR\n , c_vectorZipR, createVector )\n\nminusTimesGamma :: Storable r => r -> Vector r -> Vector r -> Vector r\nminusTimesGamma gamma u v = unsafePerformIO $ do\n r <- createVector (dim0 u)\n pval <- newArray [gamma]\n (v `applyRaw` (r `applyRaw` id))\n (c_vectorMapValR (fromei Scale) pval)\n #| \"minusTimesGamma1\"\n free pval\n (u `applyRaw` (v `applyRaw` (r `applyRaw` id)))\n (c_vectorZipR (fromei Sub))\n #| \"minusTimesGamma2\"\n return r\n\nBTW, a version with HM.Devel.zipVectorWith makes\nthe test twice slower and allocate twice more\n\n let updateVector = zipVectorWith (\\i r -> i - gamma * r)\n\nand a version with Vector.Storable makes the test thrice slower\nand allocate thrice more\n\n let updateVector = V.zipWith (\\i r -> i - gamma * r)\n\nwhich is probably a bug in stream fusion which, additionally in this case,\ncan't fuse with anything and so can't pay for its overhead.\n\n-}\n\nupdateWithGradient :: (Numeric r, Floating (Vector r))\n => r -> Domains r -> Domains r -> Domains r\nupdateWithGradient gamma (params0, params1, params2, paramsX)\n (gradient0, gradient1, gradient2, gradientX) =\n let updateVector i r = i - HM.scale gamma r\n !params0New = updateVector params0 gradient0\n update1 i r = if V.null r -- eval didn't update it, would crash\n then i\n else updateVector i r\n !params1New = V.zipWith update1 params1 gradient1\n update2 i r = if HM.rows r <= 0 -- eval didn't update it, would crash\n then i\n else liftMatrix2 updateVector i r\n !params2New = V.zipWith update2 params2 gradient2\n updateX i r = if isTensorDummy r -- eval didn't update it, would crash\n then i\n else liftVT2 updateVector i r\n -- TODO: this is slow; add @liftArray2@ and use HM,\n -- unless we move away from HM; similarly other OT calls\n !paramsXNew = V.zipWith updateX paramsX gradientX\n in (params0New, params1New, params2New, paramsXNew)\n\ngradientIsNil :: (Eq r, Numeric r)\n => Domains r -> Bool\ngradientIsNil (gradient0, gradient1, gradient2, gradientX) =\n V.all (== 0) gradient0\n && V.all V.null gradient1\n && V.all (\\r -> HM.rows r <= 0) gradient2\n && V.all isTensorDummy gradientX\n\nminimumGradient :: (Ord r, Numeric r)\n => Domains r -> r\nminimumGradient (gradient0, gradient1, gradient2, gradientX) =\n min (if V.null gradient0 then 0 else HM.minElement gradient0)\n (min (if V.null gradient1 then 0\n else V.minimum (V.map HM.minElement gradient1))\n (min (if V.null gradient2 then 0\n else V.minimum (V.map HM.minElement gradient2))\n (if V.null gradientX then 0\n else V.minimum (V.map OT.minimumA gradientX))))\n\nmaximumGradient :: (Ord r, Numeric r)\n => Domains r -> r\nmaximumGradient (gradient0, gradient1, gradient2, gradientX) =\n max (if V.null gradient0 then 0 else HM.maxElement gradient0)\n (max (if V.null gradient1 then 0\n else V.maximum (V.map HM.maxElement gradient1))\n (max (if V.null gradient2 then 0\n else V.maximum (V.map HM.maxElement gradient2))\n (if V.null gradientX then 0\n else V.maximum (V.map OT.maximumA gradientX))))\n\ndata ArgsAdam r = ArgsAdam\n { alpha :: r\n , betaOne :: r\n , betaTwo :: r\n , epsilon :: r\n }\n\n-- The defaults taken from\n-- https://www.tensorflow.org/api_docs/python/tf/keras/optimizers/Adam\ndefaultArgsAdam :: Fractional r => ArgsAdam r\ndefaultArgsAdam = ArgsAdam\n { alpha = 0.001\n , betaOne = 0.9\n , betaTwo = 0.999\n , epsilon = 1e-7\n }\n\ndata StateAdam r = StateAdam\n { tAdam :: Int -- iteration count\n , mAdam :: Domains r\n , vAdam :: Domains r\n }\n\n-- The arguments are just sample params0, for dimensions.\nzeroParameters :: Numeric r\n => Domains r -> Domains r\nzeroParameters (params0, params1, params2, paramsX) =\n let zeroVector v = runST $ do\n vThawed <- V.thaw v\n VM.set vThawed 0\n V.unsafeFreeze vThawed\n in ( zeroVector params0\n , V.map zeroVector params1\n , V.map (liftMatrix zeroVector) params2\n , V.map (\\a -> OT.constant (OT.shapeL a) 0) paramsX ) -- fast allright\n\ninitialStateAdam :: Numeric r\n => Domains r -> StateAdam r\ninitialStateAdam parameters0 =\n let zeroP = zeroParameters parameters0\n in StateAdam\n { tAdam = 0\n , mAdam = zeroP\n , vAdam = zeroP\n }\n\n-- | Application of a vector function on the flattened matrices elements.\nliftMatrix43 :: ( Numeric a, Numeric b, Numeric c, Numeric d\n , Element x, Element y, Element z )\n => (Vector a -> Vector b -> Vector c -> Vector d\n -> (Vector x, Vector y, Vector z))\n -> Matrix a -> Matrix b -> Matrix c -> Matrix d\n -> (Matrix x, Matrix y, Matrix z)\nliftMatrix43 f m1 m2 m3 m4 =\n let sz@(r, c) = HM.size m1\n rowOrder = orderOf m1\n -- checking @m4@ (gradient) makes RNN LL test much faster and BB slower\n -- so this needs much more benchmarking and understading to tweak\n in if sz == HM.size m2 && sz == HM.size m3 && sz == HM.size m4\n then\n let (vx, vy, vz) = case rowOrder of\n RowMajor -> f (flatten m1) (flatten m2) (flatten m3) (flatten m4)\n ColumnMajor -> f (flatten (HM.tr' m1)) (flatten (HM.tr' m2))\n (flatten (HM.tr' m3)) (flatten (HM.tr' m4))\n in ( matrixFromVector rowOrder r c vx\n , matrixFromVector rowOrder r c vy\n , matrixFromVector rowOrder r c vz\n )\n else error $ \"nonconformant matrices in liftMatrix43: \"\n ++ show (HM.size m1, HM.size m2, HM.size m3, HM.size m4)\n\n-- TOOD: make sure this is not worse that OT.zipWith3A when transposing\n-- between each application or that we never encounter such situations\n--\n-- | Application of a vector function on the flattened arrays elements.\nliftArray43 :: ( Numeric a, Numeric b, Numeric c, Numeric d\n , Numeric x, Numeric y, Numeric z )\n => (Vector a -> Vector b -> Vector c -> Vector d\n -> (Vector x, Vector y, Vector z))\n -> OT.Array a -> OT.Array b -> OT.Array c -> OT.Array d\n -> (OT.Array x, OT.Array y, OT.Array z)\nliftArray43 f m1 m2 m3 m4 =\n let sz = OT.shapeL m1\n in if sz == OT.shapeL m2 && sz == OT.shapeL m3 && sz == OT.shapeL m4\n then\n let (vx, vy, vz) = f (OT.toVector m1) (OT.toVector m2)\n (OT.toVector m3) (OT.toVector m4)\n in ( OT.fromVector sz vx\n , OT.fromVector sz vy\n , OT.fromVector sz vz\n )\n else error\n $ \"nonconformant arrays in liftArray43: \"\n ++ show (OT.shapeL m1, OT.shapeL m2, OT.shapeL m3, OT.shapeL m4)\n\nupdateWithGradientAdam\n :: forall r. (Numeric r, Floating r, Floating (Vector r))\n => ArgsAdam r -> StateAdam r -> Domains r -> Domains r\n -> (Domains r, StateAdam r)\nupdateWithGradientAdam ArgsAdam{..}\n StateAdam{ tAdam\n , mAdam = (mAdam0, mAdam1, mAdam2, mAdamX)\n , vAdam = (vAdam0, vAdam1, vAdam2, vAdamX)\n }\n (params0, params1, params2, paramsX)\n (gradient0, gradient1, gradient2, gradientX) =\n let tAdamNew = tAdam + 1\n oneMinusBeta1 = 1 - betaOne\n oneMinusBeta2 = 1 - betaTwo\n updateVector :: Vector r -> Vector r\n -> Vector r -> Vector r\n -> (Vector r, Vector r, Vector r)\n updateVector mA vA p g =\n let mANew = HM.scale betaOne mA + HM.scale oneMinusBeta1 g\n vANew = HM.scale betaTwo vA + HM.scale oneMinusBeta2 (g * g)\n alphat = alpha * sqrt (1 - betaTwo ^ tAdamNew)\n / (1 - betaOne ^ tAdamNew)\n in ( mANew\n , vANew\n , p - HM.scale alphat mANew\n / (sqrt vANew + HM.scalar epsilon) ) -- the @scalar@ is safe\n -- @addConstant@ would be better, but it's not exposed\n (!mAdam0New, !vAdam0New, !params0New) =\n updateVector mAdam0 vAdam0 params0 gradient0\n update1 mA vA p g = if V.null g -- eval didn't update it, would crash\n then (mA, vA, p)\n else updateVector mA vA p g\n (!mAdam1New, !vAdam1New, !params1New) =\n V.unzip3 $ V.zipWith4 update1 mAdam1 vAdam1 params1 gradient1\n update2 mA vA p g = if HM.rows g <= 0 -- eval didn't update it; crash\n then (mA, vA, p)\n else liftMatrix43 updateVector mA vA p g\n (!mAdam2New, !vAdam2New, !params2New) =\n V.unzip3 $ V.zipWith4 update2 mAdam2 vAdam2 params2 gradient2\n updateX mA vA p g = if isTensorDummy g -- eval didn't update it\n then (mA, vA, p)\n else liftArray43 updateVector mA vA p g\n (!mAdamXNew, !vAdamXNew, !paramsXNew) =\n V.unzip3 $ V.zipWith4 updateX mAdamX vAdamX paramsX gradientX\n in ( (params0New, params1New, params2New, paramsXNew)\n , StateAdam { tAdam = tAdamNew\n , mAdam = (mAdam0New, mAdam1New, mAdam2New, mAdamXNew)\n , vAdam = (vAdam0New, vAdam1New, vAdam2New, vAdamXNew)\n }\n )\n", "meta": {"hexsha": "f1e457521ff4d45bc031f59232ae34ffb6800430", "size": 11004, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/HordeAd/Core/OptimizerTools.hs", "max_stars_repo_name": "Mikolaj/horde-ad", "max_stars_repo_head_hexsha": "1629942418f584f6b332dac0a7053338dc3bca70", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/HordeAd/Core/OptimizerTools.hs", "max_issues_repo_name": "Mikolaj/horde-ad", "max_issues_repo_head_hexsha": "1629942418f584f6b332dac0a7053338dc3bca70", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 22, "max_issues_repo_issues_event_min_datetime": "2022-01-27T11:10:21.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-31T12:03:54.000Z", "max_forks_repo_path": "src/HordeAd/Core/OptimizerTools.hs", "max_forks_repo_name": "Mikolaj/horde-ad", "max_forks_repo_head_hexsha": "1629942418f584f6b332dac0a7053338dc3bca70", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 41.0597014925, "max_line_length": 80, "alphanum_fraction": 0.6114140313, "num_tokens": 3003, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6959583250334526, "lm_q2_score": 0.4960938294709195, "lm_q1q2_score": 0.3452606306180124}} {"text": "{-# LANGUAGE OverloadedLists #-}\n\nmodule OBJReader where\n\nimport qualified Data.HashMap as HM\nimport qualified Data.Vector.Storable as VS\nimport qualified Data.Vector as V\nimport Data.Vector.Storable ((!))\nimport Control.Arrow\nimport Control.Lens\nimport Data.List (nub, nubBy)\nimport qualified Numeric.LinearAlgebra as L\nimport qualified Graphics.Rendering.OpenGL.GL as GL\nimport Data.Function (on)\nimport Debug.Trace\n\nimport Physics.Collision\n\nsplitOn x =\n foldr (\\c -> if c == x then ([]:) else over (ix 0) (c:)) [[]]\n\naddP (a,b) (c,d) = (a+b,c+d)\n\ngetFace :: [String] -> [(Int, Int)]\ngetFace =\n map ((\\[v,_,n] -> (read v - 1,read n - 1)) . splitOn '/') . tail\n\nreadVectors :: String -> [[String]] -> [VS.Vector Float]\nreadVectors vtype =\n map (VS.fromList.map read.tail) . filter ((==vtype) . head)\n\nreadPoints = readVectors \"v\"\nreadNormals = readVectors \"vn\"\n\nreadBoxFromObj :: FilePath -> IO Primitive\nreadBoxFromObj fn = do\n text <- map words . lines <$> readFile fn\n let p = V.fromList . readPoints $ text\n q = V.fromList . readNormals $ text\n f = map (V.unsafeIndex p *** V.unsafeIndex q >>> uncurry (flip Squad)) .\n nubBy ((==) `on` snd) .\n map (head . getFace) .\n filter ((==\"f\").head) $ text\n return $ Box p (V.fromList f)\n\nreadOBJ :: FilePath -> IO (VS.Vector Float, VS.Vector GL.BaseInstance,[VS.Vector Float])\nreadOBJ fn = do\n text <- map words . lines <$> readFile fn\n let\n verts = readPoints text\n normals :: [VS.Vector Float]\n normals = readNormals text\n faces = map getFace . filter ((==\"f\").head) $ text\n vertData = nub . concat $ faces\n vertIxMap= HM.fromList . flip zip [0..] $ vertData\n -- u v color\n addColor = (VS.++ [1,1,0.5,0.5,0.5])\n computeT :: [(Int,Int)] -> VS.Vector Float\n computeT [v0, v1, v2] =\n let dpos1 = verts !! fst v1 - verts !! fst v0\n -- dpos2 = verts !! fst v2 - verts !! fst v0\n tang = dpos1\n -- bitan = dpos2\n in tang\n nullTans = HM.fromList . flip zip (repeat $ VS.replicate 3 0) $ vertData\n insertT l h = let p = computeT l\n in foldr (\\k -> HM.insertWith (+) k p) h l\n tangents = foldr insertT nullTans faces\n normalize :: (Int, Int) -> VS.Vector Float -> VS.Vector Float\n normalize (_,k) t =\n let n = normals !! k\n normalizedTangent = normalizeVec $ t - L.scale (L.dot n t) n\n normalizedBitangent = L.cross normalizedTangent n\n in -- n VS.++ t\n normalizedTangent VS.++ normalizedBitangent\n normalizedTangents = HM.fromList . map (fst &&& uncurry normalize) . HM.toList $ tangents\n faceProc p = (verts!!) *** (normals!!) >>> uncurry (VS.++) >>> addColor >>> flip (VS.++) (normalizedTangents HM.! p) $ p\n vBuffData = VS.concat $ map faceProc vertData\n vertices = map ((verts!!).fst) vertData\n indices = VS.fromList . map (vertIxMap HM.!) . concat $ faces\n-- result = VS.concat $ map faceProc faces\n return (vBuffData, indices, vertices)\n\nnormalizeVec :: VS.Vector Float -> VS.Vector Float\nnormalizeVec v = L.scale (realToFrac . (1/) $ L.norm_2 v) v\n\n\n-- compute\n", "meta": {"hexsha": "82ddb8187036969f8cc83184e43150cfe561ab30", "size": 3203, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/OBJReader.hs", "max_stars_repo_name": "Antystenes/CPG", "max_stars_repo_head_hexsha": "9a9e669f30d6816735b5d004cd2ca32bcf2c32bc", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/OBJReader.hs", "max_issues_repo_name": "Antystenes/CPG", "max_issues_repo_head_hexsha": "9a9e669f30d6816735b5d004cd2ca32bcf2c32bc", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/OBJReader.hs", "max_forks_repo_name": "Antystenes/CPG", "max_forks_repo_head_hexsha": "9a9e669f30d6816735b5d004cd2ca32bcf2c32bc", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 35.9887640449, "max_line_length": 124, "alphanum_fraction": 0.604745551, "num_tokens": 938, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.7745833737577158, "lm_q2_score": 0.4455295350395727, "lm_q1q2_score": 0.34509977035965866}} {"text": "import System.Environment\nimport Data.Complex\nimport Paraiso\n\n\nmain = do\n args <- getArgs\n let arch = if \"--cuda\" `elem` args then\n CUDA 128 128\n else\n X86\n putStrLn $ compile arch code\n where\n code = do\n parallel 16384 $ do\n c <- allocate\n z <- allocate \n c =$ (Rand (-2.0) 2.0) :+ (Rand (-2.0) 2.0)\n z =$ (0 :+ 0 :: Complex (Expr Double))\n cuda $ do\n sequential (65536) $ do\n z =$ z * z + c\n output [realPart c,imagPart c, realPart z, imagPart z]\n\n\n", "meta": {"hexsha": "cdb20c7c5d4529e202fd59f39319387c6fd9228c", "size": 596, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "attic/paraiso-2008-ODEsolver/MainMandel.hs", "max_stars_repo_name": "nushio3/Paraiso", "max_stars_repo_head_hexsha": "e9eaea7a8c7384ceb43f8761e4af2f9206a5bbc7", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 21, "max_stars_repo_stars_event_min_datetime": "2015-02-09T22:41:26.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-20T07:13:43.000Z", "max_issues_repo_path": "attic/paraiso-2008-ODEsolver/MainMandel.hs", "max_issues_repo_name": "nushio3/Paraiso", "max_issues_repo_head_hexsha": "e9eaea7a8c7384ceb43f8761e4af2f9206a5bbc7", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2016-09-30T07:17:17.000Z", "max_issues_repo_issues_event_max_datetime": "2016-09-30T07:17:17.000Z", "max_forks_repo_path": "attic/paraiso-2008-ODEsolver/MainMandel.hs", "max_forks_repo_name": "nushio3/Paraiso", "max_forks_repo_head_hexsha": "e9eaea7a8c7384ceb43f8761e4af2f9206a5bbc7", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 8, "max_forks_repo_forks_event_min_datetime": "2015-05-15T01:41:47.000Z", "max_forks_repo_forks_event_max_datetime": "2018-11-18T17:41:56.000Z", "avg_line_length": 22.9230769231, "max_line_length": 65, "alphanum_fraction": 0.4781879195, "num_tokens": 171, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO\n\n", "lm_q1_score": 0.712232184238947, "lm_q2_score": 0.48438008427698437, "lm_q1q2_score": 0.3449910854264418}} {"text": "{-# LANGUAGE NamedFieldPuns #-}\n\nmodule Zambini where\n\nimport Data.Complex\nimport Data.Fixed (mod')\n\nimport Graphics.Gloss.Interface.Pure.Simulate\n\nimport ViewUtil\n\ntype R = Double\ntype C = Complex Double\n\ndata Zambini = Zambini { m :: R -- physical attributes\n , i :: R\n , r :: R\n , fMax :: R\n -- input\n , f1 :: R\n , f2 :: R\n -- state\n , x :: C\n , v :: C\n , theta :: R\n , omega :: R\n }\n\nstep :: R -> Zambini -> Zambini\nstep dt c@Zambini{m, i, r, fMax, f1, f2, x, v, theta, omega} = c{x=x', v=v', theta=theta', omega=omega'}\n where\n f1' = min 1 f1\n f2' = min 1 f2\n a = mkPolar ((f1' + f2') / m) theta\n v' = v + a * realToFrac dt\n x' = x + v' * realToFrac dt\n torque = r * (f1' - f2')\n omega' = omega + torque / i * dt\n theta' = theta + omega' * dt `mod'` 2*pi\n\n\nrender :: Zambini -> Picture\nrender Zambini{f1, f2, x, theta} = move x $ rotateRad (realToFrac theta) $ pictures [zambiniPic, control1 f1, control2 f2]\n where\n zambiniPic = color (greyN 0.5) $ pictures [ polygon [(-5,0), (-10, 25), (10, 25), (5, 0), (10, -25), (-10, -25)]\n , polygon [(0, 10), (20, 0), (0, -10)]\n ]\n\n control = rotate 180 . arrow (5, 20) (15, 100) (low, high)\n where\n low = makeColorI 0 64 192 255\n high = makeColorI 0 160 192 255\n\n control1 = translate (-20) (-20) . control\n control2 = translate (-20) (20) . control\n\n move (x :+ y) = translate (realToFrac x) (realToFrac y)", "meta": {"hexsha": "5c978c540bd27f4e20d5bc6bed92c7fca752b2fc", "size": 1770, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/Zambini.hs", "max_stars_repo_name": "tyehle/control-systems", "max_stars_repo_head_hexsha": "5ebaeb4cdd12085de2383b96580c5bd39a2fba62", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2019-07-09T02:34:32.000Z", "max_stars_repo_stars_event_max_datetime": "2019-07-09T02:34:32.000Z", "max_issues_repo_path": "src/Zambini.hs", "max_issues_repo_name": "tyehle/control-systems", "max_issues_repo_head_hexsha": "5ebaeb4cdd12085de2383b96580c5bd39a2fba62", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/Zambini.hs", "max_forks_repo_name": "tyehle/control-systems", "max_forks_repo_head_hexsha": "5ebaeb4cdd12085de2383b96580c5bd39a2fba62", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 31.0526315789, "max_line_length": 122, "alphanum_fraction": 0.4564971751, "num_tokens": 549, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.7879311956428947, "lm_q2_score": 0.43782349911420193, "lm_q1q2_score": 0.344974793137609}} {"text": "{-# LANGUAGE BangPatterns #-}\n{-# LANGUAGE ForeignFunctionInterface #-}\n{-# HLINT ignore \"Use camelCase\" #-}\n{-|\nModule : Grenade.Layers.Internal.Add\nDescription : Fast functions for performing convolutions and helper functions\nLicense : BSD2\nStability : experimental\n-}\nmodule Grenade.Layers.Internal.Convolution (\n -- * im2col functions\n im2col\n , col2im\n , col2vid\n , vid2col\n\n -- * convolution functions\n , forwardConv2d\n , forwardBiasConv2d\n , backwardConv2d\n , backwardBiasConv2d\n ) where\n\nimport qualified Data.Vector.Storable as U (unsafeFromForeignPtr0,\n unsafeToForeignPtr0)\n\nimport Foreign (mallocForeignPtrArray,\n withForeignPtr)\nimport Foreign.Ptr (Ptr)\nimport Grenade.Types\nimport Numeric.LinearAlgebra (Matrix, Vector, cols, flatten,\n rows)\nimport qualified Numeric.LinearAlgebra as LA\nimport qualified Numeric.LinearAlgebra.Devel as U\nimport System.IO.Unsafe (unsafePerformIO)\n\nimport Grenade.Layers.Internal.Hmatrix\n\n-- | Rearrange the matrix columns into blocks, calculates the number of channels automatically.\ncol2vid :: Int -- ^ kernel rows\n -> Int -- ^ kernel columns \n -> Int -- ^ stride rows\n -> Int -- ^ stride columns\n -> Int -- ^ input height\n -> Int -- ^ input width\n -> Matrix RealNum -- ^ input matrix\n -> Matrix RealNum -- ^ output matrix \ncol2vid kernelRows kernelColumns strideRows strideColumns height width dataCol =\n let channels = cols dataCol `div` (kernelRows * kernelColumns)\n outRows = (height - kernelRows) `div` strideRows + 1\n outCols = (width - kernelColumns) `div` strideColumns + 1\n in col2im_c channels height width kernelRows kernelColumns strideRows strideColumns 0 0 outRows outCols dataCol\n\n-- | Rearrange the matrix columns into blocks, assumes there is only one channel\ncol2im :: Int -- ^ kernel rows\n -> Int -- ^ kernel columns \n -> Int -- ^ stride rows\n -> Int -- ^ stride columns\n -> Int -- ^ input height\n -> Int -- ^ input width\n -> Matrix RealNum -- ^ input matrix\n -> Matrix RealNum -- ^ output matrix \ncol2im kernelRows kernelColumns strideRows strideColumns height width dataCol =\n let channels = 1\n outRows = (height - kernelRows) `div` strideRows + 1\n outCols = (width - kernelColumns) `div` strideColumns + 1\n in col2im_c channels height width kernelRows kernelColumns strideRows strideColumns 0 0 outRows outCols dataCol\n\ncol2im_c :: Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Matrix RealNum -> Matrix RealNum\ncol2im_c channels height width kernelRows kernelColumns strideRows strideColumns padl padt outRows outCols dataCol =\n let vec = flatten dataCol\n in unsafePerformIO $ do\n outPtr <- mallocForeignPtrArray (height * width * channels)\n let (inPtr, _) = U.unsafeToForeignPtr0 vec\n\n withForeignPtr inPtr $ \\inPtr' ->\n withForeignPtr outPtr $ \\outPtr' ->\n col2im_cpu inPtr' channels height width kernelRows kernelColumns strideRows strideColumns padt padl outRows outCols outPtr'\n\n let matVec = U.unsafeFromForeignPtr0 outPtr (height * width * channels)\n return $ U.matrixFromVector U.RowMajor (height * channels) width matVec\n{-# INLINE col2im_c #-}\n\nforeign import ccall unsafe\n col2im_cpu\n :: Ptr RealNum -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Ptr RealNum -> IO ()\n\n-- | Rearrange the matrix blocks into columns, calculates the number of channels automatically.\nvid2col :: Int -- ^ kernel rows\n -> Int -- ^ kernel columns \n -> Int -- ^ stride rows\n -> Int -- ^ stride columns\n -> Int -- ^ input height\n -> Int -- ^ input width\n -> Matrix RealNum -- ^ input matrix\n -> Matrix RealNum -- ^ output matrix \nvid2col kernelRows kernelColumns strideRows strideColumns height width dataVid =\n let channels = rows dataVid `div` height\n rowOut = (height - kernelRows) `div` strideRows + 1\n colOut = (width - kernelColumns) `div` strideColumns + 1\n in im2col_c channels height width kernelRows kernelColumns strideRows strideColumns 0 0 dataVid rowOut colOut\n\n-- | Rearrange the matrix blocks into columns, assumes there is only one channel\nim2col :: Int -- ^ kernel rows\n -> Int -- ^ kernel columns \n -> Int -- ^ stride rows\n -> Int -- ^ stride columns\n -> Matrix RealNum -- ^ input matrix\n -> Matrix RealNum -- ^ output matrix \nim2col kernelRows kernelColumns strideRows strideColumns dataIm =\n let channels = 1\n height = rows dataIm\n width = cols dataIm\n rowOut = (height - kernelRows) `div` strideRows + 1\n colOut = (width - kernelColumns) `div` strideColumns + 1\n in im2col_c channels height width kernelRows kernelColumns strideRows strideColumns 0 0 dataIm rowOut colOut\n\nim2col_c :: Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Matrix RealNum -> Int -> Int -> Matrix RealNum\nim2col_c channels height width kernelRows kernelColumns strideRows strideColumns padl padt dataIm outRows outCols =\n let vec = flatten dataIm\n kernelSize = kernelRows * kernelColumns\n numberOfPatches = outRows * outCols\n in unsafePerformIO $ do\n outPtr <- mallocForeignPtrArray (numberOfPatches * kernelSize * channels)\n let (inPtr, _) = U.unsafeToForeignPtr0 vec\n\n withForeignPtr inPtr $ \\inPtr' ->\n withForeignPtr outPtr $ \\outPtr' ->\n im2col_cpu inPtr' channels height width kernelRows kernelColumns strideRows strideColumns padt padl outRows outCols outPtr'\n\n let matVec = U.unsafeFromForeignPtr0 outPtr (numberOfPatches * kernelSize * channels)\n return $ U.matrixFromVector U.RowMajor (kernelSize * channels) numberOfPatches matVec\n{-# INLINE im2col_c #-}\n\nforeign import ccall unsafe\n im2col_cpu\n :: Ptr RealNum -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Ptr RealNum -> IO ()\n\nforeign import ccall unsafe\n in_place_add_per_channel_cpu\n :: Ptr RealNum -> Int -> Int -> Int -> Ptr RealNum -> IO ()\n\n-- | Efficient implementation of convolutions using the im2col trick as popularised by Caffe\nforwardConv2d :: Matrix RealNum -- ^ input\n -> Int -- ^ input channels\n -> Int -- ^ input rows\n -> Int -- ^ input columns\n -> Matrix RealNum -- ^ kernel\n -> Int -- ^ kernel filters\n -> Int -- ^ kernel rows\n -> Int -- ^ kernel columns\n -> Int -- ^ stride height\n -> Int -- ^ stride width\n -> Int -- ^ output rows\n -> Int -- ^ output columns\n -> Int -- ^ pad left\n -> Int -- ^ pad top\n -> Matrix RealNum -- ^ output of convolution\nforwardConv2d input channels rows cols kernel filters kernelRows kernelCols strideRows strideCols outRows outCols padLeft padTop\n = let dataCol = im2col_c channels rows cols kernelRows kernelCols strideRows strideCols padLeft padTop input outRows outCols\n gemmM = LA.tr kernel LA.<> dataCol\n dataVid = reshapeMatrix (filters * outRows) outCols gemmM\n in dataVid\n\n-- | Efficient implementation of convolutions using the im2col trick as popularised by Caffe\n-- also adds some bias to the functions, note that it does it in place to prevent unnecessary allocation.\nforwardBiasConv2d :: Matrix RealNum -- ^ input\n -> Int -- ^ input channels\n -> Int -- ^ input rows\n -> Int -- ^ input columns\n -> Vector RealNum -- ^ bias\n -> Matrix RealNum -- ^ kernel\n -> Int -- ^ kernel filters\n -> Int -- ^ kernel rows\n -> Int -- ^ kernel columns\n -> Int -- ^ stride height\n -> Int -- ^ stride width\n -> Int -- ^ output rows\n -> Int -- ^ output columns\n -> Int -- ^ pad left\n -> Int -- ^ pad top\n -> Matrix RealNum -- ^ output of convolution\nforwardBiasConv2d input channels rows cols bias kernel filters kernelRows kernelCols strideRows strideCols outRows outCols padLeft padTop =\n let outSize = outRows * outCols * filters\n in unsafePerformIO $ do\n let dataCol = im2col_c channels rows cols kernelRows kernelCols strideRows strideCols padLeft padTop input outRows outCols\n gemmM = LA.tr kernel LA.<> dataCol\n dataVid = flatten gemmM\n (xPtr, _) = U.unsafeToForeignPtr0 dataVid\n (bPtr, _) = U.unsafeToForeignPtr0 bias\n\n withForeignPtr xPtr $ \\xPtr' ->\n withForeignPtr bPtr $ \\bPtr' ->\n in_place_add_per_channel_cpu xPtr' filters outRows outCols bPtr'\n\n let matVec = U.unsafeFromForeignPtr0 xPtr outSize\n return $ U.matrixFromVector U.RowMajor (outRows * filters) outCols matVec\n\n-- | Efficient implementation of the backward pass for convolutions using the im2col trick as popularised by Caffe\nbackwardConv2d :: Matrix RealNum -- ^ input\n -> Int -- ^ input channels\n -> Int -- ^ input rows\n -> Int -- ^ input columns\n -> Matrix RealNum -- ^ kernel\n -> Int -- ^ kernel filters\n -> Int -- ^ kernel rows\n -> Int -- ^ kernel columns\n -> Int -- ^ stride height\n -> Int -- ^ stride width\n -> Int -- ^ pad left\n -> Int -- ^ pad top\n -> Int -- ^ pad right\n -> Int -- ^ pad bottom\n -> Matrix RealNum -- ^ derivative wrt out of layer\n -> Int -- ^ output rows\n -> Int -- ^ output columns\n -> (Matrix RealNum, Matrix RealNum) -- ^ (derivated wrt input, derivative wrt kernel)\nbackwardConv2d input channels rows cols kernel filters kernelRows kernelCols strideRows strideCols padl padt padr padb dout outRows outCols =\n let dout' = LA.reshape (outRows * outCols) $ LA.flatten dout\n dX_col = kernel LA.<> dout'\n rowCol = (div (rows + padt + padb - kernelRows) strideRows) + 1\n colCol = (div (cols + padl + padr - kernelCols) strideCols) + 1\n dX = col2im_c channels rows cols kernelRows kernelCols strideRows strideCols padl padt rowCol colCol dX_col\n\n x_col = im2col_c channels rows cols kernelRows kernelCols strideRows strideCols padl padt input outRows outCols\n dw_col = dout' LA.<> (LA.tr x_col)\n dw = LA.tr $ reshapeMatrix filters (kernelRows * kernelCols * channels) dw_col \n in (dX, dw) \n\n-- | Efficient implementation of the backward pass for convolutions using the im2col trick as popularised by Caffe\nbackwardBiasConv2d :: Matrix RealNum -- ^ input\n -> Int -- ^ input channels\n -> Int -- ^ input rows\n -> Int -- ^ input columns\n -> Matrix RealNum -- ^ kernel\n -> Int -- ^ kernel filters\n -> Int -- ^ kernel rows\n -> Int -- ^ kernel columns\n -> Int -- ^ stride height\n -> Int -- ^ stride width\n -> Int -- ^ pad left\n -> Int -- ^ pad top\n -> Int -- ^ pad right\n -> Int -- ^ pad bottom\n -> Matrix RealNum -- ^ derivative wrt out of layer\n -> Int -- ^ output rows\n -> Int -- ^ output columns\n -> (Matrix RealNum, Matrix RealNum, Vector RealNum) -- ^ (derivated wrt input, derivative wrt kernel, derivative wrt bias)\nbackwardBiasConv2d input channels rows cols kernel filters kernelRows kernelCols strideRows strideCols padl padt padr padb dout outRows outCols =\n let (dX, dw) = backwardConv2d input channels rows cols kernel filters kernelRows kernelCols strideRows strideCols padl padt padr padb dout outRows outCols\n dB = sum_over_channels_c dout filters outRows outCols\n in (dX, dw, dB)\n\nsum_over_channels_c :: Matrix RealNum -> Int -> Int -> Int -> Vector RealNum\nsum_over_channels_c mat channels rows cols = unsafePerformIO $ do\n let (xPtr, _) = U.unsafeToForeignPtr0 . flatten $ mat\n outPtr <- mallocForeignPtrArray channels\n\n withForeignPtr xPtr $ \\xPtr' ->\n withForeignPtr outPtr $ \\outPtr' ->\n sum_over_channels_cpu xPtr' channels rows cols outPtr'\n\n return $ U.unsafeFromForeignPtr0 outPtr channels\n\nforeign import ccall unsafe\n sum_over_channels_cpu\n :: Ptr RealNum -> Int -> Int -> Int -> Ptr RealNum -> IO ()\n", "meta": {"hexsha": "7231eb1e040915813837ac55c63b2b35d7e37c98", "size": 13496, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/Grenade/Layers/Internal/Convolution.hs", "max_stars_repo_name": "th-char/grenade", "max_stars_repo_head_hexsha": "0be658e7cf07562cd5e4170ed1e8875ccec14cdb", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-06-09T06:06:26.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-09T06:06:26.000Z", "max_issues_repo_path": "src/Grenade/Layers/Internal/Convolution.hs", "max_issues_repo_name": "th-char/grenade", "max_issues_repo_head_hexsha": "0be658e7cf07562cd5e4170ed1e8875ccec14cdb", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/Grenade/Layers/Internal/Convolution.hs", "max_forks_repo_name": "th-char/grenade", "max_forks_repo_head_hexsha": "0be658e7cf07562cd5e4170ed1e8875ccec14cdb", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 50.3582089552, "max_line_length": 156, "alphanum_fraction": 0.5878037937, "num_tokens": 3140, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.7401743735019594, "lm_q2_score": 0.46490157137338844, "lm_q1q2_score": 0.34410822933137425}} {"text": "{-# LANGUAGE TemplateHaskell #-}\n{-# LANGUAGE RankNTypes #-}\n\nmodule Main(main) where\n\nimport Graphics.Gloss (Display, Color, Picture(..),\n circleSolid, red, color, translate, dark,\n pictures, black, white, rotate)\nimport Graphics.Gloss.Data.ViewPort\nimport Graphics.Gloss.Interface.Pure.Game (\n Event(EventKey)\n , MouseButton(..)\n , Key(Char, MouseButton)\n , KeyState(Up, Down)\n , play\n , Display(InWindow)\n )\n\nimport qualified Data.Map.Strict as Map\nimport Data.List (elemIndex, mapAccumL, partition)\nimport Data.Tuple (swap)\nimport Data.Maybe (catMaybes)\nimport System.Random\nimport Control.Monad.State\n\nimport Control.Lens\n\n{-} ###########\n # PHYSICS #\n ########### -}\n\nimport Data.Complex\n\ntype Vector = Complex Float\nj :: Vector\nj = 0:+1\n\nnormalize :: RealFloat a => Complex a -> Complex a\nnormalize (0:+0) = 0:+0\nnormalize a = a / (sqrt $ a * conjugate a)\n\ntoxy :: Complex a -> (a, a)\ntoxy (x :+ y) = (x, y)\n\ntoVector :: Float -> Vector\ntoVector x = x:+0\n\n{-} ##############\n # STRUCTURES #\n ############## -}\n\ndata Ball = Ball Vector Vector Float\ndata Timer = Timer\n { _total :: Float\n , _actual :: Float \n }\nmakeLenses ''Timer\n\ndata Body = Body Ball Int\n\ndata Entity d = Entity {\n _pos :: Vector\n , _vel :: Vector\n , _rad :: Float\n , _lifes :: Int\n , _damage :: Int\n , _body :: d\n }\nmakeLenses ''Entity\n\ntype Bullet = Entity ()\ntype Barrel = Entity ()\ntype Player = Entity ()\ntype Smoke = Entity Timer\n\ndata Satelite = Satelite Float Float Float Float Float Float -- r w h rot v t\n\ndata MonsterData = MonsterData {\n _hull :: [Satelite]\n , _shift :: Int\n }\nmakeLenses ''MonsterData\n\ntype Monster = Entity MonsterData\n\ndata Game = Game { \n _player :: Player\n , _keyboard :: Map.Map Key KeyState\n , _bullets :: [Bullet]\n , _barrels :: [Barrel]\n , _clicks :: [Vector]\n , _smoke :: [Smoke]\n , _seed :: StdGen\n , _ticks :: Int\n , _monsters :: [Monster]\n }\nmakeLenses ''Game\n\n{-} ##########\n # ENTITY #\n ########## -}\n\nrenderBody :: Entity e -> Picture\nrenderBody ent = translate x y $\n color white $\n circleSolid (ent^.rad)\n where (x:+y) = ent^.pos\n\nupdateBody :: Float -> Entity e -> Entity e\nupdateBody time ent = ent & pos +~ (toVector time)*(ent^.vel)\n\ncollide :: Entity a -> Entity b -> Bool\ncollide a b = (realPart $ abs $ (a^.pos - b^.pos)) < (a^.rad + b^.rad)\n\nisAlive :: Entity e -> Bool\nisAlive ent = (ent^.lifes) > 0\n\n{-} ##########\n # GAME #\n ########## -}\n\nwindow :: Display\nwindow = InWindow \"JampaZen\" (500, 500) (5, 5) -- w, h, offset\n\nbackground :: Color\nbackground = black\n\ninitialState :: Game\ninitialState = Game\n { _player = Entity\n { _pos = 0\n , _vel = 0\n , _rad = 10\n , _lifes = 10\n , _damage = 1\n , _body = ()\n }\n , _keyboard = Map.fromList $ zip (map Char \"wasd\") (repeat Up)\n , _bullets = []\n , _barrels = []\n , _monsters = []\n , _clicks = []\n , _smoke = []\n , _seed = mkStdGen 1\n , _ticks = 0\n }\n\nfps :: Int\nfps = 60\n\nhandleKeys :: Event -> Game -> Game\nhandleKeys (EventKey (Char key) keystate _ _) =\n keyboard %~ Map.adjust (const keystate) (Char key)\nhandleKeys (EventKey (MouseButton LeftButton) Down _ (mx, my)) =\n clicks %~ (:) (mx:+my)\nhandleKeys _ = id\n\nrenderGame :: Game -> Picture\nrenderGame game =\n let (mx:+my) = game^.player.pos\n canmap x = map renderBody (game^.x)\n in translate (-mx) (-my) $ \n pictures $ concat $ [\n [renderBody (game^.player)]\n , map renderBody (game^.bullets)\n , map renderSmoke (game^.smoke)\n , map renderMonster (game^.monsters)\n ]\n\nupdateGame :: Float -> Game -> Game\nupdateGame time game =\n game & ifPlayerAlive shot\n & removeSmoke\n & onceUpon 4 bulletSmoke\n & ifPlayerAlive (onceUpon 50 spawnMonster)\n & playerMove\n & collisions\n & player %~ updateBody time\n & bullets %~ map (updateBody time)\n & smoke %~ map (updateSmoke time)\n & monsters %~ map (updateMonster time game)\n & ticks +~ 1\n\nmain :: IO ()\nmain = play window background fps initialState renderGame handleKeys updateGame\n\n\n{-} ########\n # SHOT #\n ######## -}\n\nnewBullet :: Vector -> Vector -> Bullet\nnewBullet p v = Entity\n { _pos=p, _vel=v, _rad=5, _lifes=1, _damage=1, _body=()}\n\nshot :: Game -> Game\nshot game = game & (clicks .~ [])\n & (bullets %~ (++) newBullets)\n where newBullets = (newBullet (game^.player.pos) . (500*) . normalize) <$> game^.clicks\n\n{-} ##############\n # EXPLOSIONS #\n ############## -}\n\nrandomSt :: (Float, Float) -> State StdGen Float \nrandomSt = state . randomR\n\ngenerateExplosionSmoke :: Float -> Vector -> State StdGen Smoke\ngenerateExplosionSmoke size pos = do\n pa <- randomSt (0, 2*pi)\n pr <- randomSt (0, 5*size)\n let p = mkPolar pr pa\n va <- randomSt (0, 2*pi)\n vr <- randomSt (10, 10*size)\n let v = mkPolar vr va\n r <- randomSt (10, 50)\n ttl <- randomSt (0.25, (sqrt size)/3)\n return Entity {_pos=p+pos, _vel=v, _rad=r,\n _lifes=1, _damage=0, _body=newTimer ttl}\n\ngenerateExplosion :: Float -> Vector -> Game -> Game\ngenerateExplosion size pos game =\n game & seed .~ seed'\n & smoke %~ (++) newsmoke\n where\n (newsmoke, seed') = flip runState (game^.seed) $\n sequence $ take 30 $ repeat $ generateExplosionSmoke size pos\n\n{-} ##############\n # COLLISIONS #\n ############## -}\n\n-- two entities collide\n(<..>) :: Entity a -> Entity b -> (Entity a, Entity b)\na <..> b | collide a b && isAlive a && isAlive b = (,)\n (a & lifes %~ flip (-) (b^.damage))\n (b & lifes %~ flip (-) (a^.damage))\n | otherwise = (a, b)\n\n(<.+>) :: Entity a -> [Entity b] -> (Entity a, [Entity b]) \n(<.+>) = mapAccumL (<..>)\n\n(<+.>) :: [Entity a] -> Entity b -> ([Entity a], Entity b) \n(<+.>) as b = swap $ b <.+> as\n\n-- two list of entities collide\n(<++>) :: [Entity a] -> [Entity b] -> ([Entity a], [Entity b])\n(<++>) = mapAccumL (<+.>)\n\nsmash :: Lens' Game [Entity a]\n -> Lens' Game [Entity b]\n -> (Entity a -> Game -> Game)\n -> (Entity b -> Game -> Game)\n -> Game -> Game\n\n--smash as bs destroyA destroyB b game =\nsmash as bs destroyA destroyB game =\n game & as .~ aliveAs\n & bs .~ aliveBs\n & foldr (.) id destructions\n where\n (as', bs') = (game^.as) <++> (game^.bs)\n (aliveAs, deadAs) = partition isAlive as'\n (aliveBs, deadBs) = partition isAlive bs'\n destructions = map destroyA deadAs ++ map destroyB deadBs\n\ncollisions :: Game -> Game\ncollisions =\n smash bullets monsters destroyBullet destroyMonster\n\n{-} #########\n # TIMER #\n ######### -}\n\nnewTimer :: Float -> Timer\nnewTimer time = Timer {_total=time, _actual=time}\n\n\nonceUpon :: Int -> (Game -> Game) -> Game -> Game\nonceUpon n f game | game^.ticks `mod` n == 0 = f game\n | otherwise = game \n\n{-} ##########\n # PLAYER #\n ########## -}\n\nplayerMove game = game & player.vel .~ 100*normalize (keyboardToVector $ game^.keyboard)\n\nifPlayerAlive :: (Game -> Game) -> Game -> Game\nifPlayerAlive f game = if isAlive (game^.player) then f game else game\n\nstateToScalar :: KeyState -> Vector\nstateToScalar Up = 1\nstateToScalar Down = 0\n\nkeyToVector :: Key -> Vector\nkeyToVector (Char c) = maybe 0 (j^) (elemIndex c \"asdw\")\n\nkeyboardToVector :: Map.Map Key KeyState -> Vector\nkeyboardToVector = Map.foldrWithKey f (0:+0) where\n f k v a = a + (stateToScalar v)*(keyToVector k)\n\ndestroyPlayer :: Player -> Game -> Game\ndestroyPlayer player = generateExplosion 100 (player^.pos)\n\n{-} ###########\n # SMOKE #\n ########### -}\n\nbulletSmoke :: Game -> Game\nbulletSmoke game = game & smoke %~ (++) (map bulletToSmoke $ game^.bullets) \n where bulletToSmoke bullet = Entity{\n _pos=bullet^.pos\n , _vel=0\n , _rad=bullet^.rad\n , _lifes=1\n , _damage= 0\n , _body=newTimer 0.25\n }\n\nupdateSmoke :: Float -> Smoke -> Smoke\nupdateSmoke time = (updateBody time) . (body.actual -~ time)\n\nrenderSmoke smoke = translate x y $\n color white $\n circleSolid r\n where (x:+y) = smoke^.pos\n r = smoke^.rad * smoke^.body.actual / smoke^.body.total\n\nremoveSmoke :: Game -> Game\nremoveSmoke = smoke %~ filter ((>0) . (^.body.actual))\n\n{-} ##########\n # BULLET #\n ########## -}\n\ndestroyBullet :: Bullet -> Game -> Game\ndestroyBullet = const id\n\n{-} ###########\n # MONSTER #\n ########### -}\n\ngenerateSatelite :: State StdGen Satelite\ngenerateSatelite = do\n r <- randomSt (10, 20)\n w <- randomSt (10, 50)\n h <- randomSt (10, 50)\n v <- randomSt (1, 5)\n t <- randomSt (0, 2*pi)\n rot <- randomSt (0, 2*pi)\n o <- signum <$> randomSt (-1, 1) -- orientation\n return $ Satelite r w h rot (o*v) t\n\ngenerateMonster :: Vector -> Game -> Game\ngenerateMonster p game =\n game & seed .~ seed'\n & monsters %~ (:) Entity {\n _pos=p\n , _vel=0\n , _rad=50\n , _lifes=3\n , _damage=1\n , _body=MonsterData {\n _hull=hull'\n , _shift=game^.ticks\n }\n }\n where (hull', seed') = flip runState (game^.seed) $\n sequence $ take 20 $ repeat $ generateSatelite\n\nspawnMonster :: Game -> Game\nspawnMonster game = \n game & generateMonster (mkPolar d a)\n & seed .~ seed'\n where ((a, d), seed') = runState randomMonster (game^.seed)\n randomMonster = do\n a <- randomSt (0, 2*pi)\n d <- randomSt (1000, 2000)\n return (a, d)\n\n\nrenderSatelite :: Satelite -> Picture\nrenderSatelite (Satelite r w h rot v t) =\n rotate rot $\n translate (w*cos t) (h*sin t)$\n color white $\n circleSolid r\n\nupdateSatelite :: Float -> Satelite -> Satelite\nupdateSatelite time (Satelite r w h rot v t) = (Satelite r w h rot v (t + v*time))\n\nupdateMonster :: Float -> Game -> Monster -> Monster\nupdateMonster time game monster = \n monster & updateBody time\n & followPlayer \n & body.hull %~ map (updateSatelite time)\n where\n pp = game^.player.pos\n mp = monster^.pos\n followPlayer\n | ((game^.ticks) + (monster^.body.shift)) `mod` 120 /= 0 = id\n | otherwise = vel .~ 100*normalize (pp - mp)\n\nrenderMonster :: Monster -> Picture\nrenderMonster monster =\n translate x y $ pictures $ renderSatelite <$> (monster^.body.hull)\n where (x:+y) = monster^.pos\n\ndestroyMonster :: Monster -> Game -> Game\ndestroyMonster monster = generateExplosion 15 (monster^.pos)", "meta": {"hexsha": "e63ab467d2c6b47f9f240d829eefb42f3b492c8e", "size": 10885, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "Main.hs", "max_stars_repo_name": "jarys/jampazen", "max_stars_repo_head_hexsha": "639eefbf6ee724944edf4f64f5b43efe2dc66cd6", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Main.hs", "max_issues_repo_name": "jarys/jampazen", "max_issues_repo_head_hexsha": "639eefbf6ee724944edf4f64f5b43efe2dc66cd6", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Main.hs", "max_forks_repo_name": "jarys/jampazen", "max_forks_repo_head_hexsha": "639eefbf6ee724944edf4f64f5b43efe2dc66cd6", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 26.4841849148, "max_line_length": 93, "alphanum_fraction": 0.5538814883, "num_tokens": 3117, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.785308580887758, "lm_q2_score": 0.4378234991142019, "lm_q1q2_score": 0.34382655076868646}} {"text": "{-# LANGUAGE UndecidableInstances #-}\n{-# LANGUAGE BangPatterns, \n ScopedTypeVariables,\n RecordWildCards,\n FlexibleContexts,\n TypeFamilies #-}\nimport Data.IDX (IDXData, decodeIDXFile, idxIntContent ) \n{------------------------}\nimport Numeric.LinearAlgebra as NL (cmap, (#>), vjoin, Numeric, Vector, fromList )\n{------------------------}\nimport Data.Vector.Unboxed as DTU ( toList )\nimport qualified Data.Vector.Storable as DT\nimport Data.List (sort)\nimport Prelude hiding (readFile)\nimport Neuro\n ( ActivationFunction, Network(..), loadNetwork )\n\n\nkol_vo :: Int\nkol_vo = 1000\n\nmain :: IO ()\nmain = do\n res <- loadNetwork \"smartNet5.nn\" \n Just idxTrain <- decodeIDXFile \"test/t10k-images.idx3-ubyte\" -- image\n Just idxResult <- decodeIDXFile \"test/t10k-labels.idx1-ubyte\" -- result\n --writeFile \"resNeuro.txt\" (concat $ take (28*kol_vo) $ drowImage idxTrain)\n --writeFile \"resLabel.txt\" (show $ take kol_vo $ DTU.toList $ idxIntContent idxResult)\n putStrLn \"\u0422\u043e\u0447\u043d\u043e\u0441\u0442\u044c \u0430\u043b\u0433\u043e\u0440\u0438\u0442\u043c\u0430 :\"\n print $ (\\x -> (fromIntegral x) / fromIntegral kol_vo) $ length $ filter (\\((_,x),y) -> x == y) $ flip zip (filterCorrect idxResult) $ printRes kol_vo res idxTrain $ DTU.toList $ idxIntContent idxResult \n where filterCorrect idxResult = reverse $ take kol_vo $ DTU.toList $ idxIntContent idxResult\n\nprintRes :: Int -> Network Double -> IDXData -> t -> [(Double,Int)]\nprintRes 0 _ _ _ = []\nprintRes x res idxTrain idxResult = last (sort $ flip zip [0..] $ softmax $ DT.toList $ Main.output res tanh (last $ take x $ image idxTrain)) : printRes (x-1) res idxTrain idxResult\n\noutput :: (Floating (Vector a), Numeric a, DT.Storable a, Num (Vector a)) => Network a -> ActivationFunction a -> Vector a -> Vector a\noutput (Network{..}) act input = foldl f (vjoin [input, 1]) matrices\n where f (!inp) m = cmap act $ m #> inp\n\nsoftmax :: [Double] -> [Double]\nsoftmax xs = let xs' = exp <$> xs\n s = sum xs'\n in map (/ s) xs'\n\ndrowImage :: IDXData -> [String]\ndrowImage = _0_255to0or1 . DTU.toList . idxIntContent\n\n_0_255to0or1 :: [Int] -> [String]\n_0_255to0or1 [] = []\n_0_255to0or1 xs = (show (concat $ fmap show $ convert $ take 28 xs) ++ \" \\n\") : _0_255to0or1 (drop 28 xs)\n\nconvert [] = []\nconvert (x:xs) \n | x > 240 = 1 : convert xs\n | otherwise = 0 : convert xs\n\n\nimage :: IDXData -> [Vector Double]\nimage = matrix2x2 . _0_1to0_255 . DTU.toList . idxIntContent\nresult :: IDXData -> [Vector Double]\nresult = unitar . DTU.toList . idxIntContent\n\n\nunitar :: [Int] -> [NL.Vector Double]\nunitar [] = [] \nunitar (0:xs) = NL.fromList [1,-1,-1,-1,-1,-1,-1,-1,-1,-1] : unitar xs\nunitar (1:xs) = NL.fromList [-1,1,-1,-1,-1,-1,-1,-1,-1,-1] : unitar xs\nunitar (2:xs) = NL.fromList [-1,-1,1,-1,-1,-1,-1,-1,-1,-1] : unitar xs\nunitar (3:xs) = NL.fromList [-1,-1,-1,1,-1,-1,-1,-1,-1,-1] : unitar xs\nunitar (4:xs) = NL.fromList [-1,-1,-1,-1,1,-1,-1,-1,-1,-1] : unitar xs\nunitar (5:xs) = NL.fromList [-1,-1,-1,-1,-1,1,-1,-1,-1,-1] : unitar xs\nunitar (6:xs) = NL.fromList [-1,-1,-1,-1,-1,-1,1,-1,-1,-1] : unitar xs\nunitar (7:xs) = NL.fromList [-1,-1,-1,-1,-1,-1,-1,1,-1,-1] : unitar xs\nunitar (8:xs) = NL.fromList [-1,-1,-1,-1,-1,-1,-1,-1,1,-1] : unitar xs\nunitar (9:xs) = NL.fromList [-1,-1,-1,-1,-1,-1,-1,-1,-1,1] : unitar xs\n\n_0_1to0_255 :: [Int] -> [Double]\n_0_1to0_255 [] = []\n_0_1to0_255 (x:xs) = (fromIntegral x / 255) : _0_1to0_255 xs\n\nmatrix2x2 :: [Double] -> [NL.Vector Double]\nmatrix2x2 [] = []\nmatrix2x2 xs = NL.fromList (Prelude.take 784 xs) : matrix2x2 (Prelude.drop 784 xs)\n", "meta": {"hexsha": "21fe0ad5b0fe89ccd4fab8f2f226a4092062e131", "size": 3636, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "test/Spec.hs", "max_stars_repo_name": "Alexander671/neuroLiquid", "max_stars_repo_head_hexsha": "48e816930b6b62b3fd4418190efaf2e71739cc4d", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "test/Spec.hs", "max_issues_repo_name": "Alexander671/neuroLiquid", "max_issues_repo_head_hexsha": "48e816930b6b62b3fd4418190efaf2e71739cc4d", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "test/Spec.hs", "max_forks_repo_name": "Alexander671/neuroLiquid", "max_forks_repo_head_hexsha": "48e816930b6b62b3fd4418190efaf2e71739cc4d", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 42.7764705882, "max_line_length": 212, "alphanum_fraction": 0.6086358636, "num_tokens": 1256, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO\n\n", "lm_q1_score": 0.7905303087996142, "lm_q2_score": 0.4339814648038985, "lm_q1q2_score": 0.34307550138473475}} {"text": "{-# LANGUAGE CPP, OverloadedStrings, TypeOperators #-}\n\nmodule Main where\n\nimport Control.Exception\nimport qualified Data.Array.Accelerate as A\nimport qualified Data.Array.Accelerate.Interpreter as ALI\nimport Data.Array.Accelerate.Math.Hilbert\nimport Data.Array.Accelerate.Math.Qtfd\nimport Data.Array.Accelerate.Math.WindowFunc\nimport Data.Attoparsec.Text\nimport ParseArgs\nimport ParseFile\nimport System.Directory\n#ifdef ACCELERATE_LLVM_NATIVE_BACKEND\nimport qualified Data.Array.Accelerate.LLVM.Native as ALN\n#endif\n#ifdef ACCELERATE_LLVM_PTX_BACKEND\nimport qualified Data.Array.Accelerate.LLVM.PTX as ALP\n#endif\nimport Data.Array.Accelerate.Array.Sugar as S\nimport qualified Data.ByteString.Builder as BB\nimport Data.Complex\nimport qualified Data.Double.Conversion.Convertable as DC\nimport Data.List\nimport Data.Monoid\nimport qualified Data.Text as T\nimport qualified Data.Text.IO as TI\nimport qualified Data.Vector as V\nimport GHC.Float\nimport Math.Gamma\nimport System.IO\n\n\nmain :: IO ()\nmain = do\n args <- opts\n makeQTFDAll args\n\n-- | Transform data to text(using Float conversion. It is much faster) and write it to file.\n\nwriteData ::\n Handle -- ^ output file\n -> [Float] -- ^ Data to write\n -> Int -- ^ number of element\n -> Int -- ^ elements per row\n -> IO ()\nwriteData _ [] _ _ = return ()\nwriteData file (x:xs) w n = do\n TI.hPutStr file $ DC.toPrecision 5 x <> \" \"\n if (n `mod` w) == 0\n then do\n TI.hPutStr file \"\\n\"\n writeData file xs w (n + 1)\n else writeData file xs w (n + 1)\n\nmakeString ::\n Handle\n -> [Float] -- ^ Data to write\n -> Int -- ^ number of element\n -> Int -- ^ elements per row\n -> BB.Builder\n -> IO ()\nmakeString _ [] _ _ _ = return ()\nmakeString file (x:xs) w n acc =\n if (n `mod` w) == 0\n then BB.hPutBuilder file (acc <> DC.toPrecision 5 x <> \" \" <> \"\\n\") >> makeString file xs w (n+1) \"\"\n else makeString file xs w (n+1) (acc <> DC.toPrecision 5 x <> \" \")\n\n-- | make Pseudo Wigner-Ville transform to all files in a directory.\n\nmakeQTFDAll :: Opts -> IO ()\nmakeQTFDAll opts = do\n let path = getPath opts\n nosAVGflag = subAVGflag opts\n files <- listDirectory path\n setCurrentDirectory path\n let fFiles = filter (isSuffixOf \".txt\") files\n sAVGflag = A.constant $ not nosAVGflag\n case opts of\n (OptsPWV _ dev wlen wfun _) ->\n do\n if (even wlen)\n then error \"Window length maust be odd !\"\n else\n do\n let window = makeWindow wfun (A.unit $ A.constant wlen) :: A.Acc (A.Array A.DIM1 Float)\n mapM_ (makePWV dev window sAVGflag) fFiles\n (OptsWV path dev nosAVGflag) -> mapM_ (makeWV dev sAVGflag) fFiles\n (OptsCW path dev sigma uWindow uWindowFunc nWindow nWindowFunc normalise nosAVGflag) ->\n do\n if (even uWindow || even nWindow)\n then error \"Window length maust be odd !\"\n else\n let uWindowArray = makeWindow uWindowFunc (A.unit $ A.constant uWindow) :: A.Acc (A.Array A.DIM1 Float)\n nWindowArray = makeWindow nWindowFunc (A.unit $ A.constant nWindow) :: A.Acc (A.Array A.DIM1 Float)\n bothRectangular = uWindowFunc == Rect && nWindowFunc == Rect\n in mapM_ (makeCW dev sAVGflag sigma uWindowArray nWindowArray normalise bothRectangular) fFiles\n (OptsBJ path dev alpha uWindow uWindowFunc nWindow nWindowFunc nosAVGflag) ->\n do\n if (even uWindow || even nWindow)\n then error \"Window length maust be odd !\"\n else\n let uWindowArray = makeWindow uWindowFunc (A.unit $ A.constant uWindow) :: A.Acc (A.Array A.DIM1 Float)\n nWindowArray = makeWindow nWindowFunc (A.unit $ A.constant nWindow) :: A.Acc (A.Array A.DIM1 Float)\n bothRectangular = uWindowFunc == Rect && nWindowFunc == Rect\n in mapM_ (makeBJ dev sAVGflag alpha uWindowArray nWindowArray bothRectangular) fFiles\n (OptsEMBD path dev alpha beta uWindow uWindowFunc nWindow nWindowFunc normalise nosAVGflag) ->\n do\n if (even uWindow || even nWindow)\n then error \"Window length maust be odd !\"\n else let gammas = makeGammaArray beta uWindow\n uWindowArray = makeWindow uWindowFunc (A.unit $ A.constant uWindow) :: A.Acc (A.Array A.DIM1 Float)\n nWindowArray = makeWindow nWindowFunc (A.unit $ A.constant nWindow) :: A.Acc (A.Array A.DIM1 Float)\n bothRectangular = uWindowFunc == Rect && nWindowFunc == Rect\n in mapM_ (makeEMBD dev sAVGflag alpha gammas uWindowArray nWindowArray bothRectangular normalise) fFiles\n return ()\n\nmakeCW :: CalcDev -- ^ Calculation device - CPU or GPU\n -> A.Exp Bool -- ^ Apply subtraction of the mean value from all elements in a column.\n -> Float -- ^ sigma\n -> A.Acc (A.Array A.DIM1 Float) -- ^ Smoothing window in frequensy-domain. Length must be odd.\n -> A.Acc (A.Array A.DIM1 Float) -- ^ Smoothing window in time-domain. Length must be odd.\n -> Bool -- ^ if the core array should be normalised\n -> Bool -- ^ if Both windows are rectangular\n -> FilePath -- ^ Name of file with data.\n -> IO ()\nmakeCW dev sAVGflag sigma uWindowArray nWindowArray normalise bothRect file = do\n putStrLn $ \"processing \" ++ file ++ \"...\"\n text <- TI.readFile file\n let parseRes = parseOnly parseFile text\n case parseRes of\n (Left errStr) -> error $ errStr\n (Right dataF) -> mapM_ (startCW dev file sAVGflag sigma uWindowArray nWindowArray normalise bothRect) dataF\n\nmakeBJ :: CalcDev -- ^ Calculation device - CPU or GPU\n -> A.Exp Bool -- ^ Apply subtraction of the mean value from all elements in a column.\n -> Float -- ^ sigma\n -> A.Acc (A.Array A.DIM1 Float) -- ^ Smoothing window in frequensy-domain. Length must be odd.\n -> A.Acc (A.Array A.DIM1 Float) -- ^ Smoothing window in time-domain. Length must be odd.\n -> Bool -- ^ if Both windows are rectangular\n -> FilePath -- ^ Name of file with data.\n -> IO ()\nmakeBJ dev sAVGflag alpha uWindowArray nWindowArray bothRect file = do\n putStrLn $ \"processing \" ++ file ++ \"...\"\n text <- TI.readFile file\n let parseRes = parseOnly parseFile text\n case parseRes of\n (Left errStr) -> error $ errStr\n (Right dataF) -> mapM_ (startBJ dev file sAVGflag alpha uWindowArray nWindowArray bothRect) dataF\n\n-- | Make Pseudo Wigner-Ville transform to all columns in the given file\n\nmakePWV ::\n CalcDev -- ^ Calculation device - CPU or GPU\n -> A.Acc (A.Array A.DIM1 Float) -- ^ Smoothing window in time-domain. Length must be odd.\n -> A.Exp Bool -- ^ Apply subtraction of the mean value from all elements in a column.\n -> FilePath -- ^ Name of file with data.\n -> IO ()\nmakePWV dev window sAVGflag file = do\n putStrLn $ \"processing \" ++ file ++ \"...\"\n text <- TI.readFile file\n let parseRes = parseOnly parseFile text\n case parseRes of\n (Left errStr) -> error $ errStr\n (Right dataF) -> mapM_ (startPWV dev window file sAVGflag) dataF\n\n--makeEMBD dev alpha gammas uWindowArray nWindowArray bothRectangular normalise \n\nmakeEMBD :: CalcDev -- ^ Calculation device - CPU or GPU\n -> A.Exp Bool -- ^ Apply subtraction of the mean value from all elements in a column.\n -> Float -- ^ alpha\n -> [Float] -- ^ gammas \n -> A.Acc (A.Array A.DIM1 Float) -- ^ Smoothing window in frequensy-domain. Length must be odd.\n -> A.Acc (A.Array A.DIM1 Float) -- ^ Smoothing window in time-domain. Length must be odd.\n -> Bool -- ^ if the core array should be normalised\n -> Bool -- ^ if Both windows are rectangular\n -> FilePath -- ^ Name of file with data.\n -> IO ()\nmakeEMBD dev sAVGflag alpha gammas uWindowArray nWindowArray normalise bothRect file = do\n putStrLn $ \"processing \" ++ file ++ \"...\"\n text <- TI.readFile file\n let parseRes = parseOnly parseFile text\n case parseRes of\n (Left errStr) -> error $ errStr\n (Right dataF) -> mapM_ (startEMBD dev file sAVGflag alpha gammas uWindowArray nWindowArray normalise bothRect) dataF\n\n-- | Make Pseudo Wigner-Ville transform to the given column.\n-- At first it makes subtraction of average value (if supAVGflag) and applies hilbert transform to make analytic signal. After that it applies Pseudo-Wigner transftorm\n-- and save data to file with\n\n\nstartPWV ::\n CalcDev -- ^ Calculation device - CPU or GPU\n -> A.Acc (A.Array A.DIM1 Float) -- ^ Smoothing window in time-domain. Length must be odd.\n -> FilePath -- ^ Name of file with data.\n -> A.Exp Bool -- ^ Apply subtraction of the mean value from all elements in a column.\n -> (T.Text,[Float]) -- ^ Name of column and parsed data from column\n -> IO ()\nstartPWV dev window oldName sAVGflag (column_name,dataF) = do\n let newFName = oldName ++ \"-\" ++ T.unpack column_name ++ \".txt\"\n putStr $ \" Creating file \" ++ newFName ++ \" ...\"\n let leng = length dataF\n pData = A.fromList (A.Z A.:. leng) dataF\n appPWV = (pWignerVille window) . hilbert . supAVG sAVGflag\n processed = case dev of\n#ifdef ACCELERATE_LLVM_NATIVE_BACKEND\n CPU -> ALN.run1 appPWV pData\n#endif\n#ifdef ACCELERATE_LLVM_PTX_BACKEND\n GPU -> ALP.run1 appPWV pData\n#endif\n CPU -> ALI.run1 appPWV pData\n GPU -> error \"Compiled without GPU support\"\n pList = S.toList $! processed\n file <- openFile newFName WriteMode\n onException (writeData file pList leng 1) (removeFile newFName)\n hClose file\n putStrLn \"Done !\"\n\n-- | Make Wigner-Ville transform to all columns in the given file\n\nmakeWV ::\n CalcDev -- ^ Calculation device - CPU or GPU\n -> A.Exp Bool -- ^ Apply subtraction of the mean value from all elements in a column.\n -> FilePath -- ^ Name of file with data.\n -> IO ()\nmakeWV dev sAVGflag file = do\n putStrLn $ \"processing \" ++ file ++ \"...\"\n text <- TI.readFile file\n let parseRes = parseOnly parseFile text\n case parseRes of\n (Left errStr) -> error $ errStr\n (Right dataF) -> mapM_ (startWV dev file sAVGflag) dataF\n\n-- | Make Wigner-Ville transform to the given column.\n-- At first it makes subtraction of average value (if supAVGflag) and applies hilbert transform to make analytic signal. After that it applies Pseudo-Wigner transftorm\n-- and save data to file with\n\nstartWV ::\n CalcDev -- ^ Calculation device - CPU or GPU\n -> FilePath -- ^ Name of file with data.\n -> A.Exp Bool -- ^ Apply subtraction of the mean value from all elements in a column.\n -> (T.Text,[Float]) -- ^ Name of column and parsed data from column\n -> IO ()\nstartWV dev oldName sAVGflag (column_name,dataF) = do\n let newFName = oldName ++ \"-\" ++ T.unpack column_name ++ \".txt\"\n putStr $ \" Creating file \" ++ newFName ++ \" ...\"\n let leng = length dataF\n pData = A.fromList (A.Z A.:. leng) dataF\n appWV = wignerVilleNew . hilbert . supAVG sAVGflag\n appWVGPU = wignerVille . hilbert . supAVG sAVGflag\n processed = case dev of\n#ifdef ACCELERATE_LLVM_NATIVE_BACKEND\n CPU -> ALN.run1 appWV pData\n#endif\n#ifdef ACCELERATE_LLVM_PTX_BACKEND\n GPU -> ALP.run1 appWV pData\n#endif\n CPU -> ALI.run1 appWV pData\n GPU -> error \"Compiled without GPU support\"\n pList = S.toList $ processed\n file <- openFile newFName WriteMode\n hSetBinaryMode file True >> hSetBuffering file LineBuffering\n -- let resultBsBuilder = makeString pList leng 1 \"\"\n onException (makeString file pList leng 1 \"\") (removeFile newFName) >> hFlush file\n hClose file\n putStrLn \"Done !\"\n\nstartCW ::\n CalcDev -- ^ Calculation device - CPU or GPU\n -> FilePath -- ^ Name of file with data.\n -> A.Exp Bool -- ^ Apply subtraction of the mean value from all elements in a column.\n -> Float -- ^ Sigma\n -> A.Acc (A.Array A.DIM1 Float) -- ^ Smoothing window in frequensy-domain. Length must be odd.\n -> A.Acc (A.Array A.DIM1 Float) -- ^ Smoothing window in time-domain. Length must be odd.\n -> Bool -- ^ if the core array should be normalised\n -> Bool -- ^ if Both windows are rectangular\n -> (T.Text,[Float]) -- ^ Name of column and parsed data from column\n -> IO ()\nstartCW dev oldName sAVGflag sigma uWindowArray nWindowArray normalise bothRect (column_name,dataF) = do\n let newFName = oldName ++ \"-\" ++ T.unpack column_name ++ \".txt\"\n putStr $ \" Creating file \" ++ newFName ++ \" ...\"\n let leng = length dataF\n uWindow = A.length uWindowArray\n nWindow = A.length nWindowArray\n mWindowArrays = if bothRect then Nothing else Just (uWindowArray,nWindowArray)\n pData = A.fromList (A.Z A.:. leng) dataF\n appCW = (choiWilliams (A.constant sigma) mWindowArrays uWindow nWindow normalise) . hilbert . supAVG sAVGflag\n processed = case dev of\n#ifdef ACCELERATE_LLVM_NATIVE_BACKEND\n CPU -> ALN.run1 appCW pData\n#endif\n#ifdef ACCELERATE_LLVM_PTX_BACKEND\n GPU -> ALP.run1 appCW pData\n#endif\n CPU -> ALI.run1 appCW pData\n GPU -> error \"Compiled without GPU support\"\n pList = S.toList $ processed\n file <- openFile newFName WriteMode\n onException (writeData file pList leng 1) (removeFile newFName)\n hClose file\n putStrLn \"Done !\"\n\nstartBJ ::\n CalcDev -- ^ Calculation device - CPU or GPU\n -> FilePath -- ^ Name of file with data.\n -> A.Exp Bool -- ^ Apply subtraction of the mean value from all elements in a column.\n -> Float -- ^ Sigma\n -> A.Acc (A.Array A.DIM1 Float) -- ^ Smoothing window in frequensy-domain. Length must be odd.\n -> A.Acc (A.Array A.DIM1 Float) -- ^ Smoothing window in time-domain. Length must be odd.\n -> Bool -- ^ if Both windows are rectangular\n -> (T.Text,[Float]) -- ^ Name of column and parsed data from column\n -> IO ()\nstartBJ dev oldName sAVGflag alpha uWindowArray nWindowArray bothRect (column_name,dataF) = do\n let newFName = oldName ++ \"-\" ++ T.unpack column_name ++ \".txt\"\n putStr $ \" Creating file \" ++ newFName ++ \" ...\"\n let leng = length dataF\n uWindow = A.length uWindowArray\n nWindow = A.length nWindowArray\n mWindowArrays = if bothRect then Nothing else Just (uWindowArray,nWindowArray)\n pData = A.fromList (A.Z A.:. leng) dataF\n appCW = (bornJordan (A.constant alpha) mWindowArrays uWindow nWindow) . hilbert . supAVG sAVGflag\n processed = case dev of\n#ifdef ACCELERATE_LLVM_NATIVE_BACKEND\n CPU -> ALN.run1 appCW pData\n#endif\n#ifdef ACCELERATE_LLVM_PTX_BACKEND\n GPU -> ALP.run1 appCW pData\n#endif\n CPU -> ALI.run1 appCW pData\n GPU -> error \"Compiled without GPU support\"\n pList = S.toList $ processed\n file <- openFile newFName WriteMode\n onException (writeData file pList leng 1) (removeFile newFName)\n hClose file\n putStrLn \"Done !\"\n\nstartEMBD ::\n CalcDev -- ^ Calculation device - CPU or GPU\n -> FilePath -- ^ Name of file with data.\n -> A.Exp Bool -- ^ Apply subtraction of the mean value from all elements in a column.\n -> Float -- ^ Alpha \n -> [Float] -- ^ Gammas \n -> A.Acc (A.Array A.DIM1 Float) -- ^ Smoothing window in frequensy-domain. Length must be odd.\n -> A.Acc (A.Array A.DIM1 Float) -- ^ Smoothing window in time-domain. Length must be odd.\n -> Bool -- ^ if the core array should be normalised\n -> Bool -- ^ if Both windows are rectangular\n -> (T.Text,[Float]) -- ^ Name of column and parsed data from column\n -> IO ()\nstartEMBD dev oldName sAVGflag alpha gammas uWindowArray nWindowArray normalise bothRect (column_name,dataF) = do\n let newFName = oldName ++ \"-\" ++ T.unpack column_name ++ \".txt\"\n putStr $ \" Creating file \" ++ newFName ++ \" ...\"\n let leng = length dataF\n uWindow = A.length uWindowArray\n nWindow = A.length nWindowArray\n gammasArr = A.use $ A.fromList (A.Z A.:. (length gammas)) gammas \n mWindowArrays = if bothRect then Nothing else Just (uWindowArray,nWindowArray)\n pData = A.fromList (A.Z A.:. leng) dataF\n appEMBD = (eModifiedB (A.constant alpha) gammasArr mWindowArrays uWindow nWindow normalise) . hilbert . supAVG sAVGflag\n processed = case dev of\n#ifdef ACCELERATE_LLVM_NATIVE_BACKEND\n CPU -> ALN.run1 appEMBD pData\n#endif\n#ifdef ACCELERATE_LLVM_PTX_BACKEND\n GPU -> ALP.run1 appEMBD pData\n#endif\n CPU -> ALI.run1 appEMBD pData\n GPU -> error \"Compiled without GPU support\"\n pList = S.toList $ processed\n file <- openFile newFName WriteMode\n onException (writeData file pList leng 1) (removeFile newFName)\n hClose file\n putStrLn \"Done !\"\n\n\n-- | Subtraction of average value from all elements of column\n\nsupAVG :: A.Exp Bool -> A.Acc (Array DIM1 Float) -> A.Acc (Array DIM1 Float)\nsupAVG flag arr =\n A.acond flag (A.map (\\x -> x - avg) arr) arr\n where leng = A.length arr\n avg = (A.the $ A.sum arr)/(A.fromIntegral leng)\n\n\nmakeGammaArray :: Float -> Int -> [Float]\nmakeGammaArray beta wLength =\n let dwLength = fromIntegral wLength :: Float\n v = [(-0.5), ((-0.5) + 1.0/dwLength)..0.5]\n s = map (\\x -> beta :+ pi*x) v\n f = map (\\x -> abs $ ((magnitude $ gamma x) ^ 2)/((gamma beta) ^ 2)) s\n n = floor $ (fromIntegral $ length f)/2.0\n frst = Data.List.take (n-1) f\n secnd = Data.List.drop n f\n in secnd ++ frst\n", "meta": {"hexsha": "9b3d8744be75d1fcbe51ebfda672e60973945170", "size": 18082, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "app/Main.hs", "max_stars_repo_name": "Haskell-mouse/WVille", "max_stars_repo_head_hexsha": "e71506773f587510a4b1832e8a649b6135a85373", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2019-11-27T13:56:35.000Z", "max_stars_repo_stars_event_max_datetime": "2019-11-27T13:56:35.000Z", "max_issues_repo_path": "app/Main.hs", "max_issues_repo_name": "Haskell-mouse/WVille", "max_issues_repo_head_hexsha": "e71506773f587510a4b1832e8a649b6135a85373", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "app/Main.hs", "max_forks_repo_name": "Haskell-mouse/WVille", "max_forks_repo_head_hexsha": "e71506773f587510a4b1832e8a649b6135a85373", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 45.6616161616, "max_line_length": 167, "alphanum_fraction": 0.6320097334, "num_tokens": 4817, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.685949467848392, "lm_q2_score": 0.5, "lm_q1q2_score": 0.342974733924196}} {"text": "{-# LANGUAGE OverloadedStrings #-}\n\nmodule Numeric.PHCPack.Parse (\n parseSolutions\n )\n where\n\nimport Data.Attoparsec\nimport Data.Attoparsec.ByteString.Char8 hiding (satisfy)\nimport Data.Attoparsec.Combinator\nimport Control.Applicative((<|>))\n\nimport Data.ByteString(ByteString)\n\n\nimport Data.ByteString.Char8(pack)\nimport qualified Data.ByteString as BS\n\nimport Numeric.PHCPack.Types\nimport qualified Data.Map as Map\nimport Data.Complex\n\nspace' :: Parser ()\nspace' = satisfy isHorizontalSpace >> return ()\n \nspaces :: Parser ()\nspaces = skipMany space' >> return ()\n\nspaces1 :: Parser ()\nspaces1 = space' >> spaces\n\nparseSolutions :: ByteString -> Maybe [Solution]\nparseSolutions = maybeResult . ((flip feed) BS.empty) . (parse solutionsParser)\n\nsolutionsParser :: Parser [Solution]\nsolutionsParser = do\n manyTill anyChar (try (string \"START SOLUTIONS : \" >> endOfLine))\n skipMany (space' <|> endOfLine)\n solutionCount <- decimal\n spaces1\n dimension <- decimal\n endOfLine\n \n sepLine\n solutions <- solution `sepBy1` bannerLine\n bannerLine\n skipMany anyChar\n \n return solutions\n \nsepLine :: Parser ()\nsepLine = skipMany (char '=') >> endOfLine\n\nbannerLine :: Parser ()\nbannerLine = string \"==\" >> manyTill anyChar (try endOfLine) >> return ()\n \nsolution :: Parser Solution\nsolution = do\n string \"solution \"\n solutionNumber <- decimal\n manyTill anyChar (try (string \"the solution\" >> manyTill anyChar (try endOfLine))) -- skip until \"the solution for t :\"\n solutions <- variableSolution `sepBy` endOfLine\n endOfLine\n return (Solution $ Map.fromList solutions)\n \n-- variableSolution :: (Num c) => Parser (Unknown, Complex c)\nvariableSolution = do\n spaces\n name <- manyTill anyChar space\n spaces\n char ':'\n spaces\n real <- double\n spaces\n imag <- double\n return (name, real :+ imag)\n \n", "meta": {"hexsha": "3daed3c757f165ddf9fd2a990754a26916910202", "size": 1816, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "Numeric/PHCPack/Parse.hs", "max_stars_repo_name": "mruegenberg/PHCPack-hs", "max_stars_repo_head_hexsha": "a3c918c50accc3cb4a6009d85b12c2ed035c0cc5", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-04-18T16:36:35.000Z", "max_stars_repo_stars_event_max_datetime": "2020-04-18T16:36:35.000Z", "max_issues_repo_path": "Numeric/PHCPack/Parse.hs", "max_issues_repo_name": "mruegenberg/PHCPack-hs", "max_issues_repo_head_hexsha": "a3c918c50accc3cb4a6009d85b12c2ed035c0cc5", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Numeric/PHCPack/Parse.hs", "max_forks_repo_name": "mruegenberg/PHCPack-hs", "max_forks_repo_head_hexsha": "a3c918c50accc3cb4a6009d85b12c2ed035c0cc5", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 23.2820512821, "max_line_length": 121, "alphanum_fraction": 0.7158590308, "num_tokens": 473, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.600188359260205, "lm_q2_score": 0.5698526514141571, "lm_q1q2_score": 0.34201892787234045}} {"text": "{-# LANGUAGE DataKinds #-}\n{-# LANGUAGE PolyKinds #-}\n{-# LANGUAGE ScopedTypeVariables #-}\n{-# LANGUAGE TypeApplications #-}\n{-# LANGUAGE ViewPatterns #-}\n\nimport Control.Concurrent\nimport Control.DeepSeq\nimport Control.Monad\nimport Control.Monad.Primitive\nimport Control.Monad.Trans.Class\nimport Control.Monad.Trans.State\nimport Data.Bifunctor\nimport Data.Char\nimport Data.Finite\nimport Data.Foldable\nimport Data.List\nimport Data.Maybe\nimport Data.Neural.Activation\nimport Data.Neural.HMatrix.Recurrent\nimport Data.Neural.HMatrix.Recurrent.Dropout\nimport Data.Neural.HMatrix.Recurrent.Generate\nimport Data.Neural.HMatrix.Recurrent.Train\nimport Data.Ord\nimport Data.Proxy\nimport Data.Tuple\nimport GHC.TypeLits\nimport GHC.TypeLits.List\nimport Numeric.LinearAlgebra.Static\nimport Text.Printf\nimport qualified Data.Map.Strict as M\nimport qualified Data.Set as S\nimport qualified Data.Vector as VB\nimport qualified Data.Vector.Storable as V\nimport qualified Linear.V as L\nimport qualified System.Random.MWC as R\nimport qualified System.Random.MWC.Distributions as R\n\ngenIx :: forall n. KnownNat n => Finite n -> R n\ngenIx (fromIntegral->i) = fromJust\n . create\n $ V.generate l (\\i' -> if i' == i then 1 else 0)\n where\n l = fromInteger $ natVal (Proxy @n)\n\nixMax :: (Foldable t, Ord a) => t a -> Int\nixMax = fst . maximumBy (comparing snd) . zip [0..] . toList\n\nixSort :: (Foldable t, Ord a) => t a -> [Int]\nixSort = map fst . sortBy (flip (comparing snd)) . zip [0..] . toList\n\nsanitize :: Char -> Char\nsanitize c | isPrint c = c\n | otherwise = '#'\n\n\nmain :: IO ()\nmain = do\n g <- R.create\n holmes <- readFile \"data/holmes.txt\"\n let holmesVec :: VB.Vector Char\n holmesVec = VB.fromList holmes\n let allCharsV :: VB.Vector Char\n allCharsV = VB.fromList\n . S.toList\n . S.fromList\n $ holmes\n\n L.reifyVectorNat allCharsV $ \\(allChars :: L.V c Char) -> do\n let charMap :: M.Map Char (Finite c)\n charMap = M.fromList\n . (`zip` [0..])\n . toList\n $ allChars\n c2v :: Char -> R c\n c2v = genIx . (charMap M.!)\n holmesSeries :: VB.Vector (L.V 15 Char, Char)\n holmesSeries = processSeries $ VB.zip holmesVec (VB.tail holmesVec)\n holmesSeries' :: VB.Vector ([R c], R c)\n holmesSeries' = bimap (map c2v . toList) c2v <$> holmesSeries\n ins :: VB.Vector [R c]\n ins = fst <$> holmesSeries'\n nextChar :: R c -> IO Int\n nextChar i = R.categorical (V.map ((**8) . max 0) (extract i)) g\n fb :: R c -> IO (R c)\n fb = fmap (genIx . fromIntegral) . nextChar\n cb :: Int -> Int -> Network c hs c -> IO ()\n cb e i n = when (i `mod` 1000 == 0) $ do\n let toCharList = map (sanitize . (allCharsV VB.!))\n . take 50 . ixSort . V.toList . extract\n insTest = ins VB.! 100\n insChars = head . toCharList <$> insTest\n (last->lo, pp) = runNetStream naRLLog n (ins VB.! 100)\n lo' <- fb lo\n testOut <- (lo:) <$> runNetFeedbackM_ naRLLog fb pp 75 lo'\n let testChars = toCharList <$> testOut\n threadDelay 250000\n printf \"%d\\t%d\\n\" e i\n mapM_ putStrLn (take 15 testChars)\n testCharsPick <- map (sanitize . (allCharsV VB.!)) <$> mapM nextChar testOut\n putStrLn $ insChars ++ \"|\" ++ testCharsPick\n\n\n print $ M.keys charMap\n print $ natVal (Proxy @c)\n print $ length holmes\n\n net0 <- randomNetMWC (-0.1,0.1) g :: IO (Network c '[100,75,50] c)\n net1 <- trainHistory 0.2 0.01 0.005 100 holmesSeries' net0 cb g\n return ()\n\n\ntrainHistory\n :: forall i m hs o. (PrimMonad m, KnownNats hs, KnownNat i, KnownNat o)\n => Double -- ^ dropout\n -> Double -- ^ step size (weights)\n -> Double -- ^ step size (state)\n -> Int -- ^ number of epochs\n -> VB.Vector ([R i], R o)\n -> Network i hs o\n -> (Int -> Int -> Network i hs o -> m ()) -- ^ callback\n -> R.Gen (PrimState m)\n -> m (Network i hs o)\ntrainHistory d sw ss e samps net0 cb g =\n flip execStateT net0\n . for_ [1 .. e] $ \\i -> do\n samps' <- lift $ R.uniformShuffle samps g\n for_ (zip [1..] (VB.toList samps')) $ \\(j, (h, t)) ->\n StateT $ \\net -> do\n net' <- trainSeriesDOMWC naRLLog d sw ss t h net g\n cb i j net'\n net' `deepseq` return ((), net')\n\n", "meta": {"hexsha": "08de3339cbb5fc36afbffa8e484e2e3473aa3bf7", "size": 5015, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "app/Sherlock.hs", "max_stars_repo_name": "mstksg/neural-tests", "max_stars_repo_head_hexsha": "4655402bddf4b7829dc25cba090963c97fffb7fd", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2016-06-22T20:34:43.000Z", "max_stars_repo_stars_event_max_datetime": "2019-11-27T07:54:20.000Z", "max_issues_repo_path": "app/Sherlock.hs", "max_issues_repo_name": "mstksg/neural-tests", "max_issues_repo_head_hexsha": "4655402bddf4b7829dc25cba090963c97fffb7fd", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "app/Sherlock.hs", "max_forks_repo_name": "mstksg/neural-tests", "max_forks_repo_head_hexsha": "4655402bddf4b7829dc25cba090963c97fffb7fd", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 37.4253731343, "max_line_length": 88, "alphanum_fraction": 0.5300099701, "num_tokens": 1327, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.7879311956428947, "lm_q2_score": 0.43398146480389854, "lm_q1q2_score": 0.3419475344497906}} {"text": "{-# LANGUAGE DeriveDataTypeable, DeriveGeneric, OverloadedStrings,\n RecordWildCards #-}\n\n-- |\n-- Module : Statistics.Resampling.Bootstrap\n-- Copyright : (c) 2009, 2011 Bryan O'Sullivan\n-- License : BSD3\n--\n-- Maintainer : bos@serpentine.com\n-- Stability : experimental\n-- Portability : portable\n--\n-- The bootstrap method for statistical inference.\n\nmodule Statistics.Resampling.Bootstrap\n (\n Estimate(..)\n , bootstrapBCA\n , scale\n -- * References\n -- $references\n ) where\n\nimport Control.Applicative ((<$>), (<*>))\nimport Control.DeepSeq (NFData)\nimport Control.Exception (assert)\nimport Control.Monad.Par (parMap, runPar)\nimport Data.Aeson (FromJSON, ToJSON)\nimport Data.Binary (Binary)\nimport Data.Binary (put, get)\nimport Data.Data (Data)\nimport Data.Typeable (Typeable)\nimport Data.Vector.Unboxed ((!))\nimport GHC.Generics (Generic)\nimport Statistics.Distribution (cumulative, quantile)\nimport Statistics.Distribution.Normal\nimport Statistics.Resampling (Resample(..), jackknife)\nimport Statistics.Sample (mean)\nimport Statistics.Types (Estimator, Sample)\nimport qualified Data.Vector.Unboxed as U\nimport qualified Statistics.Resampling as R\n\n-- | A point and interval estimate computed via an 'Estimator'.\ndata Estimate = Estimate {\n estPoint :: {-# UNPACK #-} !Double\n -- ^ Point estimate.\n , estLowerBound :: {-# UNPACK #-} !Double\n -- ^ Lower bound of the estimate interval (i.e. the lower bound of\n -- the confidence interval).\n , estUpperBound :: {-# UNPACK #-} !Double\n -- ^ Upper bound of the estimate interval (i.e. the upper bound of\n -- the confidence interval).\n , estConfidenceLevel :: {-# UNPACK #-} !Double\n -- ^ Confidence level of the confidence intervals.\n } deriving (Eq, Read, Show, Typeable, Data, Generic)\n\ninstance FromJSON Estimate\ninstance ToJSON Estimate\n\ninstance Binary Estimate where\n put (Estimate w x y z) = put w >> put x >> put y >> put z\n get = Estimate <$> get <*> get <*> get <*> get\ninstance NFData Estimate\n\n-- | Multiply the point, lower bound, and upper bound in an 'Estimate'\n-- by the given value.\nscale :: Double -- ^ Value to multiply by.\n -> Estimate -> Estimate\nscale f e@Estimate{..} = e {\n estPoint = f * estPoint\n , estLowerBound = f * estLowerBound\n , estUpperBound = f * estUpperBound\n }\n\nestimate :: Double -> Double -> Double -> Double -> Estimate\nestimate pt lb ub cl =\n assert (lb <= ub) .\n assert (cl > 0 && cl < 1) $\n Estimate { estPoint = pt\n , estLowerBound = lb\n , estUpperBound = ub\n , estConfidenceLevel = cl\n }\n\ndata T = {-# UNPACK #-} !Double :< {-# UNPACK #-} !Double\ninfixl 2 :<\n\n-- | Bias-corrected accelerated (BCA) bootstrap. This adjusts for both\n-- bias and skewness in the resampled distribution.\nbootstrapBCA :: Double -- ^ Confidence level\n -> Sample -- ^ Sample data\n -> [Estimator] -- ^ Estimators\n -> [Resample] -- ^ Resampled data\n -> [Estimate]\nbootstrapBCA confidenceLevel sample estimators resamples\n | confidenceLevel > 0 && confidenceLevel < 1\n = runPar $ parMap (uncurry e) (zip estimators resamples)\n | otherwise = error \"Statistics.Resampling.Bootstrap.bootstrapBCA: confidence level outside (0,1) range\"\n where\n e est (Resample resample)\n | U.length sample == 1 || isInfinite bias =\n estimate pt pt pt confidenceLevel\n | otherwise =\n estimate pt (resample ! lo) (resample ! hi) confidenceLevel\n where\n pt = R.estimate est sample\n lo = max (cumn a1) 0\n where a1 = bias + b1 / (1 - accel * b1)\n b1 = bias + z1\n hi = min (cumn a2) (ni - 1)\n where a2 = bias + b2 / (1 - accel * b2)\n b2 = bias - z1\n z1 = quantile standard ((1 - confidenceLevel) / 2)\n cumn = round . (*n) . cumulative standard\n bias = quantile standard (probN / n)\n where probN = fromIntegral . U.length . U.filter (\n", "meta": {"hexsha": "e1eef10d95108815345e0414810fdedc675f570d", "size": 4730, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "Statistics/Resampling/Bootstrap.hs", "max_stars_repo_name": "StefanHubner/statistics", "max_stars_repo_head_hexsha": "e98af025ef4aa0bc31a5b1fcf88bb80295aac956", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2015-02-03T06:18:47.000Z", "max_stars_repo_stars_event_max_datetime": "2015-02-03T06:18:47.000Z", "max_issues_repo_path": "Statistics/Resampling/Bootstrap.hs", "max_issues_repo_name": "StefanHubner/statistics", "max_issues_repo_head_hexsha": "e98af025ef4aa0bc31a5b1fcf88bb80295aac956", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Statistics/Resampling/Bootstrap.hs", "max_forks_repo_name": "StefanHubner/statistics", "max_forks_repo_head_hexsha": "e98af025ef4aa0bc31a5b1fcf88bb80295aac956", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 36.106870229, "max_line_length": 106, "alphanum_fraction": 0.599154334, "num_tokens": 1226, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO\n\n", "lm_q1_score": 0.6992544210587585, "lm_q2_score": 0.4882833952958347, "lm_q1q2_score": 0.3414343228901938}} {"text": "--\n-- CNN : CNN filter generator\n--\n{-# LANGUAGE BangPatterns #-}\n\nmodule Main (\n main\n) where\n\nimport Control.DeepSeq\nimport Control.Monad\n--import Data.List\nimport Data.Time\nimport Data.List (foldl')\nimport Debug.Trace\nimport Numeric.LinearAlgebra\nimport System.Environment\nimport System.IO\nimport Text.Printf\n\nimport CNN.ActLayer\nimport CNN.Algebra\nimport CNN.ConvLayer\nimport CNN.FullConnLayer\nimport CNN.Image\nimport CNN.Layer\nimport CNN.LayerType\nimport CNN.PoolLayer\nimport CNN.Propagation\n\nimport Pool\nimport Status\n\nusage :: String\nusage = \"Usage: train []\"\n\n-- MAIN\n\nmain :: IO ()\nmain = do\n as <- getArgs\n case length as of\n 1 -> train (as !! 0)\n 2 -> judge (as !! 0) (as !! 1)\n _ -> error usage\n\ntrain :: String -> IO ()\ntrain dn = do\n putStrLn \"Initializing...\"\n st <- loadStatus dn\n-- st <- loadStatus \"\"\n tm0 <- getCurrentTime\n\n let\n --getTeachers = getImages (poolT st) (batchSz st)\n --getTests = getImages (poolE st) (testSz st)\n getTeachers = getImagesRandomly (poolT st) (batchSz st)\n getTests = getImagesRandomly (poolE st) (testSz st)\n putF = putStatus tm0 st getTests\n loopFunc = trainLoop' getTeachers putF st\n putStrLn (\"Training the model... (#batch:\" ++ (show (batchSz st * nclass st)) ++ \")\")\n putF 0 (layers st)\n layers' <- foldM' loopFunc (layers st) [1 .. (repeatCt st)]\n\n putStrLn \"Saving status...\"\n saveStatus st layers' (repeatCt st * batchSz st)\n putStrLn \"Finished!\"\n\njudge :: String -> String -> IO ()\njudge dn imf = do\n st <- loadStatus dn\n fh <- openFile imf ReadMode\n lst <- hGetContents fh\n forM_ (lines lst) $ \\i -> do\n im <- loadImage i\n putStr (i ++ \",\")\n let (y, _) = judgeImage (layers st) im\n forM_ (zip [0..] (toList y)) $ \\(c, v) -> do\n let res = show c ++ (printf \":%.2f,\" (v*100))\n putStr res\n putStrLn \"\"\n\n--\n-- FUNCTIONS\n--\n\n{- |\nfoldM' : monadic version of foldl'\n\n URL: http://stackoverflow.com/questions/8919026/does-haskell-have-foldlm\n\n-}\n\nfoldM' :: (Monad m) => ([a] -> b -> m [a]) -> [a] -> [b] -> m [a]\nfoldM' _ z [] = return z\nfoldM' f z (x:xs) = do\n z' <- f z x\n z' `seq` foldM' f z' xs\n\n{- |\ntrainLoop\n\n IN : func of getting teachers (including batch size and pool)\n sample of evaluation\n output func\n learning rate\n layers\n epoch numbers\n\n OUT: updated layers\n\n-}\n\ntrainLoop' :: (Int -> IO [Trainer]) -> (Int -> [Layer] -> IO ()) -> Status\n -> [Layer] -> Int -> IO [Layer]\ntrainLoop' getT putF st ls i = do\n --teachers <- getT ((i-1) * batchSz st)\n teachers <- getT 0\n let ls' = updateLayers (learnR st) teachers ls\n if i `mod` (savePt st) == 0\n then putF i ls'\n else return ()\n return ls'\n\n{- |\nupdateLayers\n-}\n\nupdateLayers :: Double -> [Trainer] -> [Layer] -> [Layer]\nupdateLayers lr ts ls = update lr ls (transpose dls)\n where\n rls = tail $ map reverseLayer $ reverse ls -- fist element isn't used\n dls = map (trainLayers ls rls) ts -- dls = diff of layers\n\n{-\nputStatus\n\n IN : start time\n status\n start epoch number\n end epoch number\n step size of status output\n epoch\n layers\n sample of evaluation\n\n-}\n\nputStatus :: UTCTime -> Status -> (Int -> IO [Trainer]) -> Int -> [Layer] -> IO ()\nputStatus tm0 st getE i ls = do\n --tests <- getE ((i-1) * testSz st)\n tests <- getE 0\n let\n --(rv, rr) = unzip $ evaluate ls tests\n rr = foldl' (evaluateLayers ls) 0.0 tests\n let\n ite = printf \"iter = %5d/%d \" i (repeatCt st)\n acc = printf \"accuracy = %.10f \" (rr / fromIntegral (length tests))\n putStr (ite ++ acc)\n tm <- getCurrentTime\n putStrLn (\"time = \" ++ show (diffUTCTime tm tm0))\n saveStatus st ls (batchSz st * i)\n --mapM_ putOne rs -- for debug\n where\n putOne :: ([Double], Double) -> IO ()\n putOne (v, r) = putStrLn (\"result:\" ++ show v ++ \", ratio:\" ++ show r)\n", "meta": {"hexsha": "c777a3746380d926653ac34bdf43a0c131963e57", "size": 3871, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/Main-train.hs", "max_stars_repo_name": "eijian/deeplearning", "max_stars_repo_head_hexsha": "ef7ab2ef7664bdad240f11becb2f5efe7b9d2b29", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 4, "max_stars_repo_stars_event_min_datetime": "2016-08-30T01:28:42.000Z", "max_stars_repo_stars_event_max_datetime": "2020-02-13T18:58:17.000Z", "max_issues_repo_path": "src/Main-train.hs", "max_issues_repo_name": "eijian/deeplearning", "max_issues_repo_head_hexsha": "ef7ab2ef7664bdad240f11becb2f5efe7b9d2b29", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/Main-train.hs", "max_forks_repo_name": "eijian/deeplearning", "max_forks_repo_head_hexsha": "ef7ab2ef7664bdad240f11becb2f5efe7b9d2b29", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 23.1796407186, "max_line_length": 87, "alphanum_fraction": 0.6104365797, "num_tokens": 1193, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6926419958239132, "lm_q2_score": 0.49218813572079556, "lm_q1q2_score": 0.34091017264650286}} {"text": "module ChartHistogram (\n backendFormats,\n writeHistogram\n) where\n\nimport Control.Lens.Setter ((.~))\nimport Control.Monad.ST (runST)\nimport qualified Data.Colour as Colour\nimport qualified Data.Colour.Names as ColourNames\nimport Data.Default.Class\nimport qualified Data.Vector.Algorithms.Intro as VI\nimport qualified Data.Vector.Generic as VG\nimport Data.Vector.Unboxed ((!))\nimport qualified Graphics.Rendering.Chart as Chart\nimport Statistics.Test.ApproxRand\nimport Statistics.Test.Types (TestType(..))\nimport System.IO (hPutStrLn, stderr)\n\nimport Histogram\nimport ChartBackend\n\nwriteHistogram :: TestOptions -> Int -> TestResult -> FilePath -> IO ()\nwriteHistogram testOptions bins result path =\n case histogram bins result of\n Left err -> hPutStrLn stderr err\n Right h ->\n writeWithBackend (createHistogram testOptions result h) path\n\n-- Creates a histogram. The histogram is stacked, but the second bar\n-- is always empty, except for the bin of the original statistic (if any).\n-- There, the first bar is empty and the second bar has the frequency.\n-- Yes, this is cheating ;).\ncreateHistogram :: TestOptions -> TestResult -> [(Double, Int)] ->\n Chart.Renderable ()\ncreateHistogram testOptions result his =\n Chart.toRenderable layout\n where\n layout =\n Chart.layout_background .~ Chart.solidFillStyle opaqueWhite\n $ Chart.layout_y_axis . Chart.laxis_title .~ \"Frequency\"\n $ Chart.layout_x_axis . Chart.laxis_title .~ \"Statistic\"\n $ Chart.layout_plots .~ [ Chart.plotBars randomizationBars,\n statisticLine, sigLines ]\n $ Chart.setLayoutForeground opaqueBlack\n $ def\n randomizationBars =\n Chart.plot_bars_style .~ Chart.BarsStacked\n $ Chart.plot_bars_spacing .~ Chart.BarsFixGap 6 2\n -- $ Chart.plot_bars_spacing ^= Chart.BarsFixGap 0 0\n $ Chart.plot_bars_item_styles .~ [\n (Chart.solidFillStyle $ opaqueGreen, Nothing) ]\n $ Chart.plot_bars_values .~ map (\\(b, f) -> (b, [f])) his\n $ def\n statisticLine =\n Chart.vlinePlot \"Statistic for samples\" (Chart.solidLine 2 (opaqueRed)) $ trStat result\n sigLines =\n vlinesPlot \"Significance\" (Chart.dashedLine 2 [8, 4] opaqueBlack) $\n sigBounds testOptions result\n\n-- Plot vertical lines, adapted from Chart.vlinePlot.\nvlinesPlot :: String -> Chart.LineStyle -> [a] -> Chart.Plot a b\nvlinesPlot t ls xs = Chart.toPlot vlines\n where\n vlines =\n Chart.plot_lines_title .~ t\n $ Chart.plot_lines_style .~ ls\n $ Chart.plot_lines_limit_values .~ minMax\n $ def\n minMax =\n [[(Chart.LValue v, Chart.LMin), (Chart.LValue v, Chart.LMax)] | v <- xs]\n\n\n-- Calculate the bounds of significance.\nsigBounds :: TestOptions -> TestResult -> [Double]\nsigBounds (TestOptions testType _ n pTest) (TestResult _ _ stats) =\n case testType of\n TwoTailed -> [sorted ! (nExtreme - 1), sorted ! (n - nExtreme)]\n OneTailed -> [sorted ! (n - nExtreme)]\n where\n sorted = sortVector stats\n nExtreme = floor $ (pVal testType pTest) * (fromIntegral n + 1) - 1\n pVal OneTailed p = p\n pVal TwoTailed p = p / 2\n -- XXX: Fix extreme cases: p-value of 0, small n.\n\nsortVector :: (Ord a, VG.Vector v a) => v a -> v a\nsortVector v = runST $ do\n s <- VG.thaw v\n VI.sort s\n VG.freeze s\n\n-- Convenience...\nopaqueBlack, opaqueGreen, opaqueRed, opaqueWhite :: Colour.AlphaColour Double\nopaqueBlack = Colour.opaque ColourNames.black\nopaqueGreen = Colour.opaque ColourNames.green\nopaqueRed = Colour.opaque ColourNames.red\nopaqueWhite = Colour.opaque ColourNames.white\n", "meta": {"hexsha": "a22a407122c81008a891708369be03cf86a5c86b", "size": 3763, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "utils/ChartHistogram.hs", "max_stars_repo_name": "danieldk/approx-rand-test", "max_stars_repo_head_hexsha": "0bfc9a3f16381960bb0420264915f2baf2eea175", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-08-15T18:15:56.000Z", "max_stars_repo_stars_event_max_datetime": "2020-08-15T18:15:56.000Z", "max_issues_repo_path": "utils/ChartHistogram.hs", "max_issues_repo_name": "danieldk/approx-rand-test", "max_issues_repo_head_hexsha": "0bfc9a3f16381960bb0420264915f2baf2eea175", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "utils/ChartHistogram.hs", "max_forks_repo_name": "danieldk/approx-rand-test", "max_forks_repo_head_hexsha": "0bfc9a3f16381960bb0420264915f2baf2eea175", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 38.3979591837, "max_line_length": 93, "alphanum_fraction": 0.665160776, "num_tokens": 945, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.6187804337438501, "lm_q2_score": 0.5506073655352404, "lm_q1q2_score": 0.3407050644684546}} {"text": "-- This file is auto-generated. Do not edit directly.\n-- |\n-- Stability: Experimental\n--\n-- Generic interface to Blas using unsafe foreign calls. Refer to the GHC\n-- documentation for more information regarding appropriate use of safe and unsafe\n-- foreign calls.\n--\n-- The functions here are named in a similar fashion to the original Blas interface, with\n-- the type-dependent letter(s) removed. Some functions have been merged with\n-- others to allow the interface to work on both real and complex numbers. If you can't a\n-- particular function, try looking for its corresponding complex equivalent (e.g.\n-- @symv@ is a special case of 'hemv' applied to real numbers).\n--\n-- Note: although complex versions of @rot@ and @rotg@ exist in many implementations,\n-- they are not part of the official Blas standard and therefore not included here. If\n-- you /really/ need them, submit a ticket so we can try to come up with a solution.\n--\n-- The documentation here is still incomplete. Consult the\n-- for more\n-- information.\n--\n-- Notation:\n--\n-- * @\u22c5@ denotes dot product (without any conjugation).\n-- * @*@ denotes complex conjugation.\n-- * @\u22a4@ denotes transpose.\n-- * @\u2020@ denotes conjugate transpose (Hermitian conjugate).\n--\n-- Conventions:\n--\n-- * All scalars are denoted with lowercase Greek letters\n-- * All vectors are denoted with lowercase Latin letters and are\n-- assumed to be column vectors (unless transposed).\n-- * All matrices are denoted with uppercase Latin letters.\n--\n-- /Since: 0.1.1/\nmodule Blas.Specialized.ComplexDouble.Unsafe (\n -- * Level 1: vector-vector operations\n -- ** Basic operations\n swap\n , scal\n , copy\n , axpy\n , dotu\n , dotc\n -- ** Norm operations\n , nrm2\n , asum\n , iamax\n -- * Level 2: matrix-vector operations\n -- ** Multiplication\n , gemv\n , gbmv\n , hemv\n , hbmv\n , hpmv\n -- ** Triangular operations\n , trmv\n , tbmv\n , tpmv\n , trsv\n , tbsv\n , tpsv\n -- ** Rank updates\n , geru\n , gerc\n , her\n , hpr\n , her2\n , hpr2\n -- * Level 3: matrix-matrix operations\n -- ** Multiplication\n , gemm\n , symm\n , hemm\n -- ** Rank updates\n , syrk\n , herk\n , syr2k\n , her2k\n -- ** Triangular operations\n , trmm\n , trsm\n ) where\nimport Prelude (Double, Int, IO)\nimport Foreign (Ptr)\nimport Data.Complex (Complex((:+)))\nimport FFI (getReturnValue)\nimport Blas.Primitive.Types (Order, Transpose, Uplo, Diag, Side)\nimport qualified Blas.Primitive.Unsafe as C\n\n-- | Swap two vectors:\n--\n-- > (x, y) \u2190 (y, x)\nswap :: Int\n -> Ptr (Complex Double)\n -> Int\n -> Ptr (Complex Double)\n -> Int\n -> IO ()\nswap = C.zswap\n\n\n-- | Multiply a vector by a scalar.\n--\n-- > x \u2190 \u03b1 x\nscal :: Int\n -> Complex Double\n -> Ptr (Complex Double)\n -> Int\n -> IO ()\nscal n (alpha :+ 0) = C.zdscal n alpha\nscal n alpha = C.zscal n alpha\n\n\n-- | Copy a vector into another vector:\n--\n-- > y \u2190 x\ncopy :: Int\n -> Ptr (Complex Double)\n -> Int\n -> Ptr (Complex Double)\n -> Int\n -> IO ()\ncopy = C.zcopy\n\n\n-- | Add a scalar-vector product to a vector.\n--\n-- > y \u2190 \u03b1 x + y\naxpy :: Int\n -> Complex Double\n -> Ptr (Complex Double)\n -> Int\n -> Ptr (Complex Double)\n -> Int\n -> IO ()\naxpy = C.zaxpy\n\n\n-- | Calculate the bilinear dot product of two vectors:\n--\n-- > x \u22c5 y \u2261 \u2211[i] x[i] y[i]\ndotu :: Int\n -> Ptr (Complex Double)\n -> Int\n -> Ptr (Complex Double)\n -> Int\n -> IO (Complex Double)\ndotu a b c d e = getReturnValue (C.zdotu_sub a b c d e)\n\n\n-- | Calculate the sesquilinear dot product of two vectors.\n--\n-- > x* \u22c5 y \u2261 \u2211[i] x[i]* y[i]\ndotc :: Int\n -> Ptr (Complex Double)\n -> Int\n -> Ptr (Complex Double)\n -> Int\n -> IO (Complex Double)\ndotc a b c d e = getReturnValue (C.zdotc_sub a b c d e)\n\n\n-- | Calculate the Euclidean (L\u00b2) norm of a vector:\n--\n-- > \u2016x\u2016\u2082 \u2261 \u221a(\u2211[i] x[i]\u00b2)\nnrm2 :: Int\n -> Ptr (Complex Double)\n -> Int\n -> IO Double\nnrm2 = C.dznrm2\n\n\n-- | Calculate the Manhattan (L\u00b9) norm, equal to the sum of the magnitudes of the elements:\n--\n-- > \u2016x\u2016\u2081 = \u2211[i] |x[i]|\nasum :: Int\n -> Ptr (Complex Double)\n -> Int\n -> IO Double\nasum = C.dzasum\n\n\n-- | Calculate the index of the element with the maximum magnitude (absolute value).\niamax :: Int\n -> Ptr (Complex Double)\n -> Int\n -> IO Int\niamax = C.izamax\n\n\n-- | Perform a general matrix-vector update.\n--\n-- > y \u2190 \u03b1 T(A) x + \u03b2 y\ngemv :: Order\n -> Transpose\n -> Int\n -> Int\n -> Complex Double\n -> Ptr (Complex Double)\n -> Int\n -> Ptr (Complex Double)\n -> Int\n -> Complex Double\n -> Ptr (Complex Double)\n -> Int\n -> IO ()\ngemv = C.zgemv\n\n\n-- | Perform a general banded matrix-vector update.\n--\n-- > y \u2190 \u03b1 T(A) x + \u03b2 y\ngbmv :: Order\n -> Transpose\n -> Int\n -> Int\n -> Int\n -> Int\n -> Complex Double\n -> Ptr (Complex Double)\n -> Int\n -> Ptr (Complex Double)\n -> Int\n -> Complex Double\n -> Ptr (Complex Double)\n -> Int\n -> IO ()\ngbmv = C.zgbmv\n\n\n-- | Perform a hermitian matrix-vector update.\n--\n-- > y \u2190 \u03b1 A x + \u03b2 y\nhemv :: Order\n -> Uplo\n -> Int\n -> Complex Double\n -> Ptr (Complex Double)\n -> Int\n -> Ptr (Complex Double)\n -> Int\n -> Complex Double\n -> Ptr (Complex Double)\n -> Int\n -> IO ()\nhemv = C.zhemv\n\n\n-- | Perform a hermitian banded matrix-vector update.\n--\n-- > y \u2190 \u03b1 A x + \u03b2 y\nhbmv :: Order\n -> Uplo\n -> Int\n -> Int\n -> Complex Double\n -> Ptr (Complex Double)\n -> Int\n -> Ptr (Complex Double)\n -> Int\n -> Complex Double\n -> Ptr (Complex Double)\n -> Int\n -> IO ()\nhbmv = C.zhbmv\n\n\n-- | Perform a hermitian packed matrix-vector update.\n--\n-- > y \u2190 \u03b1 A x + \u03b2 y\nhpmv :: Order\n -> Uplo\n -> Int\n -> Complex Double\n -> Ptr (Complex Double)\n -> Ptr (Complex Double)\n -> Int\n -> Complex Double\n -> Ptr (Complex Double)\n -> Int\n -> IO ()\nhpmv = C.zhpmv\n\n\n-- | Multiply a triangular matrix by a vector.\n--\n-- > x \u2190 T(A) x\ntrmv :: Order\n -> Uplo\n -> Transpose\n -> Diag\n -> Int\n -> Ptr (Complex Double)\n -> Int\n -> Ptr (Complex Double)\n -> Int\n -> IO ()\ntrmv = C.ztrmv\n\n\n-- | Multiply a triangular banded matrix by a vector.\n--\n-- > x \u2190 T(A) x\ntbmv :: Order\n -> Uplo\n -> Transpose\n -> Diag\n -> Int\n -> Int\n -> Ptr (Complex Double)\n -> Int\n -> Ptr (Complex Double)\n -> Int\n -> IO ()\ntbmv = C.ztbmv\n\n\n-- | Multiply a triangular packed matrix by a vector.\n--\n-- > x \u2190 T(A) x\ntpmv :: Order\n -> Uplo\n -> Transpose\n -> Diag\n -> Int\n -> Ptr (Complex Double)\n -> Ptr (Complex Double)\n -> Int\n -> IO ()\ntpmv = C.ztpmv\n\n\n-- | Multiply an inverse triangular matrix by a vector.\n--\n-- > x \u2190 T(A\u207b\u00b9) x\ntrsv :: Order\n -> Uplo\n -> Transpose\n -> Diag\n -> Int\n -> Ptr (Complex Double)\n -> Int\n -> Ptr (Complex Double)\n -> Int\n -> IO ()\ntrsv = C.ztrsv\n\n\n-- | Multiply an inverse triangular banded matrix by a vector.\n--\n-- > x \u2190 T(A\u207b\u00b9) x\ntbsv :: Order\n -> Uplo\n -> Transpose\n -> Diag\n -> Int\n -> Int\n -> Ptr (Complex Double)\n -> Int\n -> Ptr (Complex Double)\n -> Int\n -> IO ()\ntbsv = C.ztbsv\n\n\n-- | Multiply an inverse triangular packed matrix by a vector.\n--\n-- > x \u2190 T(A\u207b\u00b9) x\ntpsv :: Order\n -> Uplo\n -> Transpose\n -> Diag\n -> Int\n -> Ptr (Complex Double)\n -> Ptr (Complex Double)\n -> Int\n -> IO ()\ntpsv = C.ztpsv\n\n\n-- | Perform an unconjugated rank-1 update of a general matrix.\n--\n-- > A \u2190 \u03b1 x y\u22a4 + A\ngeru :: Order\n -> Int\n -> Int\n -> Complex Double\n -> Ptr (Complex Double)\n -> Int\n -> Ptr (Complex Double)\n -> Int\n -> Ptr (Complex Double)\n -> Int\n -> IO ()\ngeru = C.zgeru\n\n\n-- | Perform a conjugated rank-1 update of a general matrix.\n--\n-- > A \u2190 \u03b1 x y\u2020 + A\ngerc :: Order\n -> Int\n -> Int\n -> Complex Double\n -> Ptr (Complex Double)\n -> Int\n -> Ptr (Complex Double)\n -> Int\n -> Ptr (Complex Double)\n -> Int\n -> IO ()\ngerc = C.zgerc\n\n\n-- | Perform a rank-1 update of a Hermitian matrix.\n--\n-- > A \u2190 \u03b1 x y\u2020 + A\nher :: Order\n -> Uplo\n -> Int\n -> Double\n -> Ptr (Complex Double)\n -> Int\n -> Ptr (Complex Double)\n -> Int\n -> IO ()\nher = C.zher\n\n\n-- | Perform a rank-1 update of a Hermitian packed matrix.\n--\n-- > A \u2190 \u03b1 x y\u2020 + A\nhpr :: Order\n -> Uplo\n -> Int\n -> Double\n -> Ptr (Complex Double)\n -> Int\n -> Ptr (Complex Double)\n -> IO ()\nhpr = C.zhpr\n\n\n-- | Perform a rank-2 update of a Hermitian matrix.\n--\n-- > A \u2190 \u03b1 x y\u2020 + y (\u03b1 x)\u2020 + A\nher2 :: Order\n -> Uplo\n -> Int\n -> Complex Double\n -> Ptr (Complex Double)\n -> Int\n -> Ptr (Complex Double)\n -> Int\n -> Ptr (Complex Double)\n -> Int\n -> IO ()\nher2 = C.zher2\n\n\n-- | Perform a rank-2 update of a Hermitian packed matrix.\n--\n-- > A \u2190 \u03b1 x y\u2020 + y (\u03b1 x)\u2020 + A\nhpr2 :: Order\n -> Uplo\n -> Int\n -> Complex Double\n -> Ptr (Complex Double)\n -> Int\n -> Ptr (Complex Double)\n -> Int\n -> Ptr (Complex Double)\n -> IO ()\nhpr2 = C.zhpr2\n\n\n-- | Perform a general matrix-matrix update.\n--\n-- > C \u2190 \u03b1 T(A) U(B) + \u03b2 C\ngemm :: Order -- ^ Layout of all the matrices.\n -> Transpose -- ^ The operation @T@ to be applied to @A@.\n -> Transpose -- ^ The operation @U@ to be applied to @B@.\n -> Int -- ^ Number of rows of @T(A)@ and @C@.\n -> Int -- ^ Number of columns of @U(B)@ and @C@.\n -> Int -- ^ Number of columns of @T(A)@ and number of rows of @U(B)@.\n -> Complex Double -- ^ Scaling factor @\u03b1@ of the product.\n -> Ptr (Complex Double) -- ^ Pointer to a matrix @A@.\n -> Int -- ^ Stride of the major dimension of @A@.\n -> Ptr (Complex Double) -- ^ Pointer to a matrix @B@.\n -> Int -- ^ Stride of the major dimension of @B@.\n -> Complex Double -- ^ Scaling factor @\u03b2@ of the original @C@.\n -> Ptr (Complex Double) -- ^ Pointer to a mutable matrix @C@.\n -> Int -- ^ Stride of the major dimension of @C@.\n -> IO ()\ngemm = C.zgemm\n\n\n-- | Perform a symmetric matrix-matrix update.\n--\n-- > C \u2190 \u03b1 A B + \u03b2 C or C \u2190 \u03b1 B A + \u03b2 C\n--\n-- where @A@ is symmetric. The matrix @A@ must be in an unpacked format, although the\n-- routine will only access half of it as specified by the @'Uplo'@ argument.\nsymm :: Order -- ^ Layout of all the matrices.\n -> Side -- ^ Side that @A@ appears in the product.\n -> Uplo -- ^ The part of @A@ that is used.\n -> Int -- ^ Number of rows of @C@.\n -> Int -- ^ Number of columns of @C@.\n -> Complex Double -- ^ Scaling factor @\u03b1@ of the product.\n -> Ptr (Complex Double) -- ^ Pointer to a symmetric matrix @A@.\n -> Int -- ^ Stride of the major dimension of @A@.\n -> Ptr (Complex Double) -- ^ Pointer to a matrix @B@.\n -> Int -- ^ Stride of the major dimension of @B@.\n -> Complex Double -- ^ Scaling factor @\u03b1@ of the original @C@.\n -> Ptr (Complex Double) -- ^ Pointer to a mutable matrix @C@.\n -> Int -- ^ Stride of the major dimension of @C@.\n -> IO ()\nsymm = C.zsymm\n\n\n-- | Perform a Hermitian matrix-matrix update.\n--\n-- > C \u2190 \u03b1 A B + \u03b2 C or C \u2190 \u03b1 B A + \u03b2 C\n--\n-- where @A@ is Hermitian. The matrix @A@ must be in an unpacked format, although the\n-- routine will only access half of it as specified by the @'Uplo'@ argument.\nhemm :: Order -- ^ Layout of all the matrices.\n -> Side -- ^ Side that @A@ appears in the product.\n -> Uplo -- ^ The part of @A@ that is used.\n -> Int -- ^ Number of rows of @C@.\n -> Int -- ^ Number of columns of @C@.\n -> Complex Double -- ^ Scaling factor @\u03b1@ of the product.\n -> Ptr (Complex Double) -- ^ Pointer to a Hermitian matrix @A@.\n -> Int -- ^ Stride of the major dimension of @A@.\n -> Ptr (Complex Double) -- ^ Pointer to a matrix @B@.\n -> Int -- ^ Stride of the major dimension of @B@.\n -> Complex Double -- ^ Scaling factor @\u03b1@ of the original @C@.\n -> Ptr (Complex Double) -- ^ Pointer to a mutable matrix @C@.\n -> Int -- ^ Stride of the major dimension of @C@.\n -> IO ()\nhemm = C.zhemm\n\n\n-- | Perform a symmetric rank-k update.\n--\n-- > C \u2190 \u03b1 A A\u22a4 + \u03b2 C or C \u2190 \u03b1 A\u22a4 A + \u03b2 C\nsyrk :: Order\n -> Uplo\n -> Transpose\n -> Int\n -> Int\n -> Complex Double\n -> Ptr (Complex Double)\n -> Int\n -> Complex Double\n -> Ptr (Complex Double)\n -> Int\n -> IO ()\nsyrk = C.zsyrk\n\n\n-- | Perform a Hermitian rank-k update.\n--\n-- > C \u2190 \u03b1 A A\u2020 + \u03b2 C or C \u2190 \u03b1 A\u2020 A + \u03b2 C\nherk :: Order\n -> Uplo\n -> Transpose\n -> Int\n -> Int\n -> Double\n -> Ptr (Complex Double)\n -> Int\n -> Double\n -> Ptr (Complex Double)\n -> Int\n -> IO ()\nherk = C.zherk\n\n\n-- | Perform a symmetric rank-2k update.\n--\n-- > C \u2190 \u03b1 A B\u22a4 + \u03b1* B A\u22a4 + \u03b2 C or C \u2190 \u03b1 A\u22a4 B + \u03b1* B\u22a4 A + \u03b2 C\nsyr2k :: Order\n -> Uplo\n -> Transpose\n -> Int\n -> Int\n -> Complex Double\n -> Ptr (Complex Double)\n -> Int\n -> Ptr (Complex Double)\n -> Int\n -> Complex Double\n -> Ptr (Complex Double)\n -> Int\n -> IO ()\nsyr2k = C.zsyr2k\n\n\n-- | Perform a Hermitian rank-2k update.\n--\n-- > C \u2190 \u03b1 A B\u2020 + \u03b1* B A\u2020 + \u03b2 C or C \u2190 \u03b1 A\u2020 B + \u03b1* B\u2020 A + \u03b2 C\nher2k :: Order\n -> Uplo\n -> Transpose\n -> Int\n -> Int\n -> Complex Double\n -> Ptr (Complex Double)\n -> Int\n -> Ptr (Complex Double)\n -> Int\n -> Double\n -> Ptr (Complex Double)\n -> Int\n -> IO ()\nher2k = C.zher2k\n\n\n-- | Perform a triangular matrix-matrix multiplication.\n--\n-- > B \u2190 \u03b1 T(A) B or B \u2190 \u03b1 B T(A)\n--\n-- where @A@ is triangular.\ntrmm :: Order\n -> Side\n -> Uplo\n -> Transpose\n -> Diag\n -> Int\n -> Int\n -> Complex Double\n -> Ptr (Complex Double)\n -> Int\n -> Ptr (Complex Double)\n -> Int\n -> IO ()\ntrmm = C.ztrmm\n\n\n-- | Perform an inverse triangular matrix-matrix multiplication.\n--\n-- > B \u2190 \u03b1 T(A\u207b\u00b9) B or B \u2190 \u03b1 B T(A\u207b\u00b9)\n--\n-- where @A@ is triangular.\ntrsm :: Order\n -> Side\n -> Uplo\n -> Transpose\n -> Diag\n -> Int\n -> Int\n -> Complex Double\n -> Ptr (Complex Double)\n -> Int\n -> Ptr (Complex Double)\n -> Int\n -> IO ()\ntrsm = C.ztrsm\n", "meta": {"hexsha": "b79a7703c62a32035c3341a9387148bcdf6843cf", "size": 14483, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/Blas/Specialized/ComplexDouble/Unsafe.hs", "max_stars_repo_name": "Rufflewind/blas-hs", "max_stars_repo_head_hexsha": "59fdc1c48b19024f9bb6283b4ddc90fe45383937", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2016-01-20T04:34:54.000Z", "max_stars_repo_stars_event_max_datetime": "2018-06-09T12:09:06.000Z", "max_issues_repo_path": "src/Blas/Specialized/ComplexDouble/Unsafe.hs", "max_issues_repo_name": "Rufflewind/blas-hs", "max_issues_repo_head_hexsha": "59fdc1c48b19024f9bb6283b4ddc90fe45383937", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 3, "max_issues_repo_issues_event_min_datetime": "2016-04-25T05:53:19.000Z", "max_issues_repo_issues_event_max_datetime": "2020-11-28T22:27:04.000Z", "max_forks_repo_path": "src/Blas/Specialized/ComplexDouble/Unsafe.hs", "max_forks_repo_name": "Rufflewind/blas-hs", "max_forks_repo_head_hexsha": "59fdc1c48b19024f9bb6283b4ddc90fe45383937", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 21.8446455505, "max_line_length": 92, "alphanum_fraction": 0.5358696403, "num_tokens": 4471, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.665410558746814, "lm_q2_score": 0.5117166047041654, "lm_q1q2_score": 0.34050163185622123}} {"text": "{-# LANGUAGE CPP #-}\n#if defined(__GLASGOW_HASKELL__) && __GLASGOW_HASKELL__ >= 702\n{-# LANGUAGE Safe #-}\n#endif \n-------------------------------------------------------------------------------\n-- |\n-- Module : OGLS.Engine.Math.Vectors\n-- description : 3D and 4D vectors arithmetic \n-- Copyright : (c) Adam, 2017\n-- License : MIT\n-- Maintainer : awkure@protonmail.ch \n-- Stability : unstable \n-- Portability : POSIX\n-------------------------------------------------------------------------------\n\nmodule OGLS.Engine.Math.Instances where \n\nimport Data.Hashable ( Hashable (..) )\nimport Control.Monad.Fix ( MonadFix (..) )\nimport Control.Monad.Zip ( MonadZip (..) )\nimport Control.Applicative ( liftA2 )\nimport Data.Functor.Bind ( Apply (..), Bind (..) )\nimport Data.Semigroup.Foldable ( Foldable1 (..) )\nimport Data.Semigroup.Traversable ( Traversable1 (..) )\nimport Data.Complex ( Complex (..) )\nimport Data.Semigroup ( (<>) )\nimport Data.HashMap.Lazy as HashMap\n\ninstance (Hashable k, Eq k) => Apply (HashMap k) where\n (<.>) = HashMap.intersectionWith id\n\ninstance (Hashable k, Eq k) => Bind (HashMap k) where\n m >>- f = HashMap.fromList $ do\n (k, a) <- HashMap.toList m\n case HashMap.lookup k (f a) of\n Just b -> [(k,b)]\n Nothing -> []\n\ninstance Apply Complex where\n (a :+ b) <.> (c :+ d) = a c :+ b d\n\ninstance Bind Complex where\n (a :+ b) >>- f = a' :+ b' where\n a' :+ _ = f a\n _ :+ b' = f b\n {-# INLINE (>>-) #-}\n\ninstance MonadZip Complex where\n mzipWith = liftA2\n\ninstance MonadFix Complex where\n mfix f = (let a :+ _ = f a in a) :+ (let _ :+ a = f a in a)\n\ninstance Foldable1 Complex where\n foldMap1 f (a :+ b) = f a <> f b\n {-# INLINE foldMap1 #-}\n\ninstance Traversable1 Complex where\n traverse1 f (a :+ b) = (:+) <$> f a <.> f b\n {-# INLINE traverse1 #-}\n\n\n", "meta": {"hexsha": "19c53ef9087af3535dacc9deebf17f8609ac7caa", "size": 1969, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/OGLS/Engine/Math/Instances.hs", "max_stars_repo_name": "awkure/ogls", "max_stars_repo_head_hexsha": "eabc1532e6922192fca718fc12f05f6950ba09cd", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/OGLS/Engine/Math/Instances.hs", "max_issues_repo_name": "awkure/ogls", "max_issues_repo_head_hexsha": "eabc1532e6922192fca718fc12f05f6950ba09cd", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/OGLS/Engine/Math/Instances.hs", "max_forks_repo_name": "awkure/ogls", "max_forks_repo_head_hexsha": "eabc1532e6922192fca718fc12f05f6950ba09cd", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2018-03-01T07:11:48.000Z", "max_forks_repo_forks_event_max_datetime": "2018-03-01T07:11:48.000Z", "avg_line_length": 31.253968254, "max_line_length": 79, "alphanum_fraction": 0.5210766887, "num_tokens": 550, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.7025300573952052, "lm_q2_score": 0.48438008427698437, "lm_q1q2_score": 0.3402915684082042}} {"text": "module LispVal\n ( LispVal(..)\n ) where\n\nimport Data.Complex\n\ndata LispVal\n = Atom String\n | List [LispVal]\n | DottedList [LispVal] LispVal\n | Number Integer\n | String String\n | Bool Bool\n | Character Char\n | Float Double\n | Ratio Rational\n | Complex (Complex Double)\n", "meta": {"hexsha": "633a0b7b587b7ef8d526bbab5f3ea056461bf750", "size": 279, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "app/LispVal.hs", "max_stars_repo_name": "anushriadhia/haskellScheme", "max_stars_repo_head_hexsha": "af5699685e7a02e3222c5e147778df07b7c564dd", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "app/LispVal.hs", "max_issues_repo_name": "anushriadhia/haskellScheme", "max_issues_repo_head_hexsha": "af5699685e7a02e3222c5e147778df07b7c564dd", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "app/LispVal.hs", "max_forks_repo_name": "anushriadhia/haskellScheme", "max_forks_repo_head_hexsha": "af5699685e7a02e3222c5e147778df07b7c564dd", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 15.5, "max_line_length": 32, "alphanum_fraction": 0.6738351254, "num_tokens": 86, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES\n\n", "lm_q1_score": 0.5736784220301065, "lm_q2_score": 0.5926665999540698, "lm_q1q2_score": 0.34000003985159916}} {"text": "{-# LANGUAGE FlexibleContexts #-}\n\nmodule Numeric.Trainee.Data.Common (\n\tCsvM, runCsvM, col_, read_, single_, enum_, class_, sample_\n\t) where\n\nimport Prelude.Unicode\n\nimport Control.DeepSeq\nimport Control.Monad.Except\nimport Control.Monad.Reader\nimport Data.List\nimport qualified Data.Vector as V\nimport qualified Data.Text as T\nimport Numeric.LinearAlgebra\nimport Text.Read\n\nimport Numeric.Trainee.Types\n\ntype CsvM a = ReaderT (V.Vector T.Text) (Either String) a\n\nrunCsvM \u2237 CsvM a \u2192 V.Vector T.Text \u2192 Either String a\nrunCsvM = runReaderT\n\ncol_ \u2237 Int \u2192 CsvM String\ncol_ idx = ReaderT $ \\r \u2192 maybe (throwError $ \"invalid column index: \" ++ show idx) (return \u2218 T.unpack) (r V.!? idx)\n\nread_ \u2237 Read a \u21d2 String \u2192 CsvM a\nread_ s = maybe (throwError $ \"can't parse: \" ++ s) return \u2218 readMaybe $ s\n\nsingle_ \u2237 a \u2192 CsvM [a]\nsingle_ = return \u2218 return\n\nenum_ \u2237 Fractional a \u21d2 [String] \u2192 String \u2192 CsvM a\nenum_ names name = case findIndex (\u2261 name) names of\n\tNothing \u2192 throwError $ \"invalid enum value: \" ++ name ++ \", expected \" ++ intercalate \", \" names\n\tJust idx \u2192 return (fromIntegral idx / fromIntegral (length names - 1))\n\nclass_ \u2237 Num a \u21d2 [String] \u2192 String \u2192 CsvM [a]\nclass_ names name = case findIndex (\u2261 name) names of\n\tNothing \u2192 throwError $ \"invalid class value: \" ++ name ++ \", expected \" ++ intercalate \", \" names\n\tJust idx \u2192 return $ replicate idx 0 ++ [1] ++ replicate (length names - idx - 1) 0\n\nsample_ \u2237 Container Vector a \u21d2 [a] \u2192 [a] \u2192 CsvM (Sample (Vector a) (Vector a))\nsample_ is os = return $!! Sample (fromList is) (fromList os)\n", "meta": {"hexsha": "439b0382b5f95ebda18001b527ab522409c1fa7b", "size": 1539, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/Numeric/Trainee/Data/Common.hs", "max_stars_repo_name": "mvoidex/trainee", "max_stars_repo_head_hexsha": "60a935e53cabcf145736716829ee1be986b0ffc7", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2017-04-25T19:54:44.000Z", "max_stars_repo_stars_event_max_datetime": "2020-01-20T03:03:26.000Z", "max_issues_repo_path": "src/Numeric/Trainee/Data/Common.hs", "max_issues_repo_name": "mvoidex/trainee", "max_issues_repo_head_hexsha": "60a935e53cabcf145736716829ee1be986b0ffc7", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/Numeric/Trainee/Data/Common.hs", "max_forks_repo_name": "mvoidex/trainee", "max_forks_repo_head_hexsha": "60a935e53cabcf145736716829ee1be986b0ffc7", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 33.4565217391, "max_line_length": 116, "alphanum_fraction": 0.6926575699, "num_tokens": 457, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.5736784220301065, "lm_q2_score": 0.5926665999540698, "lm_q1q2_score": 0.34000003985159916}} {"text": "{-# LANGUAGE GADTs #-}\n{-# LANGUAGE ScopedTypeVariables #-}\n{-# LANGUAGE TypeApplications #-}\n-- |\n-- Module : Data.Array.Accelerate.Numeric.LinearAlgebra.LLVM.PTX.Level2\n-- Copyright : [2017..2020] Trevor L. McDonell\n-- License : BSD3\n--\n-- Maintainer : Trevor L. McDonell \n-- Stability : experimental\n-- Portability : non-portable (GHC extensions)\n--\n\nmodule Data.Array.Accelerate.Numeric.LinearAlgebra.LLVM.PTX.Level2\n where\n\nimport Data.Complex\nimport Data.Array.Accelerate.Representation.Array\nimport Data.Array.Accelerate.Representation.Shape\nimport Data.Array.Accelerate.Sugar.Elt\n\nimport Data.Array.Accelerate.LLVM.PTX.Foreign\nimport Data.Array.Accelerate.Numeric.LinearAlgebra.LLVM.PTX.Base\nimport Data.Array.Accelerate.Numeric.LinearAlgebra.LLVM.PTX.Context\nimport Data.Array.Accelerate.Numeric.LinearAlgebra.LLVM.PTX.Level3\nimport Data.Array.Accelerate.Numeric.LinearAlgebra.Type\n\nimport Foreign.Marshal ( with )\nimport qualified Foreign.CUDA.Ptr as CUDA\nimport qualified Foreign.CUDA.BLAS as BLAS\n\nimport Control.Monad.Reader\n\n\n-- NOTE: cuBLAS requires matrices to be stored in column-major order\n-- (Fortran-style), but Accelerate uses C-style arrays in row-major order.\n--\n-- If the operation is N or T, we can just swap the operation. For\n-- conjugate-transpose (H) operations (on complex valued arguments), since there\n-- is no conjugate-no-transpose operation, we implement that via 'gemm', which\n-- I assume is more efficient than ?geam followed by ?gemv.\n--\ngemv :: NumericR s e\n -> Transpose\n -> ForeignAcc ((((((), Scalar e), Matrix e), Vector e)) -> Vector e)\ngemv eR opA = ForeignAcc \"ptx.gemv\" (gemv' eR opA)\n\ngemv' :: NumericR s e\n -> Transpose\n -> ((((), Scalar e), Matrix e), Vector e)\n -> Par PTX (Future (Vector e))\ngemv' NumericRcomplex32 H = as_gemm NumericRcomplex32 H\ngemv' NumericRcomplex64 H = as_gemm NumericRcomplex64 H\ngemv' nR t = as_gemv nR t\n\n\nas_gemm\n :: NumericR s e\n -> Transpose\n -> ((((), Scalar e), Matrix e), Vector e)\n -> Par PTX (Future (Vector e))\nas_gemm nR opA ((((), alpha), matA), Array sh adata) = do\n let matB = Array (sh,1) adata\n --\n future <- new\n result <- gemm' nR opA N ((((), alpha), matA), matB)\n fork $ do Array (sh',_) vecy <- get result\n put future (Array sh' vecy)\n return future\n\nas_gemv\n :: NumericR s e\n -> Transpose\n -> ((((), Scalar e), Matrix e), Vector e)\n -> Par PTX (Future (Vector e))\nas_gemv nR opA ((((), alpha), matA), vecx) = do\n let\n (((), rowsA), colsA) = shape matA\n\n sizeY = case opA of\n N -> rowsA\n _ -> colsA\n\n opA' = encodeTranspose\n $ case opA of\n N -> T\n _ -> N\n\n aR = ArrayR dim1 eR\n eR = case nR of\n NumericRfloat32 -> eltR @Float\n NumericRfloat64 -> eltR @Double\n NumericRcomplex32 -> eltR @(Complex Float)\n NumericRcomplex64 -> eltR @(Complex Double)\n --\n future <- new\n stream <- asks ptxStream\n vecy <- allocateRemote aR ((), sizeY)\n alpha' <- indexRemote eR alpha 0\n () <- liftPar $ do\n withArray nR matA stream $ \\ptr_A -> do\n withArray nR vecx stream $ \\ptr_x -> do\n withArray nR vecy stream $ \\ptr_y -> do\n withBLAS $ \\hdl -> do\n case nR of\n NumericRfloat32 -> liftIO $\n with alpha' $ \\ptr_alpha ->\n with 0 $ \\ptr_beta ->\n BLAS.sgemv hdl opA' colsA rowsA ptr_alpha ptr_A colsA ptr_x 1 ptr_beta ptr_y 1\n\n NumericRfloat64 -> liftIO $\n with alpha' $ \\ptr_alpha ->\n with 0 $ \\ptr_beta ->\n BLAS.dgemv hdl opA' colsA rowsA ptr_alpha ptr_A colsA ptr_x 1 ptr_beta ptr_y 1\n\n NumericRcomplex32 -> liftIO $\n withV2 nR alpha' $ \\ptr_alpha ->\n with 0 $ \\ptr_beta ->\n BLAS.cgemv hdl opA' colsA rowsA ptr_alpha (CUDA.castDevPtr ptr_A) colsA (CUDA.castDevPtr ptr_x) 1 ptr_beta (CUDA.castDevPtr ptr_y) 1\n\n NumericRcomplex64 -> liftIO $\n withV2 nR alpha' $ \\ptr_alpha ->\n with 0 $ \\ptr_beta ->\n BLAS.zgemv hdl opA' colsA rowsA ptr_alpha (CUDA.castDevPtr ptr_A) colsA (CUDA.castDevPtr ptr_x) 1 ptr_beta (CUDA.castDevPtr ptr_y) 1\n --\n put future vecy\n return future\n\n", "meta": {"hexsha": "bb740d8cfb9d6c5feb9247dc0c5d82b102907f8c", "size": 4579, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/Data/Array/Accelerate/Numeric/LinearAlgebra/LLVM/PTX/Level2.hs", "max_stars_repo_name": "statusfailed/accelerate-blas", "max_stars_repo_head_hexsha": "4e59e73f8545db76ea5d4570fb118af4080b0385", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 8, "max_stars_repo_stars_event_min_datetime": "2017-07-01T06:41:27.000Z", "max_stars_repo_stars_event_max_datetime": "2019-12-02T04:28:37.000Z", "max_issues_repo_path": "src/Data/Array/Accelerate/Numeric/LinearAlgebra/LLVM/PTX/Level2.hs", "max_issues_repo_name": "statusfailed/accelerate-blas", "max_issues_repo_head_hexsha": "4e59e73f8545db76ea5d4570fb118af4080b0385", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 4, "max_issues_repo_issues_event_min_datetime": "2017-07-17T02:23:37.000Z", "max_issues_repo_issues_event_max_datetime": "2020-08-26T16:52:28.000Z", "max_forks_repo_path": "src/Data/Array/Accelerate/Numeric/LinearAlgebra/LLVM/PTX/Level2.hs", "max_forks_repo_name": "statusfailed/accelerate-blas", "max_forks_repo_head_hexsha": "4e59e73f8545db76ea5d4570fb118af4080b0385", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 4, "max_forks_repo_forks_event_min_datetime": "2017-07-16T03:06:17.000Z", "max_forks_repo_forks_event_max_datetime": "2020-07-30T15:49:28.000Z", "avg_line_length": 35.496124031, "max_line_length": 148, "alphanum_fraction": 0.6005678096, "num_tokens": 1285, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.7310585786300049, "lm_q2_score": 0.4649015713733885, "lm_q1q2_score": 0.33987028197108515}} {"text": "{-# LANGUAGE AllowAmbiguousTypes #-}\n{-# LANGUAGE DataKinds #-}\n{-# LANGUAGE PolyKinds #-}\n{-# LANGUAGE FlexibleContexts #-}\n{-# LANGUAGE FlexibleInstances #-}\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE NoMonomorphismRestriction #-}\n{-# LANGUAGE OverloadedStrings #-}\n{-# LANGUAGE QuantifiedConstraints #-}\n{-# LANGUAGE ScopedTypeVariables #-}\n{-# LANGUAGE TypeApplications #-}\n{-# LANGUAGE TypeFamilies #-}\n{-# LANGUAGE TypeOperators #-}\n\n{-# OPTIONS_GHC -O0 #-}\n\nmodule BlueRipple.Data.UsefulDataJoins where\n\nimport qualified Control.Foldl as FL\nimport Control.Monad ( join )\nimport qualified Data.Array as A\nimport Data.Function ( on )\nimport qualified Data.List as L\nimport qualified Data.Set as S\nimport qualified Data.Map as M\nimport Data.Maybe ( isJust )\n\nimport qualified Data.Text as T\nimport qualified Data.Serialize as SE\nimport Data.Serialize.Text ( )\nimport qualified Frames as F\nimport qualified Frames.Melt as F\nimport qualified Frames.InCore as FI\nimport qualified Data.Vinyl as V\nimport qualified Data.Vinyl.TypeLevel as V\nimport qualified Data.Discrimination.Grouping as G\n\n\nimport qualified Control.MapReduce as MR\nimport qualified Frames.Transform as FT\nimport qualified Frames.Folds as FF\nimport qualified Frames.MapReduce as FMR\nimport qualified Frames.Enumerations as FE\nimport qualified Frames.SimpleJoins as FJ\nimport qualified Frames.Serialize as FS\n\nimport qualified Graphics.Vega.VegaLite as GV\nimport qualified Knit.Report as K\n\nimport BlueRipple.Utilities.KnitUtils\n\nimport qualified Statistics.Types as ST\nimport GHC.Generics ( Generic )\n\nimport qualified BlueRipple.Data.DataFrames as BR\nimport qualified BlueRipple.Data.DemographicTypes\n as BR\n\nimport qualified BlueRipple.Data.ElectionTypes\n as BR\n\n--import qualified BlueRipple.Data.PrefModel as BR\nimport qualified BlueRipple.Model.TurnoutAdjustment\n as BR\n\nimport qualified BlueRipple.Utilities.KnitUtils\n as BR\nimport qualified BlueRipple.Data.Keyed as Keyed\n\n\n\nrollupF :: forall as bs ds. (Ord (F.Record bs)\n , bs F.\u2286 (as V.++ bs V.++ ds)\n , ds F.\u2286 (as V.++ bs V.++ ds)\n , FI.RecVec (bs V.++ ds)\n ) => FL.Fold (F.Record ds) (F.Record ds) -> FL.Fold (F.Record (as V.++ bs V.++ ds)) (F.FrameRec (bs V.++ ds))\nrollupF dataF = FMR.concatFold $ FMR.mapReduceFold\n FMR.noUnpack\n (FMR.assignKeysAndData @bs)\n (FMR.foldAndAddKey dataF)\n\n\nrollupSumF :: forall as bs ds. (Ord (F.Record bs)\n , bs F.\u2286 (as V.++ bs V.++ ds)\n , ds F.\u2286 (as V.++ bs V.++ ds)\n , FI.RecVec (bs V.++ ds)\n , FF.ConstrainedFoldable Num ds\n )\n => FL.Fold (F.Record (as V.++ bs V.++ ds)) (F.FrameRec (bs V.++ ds))\nrollupSumF = rollupF @as @bs @ds (FF.foldAllConstrained @Num FL.sum)\n\naddElectoralWeight ::\n BR.ElectoralWeightSourceT\n -> BR.ElectoralWeightOfT\n -> (F.Record rs -> Double)\n -> F.Record rs\n -> F.Record (rs V.++ [BR.ElectoralWeightSource, BR.ElectoralWeightOf, BR.ElectoralWeight])\naddElectoralWeight ews ewof calcEW r =\n let ewcs :: F.Record [BR.ElectoralWeightSource, BR.ElectoralWeightOf, BR.ElectoralWeight] = ews F.&: ewof F.&: calcEW r F.&: V.RNil\n in r `V.rappend` ewcs\n\n\n\ntype PCols p = [BR.PopCountOf, p]\ntype PEWCols p = PCols p V.++ BR.EWCols --[BR.PopCountOf, p, BR.ElectoralWeightSource, BR.ElectoralWeightOf, BR.ElectoralWeight]\n\njoinDemoAndWeights\n :: forall js ks p\n . ( FJ.CanLeftJoinM js (ks V.++ PCols p) (js V.++ BR.EWCols)\n , ((ks V.++ PCols p) V.++ F.RDeleteAll js (js V.++ BR.EWCols)) ~ ((ks V.++ PCols p) V.++ BR.EWCols)\n , js F.\u2286 ks\n , FI.RecVec (ks V.++ PCols p V.++ BR.EWCols)\n , (ks V.++ PCols p V.++ BR.EWCols) F.\u2286 ((ks V.++ PCols p) V.++ F.RDeleteAll js (js V.++ BR.EWCols))\n , js F.\u2286 (ks V.++ PCols p)\n , js F.\u2286 (js V.++ BR.EWCols)\n , (ks V.++ PCols p) F.\u2286 ((ks V.++ PCols p) V.++ F.RDeleteAll js (js V.++ BR.EWCols))\n , F.RDeleteAll js (js V.++ BR.EWCols) F.\u2286 (js V.++ BR.EWCols)\n , V.RMap (ks V.++ PCols p)\n , V.RMap ((ks V.++ PCols p) V.++ F.RDeleteAll js (js V.++ BR.EWCols))\n , V.RecApplicative (F.RDeleteAll js (js V.++ BR.EWCols))\n , G.Grouping (F.Record js)\n , FI.RecVec (ks V.++ PCols p)\n , FI.RecVec (F.RDeleteAll js (js V.++ BR.EWCols))\n , FI.RecVec ((ks V.++ PCols p) V.++ F.RDeleteAll js (js V.++ BR.EWCols))\n )\n => F.FrameRec (ks V.++ (PCols p))\n -> F.FrameRec (js V.++ BR.EWCols)\n -> Either [F.Record js] (F.FrameRec (ks V.++ PCols p V.++ BR.EWCols))\njoinDemoAndWeights d w = FJ.leftJoinE @js d w\n{-F.toFrame\n $ fmap F.rcast\n $ catMaybes\n $ fmap F.recMaybe\n $ F.leftJoin @js d w\n-}\n\n{-\n--defaultPopRec :: BR.PopCountOfT -> V.Snd p -> F.Record (PCols p)\n--defaultPopRec pco x = pco F.&: x F.&: V.RNil\n\n\njoinDemoAndWeightsWithDefaults\n :: forall js ks p\n . (js F.\u2286 ks\n , Keyed.FiniteSet (F.Record ks)\n , FI.RecVec (ks V.++ PCols p V.++ BR.EWCols)\n , (ks V.++ PCols p V.++ BR.EWCols) F.\u2286 ((ks V.++ PCols p) V.++ F.RDeleteAll js (js V.++ BR.EWCols))\n , js F.\u2286 (ks V.++ PCols p)\n , js F.\u2286 (js V.++ BR.EWCols)\n , (ks V.++ PCols p) F.\u2286 ((ks V.++ PCols p) V.++ F.RDeleteAll js (js V.++ BR.EWCols))\n , (F.RDeleteAll js (js V.++ BR.EWCols)) F.\u2286 (js V.++ BR.EWCols)\n , V.RMap (ks V.++ PCols p)\n , V.RMap ((ks V.++ PCols p) V.++ F.RDeleteAll js (js V.++ BR.EWCols))\n , V.RecApplicative (F.RDeleteAll js (js V.++ BR.EWCols))\n , G.Grouping (F.Record js)\n , FI.RecVec (ks V.++ PCols p)\n , FI.RecVec (F.RDeleteAll js (js V.++ BR.EWCols))\n , FI.RecVec ((ks V.++ PCols p) V.++ F.RDeleteAll js (js V.++ BR.EWCols))\n , V.KnownField p\n , F.ElemOf (ks V.++ (PCols p)) p\n , F.ElemOf (ks V.++ (PCols p)) BR.PopCountOf\n , ks F.\u2286 (ks V.++ (PCols p))\n , (ks V.++ PCols p V.++ BR.EWCols) F.\u2286 ((js V.++ BR.EWCols) V.++ F.RDeleteAll js (ks V.++ PCols p))\n , (js V.++ BR.EWCols) F.\u2286 ((js V.++ BR.EWCols) V.++ F.RDeleteAll js (ks V.++ PCols p))\n , (F.RDeleteAll js (ks V.++ PCols p)) F.\u2286 (ks V.++ PCols p)\n , V.RMap (js V.++ BR.EWCols)\n , V.RMap ((js V.++ BR.EWCols) V.++ F.RDeleteAll js (ks V.++ PCols p))\n , V.RecApplicative (F.RDeleteAll js (ks V.++ PCols p))\n , FI.RecVec (js V.++ BR.EWCols)\n , FI.RecVec (F.RDeleteAll js (ks V.++ PCols p))\n , FI.RecVec ((js V.++ BR.EWCols) V.++ F.RDeleteAll js (ks V.++ PCols p))\n )\n => BR.PopCountOfT\n -> V.Snd p\n -> F.FrameRec (ks V.++ (PCols p))\n -> F.FrameRec (js V.++ BR.EWCols)\n -> F.FrameRec (ks V.++ PCols p V.++ BR.EWCols)\njoinDemoAndWeightsWithDefaults pco x d w =\n let demoWithDefaults :: F.FrameRec (ks V.++ (PCols p))\n demoWithDefaults = F.toFrame $ FL.fold (Keyed.addDefaultRec @ks @(PCols p) (pco F.&: x F.&: V.RNil)) d\n in F.toFrame\n $ fmap F.rcast\n $ catMaybes\n $ fmap F.recMaybe\n $ F.leftJoin @js w demoWithDefaults\n-}\n\nadjustWeightsForStateTotals\n :: forall ks p r\n . (K.KnitEffects r\n , V.KnownField p\n , V.Snd p ~ Int\n , F.ElemOf (BR.WithYS ks) BR.Year\n , F.ElemOf (BR.WithYS ks) BR.StateAbbreviation\n , (ks V.++ PCols p V.++ BR.EWCols) F.\u2286 BR.WithYS (ks V.++ PCols p V.++ BR.EWCols)\n , F.ElemOf (ks V.++ PCols p V.++ BR.EWCols) p\n , F.ElemOf (ks V.++ PCols p V.++ BR.EWCols) BR.ElectoralWeight\n , FI.RecVec (ks V.++ PCols p V.++ BR.EWCols)\n , Show (F.Record ((ks V.++ PCols '(V.Fst p, Int)) V.++ BR.EWCols))\n )\n => F.Frame BR.StateTurnout\n -> F.FrameRec (BR.WithYS ks V.++ PCols p V.++ BR.EWCols)\n -> K.Sem r (F.FrameRec (BR.WithYS ks V.++ PCols p V.++ BR.EWCols))\nadjustWeightsForStateTotals stateTurnout unadj =\n FL.foldM\n (BR.adjTurnoutFold @p @BR.ElectoralWeight stateTurnout)\n unadj\n\n\ndemographicsWithAdjTurnoutByState\n :: forall catCols p ks js effs\n . ( K.KnitEffects effs\n , FJ.CanLeftJoinM (js V.++ catCols) ((BR.WithYS ks) V.++ catCols V.++ (PCols p)) (js V.++ catCols V.++ BR.EWCols)\n , (((ks V.++ catCols) V.++ PCols p) V.++ F.RDeleteAll (js V.++ catCols) ((js V.++ catCols) V.++ BR.EWCols)) ~ (((ks V.++ catCols) V.++ PCols p) V.++ BR.EWCols\n )\n\n , V.RMap (js V.++ catCols)\n , V.ReifyConstraint Show V.ElField (js V.++ catCols)\n , V.RecordToList (js V.++ catCols)\n , V.KnownField p\n , V.Snd p ~ Int\n , F.ElemOf (ks V.++ catCols V.++ PEWCols p) p\n , F.ElemOf (ks V.++ catCols V.++ PEWCols p) BR.ElectoralWeight\n , (ks V.++ catCols V.++ PEWCols p) F.\u2286 BR.WithYS (ks V.++ catCols V.++ PEWCols p)\n , FI.RecVec (ks V.++ catCols V.++ PEWCols p)\n , (ks V.++ catCols V.++ PEWCols p) F.\u2286 (BR.WithYS (ks V.++ catCols V.++ PCols p) V.++ F.RDeleteAll (js V.++ catCols) (js V.++ catCols V.++ BR.EWCols))\n , (js V.++ catCols) F.\u2286 ((js V.++ catCols V.++ BR.EWCols))\n , (js V.++ catCols) F.\u2286 BR.WithYS (ks V.++ catCols)\n , (js V.++ catCols) F.\u2286 BR.WithYS (ks V.++ catCols V.++ (PCols p))\n , (ks V.++ catCols V.++ (PCols p)) F.\u2286 BR.WithYS (ks V.++ catCols V.++ (PCols p) V.++ F.RDeleteAll (js V.++ catCols) ((js V.++ catCols) V.++ BR.EWCols))\n , (F.RDeleteAll (js V.++ catCols) ((js V.++ catCols) V.++ BR.EWCols)) F.\u2286 ((js V.++ catCols) V.++ BR.EWCols)\n , V.RMap ((ks V.++ catCols) V.++ PCols p)\n , V.RMap ((((ks V.++ catCols) V.++ PCols p) V.++ F.RDeleteAll (js V.++ catCols) ((js V.++ catCols) V.++ BR.EWCols)))\n , V.RecApplicative (F.RDeleteAll (js V.++ catCols) ((js V.++ catCols) V.++ BR.EWCols))\n , G.Grouping (F.Record (js V.++ catCols))\n , FI.RecVec ((ks V.++ catCols) V.++ PCols p)\n , FI.RecVec (F.RDeleteAll (js V.++ catCols) ((js V.++ catCols) V.++ BR.EWCols))\n , FI.RecVec (((ks V.++ catCols) V.++ PCols p) V.++ F.RDeleteAll (js V.++ catCols) ((js V.++ catCols) V.++ BR.EWCols))\n , (ks V.++ catCols V.++ PCols p V.++ BR.EWCols) ~ (ks V.++ catCols V.++ (PCols p V.++ BR.EWCols))\n , Show (F.Record ((ks V.++ catCols)\n V.++ '[ '(\"PopCountOf\", BR.PopCountOfT), p,\n BR.ElectoralWeightSource, BR.ElectoralWeightOf,\n BR.ElectoralWeight]))\n )\n => F.Frame BR.StateTurnout\n -> F.FrameRec ((BR.WithYS ks) V.++ catCols V.++ (PCols p))\n -> F.FrameRec (js V.++ catCols V.++ BR.EWCols)\n -> K.Sem effs (F.FrameRec ((BR.WithYS ks) V.++ catCols V.++ (PEWCols p)))\ndemographicsWithAdjTurnoutByState stateTurnout demos ews = do\n let joinedE :: Either [F.Record (js V.++ catCols)] (F.FrameRec ((BR.WithYS ks) V.++ catCols V.++ (PEWCols p)))\n joinedE = joinDemoAndWeights @(js V.++ catCols) @((BR.WithYS ks) V.++ catCols) @p demos ews\n joined <- K.knitEither\n $ either (\\missingKeys -> Left $ \"missing keys in electoral weights in demographicsWithAdjTurnoutByState: \" <> show missingKeys) Right\n $ joinedE\n adjustWeightsForStateTotals @(ks V.++ catCols) @p stateTurnout joined\n\n{-\ndemographicsWithDefaultsWithAdjTurnoutByState\n :: forall catCols p ks js effs\n . ( K.KnitEffects effs\n , V.KnownField p\n , V.Snd p ~ Int\n , F.ElemOf (ks V.++ catCols V.++ PEWCols p) p\n , F.ElemOf (ks V.++ catCols V.++ PEWCols p) BR.ElectoralWeight\n , (ks V.++ catCols V.++ PEWCols p) F.\u2286 BR.WithYS (ks V.++ catCols V.++ PEWCols p)\n , FI.RecVec (ks V.++ catCols V.++ PEWCols p)\n , (ks V.++ catCols V.++ PEWCols p) F.\u2286 (BR.WithYS (ks V.++ catCols V.++ PCols p) V.++ F.RDeleteAll (js V.++ catCols) (js V.++ catCols V.++ BR.EWCols))\n , (js V.++ catCols) F.\u2286 ((js V.++ catCols V.++ BR.EWCols))\n , (js V.++ catCols) F.\u2286 BR.WithYS (ks V.++ catCols)\n , (js V.++ catCols) F.\u2286 BR.WithYS (ks V.++ catCols V.++ (PCols p))\n , (ks V.++ catCols V.++ (PCols p)) F.\u2286 BR.WithYS (ks V.++ catCols V.++ (PCols p) V.++ F.RDeleteAll (js V.++ catCols) ((js V.++ catCols) V.++ BR.EWCols))\n , (F.RDeleteAll (js V.++ catCols) ((js V.++ catCols) V.++ BR.EWCols)) F.\u2286 ((js V.++ catCols) V.++ BR.EWCols)\n , V.RMap ((ks V.++ catCols) V.++ PCols p)\n , V.RMap ((((ks V.++ catCols) V.++ PCols p) V.++ F.RDeleteAll (js V.++ catCols) ((js V.++ catCols) V.++ BR.EWCols)))\n , V.RecApplicative (F.RDeleteAll (js V.++ catCols) ((js V.++ catCols) V.++ BR.EWCols))\n , G.Grouping (F.Record (js V.++ catCols))\n , FI.RecVec ((ks V.++ catCols) V.++ PCols p)\n , FI.RecVec (F.RDeleteAll (js V.++ catCols) ((js V.++ catCols) V.++ BR.EWCols))\n , FI.RecVec (((ks V.++ catCols) V.++ PCols p) V.++ F.RDeleteAll (js V.++ catCols) ((js V.++ catCols) V.++ BR.EWCols))\n , (ks V.++ catCols V.++ PCols p V.++ BR.EWCols) ~ (ks V.++ catCols V.++ (PCols p V.++ BR.EWCols))\n )\n => BR.PopCountOfT\n -> V.Snd p\n -> F.Frame BR.StateTurnout\n -> F.FrameRec ((BR.WithYS ks) V.++ catCols V.++ (PCols p))\n -> F.FrameRec (js V.++ catCols V.++ BR.EWCols)\n -> K.Sem effs (F.FrameRec ((BR.WithYS ks) V.++ catCols V.++ (PEWCols p)))\ndemographicsWithDefaultsWithAdjTurnoutByState pco x stateTurnout demos ews = do\n let joined :: F.FrameRec ((BR.WithYS ks) V.++ catCols V.++ (PEWCols p))\n joined = joinDemoAndWeightsWithDefaults @(js V.++ catCols) @((BR.WithYS ks) V.++ catCols) @p pco x demos ews\n adjustWeightsForStateTotals @(ks V.++ catCols) @p stateTurnout joined\n\n-}\n\n-- This is monstrous\nrollupAdjustAndJoin\n :: forall as catCols p ks js effs\n .(K.KnitEffects effs\n , FJ.CanLeftJoinM (js V.++ catCols) ((BR.WithYS ks) V.++ catCols V.++ (PCols p)) (js V.++ catCols V.++ BR.EWCols)\n , (((ks V.++ catCols) V.++ PCols p) V.++ F.RDeleteAll (js V.++ catCols) ((js V.++ catCols) V.++ BR.EWCols)) ~ (((ks V.++ catCols) V.++ PCols p) V.++ BR.EWCols)\n , V.RMap (js V.++ catCols)\n , V.ReifyConstraint Show V.ElField (js V.++ catCols)\n , V.RecordToList (js V.++ catCols)\n , V.KnownField p\n , V.Snd p ~ Int\n , F.ElemOf (ks V.++ catCols V.++ (PEWCols p)) p\n , F.ElemOf (ks V.++ catCols V.++ (PEWCols p)) BR.ElectoralWeight\n , (ks V.++ catCols V.++ (PEWCols p)) F.\u2286 BR.WithYS (ks V.++ catCols V.++ (PEWCols p))\n , FI.RecVec (ks V.++ catCols V.++ (PEWCols p))\n , (ks V.++ catCols V.++ (PEWCols p)) F.\u2286 BR.WithYS (ks V.++ catCols V.++ (PCols p) V.++ F.RDeleteAll (js V.++ catCols) ((js V.++ catCols V.++ BR.EWCols)))\n , (js V.++ catCols) F.\u2286 ((js V.++ catCols V.++ BR.EWCols))\n , (js V.++ catCols) F.\u2286 BR.WithYS (ks V.++ catCols)\n , (js V.++ catCols) F.\u2286 BR.WithYS (ks V.++ catCols V.++ (PCols p))\n , (ks V.++ catCols V.++ (PCols p)) F.\u2286 BR.WithYS (ks V.++ catCols V.++ (PCols p) V.++ F.RDeleteAll (js V.++ catCols) ((js V.++ catCols) V.++ BR.EWCols))\n , (F.RDeleteAll (js V.++ catCols) ((js V.++ catCols) V.++ BR.EWCols)) F.\u2286 ((js V.++ catCols) V.++ BR.EWCols)\n , V.RMap ((ks V.++ catCols) V.++ PCols p)\n , V.RMap ((((ks V.++ catCols) V.++ PCols p) V.++ F.RDeleteAll (js V.++ catCols) ((js V.++ catCols) V.++ BR.EWCols)))\n , V.RecApplicative (F.RDeleteAll (js V.++ catCols) ((js V.++ catCols) V.++ BR.EWCols))\n , G.Grouping (F.Record (js V.++ catCols))\n , FI.RecVec ((ks V.++ catCols) V.++ PCols p)\n , FI.RecVec (F.RDeleteAll (js V.++ catCols) ((js V.++ catCols) V.++ BR.EWCols))\n , FI.RecVec (((ks V.++ catCols) V.++ PCols p) V.++ F.RDeleteAll (js V.++ catCols) ((js V.++ catCols) V.++ BR.EWCols))\n , (as V.++ BR.WithYS ks V.++ catCols V.++ PCols p) ~ (as V.++ BR.WithYS (ks V.++ catCols V.++ '[BR.PopCountOf]) V.++ '[p])\n , (((ks V.++ catCols) V.++ '[BR.PopCountOf]) V.++ '[p]) ~ ((ks V.++ catCols) V.++ PCols p)\n , Ord (F.Record ((ks V.++ catCols) V.++ '[BR.PopCountOf]))\n , F.ElemOf (as V.++ BR.WithYS (ks V.++ catCols V.++ '[BR.PopCountOf]) V.++ '[p]) p\n , F.ElemOf (as V.++ BR.WithYS (ks V.++ catCols V.++ '[BR.PopCountOf]) V.++ '[p]) BR.StateAbbreviation\n , F.ElemOf (as V.++ BR.WithYS (ks V.++ catCols V.++ '[BR.PopCountOf]) V.++ '[p]) BR.Year\n , ((ks V.++ catCols) V.++ '[BR.PopCountOf]) F.\u2286 (as V.++ BR.WithYS (ks V.++ catCols V.++ '[BR.PopCountOf]) V.++ '[p])\n , FI.RecVec (as V.++ BR.WithYS (ks V.++ catCols V.++ '[BR.PopCountOf]) V.++ '[p] V.++ F.RDeleteAll (ks V.++ catCols) ((ks V.++ catCols) V.++ BR.EWCols))\n , V.AllConstrained G.Grouping (F.UnColumn (ks V.++ catCols))\n , (ks V.++ catCols) F.\u2286 (as V.++ BR.WithYS (ks V.++ catCols V.++ '[BR.PopCountOf]) V.++ '[p])\n , (as V.++ BR.WithYS (ks V.++ catCols V.++ '[BR.PopCountOf]) V.++ '[p]) F.\u2286 (as V.++ BR.WithYS (ks V.++ catCols V.++ '[BR.PopCountOf]) V.++ '[p] V.++ F.RDeleteAll (ks V.++ catCols) ((ks V.++ catCols) V.++ BR.EWCols))\n , V.RMap (as V.++ BR.WithYS (ks V.++ catCols V.++ '[BR.PopCountOf]) V.++ '[p])\n , V.RMap (as V.++ BR.WithYS (ks V.++ catCols V.++ '[BR.PopCountOf]) V.++ '[p] V.++ F.RDeleteAll (ks V.++ catCols) ((ks V.++ catCols) V.++ BR.EWCols))\n , G.Grouping (F.Record (ks V.++ catCols))\n , FI.RecVec (as V.++ BR.WithYS (ks V.++ catCols V.++ '[BR.PopCountOf]) V.++ '[p])\n , (ks V.++ catCols V.++ PCols p V.++ BR.EWCols) ~ (ks V.++ catCols V.++ (PCols p V.++ BR.EWCols))\n , (as V.++ BR.WithYS (ks V.++ catCols V.++ '[BR.PopCountOf]) V.++ '[p] V.++ BR.EWCols)\n ~ ((as V.++ BR.WithYS (ks V.++ catCols V.++ '[BR.PopCountOf]) V.++ '[p]) V.++ F.RDeleteAll (ks V.++ catCols) (ks V.++ catCols V.++ BR.EWCols))\n , (ks V.++ catCols V.++ BR.EWCols) F.\u2286 BR.WithYS (ks V.++ catCols V.++ PEWCols p)\n , (ks V.++ catCols) F.\u2286 BR.WithYS (ks V.++ catCols V.++ BR.EWCols)\n , (F.RDeleteAll (ks V.++ catCols) ((ks V.++ catCols) V.++ BR.EWCols)) F.\u2286 BR.WithYS (ks V.++ catCols V.++ BR.EWCols)\n , V.RecApplicative (F.RDeleteAll (ks V.++ catCols) ((ks V.++ catCols) V.++ BR.EWCols))\n , FI.RecVec (F.RDeleteAll (ks V.++ catCols) ((ks V.++ catCols) V.++ BR.EWCols))\n , Show (F.Record ((ks V.++ catCols)\n V.++ '[ '(\"PopCountOf\", BR.PopCountOfT), p,\n BR.ElectoralWeightSource, BR.ElectoralWeightOf,\n BR.ElectoralWeight]))\n )\n => F.Frame BR.StateTurnout\n -> F.FrameRec (as V.++ (BR.WithYS ks) V.++ catCols V.++ (PCols p))\n -> F.FrameRec (js V.++ catCols V.++ BR.EWCols)\n -> K.Sem effs (F.FrameRec (as V.++ (BR.WithYS ks) V.++ catCols V.++ PCols p V.++ BR.EWCols))\nrollupAdjustAndJoin stateTurnout demos ews = do\n let rolledUpDemos :: F.FrameRec ((BR.WithYS ks) V.++ catCols V.++ (PCols p))\n rolledUpDemos = FL.fold (rollupSumF @as @((BR.WithYS ks) V.++ catCols V.++ '[BR.PopCountOf]) @'[p]) demos\n adjusted :: F.FrameRec (BR.WithYS ks V.++ catCols V.++ PEWCols p) <- demographicsWithAdjTurnoutByState @catCols @p @ks @js stateTurnout rolledUpDemos ews\n let adjustedWithoutDemo = fmap (F.rcast @(BR.WithYS ks V.++ catCols V.++ BR.EWCols)) adjusted\n return\n $ F.toFrame\n $ catMaybes\n $ fmap F.recMaybe\n $ F.leftJoin @(BR.WithYS ks V.++ catCols) demos adjustedWithoutDemo\n\ntype TurnoutCols = [BR.Population, BR.Citizen, BR.Registered, BR.Voted]\ntype ACSColsCD = [BR.CongressionalDistrict, BR.Year, BR.StateAbbreviation, BR.StateFIPS, BR.StateName]\ntype ACSCols = [BR.Year, BR.StateAbbreviation, BR.StateFIPS, BR.StateName]\n\n-- This is also monstrous. Which is surprising??\nacsDemographicsWithAdjCensusTurnoutByCD\n :: forall catCols r\n . (K.KnitEffects r\n , BR.CacheEffects r\n , V.RMap catCols\n , V.ReifyConstraint Show V.ElField catCols\n , V.RecordToList catCols\n , ((catCols V.++ PCols BR.ACSCount) V.++ BR.EWCols) ~ (catCols V.++ PEWCols BR.ACSCount)\n , ((catCols V.++ '[BR.PopCountOf]) V.++ '[BR.ACSCount]) ~ (catCols V.++ [BR.PopCountOf, BR.ACSCount])\n , ((catCols V.++ PCols BR.ACSCount) V.++ F.RDeleteAll catCols (catCols V.++ BR.EWCols)) ~ (catCols V.++ PEWCols BR.ACSCount)\n , BR.RecSerializerC (BR.ACSKeys V.++ catCols V.++ '[BR.ACSCount, BR.VotedPctOfAll])\n , V.RMap (catCols V.++ '[BR.ACSCount, BR.VotedPctOfAll])\n , FI.RecVec (catCols V.++ '[BR.ACSCount, BR.VotedPctOfAll])\n , (catCols V.++ PCols BR.ACSCount) F.\u2286 (BR.ACSKeys V.++ (catCols V.++ '[BR.ACSCount]) V.++ '[BR.PopCountOf])\n , (catCols V.++ BR.EWCols) F.\u2286 (BR.Year : (catCols V.++ TurnoutCols V.++ BR.EWCols))\n , F.ElemOf (catCols V.++ TurnoutCols) BR.Population\n , F.ElemOf (catCols V.++ TurnoutCols) BR.Voted\n , V.AllConstrained G.Grouping (F.UnColumn catCols)\n , V.RMap (catCols V.++ PCols BR.ACSCount)\n , V.RMap (catCols V.++ PEWCols BR.ACSCount)\n , V.RecApplicative (F.RDeleteAll catCols (catCols V.++ BR.EWCols))\n , G.Grouping (F.Record catCols)\n , FI.RecVec (catCols V.++ PEWCols BR.ACSCount)\n , FI.RecVec (catCols V.++ PCols BR.ACSCount)\n , FI.RecVec (F.RDeleteAll catCols (catCols V.++ BR.EWCols))\n , Ord (F.Record (catCols V.++ '[BR.PopCountOf]))\n , F.ElemOf (catCols V.++ PEWCols BR.ACSCount) BR.ACSCount\n , F.ElemOf (catCols V.++ PCols BR.ACSCount) BR.ACSCount\n , F.ElemOf (catCols V.++ PEWCols BR.ACSCount) BR.ElectoralWeight\n , (catCols V.++ PEWCols BR.ACSCount) F.\u2286 (ACSCols V.++ catCols V.++ PEWCols BR.ACSCount)\n , (catCols V.++ '[BR.PopCountOf]) F.\u2286 (ACSColsCD V.++ catCols V.++ PCols BR.ACSCount)\n , (catCols V.++ PCols BR.ACSCount) F.\u2286 (ACSCols V.++ catCols V.++ PEWCols BR.ACSCount)\n , (catCols V.++ PCols BR.ACSCount) F.\u2286 (ACSColsCD V.++ catCols V.++ PEWCols BR.ACSCount)\n , (catCols V.++ BR.EWCols) F.\u2286 (ACSCols V.++ catCols V.++ PEWCols BR.ACSCount)\n , catCols F.\u2286 (ACSColsCD V.++ catCols V.++ PCols BR.ACSCount)\n , catCols F.\u2286 (BR.Year ': (catCols V.++ BR.EWCols))\n , catCols F.\u2286 (ACSCols V.++ catCols)\n , catCols F.\u2286 (ACSCols V.++ catCols V.++ PCols BR.ACSCount)\n , catCols F.\u2286 (ACSCols V.++ catCols V.++ BR.EWCols)\n , (F.RDeleteAll catCols (catCols V.++ BR.EWCols)) F.\u2286 (BR.Year ': (catCols V.++ BR.EWCols))\n , (F.RDeleteAll catCols (catCols V.++ BR.EWCols)) F.\u2286 (ACSCols V.++ (catCols V.++ BR.EWCols))\n , (catCols V.++ '[BR.ACSCount, BR.VotedPctOfAll]) F.\u2286 (ACSColsCD V.++ (F.RDelete BR.ElectoralWeight (catCols V.++ PEWCols BR.ACSCount)) V.++ '[BR.VotedPctOfAll])\n , (F.RDelete BR.ElectoralWeight (catCols V.++ PEWCols BR.ACSCount)) F.\u2286 (ACSColsCD V.++ catCols V.++ PEWCols BR.ACSCount)\n , V.ReifyConstraint Show V.ElField (catCols\n V.++ '[ '(\"PopCountOf\", BR.PopCountOfT), '(\"ACSCount\", Int),\n BR.ElectoralWeightSource, BR.ElectoralWeightOf,\n BR.ElectoralWeight])\n , V.RecordToList (catCols\n V.++ '[ '(\"PopCountOf\", BR.PopCountOfT), '(\"ACSCount\", Int),\n BR.ElectoralWeightSource, BR.ElectoralWeightOf,\n BR.ElectoralWeight])\n )\n => T.Text\n -> K.ActionWithCacheTime r (F.FrameRec (BR.ACSKeys V.++ catCols V.++ '[BR.ACSCount]))\n -> K.ActionWithCacheTime r (F.FrameRec ('[BR.Year] V.++ catCols V.++ '[BR.Population, BR.Citizen, BR.Registered, BR.Voted]))\n -> K.ActionWithCacheTime r (F.Frame BR.StateTurnout)\n -> K.Sem r (K.ActionWithCacheTime r (F.FrameRec (BR.ACSKeys V.++ catCols V.++ '[BR.ACSCount, BR.VotedPctOfAll])))\nacsDemographicsWithAdjCensusTurnoutByCD cacheKey cachedDemo cachedTurnout cachedStateTurnout = do\n let cachedDeps = (,,) <$> cachedDemo <*> cachedTurnout <*> cachedStateTurnout\n BR.retrieveOrMakeFrame cacheKey cachedDeps $ \\(demoF, turnoutF, stateTurnoutF) -> do\n let demo' = fmap (FT.mutate $ const $ FT.recordSingleton @BR.PopCountOf BR.PC_All) demoF\n demo'' = fmap (F.rcast @([BR.CongressionalDistrict, BR.Year, BR.StateAbbreviation, BR.StateFIPS, BR.StateName] V.++ catCols V.++ (PCols BR.ACSCount))) demo'\n vpa r = realToFrac (F.rgetField @BR.Voted r) / realToFrac (F.rgetField @BR.Population r)\n let turnout' = fmap (F.rcast @('[BR.Year] V.++ catCols V.++ BR.EWCols) . addElectoralWeight BR.EW_Census BR.EW_All vpa) turnoutF\n result <- rollupAdjustAndJoin @'[BR.CongressionalDistrict] @catCols @BR.ACSCount @[BR.StateFIPS, BR.StateName] @'[BR.Year] stateTurnoutF demo'' turnout'\n return $ F.toFrame $ fmap (F.rcast . FT.retypeColumn @BR.ElectoralWeight @BR.VotedPctOfAll) result\n\n\ncachedASEDemographicsWithAdjTurnoutByCD\n :: (K.KnitEffects r\n , BR.CacheEffects r\n )\n => K.ActionWithCacheTime r (F.FrameRec (BR.ACSKeys V.++ BR.CatColsASE V.++ '[BR.ACSCount]))\n -> K.ActionWithCacheTime r (F.FrameRec ( '[BR.Year] V.++ BR.CatColsASE V.++ '[BR.Population, BR.Citizen, BR.Registered, BR.Voted]))\n -> K.ActionWithCacheTime r (F.Frame BR.StateTurnout)\n -> K.Sem r (K.ActionWithCacheTime r (F.FrameRec (BR.ACSKeys V.++ BR.CatColsASE V.++'[BR.ACSCount, BR.VotedPctOfAll])))\ncachedASEDemographicsWithAdjTurnoutByCD = acsDemographicsWithAdjCensusTurnoutByCD @BR.CatColsASE \"turnout/aseDemoWithStateAdjTurnoutByCD.bin\"\n\ncachedASRDemographicsWithAdjTurnoutByCD\n :: (K.KnitEffects r\n , BR.CacheEffects r\n )\n => K.ActionWithCacheTime r (F.FrameRec (BR.ACSKeys V.++ BR.CatColsASR V.++ '[BR.ACSCount]))\n -> K.ActionWithCacheTime r (F.FrameRec ( '[BR.Year] V.++ BR.CatColsASR V.++ '[BR.Population, BR.Citizen, BR.Registered, BR.Voted]))\n -> K.ActionWithCacheTime r (F.Frame BR.StateTurnout)\n -> K.Sem r (K.ActionWithCacheTime r (F.FrameRec (BR.ACSKeys V.++ BR.CatColsASR V.++'[BR.ACSCount, BR.VotedPctOfAll])))\ncachedASRDemographicsWithAdjTurnoutByCD = acsDemographicsWithAdjCensusTurnoutByCD @BR.CatColsASR \"turnout/asrDemoWithStateAdjTurnoutByCD.bin\"\n", "meta": {"hexsha": "7124687051cb49d876aafb163efb80898b1cfbea", "size": 26091, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/BlueRipple/Data/UsefulDataJoins.hs", "max_stars_repo_name": "blueripple/preference-model", "max_stars_repo_head_hexsha": "beae97c2d854830bc0e9027609e54166f93d976b", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2019-07-24T11:32:48.000Z", "max_stars_repo_stars_event_max_datetime": "2019-07-24T11:32:48.000Z", "max_issues_repo_path": "src/BlueRipple/Data/UsefulDataJoins.hs", "max_issues_repo_name": "blueripple/preference-model", "max_issues_repo_head_hexsha": "beae97c2d854830bc0e9027609e54166f93d976b", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/BlueRipple/Data/UsefulDataJoins.hs", "max_forks_repo_name": "blueripple/preference-model", "max_forks_repo_head_hexsha": "beae97c2d854830bc0e9027609e54166f93d976b", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 56.9672489083, "max_line_length": 220, "alphanum_fraction": 0.580391706, "num_tokens": 9369, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO\n\n", "lm_q1_score": 0.679178699175393, "lm_q2_score": 0.5, "lm_q1q2_score": 0.3395893495876965}} {"text": "{-# LANGUAGE AllowAmbiguousTypes #-}\n{-# LANGUAGE DataKinds #-}\n{-# LANGUAGE FlexibleContexts #-}\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE OverloadedStrings #-}\n{-# LANGUAGE PolyKinds #-}\n{-# LANGUAGE ScopedTypeVariables #-}\n{-# LANGUAGE TypeApplications #-}\n{-# LANGUAGE TypeOperators #-}\n{-# LANGUAGE UndecidableInstances #-}\n\nmodule BlueRipple.Model.Preference where\n\nimport qualified Control.Foldl as FL\nimport qualified Control.Lens as L\nimport qualified Control.Monad.Except as X\nimport Control.Monad.IO.Class ( MonadIO(liftIO) )\nimport qualified Colonnade as C\nimport qualified Text.Blaze.Colonnade as BC\nimport qualified Text.Blaze.Html as BH\nimport qualified Text.Blaze.Html5.Attributes as BHA\nimport qualified Data.List as L\nimport qualified Data.Map as M\nimport qualified Data.Array as A\nimport qualified Data.Vector as VB\nimport qualified Data.Vector.Storable as VS\n\nimport qualified Text.Pandoc.Error as PA\n\nimport qualified Data.Profunctor as PF\nimport qualified Data.Text as T\nimport qualified Data.Time.Calendar as Time\nimport qualified Data.Time.Clock as Time\nimport qualified Data.Time.Format as Time\nimport qualified Data.Vinyl as V\nimport qualified Text.Printf as PF\nimport qualified Frames as F\nimport qualified Frames.Melt as F\nimport qualified Frames.CSV as F\nimport qualified Frames.InCore as F\n hiding ( inCoreAoS )\n\nimport qualified Pipes as P\nimport qualified Pipes.Prelude as P\nimport qualified Statistics.Types as S\nimport qualified Statistics.Distribution as S\nimport qualified Statistics.Distribution.StudentT as S\n\nimport qualified Numeric.LinearAlgebra as LA\n\nimport qualified Graphics.Vega.VegaLite as GV\nimport Graphics.Vega.VegaLite.Configuration as FV\nimport qualified Graphics.Vega.VegaLite.Compat as FV\n\nimport qualified Frames.Visualization.VegaLite.Data\n as FV\nimport qualified Frames.Visualization.VegaLite.StackedArea\n as FV\nimport qualified Frames.Visualization.VegaLite.LineVsTime\n as FV\nimport qualified Frames.Visualization.VegaLite.ParameterPlots\n as FV\n\nimport qualified Frames.Visualization.VegaLite.Correlation\n as FV\n\nimport qualified Frames.Transform as FT\nimport qualified Frames.Folds as FF\nimport qualified Frames.MapReduce as MR\nimport qualified Frames.Enumerations as FE\n\nimport qualified Knit.Report as K\nimport qualified Knit.Report.Input.MarkDown.PandocMarkDown as K\nimport Polysemy.Error (Error)\nimport qualified Text.Pandoc.Options as PA\n\nimport Data.String.Here ( here, i )\nimport qualified Relude.Extra as Relude\nimport BlueRipple.Configuration\nimport BlueRipple.Utilities.KnitUtils\nimport BlueRipple.Utilities.TableUtils\nimport BlueRipple.Data.DataFrames\nimport BlueRipple.Data.PrefModel\nimport BlueRipple.Data.PrefModel.SimpleAgeSexRace\nimport BlueRipple.Data.PrefModel.SimpleAgeSexEducation\nimport qualified BlueRipple.Model.PreferenceBayes as PB\nimport qualified BlueRipple.Model.TurnoutAdjustment as TA\n\n\nmodeledResults :: ( MonadIO (K.Sem r)\n , K.KnitEffects r\n , Show tr\n , Show b\n , Enum b\n , Bounded b\n , A.Ix b\n , FL.Vector (F.VectorFor b) b)\n => DemographicStructure dr tr HouseElections b\n -> (F.Record LocationKey -> Bool)\n -> F.Frame dr\n -> F.Frame tr\n -> F.Frame HouseElections\n -> M.Map Int Int\n -> K.Sem r (M.Map Int (PreferenceResults b FV.ParameterEstimate))\nmodeledResults ds locFilter dFrame tFrame eFrame years = flip traverse years $ \\y -> do\n K.logLE K.Info $ \"inferring \" <> show (dsCategories ds) <> \" for \" <> show y\n preferenceModel ds locFilter y dFrame eFrame tFrame\n\n-- PreferenceResults to list of group names and predicted D votes\n-- But we want them as a fraction of D/D+R\ndata VoteShare = ShareOfAll | ShareOfD\n\nmodeledDVotes :: forall b. (A.Ix b, Bounded b, Enum b, Show b)\n => VoteShare -> PreferenceResults b Double -> [(T.Text, Double)]\nmodeledDVotes vs pr =\n let\n summed = FL.fold\n (votesAndPopByDistrictF @b)\n (F.rcast <$> votesAndPopByDistrict pr)\n popArray =\n F.rgetField @(PopArray b) summed\n turnoutArray =\n F.rgetField @(TurnoutArray b) summed\n predVoters = zipWith (*) (A.elems turnoutArray) $ fmap realToFrac (A.elems popArray)\n allDVotes = F.rgetField @DVotes summed\n allRVotes = F.rgetField @RVotes summed\n dVotes b =\n realToFrac (popArray A.! b)\n * (turnoutArray A.! b)\n * (modeled pr A.! b)\n allPredictedD = FL.fold FL.sum $ fmap dVotes Relude.universe --[minBound..maxBound]\n scale = case vs of\n ShareOfAll -> (realToFrac allDVotes/realToFrac (allDVotes + allRVotes))/allPredictedD\n ShareOfD -> 1/allPredictedD\n in\n fmap (\\b -> (show b, scale * dVotes b))\n [(minBound :: b) .. maxBound]\n\n\ndata DeltaTableRow =\n DeltaTableRow\n { dtrGroup :: T.Text\n , dtrPop :: Int\n , dtrFromPop :: Int\n , dtrFromTurnout :: Int\n , dtrFromOpinion :: Int\n , dtrTotal :: Int\n , dtrPct :: Double\n } deriving (Show)\n\ndeltaTable\n :: forall dr tr e b r\n . (A.Ix b\n , Bounded b\n , Enum b\n , Show b\n , MonadIO (K.Sem r)\n , K.KnitEffects r\n )\n => DemographicStructure dr tr e b\n -> (F.Record LocationKey -> Bool)\n -> F.Frame e\n -> Int -- ^ year A\n -> Int -- ^ year B\n -> PreferenceResults b FV.ParameterEstimate\n -> PreferenceResults b FV.ParameterEstimate\n -> K.Sem r ([DeltaTableRow], (Int, Int), (Int, Int))\ndeltaTable ds locFilter electionResultsFrame yA yB trA trB = do\n let\n groupNames = show <$> dsCategories ds\n getPopAndTurnout\n :: Int -> PreferenceResults b FV.ParameterEstimate -> K.Sem r (A.Array b Int, A.Array b Double)\n getPopAndTurnout y tr = do\n resultsFrame <- knitX $ dsPreprocessElectionData ds y electionResultsFrame\n let\n totalDRVotes =\n let filteredResultsF = F.filterFrame (locFilter . F.rcast) resultsFrame\n in FL.fold (FL.premap (\\r -> F.rgetField @DVotes r + F.rgetField @RVotes r) FL.sum) filteredResultsF\n totalRec = FL.fold\n votesAndPopByDistrictF\n ( fmap\n (F.rcast\n @'[PopArray b, TurnoutArray b, DVotes, RVotes]\n )\n $ F.filterFrame (locFilter . F.rcast)\n $ F.toFrame\n $ votesAndPopByDistrict tr\n )\n totalCounts = F.rgetField @(PopArray b) totalRec\n unAdjTurnout = nationalTurnout tr\n tDelta <- liftIO $ TA.findDeltaA totalDRVotes totalCounts unAdjTurnout\n let adjTurnout = TA.adjTurnoutP tDelta unAdjTurnout\n return (totalCounts, adjTurnout)\n\n (popA, turnoutA) <- getPopAndTurnout yA trA\n (popB, turnoutB) <- getPopAndTurnout yB trB\n{- K.logLE K.Info $ (T.pack $ show yA) <> \"->\" <> (T.pack $ show yB)\n K.logLE K.Info $ T.pack $ show turnoutA\n K.logLE K.Info $ T.pack $ show turnoutB -}\n let\n pop = FL.fold FL.sum popA\n probsArray = fmap FV.value . modeled\n probA = probsArray trA\n probB = probsArray trB\n modeledVotes popArray turnoutArray probArray =\n let dVotes b =\n round\n $ realToFrac (popArray A.! b)\n * (turnoutArray A.! b)\n * (probArray A.! b)\n rVotes b =\n round\n $ realToFrac (popArray A.! b)\n * (turnoutArray A.! b)\n * (1.0 - probArray A.! b)\n in FL.fold\n ((,) <$> FL.premap dVotes FL.sum <*> FL.premap rVotes FL.sum) Relude.universe\n makeDTR b =\n let pop0 = realToFrac $ popA A.! b\n dPop = realToFrac $ (popB A.! b) - (popA A.! b)\n turnout0 = realToFrac $ turnoutA A.! b\n dTurnout = realToFrac $ (turnoutB A.! b) - (turnoutA A.! b)\n prob0 = realToFrac (probA A.! b)\n dProb = realToFrac $ (probB A.! b) - (probA A.! b)\n dtrCombo = dPop * dTurnout * (2 * dProb) / 4 -- the rest is accounted for in other terms, we spread this among them\n dtrN =\n round\n $ dPop\n * (turnout0 + dTurnout / 2)\n * (2 * (prob0 + dProb / 2) - 1)\n + (dtrCombo / 3)\n dtrT =\n round\n $ (pop0 + dPop / 2)\n * dTurnout\n * (2 * (prob0 + dProb / 2) - 1)\n + (dtrCombo / 3)\n dtrO =\n round\n $ (pop0 + dPop / 2)\n * (turnout0 + dTurnout / 2)\n * (2 * dProb)\n + (dtrCombo / 3)\n dtrTotal = dtrN + dtrT + dtrO\n in DeltaTableRow (show b)\n (popB A.! b)\n dtrN\n dtrT\n dtrO\n dtrTotal\n (realToFrac dtrTotal / realToFrac pop)\n groupRows = fmap makeDTR [minBound ..]\n addRow (DeltaTableRow g p fp ft fo t _) (DeltaTableRow _ p' fp' ft' fo' t' _)\n = DeltaTableRow g\n (p + p')\n (fp + fp')\n (ft + ft')\n (fo + fo')\n (t + t')\n (realToFrac (t + t') / realToFrac (p + p'))\n totalRow = FL.fold\n (FL.Fold addRow (DeltaTableRow \"Total\" 0 0 0 0 0 0) id)\n groupRows\n dVotesA = modeledVotes popA turnoutA probA\n dVotesB = modeledVotes popB turnoutB probB\n return (groupRows ++ [totalRow], dVotesA, dVotesB)\n\ndeltaTableColonnade :: C.Colonnade C.Headed DeltaTableRow T.Text\ndeltaTableColonnade =\n C.headed \"Group\" dtrGroup\n <> C.headed \"Population (k)\" (show . (`div` 1000) . dtrPop)\n <> C.headed \"+/- From Population (k)\"\n (show . (`div` 1000) . dtrFromPop)\n <> C.headed \"+/- From Turnout (k)\"\n (show . (`div` 1000) . dtrFromTurnout)\n <> C.headed \"+/- From Opinion (k)\"\n (show . (`div` 1000) . dtrFromOpinion)\n <> C.headed \"+/- Total (k)\" (show . (`div` 1000) . dtrTotal)\n <> C.headed \"+/- %Vote\" (toText @String . PF.printf \"%2.2f\" . (* 100) . dtrPct)\n\ndeltaTableColonnadeBlaze :: CellStyle DeltaTableRow T.Text -> C.Colonnade C.Headed DeltaTableRow BC.Cell\ndeltaTableColonnadeBlaze cas =\n C.headed \"Group\" (toCell cas \"Group\" \"\" (textToStyledHtml . dtrGroup))\n <> C.headed \"Population (k)\" (toCell cas \"Population\" \"Population\" (textToStyledHtml . show . (`div` 1000) . dtrPop))\n <> C.headed \"+/- From Population (k)\"\n (toCell cas \"FromPop\" \"+/- From Population\" (numberToStyledHtml \"%d\" . (`div` 1000) . dtrFromPop))\n <> C.headed \"+/- From Turnout (k)\"\n (toCell cas \"FromTurnout\" \"+/- From Turnout\" (numberToStyledHtml \"%d\" . (`div` 1000) . dtrFromTurnout))\n <> C.headed \"+/- From Opinion (k)\"\n (toCell cas \"FromOpinion\" \"+/- From Opinion\" (numberToStyledHtml \"%d\" . (`div` 1000) . dtrFromOpinion))\n-- (\\tr -> (numberCell \"%.0d\" (opinionHighlight (dtrGroup tr)) . (`div` 1000) $ dtrFromOpinion tr))\n <> C.headed \"+/- Total (k)\" (toCell cas \"Total\" \"Total\" (numberToStyledHtml \"%d\" . (`div` 1000) . dtrTotal))\n <> C.headed \"+/- %Vote\" (toCell cas \"PctVote\" \"% Vote\" (numberToStyledHtml \"%2.2f\" . (* 100) . dtrPct))\n\ntype X = \"X\" F.:-> Double\ntype ScaledDVotes = \"ScaledDVotes\" F.:-> Int\ntype ScaledRVotes = \"ScaledRVotes\" F.:-> Int\ntype PopArray b = \"PopArray\" F.:-> A.Array b Int\ntype TurnoutArray b = \"TurnoutArray\" F.:-> A.Array b Double\n\nvotesAndPopByDistrictF\n :: forall b\n . (A.Ix b, Bounded b, Enum b)\n => FL.Fold\n (F.Record '[PopArray b, TurnoutArray b, DVotes, RVotes])\n (F.Record '[PopArray b, TurnoutArray b, DVotes, RVotes])\nvotesAndPopByDistrictF =\n let voters r = A.listArray (minBound, maxBound)\n $ zipWith (*) (A.elems $ F.rgetField @(TurnoutArray b) r) (fmap realToFrac $ A.elems $ F.rgetField @(PopArray b) r)\n g r = A.listArray (minBound, maxBound)\n $ zipWith (/) (A.elems $ F.rgetField @(TurnoutArray b) r) (fmap realToFrac $ A.elems $ F.rgetField @(PopArray b) r)\n recomputeTurnout r = F.rputField @(TurnoutArray b) (g r) r\n in PF.dimap (F.rcast @'[PopArray b, TurnoutArray b, DVotes, RVotes]) recomputeTurnout\n $ FF.sequenceRecFold\n $ FF.FoldRecord (PF.dimap (F.rgetField @(PopArray b)) V.Field FE.sumTotalNumArray)\n V.:& FF.FoldRecord (PF.dimap voters V.Field FE.sumTotalNumArray)\n V.:& FF.FoldRecord (PF.dimap (F.rgetField @DVotes) V.Field FL.sum)\n V.:& FF.FoldRecord (PF.dimap (F.rgetField @RVotes) V.Field FL.sum)\n V.:& V.RNil\n\n\ndata Aggregation c b where\n Aggregation :: (Enum b, Bounded b, Eq b, Ord b, A.Ix b,\n Enum c, Bounded c, Eq c, Ord c, A.Ix c) => (c -> [b]) -> Aggregation c b\n\n\naggregateFold :: forall c b a x. Aggregation c b -> FL.Fold a x -> A.Array b a -> A.Array c x\naggregateFold (Aggregation children) fld arr =\n let cs = Relude.universe\n expanded :: [[a]]\n expanded = fmap (fmap (arr A.!) . children) cs\n folded = fmap (FL.fold fld) expanded\n in A.listArray (minBound,maxBound) folded\n\naggregateFold2 :: Aggregation c b -> FL.Fold (a,w) x -> A.Array b a -> A.Array b w -> A.Array c x\naggregateFold2 (Aggregation children) fld arrA arrW =\n let cs = Relude.universe\n as = fmap (fmap (arrA A.!) . children) cs\n ws = fmap (fmap (arrW A.!) . children) cs\n folded = FL.fold fld . uncurry zip <$> zip as ws\n in A.listArray (minBound, maxBound) folded\n\nweightedFold :: (Num a, Fractional a) => FL.Fold (a,a) a\nweightedFold =\n let sumWeightsF = FL.premap snd FL.sum\n weightedSumF = FL.premap (uncurry (*)) FL.sum\n in fmap (uncurry (/)) $ (,) <$> weightedSumF <*> sumWeightsF\n\npopWeightedAggregate :: (Num d, Fractional d) => Aggregation c b -> A.Array b Int -> A.Array b d -> A.Array c d\npopWeightedAggregate agg popArray datArray = aggregateFold2 agg weightedFold datArray (fmap realToFrac popArray)\n\naggregateRecord\n :: forall b c. Aggregation c b\n -> F.Record [StateAbbreviation\n , CongressionalDistrict\n , PopArray b -- population by group\n , TurnoutArray b -- adjusted turnout by group\n , DVotes\n , RVotes\n ]\n -> F.Record [StateAbbreviation\n , CongressionalDistrict\n , PopArray c -- population by group\n , TurnoutArray c -- adjusted turnout by group\n , DVotes\n , RVotes\n ]\naggregateRecord agg r =\n let\n f :: F.Record [PopArray b, TurnoutArray b] -> F.Record [PopArray c, TurnoutArray c]\n f x =\n let popB = F.rgetField @(PopArray b) x\n turnoutB = F.rgetField @(TurnoutArray b) x\n in aggregateFold agg FL.sum popB F.&: popWeightedAggregate agg popB turnoutB F.&: V.RNil\n in F.rcast $ FT.transform f r\n\ncByB :: Aggregation c b -> LA.Matrix Double\ncByB (Aggregation children) =\n let allBs = Relude.universe\n toZeroOne y = if y then 1 else 0\n getCol c = LA.fromList $ fmap (toZeroOne . (`elem` children c)) allBs\n in LA.fromColumns $ fmap getCol Relude.universe\n\naggregatePreferenceResults :: Fractional a => Aggregation c b -> PreferenceResults b a -> PreferenceResults c a\naggregatePreferenceResults agg pr =\n let prVBPAD' = fmap (aggregateRecord agg) (votesAndPopByDistrict pr)\n prTurnout' = popWeightedAggregate agg (nationalVoters pr) (nationalTurnout pr)\n prVoters' = aggregateFold agg FL.sum (nationalVoters pr)\n prModeled' = popWeightedAggregate agg (nationalVoters pr) (modeled pr)\n mCB = cByB agg\n prCovar' = LA.tr mCB LA.<> covariances pr LA.<> mCB\n in PreferenceResults prVBPAD' prTurnout' prVoters' prModeled' prCovar'\n\n\ndata PreferenceResults b a = PreferenceResults\n {\n votesAndPopByDistrict :: [F.Record [ StateAbbreviation\n , CongressionalDistrict\n , PopArray b -- population by group\n , TurnoutArray b -- adjusted turnout by group\n , DVotes\n , RVotes\n ]]\n , nationalTurnout :: A.Array b Double\n , nationalVoters :: A.Array b Int\n , modeled :: A.Array b a\n , covariances :: LA.Matrix Double\n }\n\ninstance Functor (PreferenceResults b) where\n fmap f (PreferenceResults v nt nv m c) = PreferenceResults v nt nv (fmap f m) c\n\npreferenceModel\n :: forall dr tr b r\n . ( Show tr\n , Show b\n , Enum b\n , Bounded b\n , A.Ix b\n , FL.Vector (F.VectorFor b) b\n , K.KnitEffects r\n , MonadIO (K.Sem r)\n )\n => DemographicStructure dr tr HouseElections b\n -> (F.Record LocationKey -> Bool)\n -> Int\n -> F.Frame dr\n -> F.Frame HouseElections\n -> F.Frame tr\n -> K.Sem\n r\n (PreferenceResults b FV.ParameterEstimate)\npreferenceModel ds locFilter year identityDFrame houseElexFrame turnoutFrame =\n do\n -- reorganize data from loaded Frames\n resultsFlattenedFrameFull <- knitX\n $ dsPreprocessElectionData ds year houseElexFrame\n let resultsFlattenedFrame = F.filterFrame (locFilter . F.rcast) resultsFlattenedFrameFull\n filteredTurnoutFrame <- knitX\n $ dsPreprocessTurnoutData ds year turnoutFrame\n let year' = year --if (year == 2018) then 2017 else year -- we're using 2017 for now, until census updated ACS data\n longByDCategoryFrame <- knitX\n $ dsPreprocessDemographicData ds year' identityDFrame\n\n -- turn long-format data into Arrays by demographic category, beginning with national turnout\n turnoutByGroupArray <-\n K.knitMaybe \"Missing or extra group in turnout data?\" $ FL.foldM\n (FE.makeArrayMF (F.rgetField @(DemographicCategory b))\n (F.rgetField @VotedPctOfAll)\n (flip const)\n )\n filteredTurnoutFrame\n\n -- now the populations in each district\n let votersArrayMF = MR.mapReduceFoldM\n (MR.generalizeUnpack MR.noUnpack)\n (MR.generalizeAssign $ MR.splitOnKeys @LocationKey)\n (MR.foldAndLabelM\n (fmap (FT.recordSingleton @(PopArray b))\n (FE.recordsToArrayMF @(DemographicCategory b) @PopCount)\n )\n V.rappend\n )\n -- F.Frame (LocationKey V.++ (PopArray b))\n populationsFrame <-\n K.knitMaybe \"Error converting long demographic data to arrays!\"\n $ F.toFrame\n <$> FL.foldM votersArrayMF longByDCategoryFrame\n\n -- and the total populations in each group\n let addArray :: (A.Ix k, Num a) => A.Array k a -> A.Array k a -> A.Array k a\n addArray a1 a2 = A.accum (+) a1 (A.assocs a2)\n zeroArray :: (A.Ix k, Bounded k, Enum k, Num a) => A.Array k a\n zeroArray = A.listArray (minBound, maxBound) $ L.repeat 0\n popByGroupArray = FL.fold (FL.premap (F.rgetField @(PopArray b)) (FL.Fold addArray zeroArray id)) populationsFrame\n\n let\n resultsWithPopulationsFrame =\n catMaybes $ fmap F.recMaybe $ F.leftJoin @LocationKey resultsFlattenedFrame\n populationsFrame\n\n K.logLE K.Info \"Computing Ghitza-Gelman turnout adjustment for each district so turnouts produce correct number D+R votes.\"\n resultsWithPopulationsAndGGAdjFrame <- fmap F.toFrame $ flip traverse resultsWithPopulationsFrame $ \\r -> do\n let tVotesF x = F.rgetField @DVotes x + F.rgetField @RVotes x -- Should this be D + R or total?\n ggDelta <- ggTurnoutAdj r tVotesF turnoutByGroupArray\n K.logLE K.Diagnostic $\n \"Ghitza-Gelman turnout adj=\"\n <> show ggDelta\n <> \"; Adj Turnout=\" <> show (TA.adjTurnoutP ggDelta turnoutByGroupArray)\n return $ FT.mutate (const $ FT.recordSingleton @(TurnoutArray b) $ TA.adjTurnoutP ggDelta turnoutByGroupArray) r\n\n let onlyOpposed r =\n (F.rgetField @DVotes r > 0) && (F.rgetField @RVotes r > 0)\n opposedFrame = F.filterFrame onlyOpposed resultsWithPopulationsAndGGAdjFrame\n numCompetitiveRaces = FL.fold FL.length opposedFrame\n\n K.logLE K.Info\n $ \"After removing races where someone is running unopposed we have \"\n <> show numCompetitiveRaces\n <> \" contested races.\"\n\n totalVoteDiagnostics @b resultsWithPopulationsAndGGAdjFrame opposedFrame\n\n\n let\n scaleInt s n = round $ s * realToFrac n\n mcmcData =\n fmap\n (\\r ->\n ( F.rgetField @DVotes r\n , VB.fromList $ fmap round (adjVotersL (F.rgetField @(TurnoutArray b) r) (F.rgetField @(PopArray b) r))\n )\n )\n $ FL.fold FL.list opposedFrame\n numParams = length $ dsCategories ds\n (cgRes, _, _) <- liftIO $ PB.cgOptimizeAD mcmcData (VB.fromList $ (const 0.5) <$> dsCategories ds)\n let cgParamsA = A.listArray (minBound :: b, maxBound) $ VB.toList cgRes\n cgVarsA = A.listArray (minBound :: b, maxBound) $ VS.toList $ PB.variances mcmcData cgRes\n npe cl b =\n let\n x = cgParamsA A.! b\n sigma = sqrt $ cgVarsA A.! b\n dof = realToFrac $ numCompetitiveRaces - L.length (A.elems cgParamsA)\n interval = S.quantile (S.studentTUnstandardized dof 0 sigma) (1.0 - (S.significanceLevel cl/2))\n in FV.ParameterEstimate x (x - interval/2.0, x + interval/2.0)\n-- in FV.NamedParameterEstimate (T.pack $ show b) pEstimate\n parameterEstimatesA = A.listArray (minBound :: b, maxBound) $ fmap (npe S.cl95) Relude.universe\n\n K.logLE K.Info $ \"MLE results: \" <> show (A.elems parameterEstimatesA)\n-- For now this bit is diagnostic. But we should chart the correlations\n-- and, perhaps, the eigenvectors of the covariance??\n let cgCovar = PB.covar mcmcData cgRes -- TODO: make a chart out of this\n (cgEv, cgEvs) = PB.mleCovEigens mcmcData cgRes\n K.logLE K.Diagnostic $ \"sigma = \" <> show (fmap sqrt $ cgVarsA)\n K.logLE K.Diagnostic $ \"Covariances=\" <> toText (PB.disps 3 cgCovar)\n K.logLE K.Diagnostic $ \"Correlations=\" <> toText (PB.disps 3 $ PB.correlFromCov cgCovar)\n K.logLE K.Diagnostic $ \"Eigenvalues=\" <> show cgEv\n K.logLE K.Diagnostic $ \"Eigenvectors=\" <> toText (PB.disps 3 cgEvs)\n\n return $ PreferenceResults\n (F.rcast <$> FL.fold FL.list opposedFrame)\n turnoutByGroupArray\n popByGroupArray\n parameterEstimatesA\n cgCovar\n\nggTurnoutAdj :: forall b rs r. (A.Ix b\n , F.ElemOf rs (PopArray b)\n , MonadIO (K.Sem r)\n ) => F.Record rs -> (F.Record rs -> Int) -> A.Array b Double -> K.Sem r Double\nggTurnoutAdj r totalVotesF unadjTurnoutP = do\n let population = F.rgetField @(PopArray b) r\n totalVotes = totalVotesF r\n liftIO $ TA.findDeltaA totalVotes population unadjTurnoutP\n\nadjVotersL :: A.Array b Double -> A.Array b Int -> [Double]\nadjVotersL turnoutPA popA = zipWith (*) (A.elems turnoutPA) (realToFrac <$> A.elems popA)\n\ntotalVoteDiagnostics :: forall b rs f r\n . (A.Ix b\n , Foldable f\n , F.ElemOf rs (PopArray b)\n , F.ElemOf rs (TurnoutArray b)\n , F.ElemOf rs Totalvotes\n , F.ElemOf rs DVotes\n , F.ElemOf rs RVotes\n , K.KnitEffects r\n )\n => f (F.Record rs) -- ^ frame with all rows\n -> f (F.Record rs) -- ^ frame with only rows from competitive races\n -> K.Sem r ()\ntotalVoteDiagnostics allFrame opposedFrame = K.wrapPrefix \"VoteSummary\" $ do\n let allVoters r = FL.fold FL.sum\n $ zipWith (*) (A.elems $ F.rgetField @(TurnoutArray b) r) (fmap realToFrac $ A.elems $ F.rgetField @(PopArray b) r)\n allVotersF = FL.premap allVoters FL.sum\n allVotesF = FL.premap (F.rgetField @Totalvotes) FL.sum\n allDVotesF = FL.premap (F.rgetField @DVotes) FL.sum\n allRVotesF = FL.premap (F.rgetField @RVotes) FL.sum\n -- allDRVotesF = FL.premap (\\r -> F.rgetField @DVotes r + F.rgetField @RVotes r) FL.sum\n (totalVoters, totalVotes, totalDVotes, totalRVotes) = FL.fold\n ((,,,) <$> allVotersF <*> allVotesF <*> allDVotesF <*> allRVotesF)\n allFrame\n (totalVotersCD, totalVotesCD, totalDVotesCD, totalRVotesCD) = FL.fold\n ((,,,) <$> allVotersF <*> allVotesF <*> allDVotesF <*> allRVotesF)\n opposedFrame\n K.logLE K.Info $ \"voters=\" <> show totalVoters\n K.logLE K.Info $ \"house votes=\" <> show totalVotes\n K.logLE K.Info\n $ \"D/R/D+R house votes=\"\n <> show totalDVotes\n <> \"/\"\n <> show totalRVotes\n <> \"/\"\n <> show (totalDVotes + totalRVotes)\n K.logLE K.Info\n $ \"voters (competitive districts)=\"\n <> show totalVotersCD\n K.logLE K.Info\n $ \"house votes (competitive districts)=\"\n <> show totalVotesCD\n K.logLE K.Info\n $ \"D/R/D+R house votes (competitive districts)=\"\n <> show totalDVotesCD\n <> \"/\"\n <> show totalRVotesCD\n <> \"/\"\n <> show (totalDVotesCD + totalRVotesCD)\n\n\ntotalArrayZipWith :: (A.Ix b, Enum b, Bounded b)\n => (x -> y -> z)\n -> A.Array b x\n -> A.Array b y\n -> A.Array b z\ntotalArrayZipWith f xs ys = A.listArray (minBound, maxBound) $ zipWith f (A.elems xs) (A.elems ys)\n\nvlGroupingChart :: Foldable f\n => T.Text\n -> FV.ViewConfig\n -> f (F.Record ['(\"Group\", T.Text)\n ,'(\"VotingAgePop\", Int)\n ,'(\"Turnout\",Double)\n ,'(\"Voters\", Int)\n ,'(\"D Voter Preference\", Double)\n ])\n -> GV.VegaLite\nvlGroupingChart title vc rows =\n let dat = FV.recordsToVLData id FV.defaultParse rows\n xLabel = \"Inferred (%) Likelihood of Voting Democratic\"\n estimateXenc = GV.position GV.X [FV.pName @'(\"D Voter Preference\", Double)\n ,GV.PmType GV.Quantitative\n ,GV.PAxis [GV.AxTitle xLabel]\n ]\n estimateYenc = GV.position GV.Y [FV.pName @'(\"Group\",T.Text)\n ,GV.PmType GV.Ordinal\n ,GV.PAxis [GV.AxTitle \"Demographic Group\"]\n ]\n estimateSizeEnc = GV.size [FV.mName @'(\"Voters\",Int)\n , GV.MmType GV.Quantitative\n , GV.MScale [GV.SDomain $ GV.DNumbers [5e6,30e6]]\n , GV.MLegend [GV.LFormatAsNum]\n\n ]\n estimateColorEnc = GV.color [FV.mName @'(\"Turnout\", Double)\n , GV.MmType GV.Quantitative\n , GV.MScale [GV.SDomain $ GV.DNumbers [0.2,0.8]\n ,GV.SScheme \"blues\" [0.3,1.0]\n ]\n , GV.MLegend [GV.LGradientLength (vcHeight vc / 3)\n , GV.LFormatAsNum\n , GV.LFormat \"%\"\n ]\n ]\n estEnc = estimateXenc . estimateYenc . estimateSizeEnc . estimateColorEnc\n estSpec = GV.asSpec [(GV.encoding . estEnc) [], GV.mark GV.Point [GV.MFilled True]]\n in\n FV.configuredVegaLite vc [FV.title title, GV.layer [estSpec], dat]\n\nexitCompareChart :: Foldable f\n => T.Text\n -> FV.ViewConfig\n -> f (F.Record ['(\"Group\", T.Text)\n ,'(\"Model Dem Pref\", Double)\n ,'(\"ModelvsExit\",Double)\n ])\n -> GV.VegaLite\nexitCompareChart title vc rows =\n let dat = FV.recordsToVLData id FV.defaultParse rows\n xLabel = \"Modeled % Likelihood of Voting Democratic\"\n xEnc = GV.position GV.X [FV.pName @'(\"Model Dem Pref\", Double)\n ,GV.PmType GV.Quantitative\n ,GV.PAxis [GV.AxTitle xLabel\n , GV.AxFormatAsNum\n , GV.AxFormat \"%\"\n ]\n ]\n yEnc = GV.position GV.Y [FV.pName @'(\"ModelvsExit\", Double)\n ,GV.PmType GV.Quantitative\n ,GV.PScale [GV.SDomain $ GV.DNumbers [negate 0.15,0.15]]\n ,GV.PAxis [GV.AxTitle \"Model - Exit Poll\"\n , GV.AxFormatAsNum\n , GV.AxFormat \"%\"\n ]\n ]\n colorEnc = GV.color [FV.mName @'(\"Group\", T.Text)\n , GV.MmType GV.Nominal\n ]\n enc = xEnc . yEnc . colorEnc\n spec = GV.asSpec [(GV.encoding . enc) [], GV.mark GV.Point [GV.MFilled True, GV.MSize 100]]\n in\n FV.configuredVegaLite vc [FV.title title, GV.layer [spec], dat]\n\n\n\nvlGroupingChartExit :: Foldable f\n => T.Text\n -> FV.ViewConfig\n -> f (F.Record ['(\"Group\", T.Text)\n ,'(\"VotingAgePop\", Int)\n ,'(\"Voters\", Int)\n ,'(\"D Voter Preference\", Double)\n ,'(\"InfMinusExit\", Double)\n ])\n -> GV.VegaLite\nvlGroupingChartExit title vc rows =\n let dat = FV.recordsToVLData id FV.defaultParse rows\n xLabel = \"Inferred Likelihood of Voting Democratic\"\n estimateXenc = GV.position GV.X [FV.pName @'(\"D Voter Preference\", Double)\n ,GV.PmType GV.Quantitative\n ,GV.PAxis [GV.AxTitle xLabel]\n ]\n estimateYenc = GV.position GV.Y [FV.pName @'(\"Group\",T.Text)\n ,GV.PmType GV.Ordinal\n ]\n estimateSizeEnc = GV.size [FV.mName @'(\"VotingAgePop\",Int)\n , GV.MmType GV.Quantitative]\n estimateColorEnc = GV.color [FV.mName @'(\"InfMinusExit\", Double)\n , GV.MmType GV.Quantitative]\n estEnc = estimateXenc . estimateYenc . estimateSizeEnc . estimateColorEnc\n estSpec = GV.asSpec [(GV.encoding . estEnc) [], GV.mark GV.Point []]\n in\n FV.configuredVegaLite vc [FV.title title, GV.layer [estSpec], dat]\n", "meta": {"hexsha": "55312342af6883b3d2898ce29cb22e0718f8643c", "size": 31680, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "blueripple-glm/src/BlueRipple/Model/Preference.hs", "max_stars_repo_name": "blueripple/preference-model", "max_stars_repo_head_hexsha": "beae97c2d854830bc0e9027609e54166f93d976b", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2019-07-24T11:32:48.000Z", "max_stars_repo_stars_event_max_datetime": "2019-07-24T11:32:48.000Z", "max_issues_repo_path": "blueripple-glm/src/BlueRipple/Model/Preference.hs", "max_issues_repo_name": "blueripple/preference-model", "max_issues_repo_head_hexsha": "beae97c2d854830bc0e9027609e54166f93d976b", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "blueripple-glm/src/BlueRipple/Model/Preference.hs", "max_forks_repo_name": "blueripple/preference-model", "max_forks_repo_head_hexsha": "beae97c2d854830bc0e9027609e54166f93d976b", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 43.8174273859, "max_line_length": 135, "alphanum_fraction": 0.5647727273, "num_tokens": 8346, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO\n\n", "lm_q1_score": 0.7122321842389469, "lm_q2_score": 0.476579651063676, "lm_q1q2_score": 0.3394353658409171}} {"text": "{-# LANGUAGE DeriveGeneric #-}\n{-# LANGUAGE FlexibleContexts #-}\n{-# LANGUAGE FlexibleInstances #-}\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE GeneralizedNewtypeDeriving #-}\n{-# LANGUAGE InstanceSigs #-}\n{-# LANGUAGE KindSignatures #-}\n{-# LANGUAGE LambdaCase #-}\n{-# LANGUAGE MultiParamTypeClasses #-}\n{-# LANGUAGE RankNTypes #-}\n{-# LANGUAGE ScopedTypeVariables #-}\n{-# LANGUAGE StandaloneDeriving #-}\n{-# LANGUAGE TypeFamilies #-}\n{-# LANGUAGE TypeInType #-}\n{-# LANGUAGE TypeOperators #-}\n{-# LANGUAGE UndecidableInstances #-}\n\nmodule TensorOps.Backend.NTensor\n ( NTensor\n , NTensorL\n , NTensorV\n )\n where\n\nimport Control.DeepSeq\nimport Control.Monad.Primitive\nimport Data.Distributive\nimport Data.Kind\nimport Data.List.Util\nimport Data.Nested\nimport Data.Proxy\nimport Data.Singletons\nimport Data.Singletons.Prelude.List hiding (Length, Reverse)\nimport Data.Type.Combinator\nimport Data.Type.Combinator.Util\nimport Data.Type.Length as TCL\nimport Data.Type.Length.Util as TCL\nimport Data.Type.Product as TCP\nimport Data.Type.Product.Util as TCP\nimport Data.Type.Sing\nimport Data.Type.Uniform\nimport GHC.Generics\nimport Statistics.Distribution\nimport System.Random.MWC\nimport TensorOps.NatKind\nimport TensorOps.Types\nimport Type.Class.Higher\nimport Type.Class.Higher.Util\nimport Type.Class.Witness\nimport Type.Family.List\nimport qualified Data.Type.Vector as TCV\nimport qualified Data.Type.Vector.Util as TCV\nimport qualified Data.Vector.Sized as VS\nimport qualified Type.Family.Nat as TCN\n\nnewtype NTensor :: (k -> Type -> Type) -> Type -> [k] -> Type where\n NTensor\n :: { getNVec :: Nested v js a }\n -> NTensor v a js\n\nderiving instance (Num a, SingI ns, Nesting1 Proxy Functor v, Nesting1 Sing Applicative v)\n => Num (NTensor v a ns)\nderiving instance Generic (NTensor v a ns)\nderiving instance (NFData a, Nesting Proxy NFData v) => NFData (NTensor v a ns)\ninstance (NFData a, Nesting Proxy NFData v) => Nesting1 w NFData (NTensor v a) where\n nesting1 _ = Wit\n\ninstance (NFData a, Nesting Proxy NFData v) => NFData1 (NTensor v a)\n\ngenNTensor\n :: forall k (v :: k -> Type -> Type) (ns :: [k]) (a :: Type). Vec v\n => Sing ns\n -> (Prod (IndexN k) ns -> a)\n -> NTensor v a ns\ngenNTensor s f = NTensor $ genNested s f\n{-# INLINE genNTensor #-}\n\ngenNTensorA\n :: forall k (v :: k -> Type -> Type) (ns :: [k]) (a :: Type) f. (Applicative f, Vec v)\n => Sing ns\n -> (Prod (IndexN k) ns -> f a)\n -> f (NTensor v a ns)\ngenNTensorA s f = NTensor <$> genNestedA s f\n{-# INLINE genNTensorA #-}\n\nindexNTensor\n :: forall k (v :: k -> Type -> Type) (ns :: [k]) (a :: Type). Vec v\n => Prod (IndexN k) ns\n -> NTensor v a ns\n -> a\nindexNTensor i = indexNested i . getNVec\n{-# INLINE indexNTensor #-}\n\noverNVec2\n :: (Nested v ns a -> Nested w ms b -> Nested u os c)\n -> NTensor v a ns\n -> NTensor w b ms\n -> NTensor u c os\noverNVec2 f x y = NTensor $ f (getNVec x) (getNVec y)\n{-# INLINE overNVec2 #-}\n\nntNVec\n :: Functor f\n => (Nested v ns a -> f (Nested w ms b))\n -> NTensor v a ns\n -> f (NTensor w b ms)\nntNVec f = fmap NTensor . f . getNVec\n{-# INLINE ntNVec #-}\n\nnvecNT\n :: Functor f\n => (NTensor v a ns -> f (NTensor w b ms))\n -> Nested v ns a\n -> f (Nested w ms b)\nnvecNT f = fmap getNVec . f . NTensor\n{-# INLINE nvecNT #-}\n\noverNVec\n :: (Nested v ns a -> Nested v ms a)\n -> NTensor v a ns\n -> NTensor v a ms\noverNVec f = getI . ntNVec (I . f)\n{-# INLINE overNVec #-}\n\nunderNVec\n :: (NTensor v a ns -> NTensor v a ms)\n -> Nested v ns a\n -> Nested v ms a\nunderNVec f = getNVec . f . NTensor\n\n\ninstance\n ( Vec (v :: k -> Type -> Type)\n , RealFloat a\n , Nesting1 Proxy Functor v\n , Nesting1 Sing Applicative v\n , Nesting1 Proxy Foldable v\n , Nesting1 Proxy Traversable v\n , Nesting1 Sing Distributive v\n , Eq1 (IndexN k)\n ) => Tensor (NTensor v a) where\n type ElemT (NTensor v a) = a\n\n liftT\n :: forall (n :: TCN.N) (o :: [k]). SingI o\n => (TCV.Vec n a -> a)\n -> TCV.Vec n (NTensor v a o)\n -> NTensor v a o\n liftT f = NTensor . liftNested f . fmap getNVec\n {-# INLINE liftT #-}\n\n sumT = sum'\n {-# INLINE sumT #-}\n\n scaleT \u03b1 = overNVec (fmap (\u03b1 *))\n {-# INLINE scaleT #-}\n\n transp\n :: forall ns. (SingI ns, SingI (Reverse ns))\n => NTensor v a ns\n -> NTensor v a (Reverse ns)\n -- transp = overNVec (transpose sing)\n transp = overNVec (transpose' (singLength sing) sing)\n {-# INLINE transp #-}\n\n gmul\n :: forall ms os ns. SingI (Reverse os ++ ns)\n => Length ms\n -> Length os\n -> Length ns\n -> NTensor v a (ms ++ os)\n -> NTensor v a (Reverse os ++ ns)\n -> NTensor v a (ms ++ ns)\n gmul lM lO lN = overNVec2 (gmul' lM lO lN)\n \\\\ sO'\n \\\\ sN\n where\n sO' :: Sing (Reverse os)\n sN :: Sing ns\n (sO', sN) = splitSing (TCL.reverse' lO)\n (sing :: Sing (Reverse os ++ ns))\n {-# INLINE gmul #-}\n\n -- TODO: this is a dumb implementation\n diag\n :: forall n ns. SingI (n ': ns)\n => Uniform n ns\n -> NTensor v a '[n]\n -> NTensor v a (n ': ns)\n diag u d\n = genNTensor sing (\\i -> case TCV.uniformVec (prodToVec I (US u) i) of\n Nothing -> 0\n Just (I i') -> indexNTensor (i' :< \u00d8) d\n )\n \\\\ (produceEq1 :: Eq1 (IndexN k) :- Eq (IndexN k n))\n {-# INLINE diag #-}\n\n -- TODO: this can be just done using genNTensor\n getDiag\n :: forall n ns. SingI '[n]\n => Uniform n ns\n -> NTensor v a (n ': n ': ns)\n -> NTensor v a '[n]\n getDiag u = overNVec (diagNV sing u)\n \\\\ sHead (sing :: Sing '[n])\n {-# INLINE getDiag #-}\n\n genRand\n :: forall m d (ns :: [k]). (ContGen d, PrimMonad m, SingI ns)\n => d\n -> Gen (PrimState m)\n -> m (NTensor v a ns)\n genRand d g = generateA (\\_ -> realToFrac <$> genContVar d g)\n {-# INLINE genRand #-}\n\n generateA\n :: forall f ns. (Applicative f, SingI ns)\n => (Prod (IndexN k) ns -> f a)\n -> f (NTensor v a ns)\n generateA = genNTensorA sing\n {-# INLINE generateA #-}\n\n (!) = flip indexNTensor\n {-# INLINE (!) #-}\n\n ixRows\n :: Applicative f\n => Length ms\n -> Length os\n -> (Prod (IndexN k) ms -> NTensor v a ns -> f (NTensor v a os))\n -> NTensor v a (ms ++ ns)\n -> f (NTensor v a (ms ++ os))\n ixRows l _ f = ntNVec $ fmap joinNested . nIxRows l (\\i -> nvecNT (f i))\n {-# INLINE ixRows #-}\n\n sumRows\n :: forall n ns. SingI ns\n => NTensor v a (n ': ns)\n -> NTensor v a ns\n sumRows = overNVec sumRowsNested\n \\\\ (nesting1 Proxy :: Wit (Foldable (v n)))\n {-# INLINE sumRows #-}\n\n mapRows\n :: Length ns\n -> (NTensor v a ms -> NTensor v a ms)\n -> NTensor v a (ns ++ ms)\n -> NTensor v a (ns ++ ms)\n mapRows l f = overNVec $ joinNested . mapNVecSlices (underNVec f) l\n {-# INLINE mapRows #-}\n\ntype NTensorL = NTensor (Flip2 TCV.VecT I) Double\ntype NTensorV = NTensor (Flip2 VS.VectorT I) Double\n", "meta": {"hexsha": "d2c3b66b93a2404fa7018e8b300fa4156eb6b990", "size": 7894, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/TensorOps/Backend/NTensor.hs", "max_stars_repo_name": "mstksg/tensor-ops", "max_stars_repo_head_hexsha": "1958642d60d879e311da14469c3dd09c186b5fda", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 70, "max_stars_repo_stars_event_min_datetime": "2016-08-24T06:50:08.000Z", "max_stars_repo_stars_event_max_datetime": "2021-04-26T00:31:35.000Z", "max_issues_repo_path": "src/TensorOps/Backend/NTensor.hs", "max_issues_repo_name": "mstksg/tensor-ops", "max_issues_repo_head_hexsha": "1958642d60d879e311da14469c3dd09c186b5fda", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 6, "max_issues_repo_issues_event_min_datetime": "2016-09-29T06:01:20.000Z", "max_issues_repo_issues_event_max_datetime": "2017-03-15T10:52:51.000Z", "max_forks_repo_path": "src/TensorOps/Backend/NTensor.hs", "max_forks_repo_name": "mstksg/tensor-ops", "max_forks_repo_head_hexsha": "1958642d60d879e311da14469c3dd09c186b5fda", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2016-09-28T05:44:48.000Z", "max_forks_repo_forks_event_max_datetime": "2017-01-30T11:01:34.000Z", "avg_line_length": 31.0787401575, "max_line_length": 90, "alphanum_fraction": 0.5272358753, "num_tokens": 2241, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.6723316860482763, "lm_q2_score": 0.5039061705290806, "lm_q1q2_score": 0.338792085241947}} {"text": "module Uniform\n ( setUniform\n , setUniform4fv\n , getUniform\n ) where\n\nimport Foreign.Marshal\nimport qualified Graphics.GL.Functions as GLF\nimport Graphics.Rendering.OpenGL (($=))\nimport qualified Graphics.Rendering.OpenGL as GL\nimport Matrix\nimport Numeric.LinearAlgebra\nimport qualified Numeric.LinearAlgebra.Devel as D\n\nsetUniform program name value = do\n uniform <- GL.uniformLocation program name\n GL.uniform uniform $= value\n\nsetUniform4fv :: Matrix4 -> GL.UniformLocation -> IO ()\nsetUniform4fv value (GL.UniformLocation uniform) =\n withFloatMatrix value $ \\order rows cols ptr ->\n GLF.glUniformMatrix4fv uniform 1 (fromBool (order == D.RowMajor)) ptr\n\ngetUniform :: GL.Program -> String -> IO GL.UniformLocation\ngetUniform = GL.uniformLocation\n", "meta": {"hexsha": "b9380a8bd0c60e4744c42bbaf90963ae3bd6f3b5", "size": 811, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "app/Uniform.hs", "max_stars_repo_name": "aelg/haskell-render", "max_stars_repo_head_hexsha": "c55fd2e3cfde1899b03910545b835935fef62759", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "app/Uniform.hs", "max_issues_repo_name": "aelg/haskell-render", "max_issues_repo_head_hexsha": "c55fd2e3cfde1899b03910545b835935fef62759", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "app/Uniform.hs", "max_forks_repo_name": "aelg/haskell-render", "max_forks_repo_head_hexsha": "c55fd2e3cfde1899b03910545b835935fef62759", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 31.1923076923, "max_line_length": 73, "alphanum_fraction": 0.7250308261, "num_tokens": 191, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.6619228758499942, "lm_q2_score": 0.5117166047041654, "lm_q1q2_score": 0.3387169266059758}} {"text": "{-# LANGUAGE CPP #-}\n{-# LANGUAGE ExplicitForAll, ConstraintKinds, FlexibleContexts #-} -- For :< experiment\n{-# LANGUAGE ScopedTypeVariables, TypeOperators #-}\n{-# LANGUAGE ViewPatterns, PatternGuards #-}\n{-# LANGUAGE DataKinds, GADTs #-} -- for TU\n{-# LANGUAGE LambdaCase, TupleSections #-}\n\n{-# OPTIONS_GHC -Wall #-}\n{-# OPTIONS_GHC -fcontext-stack=30 #-}\n{-# OPTIONS_GHC -fno-warn-type-defaults #-}\n\n{-# OPTIONS_GHC -fno-warn-unused-imports #-} -- TEMP\n{-# OPTIONS_GHC -fno-warn-unused-binds #-} -- TEMP\n\n----------------------------------------------------------------------\n-- |\n-- Module : TreeTest\n-- Copyright : (c) 2014 Tabula, Inc.\n-- \n-- Maintainer : conal@tabula.com\n-- Stability : experimental\n-- \n-- Tests with length-typed treetors. To run:\n-- \n-- hermit TreeTest.hs -v0 -opt=LambdaCCC.Monomorphize DoTree.hss resume && ./TreeTest\n-- \n-- Remove the 'resume' to see intermediate Core.\n----------------------------------------------------------------------\n\n-- module TreeTest where\n\n-- TODO: explicit exports\n\nimport Prelude hiding ({- id,(.), -}foldl,foldr,sum,product,zipWith,reverse,and,or,scanl,minimum,maximum)\n\nimport Data.Monoid (Monoid(..),(<>),Sum(..),Product(..))\nimport Data.Functor ((<$>))\nimport Control.Applicative -- (Applicative(..),liftA2,liftA3)\nimport Data.Foldable (Foldable(..),sum,product,and,or,toList,minimum,maximum)\nimport Data.Traversable (Traversable(..))\n-- import Control.Category (id,(.))\nimport Control.Arrow (Arrow(..))\nimport qualified Control.Arrow as Arrow\nimport Data.Tuple (swap)\nimport Data.Maybe (fromMaybe,maybe)\nimport Text.Printf (printf)\n\nimport Test.QuickCheck (arbitrary,Gen,generate,vectorOf)\n\n-- transformers\nimport Data.Functor.Identity\n\nimport TypeUnary.TyNat\nimport TypeUnary.Nat (IsNat,natToZ)\nimport TypeUnary.Vec hiding (transpose,iota)\nimport qualified TypeUnary.Vec as V\nimport Control.Compose ((:.)(..),unO)\n\nimport LambdaCCC.Misc\n (xor,boolToInt,dup,Unop,Binop,Ternop,transpose,(:*),loop,delay,Reversible(..))\nimport LambdaCCC.Adder\nimport LambdaCCC.CRC -- hiding (crcS,sizeA)\nimport LambdaCCC.Bitonic\nimport LambdaCCC.Counters\nimport qualified LambdaCCC.RadixSort as RS\n\n-- import Circat.Misc (Reversible(..))\nimport Circat.Rep (bottom)\nimport Circat.Pair (Pair(..),sortP)\nimport qualified Circat.Pair as P\nimport qualified Circat.RTree as RT\nimport qualified Circat.LTree as LT\nimport qualified Circat.RaggedTree as Ra\nimport Circat.RaggedTree (TU(..), R1, R2, R3, R4, R5, R8, R11, R13)\nimport Circat.Shift\nimport Circat.Scan\nimport Circat.FFT\nimport Circat.Mealy hiding (ArrowCircuit(..))\nimport qualified Circat.Mealy as Mealy\nimport Circat.Circuit (GenBuses(..), GS, Attr, systemSuccess)\nimport Circat.Complex\n\n-- Strange -- why needed? EP won't resolve otherwise. Bug?\nimport qualified LambdaCCC.Lambda\nimport Circat.Classes (IfT)\nimport LambdaCCC.Lambda (EP,reifyEP)\n\nimport LambdaCCC.Run\n\n-- Experiment for Typeable resolution in reification\nimport qualified Data.Typeable\n\n-- -- To support Dave's FFT stuff, below.\n-- -- import Data.Complex (cis)\n-- import Data.Newtypes.PrettyDouble\n\n{--------------------------------------------------------------------\n Misc\n--------------------------------------------------------------------}\n\nliftA4 :: Applicative f =>\n (a -> b -> c -> a -> d) -> f a -> f b -> f c -> f a -> f d\nliftA4 f as bs cs ds = liftA3 f as bs cs <*> ds\n\n{--------------------------------------------------------------------\n Examples\n--------------------------------------------------------------------}\n\ntype RTree = RT.Tree\ntype LTree = LT.Tree\ntype Ragged = Ra.Tree\n\nt0 :: RTree N0 Bool\nt0 = pure True\n\np1 :: Unop (Pair Bool)\np1 (a :# b) = b :# a\n\npsum :: Num a => Pair a -> a\npsum (a :# b) = a + b\n\n-- tsum :: Num a => RTree n a -> a\n-- tsum = foldT id (+)\n\n-- dot :: (IsNat n, Num a) => RTree n a -> RTree n a -> a\n-- dot as bs = tsum (prod as bs)\n\nprod :: (Functor f, Num a) => f (a,a) -> f a\nprod = fmap (uncurry (*))\n\nprodA :: (Applicative f, Num a) => Binop (f a)\nprodA = liftA2 (*)\n\n-- dot :: Num a => RTree n (a,a) -> a\n-- dot = tsum . prod\n\ndot :: (Functor f, Foldable f, Num a) => f (a,a) -> a\ndot = sum . prod\n\nsquare :: Num a => a -> a\nsquare a = a * a\n\nsumSquare :: (Functor f, Foldable f, Num a) => f a -> a\nsumSquare = sum . fmap square\n\nsquares :: (Functor f, Num a) => f a -> f a\nsquares = fmap square\n\nsquares' :: (Functor f, Num a) => f a -> f a\nsquares' = fmap (^ (2 :: Int))\n\n{--------------------------------------------------------------------\n Dot products\n--------------------------------------------------------------------}\n\ndot' :: (Applicative f, Foldable f, Num a) => f a -> f a -> a\ndot' as bs = sum (prodA as bs)\n\ndot'' :: (Foldable g, Functor g, Foldable f, Num a) => g (f a) -> a\ndot'' = sum . fmap product\n\ndot''' :: (Traversable g, Foldable f, Applicative f, Num a) => g (f a) -> a\ndot''' = dot'' . transpose\n\ndotap :: (Foldable t, Num (t a), Num a) => t a -> t a -> a\nas `dotap` bs = sum (as * bs)\n\ndotsp :: (Foldable g, Foldable f, Num (f a), Num a) => g (f a) -> a\ndotsp = sum . product\n\n-- Infix binary dot product\ninfixl 7 <.>\n(<.>) :: (Foldable f, Applicative f, Num a) => f a -> f a -> a\nu <.> v = sum (liftA2 (*) u v)\n\n-- | Monoid under lifted multiplication.\nnewtype ProductA f a = ProductA { getProductA :: f a }\n\ninstance (Applicative f, Num a) => Monoid (ProductA f a) where\n mempty = ProductA (pure 1)\n ProductA u `mappend` ProductA v = ProductA (liftA2 (*) u v)\n\nproductA :: (Foldable g, Applicative f, Num a) => g (f a) -> f a\nproductA = getProductA . foldMap ProductA\n\ndota :: (Foldable g, Foldable f, Applicative f, Num a) => g (f a) -> a\ndota = sum . productA\n\n{--------------------------------------------------------------------\n Generalized matrices\n--------------------------------------------------------------------}\n\ntype Matrix m n a = Vec n (Vec m a)\ntype MatrixT m n a = RTree n (RTree m a)\ntype MatrixG p q a = Ragged q (Ragged p a)\n\ninfixr 1 $@\n-- infixl 9 .@\n\n-- | Apply a linear transformation represented as a matrix\n-- ($@) :: (IsNat m, Num a) => Matrix m n a -> Vec m a -> Vec n a\n($@) :: (Foldable m, Applicative m, Functor n, Num a) =>\n n (m a) -> m a -> n a\nmat $@ vec = (`dot'` vec) <$> mat\n\n-- -- | Compose linear transformations represented as matrices\n-- (.@) :: (IsNat m, IsNat n, IsNat o, Num a) =>\n-- Matrix n o a -> Matrix m n a -> Matrix m o a\n(.@) :: ( Applicative o, Traversable n, Applicative n\n , Traversable m, Applicative m, Num a ) =>\n o (n a) -> n (m a) -> o (m a)\n-- no .@ mn = (\\ n -> (n <.>) <$> transpose mn) <$> no\nno .@ mn = transpose ((no $@) <$> transpose mn)\n\n{--------------------------------------------------------------------\n Permutations\n--------------------------------------------------------------------}\n\ninvertR :: IsNat n => RTree n a -> LTree n a\ninvertR = invertR' nat\n\ninvertR' :: Nat n -> RTree n a -> LTree n a\ninvertR' Zero = \\ (RT.L a ) -> LT.L a\ninvertR' (Succ m) = \\ (RT.B ts) -> LT.B (invertR' m (transpose ts))\n-- invertR' (Succ m) = \\ (RT.B ts) -> LT.B (transpose (invertR' m <$> ts))\n\n#if 0\nRT.unB :: RTree (S n) a -> Pair (RTree n a)\ntranspose :: Pair (RTree n a) -> RTree n (Pair a)\ninvertR :: RTree n (Pair a) -> LTree n (Pair a)\nLT.B :: LTree n (Pair a) -> LTree (S n) a\n\nRT.unB :: RTree (S n) a -> Pair (RTree n a)\nfmap invertR :: Pair (RTree n a) -> Pair (LTree n a)\ntranspose :: Pair (LTree n a) -> LTree n (Pair a)\nLT.B :: LTree n (Pair a) -> LTree (S n) a\n#endif\n\n-- We needed the IsNat n for Applicative on RTree n.\n-- The reverse transformation is easier, since we know Pair is Applicative.\n\ninvertL :: LTree n a -> RTree n a\ninvertL (LT.L a ) = RT.L a\ninvertL (LT.B ts) = RT.B (transpose (invertL ts))\n-- invertL (LT.B ts) = RT.B (invertL <$> transpose ts)\n\n-- invertR' (Succ m) = \\ (RT.B ts) -> LT.B (transpose (invertR' m <$> ts))\n\n#if 0\nLT.unB :: LTree (S n) a -> LTree n (Pair a)\ninvertL :: LTree n (Pair a) -> RTree n (Pair a)\ntranspose :: RTree n (Pair a) -> Pair (RTree n a)\nRT.B :: Pair (RTree n a) -> RTree (S n) a\n\nLT.unB :: LTree (S n) a -> LTree n (Pair a)\ntranspose :: LTree n (Pair a) -> Pair (LTree n a)\nfmap invertL :: Pair (LTree n a) -> Pair (RTree n a)\nRT.B :: Pair (RTree n a) -> RTree (S n) a\n#endif\n\n{--------------------------------------------------------------------\n Run it\n--------------------------------------------------------------------}\n\ninTest :: String -> IO ()\ninTest cmd = systemSuccess (\"cd ../test; \" ++ cmd) -- (I run ghci in ../src)\n\nmk :: String -> IO ()\nmk s = inTest (\"make \" ++ s)\n\ndoit :: IO ()\ndoit = mk \"doit\"\n\nreify :: IO ()\nreify = mk \"reify\"\n\nreifyDone :: IO ()\nreifyDone = mk \"reify-done\"\n\nnoReify :: IO ()\nnoReify = mk \"no-reify\"\n\nnoReifyDone :: IO ()\nnoReifyDone = mk \"no-reify-done\"\n\ncompile :: IO ()\ncompile = mk \"compile\"\n\ndateFigureSvg :: String -> String -> IO ()\ndateFigureSvg date fig = systemSuccess (printf \"cd ../test; ./date-figure-svg %s \\\"%s\\\"\" date fig)\n\nfigureSvg :: String -> IO ()\nfigureSvg str = systemSuccess (\"cd ../test; ./figure-svg \" ++ str)\n\ndateLatestSvg :: String -> IO ()\ndateLatestSvg date = systemSuccess (printf \"cd ../test; ./date-latest-svg \\\"%s\\\"\" date)\n\nlatestSvg :: IO ()\nlatestSvg = systemSuccess \"cd ../test; ./latest-svg\"\n\ndo1 :: IO ()\ndo1 = inTest \"hermit TreeTest.hs -v0 -opt=LambdaCCC.Monomorphize DoTreeNoReify.hss\"\n\ndo2 :: IO ()\ndo2 = inTest \"hermit TreeTest.hs -v0 -opt=LambdaCCC.Monomorphize DoTree.hss\"\n\n-- Only works when compiled with HERMIT\nmain :: IO ()\n\n---- FFT\n\ntype C = Complex Double\n\n-- main = go \"foo\" ()\n\n-- main = go \"fft-p\" (fft :: Unop (Pair C))\n\n-- main = go \"fft-lt1\" (fft :: LTree N1 C -> RTree N1 C)\n\n-- main = go \"fft-rt1\" (fft :: RTree N1 C -> LTree N1 C)\n\n-- twiddles :: forall g f a. (AFS g, AFS f, RealFloat a) => g (f (Complex a))\n\n-- main = go \"twiddles-lt1p\" (twiddles :: LTree N1 (Pair C))\n\n-- main = go \"foo\" (omega (size (undefined :: (LTree N1 :. Pair) ())))\n\n-- twiddles :: forall g f a. (AFS g, AFS f, RealFloat a) => g (f (Complex a))\n-- twiddles = powers <$> powers (omega (tySize(g :. f)))\n\nmain = go \"foo\" (powers :: Int -> LTree N1 Int)\n\n-- zoop :: Int\n-- zoop = 3\n\n-- main = go \"foo\" zoop\n\n-- main = go \"foo\" (size (undefined :: RTree N3 ()))\n\n-- main = go \"foo\" (size (undefined :: (LTree N3 :. Pair) ()))\n\n-- main = go \"foo\" (size (undefined :: Pair ()))\n\n-- main = go \"foo\" (negate :: Unop Double)\n\n-- omega n = cis (- 2 * pi / fromIntegral n)\n\n-- main = go \"omega-1\" (omega (1 :: Int))\n\n-- main = go \"omega-2\" (omega (2 :: Int))\n\n-- -- Okay\n-- main = go \"foo\" (\\ x -> cis (-2 * pi / x) :: C)\n\n-- -- Trips over fromInteger . toInteger\n-- main = go \"foo\" (\\ (n :: Int) -> cis (-2 * pi / fromIntegral n) :: C)\n\n-- -- Trips over fromInteger . toInteger (the definition of fromIntegral)\n-- main = go \"foo\" (fromIntegral :: Int -> Double)\n\n-- main = go \"foo\" (pure (3 :+ 4) :: RTree N2 C)\n\n-- main = go \"foo\" (size (undefined :: RTree N5 ()))\n\n-- main = go \"foo\" (exp :: C -> C)\n\n-- main = go \"foo\" (exp :: Double -> Double)\n\n---- End FFT\n\n-- main = go \"map-not-v5\" (fmap not :: Vec N5 Bool -> Vec N5 Bool)\n\n-- main = go \"map-square-v5\" (fmap square :: Vec N5 Int -> Vec N5 Int)\n\n-- main = go \"map-rt3\" (fmap not :: Unop (RTree N3 Bool))\n\n-- main = go \"tdott-2\" (dot''' :: Pair (RTree N2 Int) -> Int)\n\n-- main = go \"dotsp-v3t2\" (dotsp :: Vec N3 (RTree N2 Int) -> Int)\n\n-- main = go \"dotsp-t2t2\" (dotsp :: RTree N2 (RTree N2 Int) -> Int)\n\n-- main = go \"dotsp-pt3\" (dotsp :: Pair (RTree N3 Int) -> Int)\n\n-- main = go \"dotsp-pv5\" (dotsp :: Pair (Vec N5 Int) -> Int)\n\n-- main = go \"dotsp-plt3\" (dotsp :: Pair (LTree N3 Int) -> Int)\n\n-- main = go \"dotap-2\" (dotap :: RTree N2 Int -> RTree N2 Int -> Int)\n\n-- main = go \"tdot-2\" (dot'' :: RTree N2 (Pair Int) -> Int)\n\n-- main = go \"test\" (dot'' :: RTree N4 (Pair Int) -> Int)\n\n-- main = go \"plusInt\" ((+) :: Int -> Int -> Int)\n-- main = go \"or\" ((||) :: Bool -> Bool -> Bool)\n\n-- main = goSep \"pure-rt3\" 1 (\\ () -> (pure False :: RTree N3 Bool))\n\n-- main = go \"foo\" (\\ (_ :: RTree N3 Bool) -> False)\n\n-- main = go \"sum-p\" (sum :: Pair Int -> Int)\n\n-- main = go \"sumSquare-p\" (sumSquare :: Pair Int -> Int)\n\n-- main = goSep \"sumSquare-rt2\" 0.75 (sumSquare :: RTree N2 Int -> Int)\n\n-- main = go \"sum-v8\" (sum :: Vec N8 Int -> Int)\n\n-- main = go \"and-v5\" (and :: Vec N5 Bool -> Bool)\n\n-- main = go \"sum-t3\" (sum :: RTree N3 Int -> Int)\n\n-- main = go \"sum-lt3\" (sum :: LTree N3 Int -> Int)\n\n-- main = go \"sum-foldl-v5\" (foldl (+) 0 :: Vec N5 Int -> Int)\n\n-- main = go \"sum-foldr-v5\" (foldr (+) 0 :: Vec N5 Int -> Int)\n\n-- main = go \"sum-foldl-t3\" (foldl (+) 0 :: RTree N3 Int -> Int)\n\n-- main = go \"sum-foldr-t3\" (foldr (+) 0 :: RTree N3 Int -> Int)\n\n-- main = do go \"squares3\" (squares :: RTree N3 Int -> RTree N3 Int)\n-- go \"sum4\" (sum :: RTree N4 Int -> Int)\n-- go \"dot4\" (dot :: RTree N4 (Int,Int) -> Int)\n\n-- main = go \"test\" (dot :: RTree N4 (Int,Int) -> Int)\n\n-- -- Ranksep: rt1=0.5, rt2=1, rt3=2, rt4=4,rt5=8\n-- main = goSep \"transpose-prt4\" 4 (transpose :: Pair (RTree N4 Bool) -> RTree N4 (Pair Bool))\n\n-- -- Ranksep: rt1=0.5, rt2=1, rt3=2, rt4=4,rt5=8\n-- main = goSep \"transpose-rt2p\" 1 (transpose :: RTree N2 (Pair Bool) -> Pair (RTree N2 Bool))\n\n-- -- Ranksep: rt1=1, rt2=2, rt3=4, rt4=8, rt5=16\n-- main = goSep \"transpose-v3t5\" 16 (transpose :: Vec N3 (RTree N5 Bool) -> RTree N5 (Vec N3 Bool))\n\n-- -- Ranksep: rt1=2, rt2=4, rt3=8, rt4=16, rt5=32\n-- main = goSep \"transpose-v5t3\" 8 (transpose :: Vec N5 (RTree N3 Bool) -> RTree N3 (Vec N5 Bool))\n\n-- -- Ranksep: rt1=0.5, rt2=1, rt3=2, rt4=4, rt5=8\n-- main = goSep \"invertR-5\" 8 (invertR :: RTree N5 Bool -> LTree N5 Bool)\n\n-- main = go \"vtranspose-34\" (transpose :: Matrix N3 N4 Int -> Matrix N4 N3 Int)\n\n-- main = go \"vtranspose-34\" (transpose :: Vec N3 (Vec N4 Int) -> Vec N4 (Vec N3 Int))\n\n-- main = go \"ttranspose-23\" (transpose :: MatrixT N2 N3 Int -> MatrixT N3 N2 Int)\n\n-- main = go \"swap\" (swap :: Int :* Bool -> Bool :* Int)\n\n-- main = go \"add\" (\\ (a,b) -> a+b :: Int)\n\n-- main = go \"rot31\" (\\ (a,b,c) -> (b,c,a) :: (Bool,Bool,Bool))\n\n-- main = go \"rot41\" (\\ (a,b,c,d) -> (b,c,d,a) :: (Bool,Bool,Bool,Bool))\n\n-- main = go \"rev4\" (\\ (a,b,c,d) -> (d,c,b,a) :: (Bool,Bool,Bool,Bool))\n\n-- main = go \"sum-2\" (\\ (a,b) -> a+b :: Int)\n\n-- main = go \"sum-3\" (\\ (a,b,c) -> a+b+c :: Int)\n\n-- main = go \"sum-4a\" ((\\ (a,b,c,d) -> a+b+c+d) :: (Int,Int,Int,Int) -> Int)\n\n-- main = go \"sum-4b\" ((\\ (a,b,c,d) -> (a+b)+(c+d)) :: (Int,Int,Int,Int) -> Int)\n\n-- main = go \"dot-22\" ((\\ ((a,b),(c,d)) -> a*c + b*d) :: ((Int,Int),(Int,Int)) -> Int)\n\n-- main = go \"tdot-4\" (dot :: RTree N4 (Int,Int) -> Int)\n\n-- main = go \"tpdot-4\" (dot'' :: RTree N4 (Pair Int) -> Int)\n\n-- -- Doesn't wedge.\n-- main = go \"dotp\" ((psum . prod) :: Pair (Int,Int) -> Int)\n\n-- main = go \"prod1\" (prod :: RTree N1 (Int,Int) -> RTree N1 Int)\n\n-- main = go \"dot5\" (dot :: RTree N5 (Int,Int) -> Int)\n\n-- main = go \"squares2\" (squares :: Unop (RTree N2 Int))\n\n-- main = go \"psum\" (psum :: Pair Int -> Int)\n\n-- main = go \"tsum1\" (tsum :: RTree N1 Int -> Int)\n\n-- -- Not working yet: the (^) is problematic.\n-- main = go \"squaresp-rt0\" (squares' :: Unop (RTree N0 Int))\n\n-- main = goSep \"applyLin-v23\" 1 (($@) :: Matrix N2 N3 Int -> Vec N2 Int -> Vec N3 Int)\n\n-- main = goSep \"applyLin-v42\" 1 (($@) :: Matrix N4 N2 Int -> Vec N4 Int -> Vec N2 Int)\n\n-- main = goSep \"applyLin-v45\" 1 (($@) :: Matrix N4 N5 Int -> Vec N4 Int -> Vec N5 Int)\n\n-- main = goSep [ranksep 2] -t21 (($@) :: MatrixT N2 N1 Int -> RTree N2 Int -> RTree N1 Int)\n\n-- main = go \"applyLin-t22\" (($@) :: MatrixT N2 N2 Int -> RTree N2 Int -> RTree N2 Int)\n\n-- main = go \"applyLin-t23\" (($@) :: MatrixT N2 N3 Int -> RTree N2 Int -> RTree N3 Int)\n\n-- main = go \"applyLin-t32\" (($@) :: MatrixT N3 N2 Int -> RTree N3 Int -> RTree N2 Int)\n\n-- main = go \"applyLin-t34\" (($@) :: MatrixT N3 N4 Int -> RTree N3 Int -> RTree N4 Int)\n\n-- main = go \"applyLin-t45\" (($@) :: MatrixT N4 N5 Int -> RTree N4 Int -> RTree N5 Int)\n\n-- main = go \"applyLin-v3t2\" (($@) :: RTree N2 (Vec N3 Int) -> Vec N3 Int -> RTree N2 Int)\n\n-- main = go \"applyLin-t2v3\" (($@) :: Vec N3 (RTree N2 Int) -> RTree N2 Int -> Vec N3 Int)\n\n-- main = go \"composeLin-v234\" ((.@) :: Matrix N3 N4 Int -> Matrix N2 N3 Int -> Matrix N2 N4 Int)\n\n-- main = go \"composeLin-t234\" ((.@) :: MatrixT N3 N4 Int -> MatrixT N2 N3 Int -> MatrixT N2 N4 Int)\n\n-- -- Takes a very long time. I haven't seen it through yet.\n\n-- main = go \"composeLin-t324\" ((.@) :: MatrixT N2 N4 Int -> MatrixT N3 N2 Int -> MatrixT N3 N4 Int)\n\n-- main = go \"composeLin-t222\" ((.@) :: MatrixT N2 N2 Int -> MatrixT N2 N2 Int -> MatrixT N2 N2 Int)\n\n-- main = go \"composeLin-t232\" ((.@) :: MatrixT N3 N2 Int -> MatrixT N2 N3 Int -> MatrixT N2 N2 Int)\n\n-- -- Shift examples are identities on bit representations\n-- main = go \"shiftR-v3\" (shiftR :: Vec N3 Bool :* Bool -> Bool :* Vec N3 Bool)\n\n-- -- Shift examples are identities on bit representations\n-- main = go \"shiftR-swap-v3\" (shiftR . swap :: Unop (Bool :* Vec N3 Bool))\n\n-- main = go \"shiftR-rt2\" (shiftR :: RTree N2 Bool :* Bool -> Bool :* RTree N2 Bool)\n\n-- main = go \"shiftL-rt1\" (shiftL :: Bool :* RTree N1 Bool -> RTree N1 Bool :* Bool)\n\n-- main = go \"shiftRF-v3v2\" (shiftRF :: Vec N3 Bool :* Vec N2 Bool -> Vec N2 Bool :* Vec N3 Bool)\n\n-- main = go \"shiftRF-v2v3\" (shiftRF :: Vec N2 Bool :* Vec N3 Bool -> Vec N3 Bool :* Vec N2 Bool)\n\n-- -- Shift in two zeros from the right\n-- main = go \"shiftRF-v3v2F\" (flip (curry shift) (pure False))\n-- where\n-- shift :: Vec N3 Bool :* Vec N2 Bool -> Vec N2 Bool :* Vec N3 Bool\n-- shift = shiftRF\n\n-- -- Shift in two zeros from the left\n-- main = go \"shiftLF-v2v3F\" (curry shift (pure False))\n-- where\n-- shift :: Vec N2 Bool :* Vec N3 Bool -> Vec N3 Bool :* Vec N2 Bool\n-- shift = shiftRF\n\n-- -- Shift five zeros into a tree from the left\n-- main = go \"shiftLF-v5rt4F\" (curry shift (pure False))\n-- where\n-- shift :: Vec N5 Bool :* RTree N4 Bool -> RTree N4 Bool :* Vec N5 Bool\n-- shift = shiftRF\n\n-- main = go \"lsumsp-rt2\" (lsums' :: Unop (RTree N2 Int))\n\n-- main = go \"lsumsp-rt2\" (lsums' :: Unop (RTree N2 Int))\n\n-- main = go \"lsumsp-lt3\" (lsums' :: Unop (LTree N3 Int))\n\n-- main = go \"lsums-v5\" (lsums :: Vec N5 Int -> (Vec N5 Int, Int))\n\n-- main = go \"lsums-rt2\" (lsums :: RTree N2 Int -> (RTree N2 Int, Int))\n\n-- main = go \"lsums-lt3\" (lsums :: LTree N3 Int -> (LTree N3 Int, Int))\n\n-- -- 2:1; 3:1.5; 4:2; 5:2.5\n-- main = goSep \"lParities-rt5\" (5/2) (lParities :: RTree N5 Bool -> (RTree N5 Bool, Bool))\n\n-- -- 2:1; 3:1.5; 4:2; 5:2.5\n-- main = goSep \"lParities-lt4\" (4/2) (lParities :: LTree N4 Bool -> (LTree N4 Bool, Bool))\n\n-- -- 2:1; 3:1.5; 4:2; 5:2.5\n-- main = goSep \"lParities-ex-rt3\" (3/2) (fst . lParities :: Unop (RTree N3 Bool))\n\n-- -- 2:1; 3:1.5; 4:2; 5:2.5\n-- main = goSep \"lParities-ex-lt3\" (3/2) (fst . lParities :: Unop (LTree N3 Bool))\n\n-- main = go \"foo\" (\\ a -> not a)\n\n-- main = go \"not\" not\n\n-- main = go \"not-pair\" (\\ a -> (not a, not a))\n\n-- main = go \"and-curried\" ((&&) :: Bool -> Bool -> Bool)\n\n-- main = go \"test-add-with-constant-fold\" foo\n-- where\n-- foo :: Int -> Int\n-- foo x = f x + g x\n-- f _ = 3\n-- g _ = 4\n\n-- -- True\n-- main = go \"foo\" (\\ a -> not a || True)\n\n-- -- not a\n-- main = go \"foo\" (\\ a -> a `xor` True)\n\n-- -- a\n-- main = go \"foo\" (\\ a -> a `xor` False)\n\n-- main = go \"fmap-gt5\" (fmap not :: Unop (Ragged R5 Bool))\n\n-- main = go \"sum-gt5\" (sum :: Ragged R5 Int -> Int)\n\n-- main = go \"sum-gt13p\" (sum :: Ragged R13' Int -> Int)\n\n-- main = go \"dotsp-gt8\" (dotsp :: Pair (Ragged R8 Int) -> Int)\n\n-- main = go \"applyLin-gt45\" (($@) :: MatrixG R4 R5 Int -> Ragged R4 Int -> Ragged R5 Int)\n\n-- main = go \"composeLin-gt234\" ((.@) :: MatrixG R3 R4 Int -> MatrixG R2 R3 Int -> MatrixG R2 R4 Int)\n\n-- -- Linear map composition mixing ragged trees, top-down perfect trees, and vectors.\n-- main = go \"composeLin-gt3rt2v2\"\n-- ((.@) :: Vec N2 (RTree N2 Int) -> RTree N2 (Ragged R3 Int) -> Vec N2 (Ragged R3 Int))\n\n-- main = go \"composeLin-gt1rt0v1\"\n-- ((.@) :: Vec N1 (RTree N0 Int) -> RTree N0 (Ragged R1 Int) -> Vec N1 (Ragged R1 Int))\n\n-- Note: some of the scan examples redundantly compute some additions.\n-- I suspect that they're only the same *after* the zero simplifications.\n-- These zero additions are now removed in the circuit generation back-end.\n\n-- ranksep: 8=1.5, 11=2.5\n-- main = goSep \"lsumsp-gt3\" =1.5 (lsums' :: Unop (Ragged Ra.R3 Int))\n\n-- main = go \"add3\" (\\ (x :: Int) -> x + 3)\n\n-- main = go \"foo\" (not . not)\n\n-- main = go \"foo\" (\\ (a,b :: Int) -> if a then b else b)\n\n-- -- Equivalently: a `xor` not b\n-- main = go \"foo\" (\\ (a,b) -> if a then b else not b)\n\n-- main = go \"foo\" (\\ a (b :: Int :* Int) -> (if a then id else swap) b)\n\n-- main = goSep \"foo\" 2.5 (\\ (a, b::Int, c::Int, d::Int) -> if a then (b,c,d) else (c,d,b))\n\n-- main = go \"foo\" (\\ a b -> ( if a then b else False -- a && b\n-- , if a then True else b -- a || b\n-- , if a then False else b -- not a && b\n-- , if a then b else True -- not a || b\n-- ))\n\n-- -- Equivalently, (&& not a) <$> b\n-- main = goSep \"foo\" 2 (\\ a (b :: Vec N4 Bool) -> if a then pure False else b)\n\n-- -- Equivalently, (|| a) <$> b\n-- main = goSep \"foo\" 2 (\\ a (b :: Vec N4 Bool) -> if a then pure True else b)\n\n-- -- Equivalently, (&& not a) <$> b\n-- main = goSep \"foo\" 2 (\\ a (b :: RTree N3 Bool) -> if a then pure False else b)\n\n-- -- Equivalently, (a `xor`) <$> b\n-- main = go \"foo\" (\\ a (b :: Vec N3 Bool) -> (if a then not else id) <$> b)\n\n-- main = goSep \"foo\" 2 (\\ a (b :: RTree N2 Bool) -> (if a then reverse else id) b)\n\n-- -- Equivalent to \\ a -> (a,not a)\n-- main = go \"foo\" (\\ a -> if a then (True,False) else (False,True))\n\n-- crcStep :: (Traversable poly, Applicative poly) =>\n-- poly Bool -> poly Bool :* Bool -> poly Bool\n\n-- main = goSep \"crcStep-v1\" 1\n-- (crcStep :: Vec N1 Bool -> Vec N1 Bool :* Bool -> Vec N1 Bool)\n\n-- -- ranksep: rt2=1, rt3=2, rt4=4.5\n-- main = goSep \"crcStep-rt3\" 2 (crcStep :: RTree N3 Bool -> RTree N3 Bool :* Bool -> RTree N3 Bool)\n\n-- main = go \"crcStepK-rt2\" (crcStep (polyD :: RTree N2 Bool))\n\n-- main = goSep \"crcStepK-g5\" 1\n-- (crcStep (ra5 True False False True False))\n\n-- crc :: (Traversable poly, Applicative poly, Traversable msg) =>\n-- poly Bool -> msg Bool :* poly Bool -> poly Bool\n\n-- main = go \"crc-v3v5\" (crc :: Vec N3 Bool -> Vec N5 Bool :* Vec N3 Bool -> Vec N3 Bool)\n\n-- main = go \"crcK-v3v5\" (crc polyD :: Vec N5 Bool :* Vec N3 Bool -> Vec N3 Bool)\n\n-- main = go \"crc-v4rt3\" (crc :: Vec N4 Bool -> RTree N3 Bool :* Vec N4 Bool -> Vec N4 Bool)\n\n-- main = go \"crc-rt3rt5\" (crc :: RTree N3 Bool -> RTree N5 Bool :* RTree N3 Bool -> RTree N3 Bool)\n\n-- main = go \"crcK-rt2rt4\" (crc polyD :: RTree N4 Bool :* RTree N2 Bool -> RTree N2 Bool)\n\n-- main = go \"crcK-v5rt4\" (crc polyD :: RTree N4 Bool :* Vec N5 Bool -> Vec N5 Bool)\n\n-- main = go \"crc-encode-v3v5\" (crcEncode :: Vec N3 Bool -> Vec N5 Bool -> Vec N3 Bool)\n\n-- main = go \"crc-encode-v3rt2\" (crcEncode :: Vec N3 Bool -> RTree N2 Bool -> Vec N3 Bool)\n\n-- main = go \"crc-encode-rt2rt4\" (crcEncode :: RTree N2 Bool -> RTree N4 Bool -> RTree N2 Bool)\n\n-- Simple carry-propagate adder\n\n-- main = go \"halfAdd\" halfAdd\n\n-- main = go \"add1\" add1\n\n-- main = go \"add1-0\" (carryIn False add1)\n\n-- main = go \"add1p\" add1'\n\n-- main = go \"adder-state-v3\" (adderState :: Adder' (Vec N3))\n\n-- main = go \"adder-state-rt2\" (adderState :: Adder' (RTree N2))\n\n-- main = go \"adder-state-0-v1\" (carryIn False adderState :: Adder (Vec N1))\n\n-- main = go \"adder-state-0-rt0\" (carryIn False adderState :: Adder (RTree N0))\n\n-- -- GHC panic: \"tcTyVarDetails b{tv ah8Z} [tv]\"\n-- main = go \"adder-state-trie-v2\" (adderStateTrie :: Adder' (Vec N2))\n\n-- main = go \"adder-accuml-v8\" (adderAccumL :: Adder' (Vec N8))\n\n-- main = go \"adder-accuml-rt5\" (adderAccumL :: Adder' (RTree N5))\n\n-- Monoidal scan adders\n\n-- main = go \"gpCarry\" gpCarry\n\n-- main = go \"mappend-gpr\" (mappend :: Binop GenProp)\n\nifF :: Bool -> Binop a\nifF c a b = if c then a else b\n\n-- main = go \"if-gpr\" (ifF :: Bool -> Binop GenProp)\n\n-- main = go \"gprs-pair\" (fmap genProp :: Pair (Pair Bool) -> Pair GenProp)\n\n-- main = go \"scan-gpr-pair\" (scanGPs :: Pair (Pair Bool) -> Pair GenProp :* GenProp)\n\n-- main = go \"adder-scan-pair\" (scanAdd :: Adder Pair)\n\n-- main = go \"adder-scanp-pair\" (scanAdd' :: Adder' Pair)\n\n-- main = go \"adder-scanpp-pair\" (scanAdd'' :: Adder Pair)\n\n-- -- Ranksep: rt1=0.5, rt2=0.5, rt3=0.75, rt4=1.5,rt5=2\n-- main = goSep \"adder-scan-noinline-rt2\" 0.5 (scanAdd :: Adder (RTree N2))\n\n-- -- Ranksep: rt1=0.5, rt2=0.5, rt3=0.75, rt4=1.5,rt5=2\n-- main = goSep \"adder-scan-rt5\" 2 (scanAdd :: Adder (RTree N5))\n\n-- -- Ranksep: rt2=0.5, rt3=0.75, rt4=1.5,rt5=2\n-- main = goSep \"adder-scan-unopt-rt0\" 0.5 (scanAdd :: Adder (RTree N0))\n\n-- -- Ranksep: rt2=0.5, rt3=1, rt4=2, rt5=3\n-- main = goSep \"adder-scanp-rt3\" 1 (scanAdd' :: Adder' (RTree N3))\n\n-- -- Ranksep: rt2=0.5, rt3=0.75, rt4=1.5,rt5=2\n-- main = goSep \"adder-scanpp-rt1\" 0.5 (scanAdd'' :: Adder (RTree N1))\n\n-- main = go \"foo\" (\\ ((gx,px),(gy,py)) -> (gx || gy && px, px && py))\n\n-- main = go \"case-just\" (\\ case Just b -> not b\n-- Nothing -> True)\n\n-- -- Demos automatic commutation\n-- main = go \"foo\" (\\ (b,a) -> a || b)\n\n-- main = go \"or-with-swap\" (\\ (a,b) -> (a || b, b || a))\n\n-- -- not (a && b)\n-- main = go \"foo\" (\\ b a -> not a || not b)\n\n-- main = go \"foo\" (\\ (a::Int,x::Bool) -> if x then (square a,True) else (bottom,False))\n\n-- main = go \"foo\" (\\ x -> if x then True else bottom)\n\n-- main = go \"foo\" (bottom :: Bool)\n\n-- main = go \"foo\" (bottom::Int,False)\n\n-- main = go \"foo\" (bottom::Bool, bottom::Int, bottom::Bool)\n\n-- main = go \"foo\" (\\ x -> if x then bottom else bottom :: Bool)\n\n-- main = goSep \"if-maybe\" 0.75 (\\ a (b :: Maybe Bool) c -> if a then b else c)\n\n-- main = go \"fmap-maybe-square\" (fmap square :: Unop (Maybe Int))\n\n-- main = go \"fmap-maybe-not\" (fmap not :: Unop (Maybe Bool))\n\n-- main = go \"foo\" (\\ a b -> if b then (not a,True) else (bottom,False))\n\n-- main = go \"fromMaybe-bool\" (fromMaybe :: Bool -> Maybe Bool -> Bool)\n\n-- main = goSep \"fromMaybe-v3\" 1.5 (fromMaybe :: Vec N3 Bool -> Maybe (Vec N3 Bool) -> Vec N3 Bool)\n\n-- main = goSep \"liftA2-maybe\" 0.8 (liftA2 (*) :: Binop (Maybe Int))\n\n-- main = goSep \"liftA3-maybe\" 0.8 (liftA3 f :: Ternop (Maybe Int))\n-- where\n-- f x y z = x * (y + z)\n\n-- main = goSep \"liftA4-maybe\" 0.8 (\\ (a,b,c,d) -> liftA4 f a b c d :: Maybe Int)\n-- where\n-- f w x y z = (w + x) * (y + z)\n\n-- main = go \"lift-maybe-1-1a\" h\n-- where\n-- h a = pure square <*> a :: Maybe Int\n\n-- main = go \"lift-maybe-1-1b\" h\n-- where\n-- h a = liftA2 (*) a a :: Maybe Int\n\n-- main = go \"lift-maybe-1-1c-no-idem\" h\n-- where\n-- h a = fmap square b :: Maybe Int\n-- where\n-- b = liftA2 (+) a a\n\n-- main = go \"lift-maybe-1-2\" h\n-- where\n-- h a = liftA2 (*) a b :: Maybe Int\n-- where\n-- b = liftA2 (+) a a\n\n-- main = goSep \"lift-maybe-1-3\" 1 h\n-- where\n-- h a = liftA3 f a b c :: Maybe Int\n-- where\n-- b = liftA2 (*) a a\n-- c = liftA2 (+) b a\n-- f w x y = (w + x) * y\n\n-- main = goSep \"lift-maybe-1-4\" 0.8 h\n-- where\n-- h a = liftA4 f a b c d :: Maybe Int\n-- where\n-- b = liftA2 (*) a a\n-- c = liftA2 (+) b a\n-- d = liftA2 (*) c b\n-- f w x y z = (w + x) * (y + z)\n\n-- main = go \"liftA2-justs\" (\\ (a,b) -> liftA2 (*) (Just a) (Just b) :: Maybe Int)\n\n-- Sums\n\n-- main = go \"fmap-either-square\" (fmap square :: Unop (Either Bool Int))\n\n-- main = go \"case-of-either\" \n-- (\\ case Left x -> if x then 3 else 5 :: Int\n-- Right n -> n + 3)\n\n-- -- ranksep 1.5 when unoptimized.\n-- main = goSep \"if-to-either\" 1.5 \n-- (\\ a -> if a then Left 2 else Right (3,5) :: Either Int (Int,Int))\n\n-- main = goSep \"case-if-either\" 1\n-- (\\ a -> let e :: Either Int (Int,Int)\n-- e = if a then Left 2 else Right (3,5)\n-- in\n-- case e of\n-- Left n -> n + 5\n-- Right (p,q) -> p * q )\n\n-- main = goSep \"case-if-either-2\" 1\n-- (\\ (a,b,c,d) -> let e :: Either Int (Int,Int)\n-- e = if a then Left b else Right (c,d)\n-- in\n-- case e of\n-- Left n -> n + 5\n-- Right (p,q) -> p * q )\n\n-- main = goSep \"case-if-either-3\" 1\n-- (\\ (a,b,c) -> let e :: Either Int (Int -> Int)\n-- e = if a then Left b else Right (b *)\n-- in\n-- case e of\n-- Left n -> n + c\n-- Right f -> f c )\n\n-- -- The conditionals vanish\n-- main = goSep \"case-if-either-3b\" 0.7\n-- (\\ (a,b,c) -> let e :: Either Int (Int -> Int)\n-- e = if a then Left b else Right (b +)\n-- in\n-- case e of\n-- Left n -> n + c\n-- Right f -> f c )\n\n-- main = go \"foo\" (\\ (a::Int,old) -> dup (old+a))\n\n-- main = goM \"foo\" (Mealy (\\ (a::Int,old) -> dup (old+a)) 0)\n\n-- main = goM \"mealy-sum-0\" (Mealy (\\ (a::Int,old) -> dup (old+a)) 0)\n\n-- We can't yet handle examples built from the Arrow interface.\n\n-- main = goM \"mealy-sum-1\" (m :: Mealy Int Int)\n-- where\n-- m :: Mealy Int Int\n-- m = loop (arr (\\ (a,tot) -> dup (tot+a)) . second (delay 0))\n\n-- serialSum0 :: Mealy Int Int\n-- serialSum0 = Mealy (\\ (old,a) -> dup (old+a)) 0\n\n-- serialSum1 :: Mealy Int Int\n-- serialSum1 = loop (arr (\\ (a,tot) -> dup (tot+a)) . second (delay 0))\n\n-- main = goM \"mealy-counter-exclusive\" (Mealy (\\ ((),n::Int) -> (n,n+1)) 0)\n\n-- main = goM \"mealy-counter-inclusive\" (Mealy (\\ ((),n::Int) -> dup (n+1)) 0)\n\n-- main = goM \"mealy-sum-exclusive\" (Mealy (\\ (a::Int,n) -> (n,n+a)) 0)\n\n-- main = goM \"mealy-sum-inclusive\" (Mealy (\\ (a::Int,n) -> dup (n+a)) 0)\n\n-- -- Square of consecutive numbers, inclusive\n-- main = goM \"mealy-square-counter-inclusive\"\n-- (Mealy (\\ ((),n::Int) -> let n' = n+1 in (square n',n')) 0)\n\n-- -- Prefix sum of square of inputs\n-- main = goM \"mealy-square-sum-inclusive\"\n-- (Mealy (\\ (a::Int,tot) -> dup (tot + square a)) 0)\n\n-- Serial Fibonacci variants:\n\n-- main = goM \"serial-fibonacci-a\" $\n-- Mealy (\\ ((),(a,b)) -> (a,(b,a+b))) (0::Int,1)\n\n-- main = goM \"serial-fibonacci-b\" $\n-- Mealy (\\ ((),(a,b)) -> (b,(b,a+b))) (0::Int,1)\n\n-- main = goM \"serial-fibonacci-c\" $\n-- Mealy (\\ ((),(a,b)) -> let c = a+b in (c,(b,c))) (0::Int,1)\n\n-- main = goM \"serial-fibonacci-a-11\" $\n-- Mealy (\\ ((),(a,b)) -> (a,(b,a+b))) (1::Int,1)\n\n-- main = go \"foo\" (sumSquare :: RTree N2 Int -> Int)\n\n-- main = goM \"sumSP-rt3\" (Mealy (\\ (as :: RTree N3 (Sum Int),tot) -> dup (fold as <> tot)) mempty)\n\n-- main = goM \"sumSP-rt4\" (sumSP :: Mealy (RTree N4 Int) Int)\n\n-- main = goM \"foldSP-rt1\" (foldSP :: Mealy (RTree N1 (Sum Int)) (Sum Int))\n\n-- main = goM \"sumSP-rt2\" (sumSP :: Mealy (RTree N2 Int) Int)\n\n-- -- Not yet.\n-- main = goM \"dotSP-rt2p\" (dotSP :: Mealy (RTree N2 (Pair Int)) Int)\n\n-- main = goM \"dotSP-rt4p\" (Mealy (\\ (pas :: RTree N4 (Pair Int),tot) -> dup (dot'' pas + tot)) 0)\n\n-- type GS a = (GenBuses a, Show a)\n\nfullAdd :: Pair Bool :* Bool -> Bool :* Bool\nfullAdd = add1' . swap\n{-# INLINE fullAdd #-}\n\n-- main = go \"fullAdd\" (add1' . swap) -- fullAdd -- fullAdd doesn't inline\n\nadderS :: Bool -> Mealy (Pair Bool) Bool\nadderS = Mealy (add1 . swap)\n\n-- main = goM \"adderS\" (adderS False)\n\n-- main = goMSep \"sumS\" 0.5 (sumS :: Mealy Int Int)\n\n-- main = goMSep \"sumS-rt3\" 1.5 (sumS :: Mealy (RTree N3 Int) (RTree N3 Int))\n\n-- main = goMSep \"sumPS-rt1\" 0.75 (sumPS :: Mealy (RTree N1 Int) Int)\n\n-- main = goM \"dotPS-rt3p\" (m :: Mealy (RTree N3 (Pair Int)) Int)\n-- where\n-- m = Mealy (\\ (ts,tot) -> let tot' = tot + fmap product ts in (sum tot',tot')) 0\n\n-- main = goMSep \"mac-p\" 1 (mac :: Mealy (Pair Int) Int)\n\n-- main = goMSep \"mac-prt2\" 1 (mac :: Mealy (Pair (RTree N2 Int)) (RTree N2 Int))\n\n-- main = goM \"sum-mac-prt1\" (sumMac :: Mealy (Pair (RTree N1 Int)) Int)\n\nmatVecMultSA :: (Foldable f, Applicative f, Num a, GS (f a)) =>\n Mealy (f a) a\nmatVecMultSA =\n Mealy (\\ (row,s@(started,vec)) ->\n if started then (row <.> vec, s) else (0, (True,row))) (False,pure 0)\n\nmatVecMultS :: (Foldable f, Applicative f, Num a, GS (f a)) =>\n Mealy (f a) a\nmatVecMultS =\n Mealy (\\ (row,s@(started,vec)) ->\n (row <.> vec, if started then s else (True,row))) (False,pure 0)\n\n-- main = goM \"mat-vec-mult-rt1\" (matVecMultS :: Mealy (RTree N1 Int) Int)\n\n-- main = goM \"mat-vec-mult-rt1\" (m :: Mealy (RTree N1 Int) Int)\n-- where\n-- m = Mealy (\\ (row,mbVec) -> case mbVec of\n-- Nothing -> (0,Just row)\n-- Just v -> (row <.> v, mbVec)) Nothing\n\n-- main = goMSep \"mat-vec-mult-a-rt3\" 1 (m :: Mealy (RTree N3 Int) Int)\n-- where\n-- m = Mealy (\\ (row,s@(started,vec)) ->\n-- if started then (row <.> vec, s) else (0, (True,row))) (False,pure 0)\n\n-- -- 3:1, 4:1.5, 5:2\n-- main = goMSep \"mat-vec-mult-b-rt2\" 1 (m :: Mealy (RTree N2 Int) Int)\n-- where\n-- m = Mealy (\\ (row,s@(started,vec)) ->\n-- (row <.> vec, if started then s else (True,row))) (False,pure 0)\n\n-- -- Type error with MealyAsFun in Run\n-- -- Same result as -b\n-- main = goMSep \"mat-vec-mult-c-rt2\" 1 (m :: Mealy (RTree N2 Int) Int)\n-- where\n-- m = Mealy (\\ (row,s@(started,vec)) ->\n-- (row <.> vec, if started then s else (not started,row))) (False,pure 0)\n\n-- main = goSep \"get-p\" 1 (P.get :: Bool -> Pair Int -> Int)\n\ntype Bits n = Vec n Bool\n\n-- -- 3:1, 4:2, 5:3\n-- main = goSep \"get-rt5\" 3 (RT.get :: Bits N5 -> RTree N5 Int -> Int)\n\n-- -- 3:1, 4:2, 5:3\n-- main = goSep \"get-ib-rt3\" 1 (RT.get :: Bits N3 -> RTree N3 (Int,Bool) -> (Int,Bool))\n\n-- -- 3:1, 4:2, 5:3\n-- main = goSep \"get-lt4\" 2 (LT.get :: Bits N4 -> LTree N4 Int -> Int)\n\n-- main = go \"update-p\" (flip P.update (+2) :: Bool -> Pair Int -> Pair Int)\n\n-- main = go \"update-plus2-p\" (\\ (b,p::Pair Int) -> P.update b (+2) p)\n\n-- main = go \"update-not-p\" (\\ (b,p) -> P.update b not p)\n\n-- -- 1:0.75, 2:1.5, 3:3, 4:8\n-- main = goSep \"update-plus2-rt1\" 0.75 (\\ (v,t::RTree N1 Int) -> RT.update v (+2) t)\n\n-- -- 2:1.5, 3:3, 4:4\n-- main = goSep \"update-not-rt2\" 1.5 (\\ (v,t::RTree N2 Bool) -> RT.update v not t)\n\nhistogramStep :: Num a => RTree n a -> Bits n -> RTree n a\nhistogramStep t v = RT.update v (+1) t\n\n-- -- 1:2, 2:2, 3:2\n-- main = goSep \"histogramStep-3\" 2 (histogramStep :: RTree N3 Int -> Bits N3 -> RTree N3 Int)\n\n-- Combinational histogram\nhistogramP :: (Foldable f, IsNat n) => f (Bits n) -> RTree n Int\nhistogramP = foldl histogramStep (pure 0)\n-- histogramP = foldl (\\ t v -> RT.update v (+1) t) (pure 0)\n\n-- -- 2-3:1, 3-4:?\n-- main = goSep \"histogramP-2-rt3\" 1 (histogramP :: RTree N3 (Bits N2) -> RTree N2 Int)\n\noneTree :: (IsNat n, Num a) => Bits n -> RTree n a\noneTree = histogramStep (pure 0)\n\n-- -- 1:0.5, 2:0.75, 3:1.5\n-- main = goSep \"one-c-rt1\" 0.5 (oneTree :: Bits N1 -> RTree N1 Int)\n\noneTree' :: IsNat n => Bits n -> RTree n Bool\noneTree' v = RT.update v (const True) (pure False)\n\n-- -- 1:0.75, 2:1.5, 3:2\n-- main = goSep \"onep-rt3\" 2 (oneTree' :: Bits N3 -> RTree N3 Bool)\n\noneTree'' :: IsNat n => Bits n -> RTree n Int\noneTree'' v = boolToInt <$> oneTree' v\n\n-- -- 1:0.5, 2:0.75, 3:1.5\n-- main = goSep \"onepp-rt3\" 1.5 (oneTree'' :: Bits N3 -> RTree N3 Int)\n\n-- As I hoped, oneTree'' gives identical results to oneTree.\n\nhistogramFold :: (Foldable f, Functor f, IsNat n) => f (Bits n) -> RTree n Int\nhistogramFold = sum . fmap oneTree\n\n-- main = goSep \"histogramFold-1-v5\" 1 (histogramFold :: Vec N5 (Bits N1) -> RTree N1 Int)\n\n-- -- 1,2:0.75; 2,3:1.5\n-- main = goSep \"histogramFold-1-rt2\" 0.75 (histogramFold :: RTree N2 (Bits N1) -> RTree N1 Int)\n\nhistogramFold'' :: (Foldable f, Functor f, IsNat n) => f (Bits n) -> RTree n Int\nhistogramFold'' = sum . fmap oneTree''\n\n-- -- 1,2:1, 2,3:1.5\n-- main = goSep \"histogramFoldpp-1-rt2\" 0.5 (histogramFold'' :: RTree N2 (Bits N1) -> RTree N1 Int)\n\n-- Serial histogram\nhistogramS :: (IsNat n, GS (RTree n Int)) => Mealy (Bits n) (RTree n Int)\nhistogramS = scanl histogramStep (pure 0)\n-- histogramS = scanl (\\ t v -> RT.update v (+1) t) (pure 0)\n\n-- -- 1:0.5, 2:1, 3:3\n-- main = goMSep \"histogramS-1\" 0.75 (histogramS :: Mealy (Bits N1) (RTree N1 Int))\n\n-- main = go \"pure-sum-rt3\" (\\ a -> sum (pure a :: RTree N3 Int))\n\n-- main = go \"pure-1-sum-rt3\" (sum (pure 1 :: RTree N3 Int))\n\n-- main = go \"foo\" True\n\n-- Step via oneTree''\nhistogramStepO :: IsNat n => RTree n Int -> Bits n -> RTree n Int\nhistogramStepO t v = t + oneTree'' v\n\n-- -- 1:0.5;2:0.75;3:1\n-- main = goSep \"histogramStepO-3\" 1 (histogramStepO :: RTree N3 Int -> Bits N3 -> RTree N3 Int)\n\n-- Serial histogram\nhistogramSO :: (IsNat n, GS (RTree n Int)) => Mealy (Bits n) (RTree n Int)\nhistogramSO = scanl histogramStepO (pure 0)\n\n-- -- 1:0.5, 2:0.75, 3:1\n-- main = goMSep \"histogramSO-2\" 0.5 (histogramSO :: Mealy (Bits N2) (RTree N2 Int))\n\n-- More CRC\n\n-- crcS :: (GS (poly Bool), Applicative poly, Traversable poly) =>\n-- Mealy Bool (poly Bool, Int)\n\n-- main = goM \"crcS-rt0\" (crcS :: Mealy Bool (RTree N0 Bool, Int))\n\n-- main = goM \"adderS\" (adderS False)\n\n-- main = goM \"mealy-counter-exclusive\" (Mealy (\\ ((),n::Int) -> (n,n+1)) 0)\n\n-- main = go \"sumSquare-rt2\" (sumSquare :: RTree N2 Int -> Int)\n\n-- main = goMSep \"sumPS-rt4\" 1 (m :: Mealy (RTree N4 Int) Int)\n-- where\n-- m = Mealy (\\ (t,tot) -> let tot' = tot+t in (sum tot',tot')) 0\n\n-- Explicit delay and loop\n\n-- main = goNew \"delay-false\" (delay False)\n\n-- main = goNew \"delay-01\" (delay (0::Int,1::Int))\n\n-- main = goNew \"foo\" (loop (\\ (a::Int,s::Bool) -> (a,s)))\n\n-- -- <\n-- main = goNew \"foo\" (loop (\\ ((),n::Int) -> dup (n+1)))\n\n-- main = goNew \"foo\" (loop ((\\ ((),(a,b)) -> (a,(b,a+b))) . second (delay (0::Int,1))))\n\n-- main = goNew \"fibS\" fibS\n-- where\n-- fibS :: () -> Int\n-- fibS = loop ((\\ ((),(a,b)) -> (a,(b,a+b))) . second (delay (0,1)))\n\n-- main = goNew \"foo\" (loop (\\ ((),((),())) -> ((),((),()))))\n\n-- fibS :: Num a => () -> a\n-- fibS = loop ((\\ ((),(a,b)) -> (a,(b,a+b))) . second (delay (0,1)))\n\n-- main = goNew \"foo\" (Mealy.asFun (Mealy (\\ ((),(a,b)) -> (a,(b,a+b))) (0::Int,1)))\n\nfibM :: MStream Int\nfibM = Mealy (\\ ((),(a,b)) -> (a,(b,a+b))) (0::Int,1)\n\n-- main = goM \"foo\" fibM\n\n-- main = goNew \"foo\" (asFun fibM)\n\n-- main = goM \"foo\" fibM\n\n-- main = goM \"fib-iteratep\" (fst <$> iterateU' (\\ (a,b) -> (b,a+b)) (0::Int,1))\n\n-- main = go \"comparisons\"\n-- (\\ (x::Int,y::Int) -> (x==y || x/=y) && (x=y) && (x>y || x<=y))\n\n-- main = go \"loop-id\" (loop (\\ (a::Bool,b::Int) -> (a,b)))\n\n-- main = go \"loop-const\" (loop (\\ (a::Bool,_b::Int) -> (a,3)))\n\n-- main = go \"loop-free-state-a\" (loop (\\ (a::Int,b::Int) -> (b > a,3)))\n\n-- main = go \"loop-free-state-b\" (loop (\\ (a::Int,b::Int) -> (b > a,a)))\n\n-- -- \"<\"\n-- main = go \"loop-oops-a\" (loop (\\ (a::Int,b::Int) -> (b > a,b+1)))\n\n-- main = goM \"foo\" (Mealy swap 0 :: Mealy (RTree N3 Int) (RTree N3 Int))\n\n-- Like 'shiftR' but drop the value pushed out the left, and uncurry.\nshiftR' :: Traversable t => t a -> a -> t a\nshiftR' = curry (snd . shiftR)\n-- shiftR' as a = snd (shiftR (as,a))\n\n-- Serial\ncrcS' :: forall poly. (GS (poly Bool), Applicative poly, Traversable poly) =>\n Mealy Bool (poly Bool)\ncrcS' = Mealy h (pure False, pure False,0)\n where\n p = sizeA (undefined :: poly ())\n h :: MealyFun (poly Bool, poly Bool, Int) Bool (poly Bool)\n h (b,(poly,seg,i)) = (stepped,(poly',seg',i'))\n where\n stash q = shiftR' q b\n starting = i < 2*p\n i' = if starting then i+1 else i\n stepped = crcStep poly (seg,b)\n (poly',seg')\n | i < p = (stash poly,seg)\n | starting = (poly,stash seg)\n | otherwise = (poly,stepped)\n\n-- Can I use step instead of stash for seg?\n\n-- main = goM \"crcS-rt1\" (crcS :: Mealy Bool (RTree N1 Bool))\n\n-- main = goM \"crcSK-v1\" (crcSK poly :: Mealy Bool (Vec N1 Bool))\n-- where\n-- poly = vec1 True\n\n-- Serial with static polynomial\ncrcSKa :: forall poly. (GS (poly Bool), Applicative poly, Traversable poly) =>\n poly Bool -> Mealy Bool (poly Bool)\ncrcSKa poly = fst <$> scanl h (pure False,0)\n where\n p = sizeA (undefined :: poly ())\n h (seg,i) b | i < p = (shiftR' seg b, i+1)\n | otherwise = (crcStep poly (seg,b), i)\n\n-- main = goM \"crcSKa-v1\" (crcSKa polyD :: Mealy Bool (Vec N1 Bool))\n\n-- main = goM \"crcSKa-rt0\" (crcSKa polyD :: Mealy Bool (RTree N0 Bool))\n\n-- main = go \"foo\" (fmap not :: Unop (RTree N2 Bool))\n\nshiftLS :: (Traversable f, GS (f a)) => f a -> Mealy a a\nshiftLS = Mealy (swap . shiftL)\n\nshiftRS :: (Traversable f, GS (f a)) => f a -> Mealy a a\nshiftRS = Mealy (shiftR . swap)\n\n-- Types:\n-- \n-- shiftL :: (a, f a) -> (f a, a)\n-- swap . shiftL :: (a, f a) -> (a, f a)\n-- \n-- shiftR :: (f a, a) -> (a, f a)\n-- shiftR . swap :: (a, f a) -> (a, f a)\n\n-- main = goM \"shiftL-v3\" (shiftLS (pure False :: Vec N3 Bool))\n\n-- main = goM \"shiftR-v3\" (shiftRS (pure False :: Vec N3 Bool))\n\n-- main = goM \"shiftL-iota-v3\" (shiftLS (V.iota :: Vec N3 Int))\n\n-- main = goM \"shiftR-iota-v3\" (shiftRS (V.iota :: Vec N3 Int))\n\n-- main = goM \"shiftL-iota-rt2\" (shiftLS (iota :: RTree N2 Int))\n\n-- main = goM \"shiftRS-rt3\" (shiftRS (pure False :: RTree N3 Bool))\n\n-- main = goM \"shiftR-ib-v3\" (shiftRS (pure (0,False) :: Vec N3 (Int,Bool)))\n\n-- To simplify the circuit, output stepped even when i\n poly Bool -> Mealy Bool (poly Bool)\ncrcSKb poly = Mealy h (pure False,0)\n where\n p = sizeA (undefined :: poly ())\n h (b,(seg,i)) = (stepped,next)\n where\n stepped = crcStep poly (seg,b)\n next | i < p = (shiftR' seg b, i+1)\n | otherwise = (stepped, i)\n\n-- main = goM \"crcSKb-rt2\" (crcSKb polyD :: Mealy Bool (RTree N2 Bool))\n\n-- In this version, advance i even when i>=p, to shorten critical path.\n-- WARNING: don't use for messages of length >= 2^32.\ncrcSKc :: forall poly. (GS (poly Bool), Applicative poly, Traversable poly) =>\n poly Bool -> Mealy Bool (poly Bool)\ncrcSKc poly = Mealy h (pure False,0)\n where\n p = sizeA (undefined :: poly ())\n h (b,(seg,i)) = (stepped,(seg',i+1))\n where\n stepped = crcStep poly (seg,b)\n seg' | i < p = shiftR' seg b\n | otherwise = stepped\n\n-- main = goM \"crcSKc-rt0\" (crcSKc polyD :: Mealy Bool (RTree N0 Bool))\n\ncrcSKd :: forall poly. (GS (poly Bool), Applicative poly, Traversable poly) =>\n poly Bool -> Mealy Bool (poly Bool)\ncrcSKd poly = Mealy h (pure False)\n where\n h (b,seg) = dup stepped\n where\n stepped = crcStep poly (seg,b)\n\n-- Rewrite via Mealy scanl\n\ncrcSKe :: forall poly. (GS (poly Bool), Applicative poly, Traversable poly) =>\n poly Bool -> Mealy Bool (poly Bool)\ncrcSKe poly = scanl (curry (crcStep poly)) (pure False)\n\n-- main = goM \"crcSKe-rt4\" (crcSKe polyD :: Mealy Bool (RTree N4 Bool))\n\n-- Local curried version of crcStep\n\ncrcSKf :: forall poly. (GS (poly Bool), Applicative poly, Traversable poly) =>\n poly Bool -> Mealy Bool (poly Bool)\ncrcSKf poly = scanl step (pure False)\n where\n step seg b0 = if b0' then liftA2 xor poly seg' else seg'\n where\n (b0',seg') = shiftR (seg,b0)\n\n-- main = goM \"crcSKf-rt2\" (crcSKf polyD :: Mealy Bool (RTree N2 Bool))\n\nboolToChar :: Bool -> Char\nboolToChar False = '0'\nboolToChar True = '1'\n\nwriteFile' :: FilePath -> String -> IO ()\nwriteFile' fname str = writeFile fname str >> putStrLn (\"Wrote \" ++ fname)\n\ncrcFileName :: String -> Int -> Int -> String\ncrcFileName = printf \"../test/out/crc-bits-%s-%d-%d.txt\"\n\ngenCrcIn :: Nat d -> Int -> IO ()\ngenCrcIn nd n =\n do ins <- ( ++ replicate d False) <$>\n generate (vectorOf (n - d) (arbitrary :: Gen Bool))\n writeFile' (crcFileName \"ina\" d n) (show ins)\n writeFile' (crcFileName \"inb\" d n) (unlines $ (pure . boolToChar) <$> ins)\n where\n d = natToZ nd\n\ngenCrcOut :: forall d. (IsNat d, GenBuses (RTree d Bool), PolyD (RTree d)) =>\n Nat d -> Int -> IO ()\ngenCrcOut nd n =\n do ins <- read <$> readFile (crcFileName \"ina\" d n)\n let outs = reverse <$> runMealy (crcSKf (polyD :: RTree d Bool)) ins\n writeFile' (crcFileName \"outa-f\" d n) (show outs)\n writeFile' (crcFileName \"outb-f\" d n)\n (unlines $ (map boolToChar . toList) <$> outs)\n where\n d = natToZ nd\n\n-- main = genCrcIn d n\n-- where\n-- d = nat :: Nat N5\n-- n = 4096\n\n-- main = genCrcOut d n\n-- where\n-- d = nat :: Nat N5\n-- n = 4096\n\n-- main = goM \"foo\" (foo :: MStream (RTree N0 Bool))\n\n-- Sequential-of-parallel\ncrcSPK :: (GS (poly Bool), Applicative poly, Traversable poly, Foldable chunk) =>\n poly Bool -> Mealy (chunk Bool) (poly Bool)\ncrcSPK poly = scanl (foldl step) (pure False)\n where\n step seg b0 = if b0' then liftA2 xor poly seg' else seg'\n where\n (b0',seg') = shiftR (seg,b0)\n\n-- main = goM \"crcSPK-rt3-rt2\" (crcSPK polyD :: Mealy (RTree N3 Bool) (RTree N2 Bool))\n\ncrcP :: (Applicative poly, Traversable poly, Foldable msg) =>\n poly Bool -> msg Bool -> poly Bool\ncrcP poly = foldl step (pure False)\n where\n step seg b0 = if b0' then liftA2 xor poly seg' else seg'\n where\n (b0',seg') = shiftR (seg,b0)\n\n-- -- 1,2: 0.5; 2,2: 0.75; 3,2: 1;\n-- main = goSep \"crcPK-rt3-rt2\" 1 (crcP polyD :: RTree N3 Bool -> RTree N2 Bool)\n\nmatMatMultS :: (GS (f a), Foldable f, Applicative f, Num a) => Mealy (Bool, f a) a\nmatMatMultS = Mealy h (pure 0)\n where\n h ((new,w),row) = (row <.> w, if new then w else row)\n\n-- -- 2:0.75; 3:1.0; 4:1.5, 5:2.5\n-- main = goMSep \"matMatMultS-rt4\" 1.5 (matMatMultS :: Mealy (Bool, RTree N4 Int) Int)\n\n-- main = go \"foo\" (\\ (a,b::Int,c::Int) -> if not a then b else c)\n\nrevRT :: (IsNat n, Ord a) => Unop (RT.Tree n a)\nrevRT = RT.butterfly reverse\n\n-- -- Butterfly swap, i.e., reversal\n-- -- 1:0.5,2:1,3:2\n-- main = goSep \"butterfly-swap-rt2\" 1 (revRT :: Unop (RTree N2 Bool))\n\n-- main = goSep \"sortP\" 0.75 (sortP :: Unop (Pair Int))\n\n-- -- 2,3,4:0.75\n-- main = goSep \"bitonic-3\" 0.75 (bsort :: Unop (RTree N3 Int))\n\n-- mapAccumL :: Traversable t => (a -> b -> (a, c)) -> a -> t b -> (a, t c)\n\niotaT :: (Traversable t, Applicative t, Num a) => t a\niotaT = snd (mapAccumL (\\ n () -> dup (n+1)) 0 (pure ()))\n\niotaT4 :: RTree N4 Int\niotaT4 = iotaT\n\n-- main = go \"foo\" (True,3 :: Int)\n\n-- main = go \"foo\" (True,iotaT :: RTree N1 Int)\n\n-- -- Evokes unboxed Int, which the reifier can't handle.\n-- main = go \"foo\" (min 3 :: Int -> Int)\n\n-- main = go \"foo\" (||)\n\n-- main = go \"foo\" (\\ a b c -> a || b && c)\n\n-- main = goM \"foo\" (scanl (\\ b () -> not b) True)\n\n-- main = goM \"foo\" (scanl (\\ (a,b) () -> (b,a)) (True,False))\n\n-- main = goM \"iterate-not\" (iterateU not False)\n\n-- main = goM \"foo\" (iterateU swap (True,False))\n\n-- main = goM \"foo\" (snd <$> iterateU swap (True,False))\n\n-- Recursive.\n-- main = goM \"foo\" (iterateU rotateR iotaT4)\n-- main = goM \"foo\" (iterateU rotateR (vec1 True))\n-- main = go \"foo\" (rotateR :: Unop (Vec N1 Bool))\n\n-- main = goM \"sumS\" (sumS :: Mealy Int Int)\n\n-- main = goM \"double-sumS\" (double (sumS :: Mealy Int Int))\n\n-- main = goM \"double-2-sumS\" (double (double (sumS :: Mealy Int Int)))\n\n-- main = goM \"countS\" (iterateU (+1) (0 :: Int))\n\n-- main = go \"foo\" (RS.oneTree :: Bits N2 -> RTree N2 Int)\n\n-- -- 1,2:0.75; 2,3:1.5; 1,4:0.75\n-- main = goSep \"histogramFold-1-4\" 1.5 (RS.histogramFold :: RTree N4 (Bits N1) -> RTree N1 Int)\n\n-- -- 1,2:0.75; 2,3:1.5; 1,4:1.5\n-- main = goSep \"histogramScan-1-4\" 1.5 (RS.histogramScan :: RTree N4 (Bits N1) -> (RTree N4 (RTree N1 Int), RTree N1 Int))\n\n-- -- 1,2:0.5; 2,3:2; 1,4:1.5\n-- main = goSep \"countSortPermutation-1-4\" 1.5 (RS.positions :: RTree N4 (Bits N1) -> RTree N4 Int)\n\n-- -- 1,2:0.5; 2,3:2; 1,4:1.5\n-- main = goSep \"countSortPermutationp-1-2\" 0.5 (RS.positions :: RTree N2 (Bits N1) -> RTree N2 Int)\n\n\n{--------------------------------------------------------------------\n Polynomial evaluation\n--------------------------------------------------------------------}\n\npowers :: (LScan f, Applicative f, Num a) => a -> f a\npowers = fst . lproducts . pure\n\n-- -- 1,2:0.5,3:1; 4:1.5; 5:2;\n-- main = goSep \"powers-rt4\" 1.5 (powers :: Int -> RTree N4 Int)\n\n-- -- 1,2:0.5,3:1; 4:1.5; 5:2;\n-- main = goSep \"powers-lt4\" 1.5 (powers :: Int -> LTree N4 Int)\n\n-- -- 2:1; 3:1.5; 4:2; 5:2.5\n-- main = goSep \"foo-rt3\" (3/2) (fst . lproducts :: Unop (RTree N3 Int))\n\n-- -- 2:1; 3:1.5; 4:2; 5:2.5\n-- main = goSep \"foo-lt3\" (3/2) (fst . lproducts :: Unop (LTree N3 Int))\n\n-- -- 2:1; 3:1.5; 4:2; 5:2.5\n-- main = goSep \"bar-rt3\" (3/2) (fst . lproducts . pure :: Int -> RTree N3 Int)\n\n-- -- 2:1; 3:1.5; 4:2; 5:2.5\n-- main = goSep \"bar-lt3\" (3/2) (fst . lproducts . pure :: Int -> LTree N3 Int)\n\n\nevalPoly :: (LScan f, Applicative f, Foldable f, Num a) => f a -> a -> a\nevalPoly coeffs x = coeffs <.> powers x\n\n-- -- -- 1,2:0.5,3:1; 4:2; 5:3;\n-- main = goSep \"evalPoly-rt4\" 2 (evalPoly :: RTree N4 Int -> Int -> Int)\n\n-- -- 1,2:0.5,3:1; 4:2; 5:3;\n\n-- main = goSep \"evalPoly-lt5\" 3 (evalPoly :: LTree N5 Int -> Int -> Int)\n\n-- Linear versions for comparison\n\n#if 0\nop :: b -> a -> b\ne :: b\nmapAccumL :: Traversable t => (b -> a -> (b, c)) -> b -> t a -> (b, t c)\n(fmap.fmap) dup op :: b -> a -> (b,b)\nmapAccumL ((fmap.fmap) dup op) e :: t a -> (b, t b)\nswap . mapAccumL ((fmap.fmap) dup op) e :: t a -> (b, t b)\n#endif\n\nlproductsl :: (Traversable f, Num a) => f a -> (f a, a)\nlproductsl = scanlT (*) 1\n\npowersl :: (Traversable f, Applicative f, Num a) => a -> f a\npowersl = fst . lproductsl . pure\n\n-- main = go \"powersl-rt3\" (powersl :: Int -> RTree N3 Int)\n\nevalPolyl :: (Traversable f, Applicative f, Foldable f, Num a) => f a -> a -> a\nevalPolyl coeffs x = coeffs <.> powersl x\n\n-- To do: switch `evalPolyl` to use a linear dot product, and retry.\n\n-- main = go \"evalPolyl-rt3\" (evalPolyl :: RTree N3 Int -> Int -> Int)\n\n-- Infix binary dot product, foldl version\ninfixl 7 `dotL`\ndotL :: (Foldable f, Applicative f, Num a) => f a -> f a -> a\nu `dotL` v = foldl (+) 0 (liftA2 (*) u v)\n\n-- Infix binary dot product, foldr version\ninfixl 7 `dotR`\ndotR :: (Foldable f, Applicative f, Num a) => f a -> f a -> a\nu `dotR` v = foldr (+) 0 (liftA2 (*) u v)\n\n-- main = go \"dotl-rt3\" (dotL :: RTree N3 Int -> RTree N3 Int -> Int)\n\n-- main = go \"dotr-rt3\" (dotR :: RTree N3 Int -> RTree N3 Int -> Int)\n\nevalPolyAddL :: (Traversable f, Applicative f, Foldable f, Num a) => f a -> a -> a\nevalPolyAddL coeffs x = coeffs `dotL` powersl x\n\n-- main = go \"evalPolyAddL-rt3\" (evalPolyAddL :: RTree N3 Int -> Int -> Int)\n\n-- Serial version\n\n-- First argument is a dummy, to allow inferring f.\n-- Ignore the first p outputs, while the polynomial is loading.\nevalPolyS :: forall f a. (GS (f a), LScan f, Traversable f, Applicative f, Num a) =>\n f () -> Mealy a a\nevalPolyS _ = Mealy h (pure 0 :: f a,0)\n where\n p = sizeA (undefined :: f ())\n h (a,(poly,i)) = (evalPoly poly a,(poly',i+1))\n where\n poly' | i < p = shiftR' poly a\n | otherwise = poly\n\n-- main = goM \"evalPolyS-rt5\" (evalPolyS (undefined :: RTree N5 ()) :: Mealy Int Int)\n\n-- Linear version\nevalPolyAddLS :: forall f a. (GS (f a), LScan f, Traversable f, Applicative f, Num a) =>\n f () -> Mealy a a\nevalPolyAddLS _ = Mealy h (pure 0 :: f a,0)\n where\n p = sizeA (undefined :: f ())\n h (a,(poly,i)) = (evalPolyAddL poly a,(poly',i+1))\n where\n poly' | i < p = shiftR' poly a\n | otherwise = poly\n\n-- main = goM \"evalPolyAddLS-rt3\" (evalPolyAddLS (undefined :: RTree N3 ()) :: Mealy Int Int)\n\nevalPolyAddR :: (Traversable f, Applicative f, Foldable f, Num a) => f a -> a -> a\nevalPolyAddR coeffs x = coeffs `dotR` powersl x\n\n-- main = go \"evalPolyAddR-rt3\" (evalPolyAddR :: RTree N3 Int -> Int -> Int)\n\n-- Linear version\nevalPolyAddRS :: forall f a. (GS (f a), LScan f, Traversable f, Applicative f, Num a) =>\n f () -> Mealy a a\nevalPolyAddRS _ = Mealy h (pure 0 :: f a,0)\n where\n p = sizeA (undefined :: f ())\n h (a,(poly,i)) = (evalPolyAddR poly a,(poly',i+1))\n where\n poly' | i < p = shiftR' poly a\n | otherwise = poly\n\n-- main = goM \"evalPolyAddRS-rt3\" (evalPolyAddRS (undefined :: RTree N3 ()) :: Mealy Int Int)\n\n{--------------------------------------------------------------------\n Counters\n--------------------------------------------------------------------}\n\n-- main = go \"lAlls-rt2\" (lAlls :: Counter (RTree N2 Bool))\n\n-- main = goSep \"upL-rt3\" 1 (upL :: Counter (RTree N3 Bool))\n\nupL' :: (Applicative f, Traversable f) => Unop (f Bool)\nupL' = fst . upL\n\n-- main = goSep \"upLp-rt3\" 1 (upL' :: Unop (RTree N3 Bool))\n\n-- main = goSep \"upLp-2-rt2\" 1 (upL' . upL' :: Unop (RTree N2 Bool))\n\n-- main = goSep \"nax-a\" 1 (\\ (a,b) -> not a && (a `xor` b))\n\nupF' :: (Applicative f, LScan f) => Unop (f Bool)\nupF' = fst . upF\n\n-- main = goSep \"upFp-rt3\" 1 (upF' :: Unop (RTree N3 Bool))\n\n-- main = goSep \"upFp-2-rt1\" 1 (upF' . upF' :: Unop (RTree N1 Bool))\n\n-- main = goM \"upCounterL-rt3\" (upCounterL :: MStream (RTree N3 Bool))\n\n-- -- 2:1, 3:2, 4:3\n-- main = goSep \"upF-rt2\" (2-1) (upF :: Counter (RTree N2 Bool))\n\n-- main = goM \"upCounter-rt1\" (upCounter :: MStream (RTree N3 Bool))\n\n----\n\n-- main = goM \"foo\" (scanl (\\ _ () -> False) False)\n\n-- main = goM \"foo\" (iterateU (const False) False)\n\n-- main = go \"delay-False-False\" (delay False False)\n\n-- main = go \"foo\" (scanlT (&&) True :: RTree N1 Bool -> (RTree N1 Bool, Bool))\n\n-- upL bs = (liftA2 toggleIf alls bs, all')\n-- where\n-- (alls,all') = scanlT (&&) True bs\n\n-- Question: Suppose I use adders, partially applied to 1.\n-- Do I get the same circuits as with the up-counters?\n-- Yes, as shown below.\n\n-- type Adder f = f (Pair Bool) -> f Bool :* Bool\n-- type Adder' f = Bool :* f (Pair Bool) -> f Bool :* Bool\n\n-- Apply an Adder' to carry-in of 1 and a zero summand\nadder'1 :: Functor f => Adder' f -> Counter f\nadder'1 h bs = h (True, (False :#) <$> bs)\n\n-- main = goSep \"adder-state-c0-rt3\" 1 (adder'1 adderState :: Counter (RTree N3))\n\n-- -- GHC panic.\n-- main = goSep \"adder-state-trie-c0-rt3\" 1 (adder'1 adderStateTrie :: Counter (RTree N3))\n\n-- -- 2:1, 3:2, 4:3\n-- main = goSep \"scan-adder-c0-rt4\" (4-1) (adder'1 scanAdd' :: Counter (RTree N4))\n\nfoldMap' :: (Foldable t, Monoid m) => (a -> m) -> t a -> m\nfoldMap' f = foldl (\\ m a -> mappend (f a) m) mempty\n\n-- foldMap' f = foldr (mappend . f) mempty\n\n-- f :: a -> m\n-- mappend . f :: a -> m -> m\n\n-- \\ a -> mappend (f a)\n-- \\ a m -> mappend (f a) m\n\n-- \\ m -> mappend m . f\n\n\n-- foldMap' f = foldr (mappend . f) mempty\n\n-- main = go \"foo\" (\\ x y -> (x+y,x-y :: Complex Int))\n\n-- main = go \"foo\" ((-) :: Binop (Complex Int))\n-- main = go \"foo\" ((*) :: Binop (Complex Int))\n\n-- main = go \"foo\" (+ negate (5 :: Int))\n\n-- main = go \"foo\" (== (5 :: Int))\n\n-- main = go \"foo\" (> (5 :: Int))\n\n-- main = goSep \"foo\" 1.5 (\\ (x :: Int) -> ((x+3,x-3,x*3,-x),(x==3,x>3)))\n\n-- main = go \"foo\" (\\ (x :: Int) -> (x+3,x==3))\n\n-- main = go \"foo\" ((+) :: Binop Int)\n\n-- main = go \"foo\" ((>) :: Int -> Int -> Bool)\n\n-- main = go \"foo\" (\\ (x :: Int) y -> (x + negate y, y - negate x))\n\n-- main = go \"foo\" (negate . negate :: Unop Int)\n\n-- main = go \"foo\" (negate . negate . negate . negate . negate :: Unop Int)\n\n-- main = go \"foo\" (\\ x (y :: Int) -> (x + negate y, negate x + y, x - negate y, negate x - y))\n\n-- main = go \"foo\" (3.0 :: Double)\n\n-- main = go \"foo\" (\\ (x :: Double) -> x + 1)\n\n-- main = go \"foo\" (\\ (x :: Int) -> x + 1)\n\n-- main = go \"foo\" ((+) :: Binop (Complex Double))\n\n-- main = go \"foo\" ((*) :: Binop (Complex Double))\n\n-- main = go \"foo\" ((+) :: Binop Double)\n\n-- main = go \"foo\" ((+) :: Binop Int)\n\n-- main = go \"foo\" (1 :: Complex Double)\n\n-- main = go \"foo\" (fromInteger 1 :: Double)\n\n-- main = go \"foo\" (fromInteger 1 :: PrettyDouble)\n\n-- main = go \"foo\" (fromIntegral :: Int -> Double)\n\n-- phasor :: (IsNat n, RealFloat a, Enum a) => Nat n -> RTree n (Complex a)\n-- phasor n = scanlTEx (*) 1 (pure phaseDelta)\n-- where\n-- phaseDelta = cis ((-pi) / (2 ** natToZ n))\n\n-- main = go \"foo\" (phasor (nat :: Nat N1))\n\n-- main = go \"foo\" (natToZ (nat :: Nat N1) :: Int)\n", "meta": {"hexsha": "00cb8e1d4319ff2e3777d2cf2ed268ba59e65658", "size": 56428, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "test/TreeTest.hs", "max_stars_repo_name": "conal/lambda-ccc", "max_stars_repo_head_hexsha": "141a713456d447d27dbe440fa27a9372cd44dc7f", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 128, "max_stars_repo_stars_event_min_datetime": "2015-02-06T17:56:19.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-18T11:56:42.000Z", "max_issues_repo_path": "test/TreeTest.hs", "max_issues_repo_name": "conal/lambda-ccc", "max_issues_repo_head_hexsha": "141a713456d447d27dbe440fa27a9372cd44dc7f", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 5, "max_issues_repo_issues_event_min_datetime": "2015-09-17T02:13:13.000Z", "max_issues_repo_issues_event_max_datetime": "2016-05-17T22:33:19.000Z", "max_forks_repo_path": "test/TreeTest.hs", "max_forks_repo_name": "conal/lambda-ccc", "max_forks_repo_head_hexsha": "141a713456d447d27dbe440fa27a9372cd44dc7f", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 15, "max_forks_repo_forks_event_min_datetime": "2015-04-08T18:19:03.000Z", "max_forks_repo_forks_event_max_datetime": "2021-01-06T09:18:29.000Z", "avg_line_length": 32.5233429395, "max_line_length": 123, "alphanum_fraction": 0.5517473595, "num_tokens": 20471, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.6370307944803832, "lm_q2_score": 0.5312093733737563, "lm_q1q2_score": 0.3383967291557105}} {"text": "{-# LANGUAGE CPP #-}\n{-# LANGUAGE FlexibleContexts #-}\n{-# LANGUAGE FlexibleInstances #-}\n{-# LANGUAGE GeneralizedNewtypeDeriving #-}\n{-# LANGUAGE DeriveTraversable #-}\n{-# LANGUAGE MultiParamTypeClasses #-}\n{-# LANGUAGE UndecidableInstances #-}\n{-# LANGUAGE TypeFamilies #-}\n{-# LANGUAGE RankNTypes #-}\n#if defined(__GLASGOW_HASKELL__) && __GLASGOW_HASKELL__ >= 702\n{-# LANGUAGE Trustworthy #-}\n{-# LANGUAGE DeriveGeneric #-}\n#endif\n{-# LANGUAGE DeriveDataTypeable #-}\n#if defined(__GLASGOW_HASKELL__) && __GLASGOW_HASKELL__ < 708\n{-# LANGUAGE StandaloneDeriving #-}\n{-# LANGUAGE ScopedTypeVariables #-}\n#endif\n-----------------------------------------------------------------------------\n-- |\n-- License : BSD-style (see the file LICENSE)\n-- Maintainer : Edward Kmett \n-- Stability : provisional\n-- Portability : portable\n--\n-- Operations on affine spaces.\n-----------------------------------------------------------------------------\nmodule Linear.Affine where\n\nimport Control.Applicative\nimport Control.Lens\nimport Data.Complex (Complex)\nimport Data.Data\nimport Data.Distributive\nimport Data.Foldable as Foldable\nimport Data.Functor.Bind\nimport Data.Functor.Rep as Rep\nimport Data.HashMap.Lazy (HashMap)\nimport Data.Hashable\nimport Data.IntMap (IntMap)\nimport Data.Ix\nimport Data.Map (Map)\nimport Data.Vector (Vector)\nimport Foreign.Storable\n#if defined(__GLASGOW_HASKELL__) && __GLASGOW_HASKELL__ >= 702\nimport GHC.Generics (Generic)\n#endif\n#if defined(__GLASGOW_HASKELL__) && __GLASGOW_HASKELL__ >= 706\nimport GHC.Generics (Generic1)\n#endif\nimport Linear.Epsilon\nimport Linear.Metric\nimport Linear.Plucker\nimport Linear.Quaternion\nimport Linear.V\nimport Linear.V0\nimport Linear.V1\nimport Linear.V2\nimport Linear.V3\nimport Linear.V4\nimport Linear.Vector\n\n#ifdef HLINT\n{-# ANN module \"HLint: ignore Unused LANGUAGE pragma\" #-}\n#endif\n\n-- | An affine space is roughly a vector space in which we have\n-- forgotten or at least pretend to have forgotten the origin.\n--\n-- > a .+^ (b .-. a) = b@\n-- > (a .+^ u) .+^ v = a .+^ (u ^+^ v)@\n-- > (a .-. b) ^+^ v = (a .+^ v) .-. q@\nclass Additive (Diff p) => Affine p where\n type Diff p :: * -> *\n\n infixl 6 .-.\n -- | Get the difference between two points as a vector offset.\n (.-.) :: Num a => p a -> p a -> Diff p a\n\n infixl 6 .+^\n -- | Add a vector offset to a point.\n (.+^) :: Num a => p a -> Diff p a -> p a\n\n infixl 6 .-^\n -- | Subtract a vector offset from a point.\n (.-^) :: Num a => p a -> Diff p a -> p a\n p .-^ v = p .+^ negated v\n {-# INLINE (.-^) #-}\n\n-- | Compute the quadrance of the difference (the square of the distance)\nqdA :: (Affine p, Foldable (Diff p), Num a) => p a -> p a -> a\nqdA a b = Foldable.sum (fmap (join (*)) (a .-. b))\n{-# INLINE qdA #-}\n\n-- | Distance between two points in an affine space\ndistanceA :: (Floating a, Foldable (Diff p), Affine p) => p a -> p a -> a\ndistanceA a b = sqrt (qdA a b)\n{-# INLINE distanceA #-}\n\n#define ADDITIVEC(CTX,T) instance CTX => Affine T where type Diff T = T ; \\\n (.-.) = (^-^) ; {-# INLINE (.-.) #-} ; (.+^) = (^+^) ; {-# INLINE (.+^) #-} ; \\\n (.-^) = (^-^) ; {-# INLINE (.-^) #-}\n#define ADDITIVE(T) ADDITIVEC((), T)\n\nADDITIVE([])\nADDITIVE(Complex)\nADDITIVE(ZipList)\nADDITIVE(Maybe)\nADDITIVE(IntMap)\nADDITIVE(Identity)\nADDITIVE(Vector)\nADDITIVE(V0)\nADDITIVE(V1)\nADDITIVE(V2)\nADDITIVE(V3)\nADDITIVE(V4)\nADDITIVE(Plucker)\nADDITIVE(Quaternion)\nADDITIVE(((->) b))\nADDITIVEC(Ord k, (Map k))\nADDITIVEC((Eq k, Hashable k), (HashMap k))\nADDITIVEC(Dim n, (V n))\n\n-- | A handy wrapper to help distinguish points from vectors at the\n-- type level\nnewtype Point f a = P (f a)\n deriving ( Eq, Ord, Show, Read, Monad, Functor, Applicative, Foldable\n , Traversable, Apply, Additive, Metric\n , Fractional , Num, Ix, Storable, Epsilon\n , Hashable\n#if defined(__GLASGOW_HASKELL__) && __GLASGOW_HASKELL__ >= 702\n , Generic\n#endif\n#if defined(__GLASGOW_HASKELL__) && __GLASGOW_HASKELL__ >= 706\n , Generic1\n#endif\n#if defined(__GLASGOW_HASKELL__) && __GLASGOW_HASKELL__ >= 708\n , Typeable, Data\n#endif\n )\n\n#if defined(__GLASGOW_HASKELL__) && __GLASGOW_HASKELL__ < 708\ninstance forall f. Typeable1 f => Typeable1 (Point f) where\n typeOf1 _ = mkTyConApp (mkTyCon3 \"linear\" \"Linear.Affine\" \"Point\") [] `mkAppTy`\n typeOf1 (undefined :: f a)\n\nderiving instance (Data (f a), Typeable1 f, Typeable a) => Data (Point f a)\n#endif\n\nlensP :: Lens' (Point g a) (g a)\nlensP afb (P a) = P <$> afb a\n{-# INLINE lensP #-}\n\n_Point :: Iso' (Point f a) (f a)\n_Point = iso (\\(P a) -> a) P\n{-# INLINE _Point #-}\n\ninstance (t ~ Point g b) => Rewrapped (Point f a) t\ninstance Wrapped (Point f a) where\n type Unwrapped (Point f a) = f a\n _Wrapped' = _Point\n {-# INLINE _Wrapped' #-}\n\ninstance Bind f => Bind (Point f) where\n join (P m) = P $ join $ fmap (\\(P m')->m') m\n\ninstance Distributive f => Distributive (Point f) where\n distribute = P . collect (\\(P p) -> p)\n\ninstance Representable f => Representable (Point f) where\n type Rep (Point f) = Rep f\n tabulate f = P (tabulate f)\n {-# INLINE tabulate #-}\n index (P xs) = Rep.index xs\n {-# INLINE index #-}\n\ntype instance Index (Point f a) = Index (f a)\ntype instance IxValue (Point f a) = IxValue (f a)\n\ninstance Ixed (f a) => Ixed (Point f a) where\n ix l = lensP . ix l\n {-# INLINE ix #-}\n\ninstance Traversable f => Each (Point f a) (Point f b) a b where\n each = traverse\n {-# INLINE each #-}\n\ninstance R1 f => R1 (Point f) where\n _x = lensP . _x\n {-# INLINE _x #-}\n\ninstance R2 f => R2 (Point f) where\n _y = lensP . _y\n {-# INLINE _y #-}\n _xy = lensP . _xy\n {-# INLINE _xy #-}\n\ninstance R3 f => R3 (Point f) where\n _z = lensP . _z\n {-# INLINE _z #-}\n _xyz = lensP . _xyz\n {-# INLINE _xyz #-}\n\ninstance R4 f => R4 (Point f) where\n _w = lensP . _w\n {-# INLINE _w #-}\n _xyzw = lensP . _xyzw\n {-# INLINE _xyzw #-}\n\ninstance Additive f => Affine (Point f) where\n type Diff (Point f) = f\n P x .-. P y = x ^-^ y\n {-# INLINE (.-.) #-}\n P x .+^ v = P (x ^+^ v)\n {-# INLINE (.+^) #-}\n P x .-^ v = P (x ^-^ v)\n {-# INLINE (.-^) #-}\n\n-- | Vector spaces have origins.\norigin :: (Additive f, Num a) => Point f a\norigin = P zero\n\n-- | An isomorphism between points and vectors, given a reference\n-- point.\nrelative :: (Additive f, Num a) => Point f a -> Iso' (Point f a) (f a)\nrelative p0 = iso (.-. p0) (p0 .+^)\n{-# INLINE relative #-}\n\n", "meta": {"hexsha": "5a33cad8ba8a412a01cbba70db2312092bdd4d70", "size": 6417, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/Linear/Affine.hs", "max_stars_repo_name": "abbradar/linear", "max_stars_repo_head_hexsha": "65f84b187dee38e9d8adba27d4c2cfbf9c816334", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/Linear/Affine.hs", "max_issues_repo_name": "abbradar/linear", "max_issues_repo_head_hexsha": "65f84b187dee38e9d8adba27d4c2cfbf9c816334", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/Linear/Affine.hs", "max_forks_repo_name": "abbradar/linear", "max_forks_repo_head_hexsha": "65f84b187dee38e9d8adba27d4c2cfbf9c816334", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 28.0218340611, "max_line_length": 81, "alphanum_fraction": 0.6164874552, "num_tokens": 2032, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.6187804196836383, "lm_q2_score": 0.5467381519846138, "lm_q1q2_score": 0.3383108631420962}} {"text": "{-# LANGUAGE RecordWildCards #-}\nmodule Main where\n\nimport Control.Monad (when)\nimport qualified Data.Text.IO as TIO\nimport qualified Data.ByteString.Lazy as BL (readFile)\nimport Data.Csv (decodeByName)\n\nimport QuoteData\nimport Statistics\nimport StatReport\nimport Charts\nimport Params\n \nmain :: IO ()\nmain = cmdLineParser >>= work\n\n\nwork :: Params -> IO ()\nwork params = do\n csvData <- BL.readFile (fname params)\n case decodeByName csvData of\n Left err -> putStrLn err\n Right (_, quotes) -> generateReports params quotes\n\n\ngenerateReports :: (Functor t, Foldable t) => Params -> t QuoteData -> IO ()\ngenerateReports Params {..} quotes = do\n TIO.putStr $ statReport statInfo'\n when prices $ plotChart title quotes [Open, Close, High, Low] fname_prices\n when volumes $ plotChart title quotes [Volume] fname_volumes\n where\n statInfo' = statInfo quotes\n withCompany pref = if company /= \"\" then pref ++ company else \"\"\n img_suffix = withCompany \"_\" ++ \".svg\"\n fname_prices = \"prices\" ++ img_suffix\n fname_volumes = \"volumes\" ++ img_suffix\n title = \"Historical Quotes\" ++ withCompany \" for \"\n", "meta": {"hexsha": "e94b831be8c5665a1b9732d1f242ef7a388dea8a", "size": 1111, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "app/Main.hs", "max_stars_repo_name": "Francososa/stockell", "max_stars_repo_head_hexsha": "362b49309e227fb311b4d941404b4e65fd603226", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "app/Main.hs", "max_issues_repo_name": "Francososa/stockell", "max_issues_repo_head_hexsha": "362b49309e227fb311b4d941404b4e65fd603226", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "app/Main.hs", "max_forks_repo_name": "Francososa/stockell", "max_forks_repo_head_hexsha": "362b49309e227fb311b4d941404b4e65fd603226", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 28.4871794872, "max_line_length": 76, "alphanum_fraction": 0.7146714671, "num_tokens": 273, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.588889130767832, "lm_q2_score": 0.5736784074525096, "lm_q1q2_score": 0.3378329787049826}} {"text": "-- | The parse part of scheme. https://en.wikibooks.org/wiki/Write_Yourself_a_Scheme_in_48_Hours/\n\nmodule Parser\n ( readExpr\n , readExprList\n ) where\n\nimport Control.Monad.Error\nimport Data.Char (digitToInt)\nimport Data.Complex\nimport Data.Ratio ((%))\nimport ErrorCheckingAndExceptions\nimport LispVal\nimport Numeric (readDec, readFloat, readHex,\n readInt, readOct)\nimport Text.ParserCombinators.Parsec hiding (spaces)\n\n\nsymbol :: Parser Char\nsymbol = oneOf \"!$%&|*+-/:<=>?@^_~\" \"a symbol\"\n\n-- readExpr :: String -> Either ParseError LispVal\n-- readExpr = parse parseExpr \"lisp\"\n\n-- Whitespace\nspaces :: Parser ()\nspaces = skipMany1 space\n\nparseString :: Parser LispVal\nparseString = do\n char '\"'\n str <- many (parseHelper <|> noneOf \"\\\\\\\"\")\n char '\"'\n return $ String str\n \"a string for parseString\"\n where parseHelper :: Parser Char\n parseHelper = do\n char '\\\\'\n x <- oneOf \"\\\\\\\"nrt\"\n return $ case x of\n '\\\\' -> x\n '\"' -> x\n 'n' -> '\\n'\n 'r' -> '\\r'\n 't' -> '\\t'\n\nparseAtom :: Parser LispVal\nparseAtom = do\n first <- letter <|> symbol\n rest <- many $ letter <|> symbol <|> digit\n return $ Atom (first : rest)\n \"a atom for parseAtom\"\n\nparseBool :: Parser LispVal\nparseBool = do\n x <- try (string \"#t\") <|> string \"#f\"\n return $ if x == \"#t\"\n then Bool True\n else Bool False\n\nparseNumber :: Parser LispVal\nparseNumber = parseDigit <|> try parseOct <|> try parseDec <|> try parseHex <|> parseBin\n where parseOct = do\n char '#' >> oneOf \"oO\"\n str <- many1 octDigit\n let [(n, _)] = readOct str\n return $ Number n\n parseDec = do\n char '#' >> oneOf \"dD\"\n str <- many1 digit\n let [(n, _)] = readDec str\n return $ Number n\n parseHex = do\n char '#' >> oneOf \"xX\"\n str <- many1 hexDigit\n let [(n, _)] = readHex str\n return $ Number n\n parseBin = do\n char '#' >> oneOf \"bB\"\n str <- many1 $ oneOf \"01\"\n let [(n, _)] = readInt 2 (`elem` \"01\") digitToInt str\n return $ Number n\n parseDigit = do\n str <- many1 digit\n return $ (Number . read) str\n\nparseChar :: Parser LispVal\nparseChar = do\n string \"#\\\\\"\n x <- many $ letter <|> digit\n return $ case length x of\n 0 -> Character '\\n'\n 1 -> Character $ head x\n _ -> case x of\n \"newline\" -> Character '\\n'\n \"tab\" -> Character '\\t'\n \"space\" -> Character ' '\n\nparseFloat :: Parser LispVal\nparseFloat = do\n x <- many1 digit\n char '.'\n y <- many1 digit\n return $ let [(n, _)] = readFloat (x ++ '.' : y) in Float n\n\nparseRatio :: Parser LispVal\nparseRatio = do\n x <- many1 digit\n char '/'\n y <- many1 digit\n return $ Ratio (read x % read y)\n\nparseComplex :: Parser LispVal\nparseComplex = do\n x <- try parseFloat <|> parseNumber\n char '+'\n y <- try parseFloat <|> parseNumber\n char 'i'\n return $ Complex (toDouble x :+ toDouble y)\n where toDouble :: LispVal -> Double\n toDouble (Float f) = f\n toDouble (Number n) = fromIntegral n\n\n-- Recursive Parsers: Adding lists, dotted lists, and quoted datums\n\nparseList :: Parser LispVal\nparseList = do\n char '('\n x <- sepBy parseExpr spaces\n char ')'\n return $ List x\n\nparseDottedList :: Parser LispVal\nparseDottedList = do\n char '('\n x <- endBy parseExpr spaces\n y <- char '.' >> spaces >> parseExpr\n char ')'\n return $ DottedList x y\n\nparseQuoted :: Parser LispVal\nparseQuoted = do\n char '\\''\n x <- parseExpr\n return $ List [Atom \"quote\", x]\n\nparseBackquote :: Parser LispVal\nparseBackquote = do\n char '`'\n x <- parseExpr\n return $ List [Atom \"quasiquote\", x]\n\nparseUnquote :: Parser LispVal\nparseUnquote = do\n char ','\n y <- parseExpr\n return $ List [Atom \"unquote\", y]\n\nparseUnquoteSplicing :: Parser LispVal\nparseUnquoteSplicing = do\n char ',' >> char '@'\n y <- parseExpr\n return $ List [Atom \"unquote-splicing\", y]\n\nparseExpr :: Parser LispVal\nparseExpr = parseAtom\n <|> try parseBool\n <|> try parseRatio\n <|> try parseComplex\n <|> try parseFloat\n <|> try parseNumber\n <|> parseChar\n <|> parseString\n <|> try parseList\n <|> parseDottedList\n <|> parseQuoted\n <|> parseBackquote\n <|> try parseUnquoteSplicing\n <|> parseUnquote\n\nreadOrThrow :: Parser a -> String -> ThrowsError a\nreadOrThrow parser input = case parse parser \"lisp\" input of\n Left err -> throwError $ Parser err\n Right val -> return val\n\nreadExpr :: String -> ThrowsError LispVal\nreadExpr = readOrThrow parseExpr\n\nreadExprList :: String -> ThrowsError [LispVal]\nreadExprList = readOrThrow (endBy parseExpr spaces)\n", "meta": {"hexsha": "90ac7eb193c6563134096947a53b7b1ea6994767", "size": 5011, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "WriteYourselfAScheme/sec9-creating-IO-primitives/code/src/Parser.hs", "max_stars_repo_name": "zeqing-guo/Haskell-Exercises", "max_stars_repo_head_hexsha": "54f84d2f3ab98469d2e670170f679c0bf51e9774", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "WriteYourselfAScheme/sec9-creating-IO-primitives/code/src/Parser.hs", "max_issues_repo_name": "zeqing-guo/Haskell-Exercises", "max_issues_repo_head_hexsha": "54f84d2f3ab98469d2e670170f679c0bf51e9774", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "WriteYourselfAScheme/sec9-creating-IO-primitives/code/src/Parser.hs", "max_forks_repo_name": "zeqing-guo/Haskell-Exercises", "max_forks_repo_head_hexsha": "54f84d2f3ab98469d2e670170f679c0bf51e9774", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 26.2356020942, "max_line_length": 97, "alphanum_fraction": 0.5645579725, "num_tokens": 1367, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.5926665855647395, "lm_q2_score": 0.5698526514141571, "lm_q1q2_score": 0.3377326251886422}} {"text": "{-# language TypeFamilies #-}\nmodule Main where\n\nimport MachineLearning.Utils.Config\nimport MachineLearning.Utils.Report\nimport MachineLearning.Utils.Data\nimport MachineLearning.TIR\nimport MachineLearning.TIR.Crossover\nimport MachineLearning.TIR.Mutation\nimport MachineLearning.Model.Fitness\nimport MachineLearning.Model.Measure\nimport Control.Evolution\nimport Data.SRTree\nimport Data.SRTree.Print\n\nimport System.Environment (getArgs)\nimport Control.Monad.State.Strict\nimport Data.Bifunctor (second)\nimport Data.List.Split (splitOn)\nimport Data.Maybe (fromJust, fromMaybe)\nimport Numeric.LinearAlgebra (size)\nimport System.Random (mkStdGen, getStdGen)\nimport System.IO (Handle)\nimport System.Clock (Clock(..), getTime, sec)\nimport Numeric.ModalInterval\nimport qualified Data.Vector.Storable as VS\nimport qualified Data.Vector as V\nimport qualified Numeric.LinearAlgebra as LA\n\nimport Data.List (intercalate)\nimport Prelude hiding (null)\nimport Algorithm.ShapeConstraint (getViolationFun)\n\nfilterImage :: Kaucher Double -> [Function] -> [Function]\nfilterImage image = filter (isNotNullNaNInf . (`evalFun` image) . inverseFunc)\n{-# INLINE filterImage #-}\n\nisNotNullNaNInf :: Kaucher Double -> Bool\nisNotNullNaNInf xs = not (isEmpty xs || isNaN xl || isNaN xu || isInfinite xl || isInfinite xu)\n where\n xl = fromMaybe (-1/0) $ inf xs\n xu = fromMaybe (1/0) $ sup xs\n{-# INLINE isNotNullNaNInf #-}\n\ninstance EvoClass Individual where \n data Crossover Individual = OnePoint | UniformCX deriving (Show, Read)\n data Mutation Individual = GroupMutation deriving (Show, Read)\n\nparseCLI :: Task -> [String] -> IO ()\nparseCLI Regression [expminP, expmaxP, tfuncsP, ytfuncsP, errorMetric, nGensP, nPopP, pcP, pmP, seedP, penalty, trainname] = do\n let mutCfg = dfltMutCfg { _kRange = (read expminP, read expmaxP)\n , _yfuns = map read $ splitOn \",\" ytfuncsP\n , _funs = map read $ splitOn \",\" tfuncsP\n , _vars = []\n }\n algCfg = dfltAlgCfg { _gens = read nGensP\n , _nPop = read nPopP\n , _pm = read pmP\n , _pc = read pcP\n , _seed = let s = read seedP in if s < 0 then Nothing else Just s\n , _measures = [toMeasure errorMetric]\n }\n ioCfg = IOCfg trainname trainname Screen\n pn = read penalty\n cnst = if pn == 0.0 then dfltCnstrCfg else dfltCnstrCfg{ _penaltyType = Len pn }\n cfg = Conf mutCfg ioCfg algCfg cnst\n (champion, _, _) <- runGP cfg \n let bias = V.head $ VS.convert $ head $ _weights champion\n print $ (showPython . assembleTree bias . _chromo) champion <> \";\" <> (show . _len) champion <> \";\" <> (show . _fit) champion \n\nparseCLI task [expminP, expmaxP, tfuncsP, ytfuncsP, errorMetric, nGensP, nPopP, pcP, pmP, seedP, penalty, niter, trainname] = do\n let mutCfg = dfltMutCfg { _kRange = (read expminP, read expmaxP)\n , _yfuns = map read $ splitOn \",\" ytfuncsP\n , _funs = map read $ splitOn \",\" tfuncsP\n , _vars = []\n }\n algCfg = dfltAlgCfg { _gens = read nGensP\n , _nPop = read nPopP\n , _pm = read pmP\n , _pc = read pcP\n , _seed = let s = read seedP in if s < 0 then Nothing else Just s\n , _measures = [toMeasure errorMetric]\n , _task = case task of\n RegressionNL _ -> RegressionNL $ read niter\n Classification _ -> Classification $ read niter\n ClassMult _ -> ClassMult $ read niter\n }\n ioCfg = IOCfg trainname trainname Screen\n pn = read penalty\n cnst = if pn == 0.0 then dfltCnstrCfg else dfltCnstrCfg{ _penaltyType = Len pn }\n cfg = Conf mutCfg ioCfg algCfg cnst\n (champion, _, _) <- runGP cfg \n \n let \n tir = _chromo champion\n trees = intercalate \"#\" . map (showPython . getTree tir) $ _weights champion\n print $ trees <> \";\" <> (show . _len) champion <> \";\" <> (show . _fit) champion \n where\n getTree :: TIR -> LA.Vector Double -> SRTree Int Double\n getTree tir w = let bias = V.head $ VS.convert w\n consts = V.tail $ VS.convert w\n sigm z = 1 / (1+exp(-z))\n \n in case task of \n Classification _ -> sigm $ assembleTree bias $ replaceConsts tir consts\n ClassMult _ -> sigm $ assembleTree bias $ replaceConsts tir consts\n _ -> assembleTree bias $ replaceConsts tir consts\n \nparseCLI _ _ = putStrLn \"Usage: ./tir cli expmin expmax tfuncs ytfuncs errorMetric nGens nPop pc pm seed penalty trainname\"\n\nrunWithCfg :: [FilePath] -> IO ()\nrunWithCfg [fname] = do \n cfg <- readConfig fname \n t0 <- getTime Realtime\n (champion, mh, fitnessTest) <- runGP cfg \n putStrLn \"Best expression (training set):\\n\"\n putStrLn $ prettyPrintsolution champion\n t1 <- getTime Realtime\n putStr \"Fitness on the test set: \"\n print $ (head . fromJust . fitnessTest) champion\n closeIfJust mh\n putStrLn $ \"Total time: \" ++ show (sec t1 - sec t0) ++ \" secs.\"\n writeChampionStats cfg fitnessTest (sec t1 - sec t0) champion\nrunWithCfg _ = putStrLn \"Usage: ./tir config filename\"\n \nrunGP :: Config -> IO (Individual, Maybe Handle, Individual -> Maybe [Double])\nrunGP cfg@(Conf mutCfg _ algCfg cnstCfg) = do\n g <- case (_seed . _algorithmCfg) cfg of\n Nothing -> getStdGen\n Just x -> return $ mkStdGen x\n (train, val, alldata, test, domains, image, nvars) <- processData cfg\n let\n budget = max 5 $ min 15 $ size (snd train) `div` 10\n mutCfg' = mutCfg{ _yfuns = filterImage image (_yfuns mutCfg), _vars = [0 .. nvars-1], _budget=budget }\n task = _task algCfg\n measures = _measures algCfg\n penalty = _penaltyType cnstCfg\n cnstr = case _evaluator cnstCfg of \n Nothing -> const 0.0 \n Just e -> getViolationFun e (_shapes cnstCfg) (_domains cnstCfg)\n fitnessTrain = evalTrain task False measures cnstr penalty domains (fst train) (snd train) (fst val) (snd val)\n fitnessAll = evalTrain task True measures cnstr penalty domains (fst alldata) (snd alldata) (fst alldata) (snd alldata)\n fitnessTest = evalTest task measures (fst test) (snd test)\n \n myCX OnePoint = onepoint\n myCX UniformCX = uniformCx\n myMut GroupMutation = multiMut mutCfg'\n --myRep Generational = generational\n --mySelect (Tournament n) = tournament n\n --myFilter _ = id\n myCreate = createIndividual <$> randomTIR mutCfg'\n -- myFitness x = liftIO (print (_chromo x)) >> liftIO (print (tirToMatrix (fst train) $ selectValidTerms (_chromo x) domains)) >> pure (fitnessTrain x)\n myFitness = pure . fitnessTrain\n\n interpret :: Interpreter Individual\n interpret = Funs myCX myMut myCreate myFitness\n \n gp = Reproduce Generational \n [Cross OnePoint 2 (_pc algCfg) (Tournament 2) :> Mutate GroupMutation (_pm algCfg) :> Done]\n fi = Reproduce Merge\n [ With Feasible :> Cross OnePoint 2 (_pc algCfg) (Tournament 2) :> Mutate GroupMutation (_pm algCfg) :> Done\n , With Infeasible :> Cross OnePoint 2 (_pc algCfg) (Tournament 2) :> Mutate GroupMutation (_pm algCfg) :> Done\n ]\n \n alg = case _algorithm algCfg of\n GPTIR -> gp\n SCTIR -> fi\n (logger, mh) <- makeLogger cfg fitnessTest\n (_, champion) <- runEvolution (_gens algCfg) (_nPop algCfg) logger alg g interpret \n return (fitnessAll champion, mh, fitnessTest)\n\nmain :: IO ()\nmain = do\n args <- getArgs \n case args of\n (\"regress\":opts) -> parseCLI Regression opts\n (\"regressNL\":opts) -> parseCLI (RegressionNL 0) opts\n (\"class\":opts) -> parseCLI (Classification 0) opts\n (\"multiclass\":opts) -> parseCLI (ClassMult 0) opts\n (\"config\":opts) -> runWithCfg opts\n _ -> putStrLn \"Usage: ./tir {regress/regressNL/class/multiclass/config} args\"\n", "meta": {"hexsha": "2a9f538d745bc2bed75f8713d8ceb29744322d6f", "size": 8758, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "app/Main.hs", "max_stars_repo_name": "folivetti/tir", "max_stars_repo_head_hexsha": "5db7c8fa62975f7ce901fce68a560156b2dc6745", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "app/Main.hs", "max_issues_repo_name": "folivetti/tir", "max_issues_repo_head_hexsha": "5db7c8fa62975f7ce901fce68a560156b2dc6745", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "app/Main.hs", "max_forks_repo_name": "folivetti/tir", "max_forks_repo_head_hexsha": "5db7c8fa62975f7ce901fce68a560156b2dc6745", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 48.1208791209, "max_line_length": 157, "alphanum_fraction": 0.5846083581, "num_tokens": 2238, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6859494550081925, "lm_q2_score": 0.49218813572079556, "lm_q1q2_score": 0.337616183459178}} {"text": "{-# LANGUAGE ExistentialQuantification #-}\n{-# LANGUAGE FlexibleInstances #-}\n{-# LANGUAGE InstanceSigs #-}\n{-# LANGUAGE ScopedTypeVariables #-}\n\nmodule Commons where\n\nimport Control.Applicative (liftA2)\nimport Control.Monad (foldM, forM)\nimport Data.Array\nimport Data.Complex\nimport Data.Function.HT (nest)\nimport qualified Data.IntMap.Strict as IM\nimport Data.List (intercalate, sort)\nimport Data.Map.Strict (Map)\nimport qualified Data.Map.Strict as Map\nimport Data.Maybe (catMaybes, fromJust, mapMaybe)\nimport Data.Set (Set, fromList, toList)\nimport Data.Time (diffUTCTime, getCurrentTime)\nimport Data.Typeable (Typeable)\nimport Debug.Trace (traceShowId)\nimport GHC.IO.Unsafe (unsafePerformIO)\nimport GHC.TypeLits (KnownNat, Nat)\nimport HashedExpression.Internal.Expression\nimport HashedExpression.Internal.Normalize\nimport HashedExpression.Internal.Utils\nimport HashedExpression.Interp\nimport HashedExpression.Operation\nimport qualified HashedExpression.Operation\nimport HashedExpression.Prettify\nimport HashedExpression.Value\nimport Test.HUnit\nimport Test.Hspec\nimport Test.QuickCheck\nimport Var\nimport Prelude hiding ((^))\n\n-- |\n--\n-- | Remove duplicate but also sort\nremoveDuplicate :: (Ord a) => [a] -> [a]\nremoveDuplicate = toList . fromList\n\n-- |\nvectorOfDifferent :: Eq a => Int -> Gen a -> Gen [a]\nvectorOfDifferent sz gen = foldM f [] [1 .. sz]\n where\n f acc _ = (: acc) <$> gen `suchThat` (not . flip elem acc)\n\n-- | Format\nformat :: [(String, String)] -> String\nformat = intercalate \"\\n\" . map oneLine\n where\n oneLine (f, s) = f ++ \": \" ++ s\n\n-- |\ninspect :: (Typeable d, Typeable rc) => Expression d rc -> Expression d rc\ninspect x =\n unsafePerformIO $ do\n showExp x\n return x\n\n-- | Vars list\ntype Vars = [[String]] -- Vars 0D, 1D, 2D, 3D, ..\n\nmergeVars :: [Vars] -> Vars\nmergeVars = foldl f [[], [], [], []]\n where\n f x y = map removeDuplicate $ zipWith (++) x y\n\ngenDouble :: Gen Double\ngenDouble = arbitrary `suchThat` inSmallRange\n where\n inSmallRange x = x >= 0 && x <= 10\n\n-- |\ngenValMap ::\n forall size1D size2D1 size2D2.\n (KnownNat size1D, KnownNat size2D1, KnownNat size2D2) =>\n Vars ->\n Gen ValMaps\ngenValMap vars = do\n let sz1D = valueFromNat @size1D\n sz2D1 = valueFromNat @size2D1\n sz2D2 = valueFromNat @size2D2\n let [names0d, names1d, names2d, names3d] = vars\n list0d <- vectorOf (length names0d) genDouble\n let vm0 = Map.fromList . zip names0d $ map VScalar list0d\n list1d <- vectorOf (length names1d) . vectorOf sz1D $ genDouble\n let vm1 =\n Map.fromList . zip names1d . map (V1D . listArray (0, sz1D - 1)) $\n list1d\n list2d <- vectorOf (length names2d) . vectorOf (sz2D1 * sz2D2) $ genDouble\n let vm2 =\n Map.fromList\n . zip names2d\n . map (V2D . listArray ((0, 0), (sz2D1 - 1, sz2D2 - 1)))\n $ list2d\n let vm3 = Map.empty -- TODO: not testing with 3D yet.\n return $ Map.unions [vm0, vm1, vm2, vm3]\n\nshouldApprox :: (HasCallStack, Approximable a) => a -> a -> Expectation\nshouldApprox x y = assertBool msg (x ~= y)\n where\n msg = \"Expected: \" ++ prettifyShow y ++ \"\\nGot: \" ++ prettifyShow x\n\ninfix 1 `shouldApprox`\n\nliftE1 ::\n (Expression d1 et1 -> Expression d2 et2) ->\n (Expression d1 et1, Vars) ->\n (Expression d2 et2, Vars)\nliftE1 op (e, v) = (op e, v)\n\nliftE2 ::\n (Expression d1 et1 -> Expression d2 et2 -> Expression d3 et3) ->\n (Expression d1 et1, Vars) ->\n (Expression d2 et2, Vars) ->\n (Expression d3 et3, Vars)\nliftE2 op (e1, v1) (e2, v2) = ((op e1 e2), (mergeVars [v1, v2]))\n\n-------------------------------------------------------------------------------\nprimitiveScalarR :: Gen (Expression Scalar R, Vars)\nprimitiveScalarR = do\n name <- elements . map pure $ ['a' .. 'z']\n dbl <- genDouble\n r <- (`mod` 10) <$> arbitrary\n if r < 6\n then return ((variable name), [[(name)], [], [], []])\n else return ((constant dbl), [[], [], [], []])\n\nprimitiveScalarC :: Gen (Expression Scalar C, Vars)\nprimitiveScalarC = liftE2 (+:) <$> primitiveScalarR <*> primitiveScalarR\n\n-------------------------------------------------------------------------------\nprimitive1DR ::\n forall n.\n KnownNat n =>\n Gen (Expression n R, Vars)\nprimitive1DR = do\n name <- elements . map ((++ \"1\") . pure) $ ['a' .. 'z']\n dbl <- genDouble\n r <- (`mod` 10) <$> arbitrary\n if r < 6\n then return ((variable1D @n name), [[], [(name)], [], []])\n else return ((constant1D @n dbl), [[], [], [], []])\n\nprimitive1DC ::\n forall n.\n KnownNat n =>\n Gen (Expression n C, Vars)\nprimitive1DC = liftE2 (+:) <$> primitive1DR @n <*> primitive1DR @n\n\n-------------------------------------------------------------------------------\nprimitive2DR ::\n forall m n.\n (KnownNat m, KnownNat n) =>\n Gen (Expression '(m, n) R, Vars)\nprimitive2DR = do\n name <- elements . map ((++ \"2\") . pure) $ ['a' .. 'z']\n dbl <- genDouble\n r <- (`mod` 10) <$> arbitrary\n if r < 6\n then return (variable2D @m @n name, [[], [], [(name)], []])\n else return (constant2D @m @n dbl, [[], [], [], []])\n\nprimitive2DC ::\n forall m n.\n (KnownNat m, KnownNat n) =>\n Gen (Expression '(m, n) C, Vars)\nprimitive2DC = liftE2 (+:) <$> primitive2DR @m @n <*> primitive2DR @m @n\n\n--type = 10\n-------------------------------------------------------------------------------\ngenScalarR ::\n forall default1D default2D1 default2D2.\n (KnownNat default1D, KnownNat default2D1, KnownNat default2D2) =>\n Int ->\n Gen (Expression Scalar R, Vars)\ngenScalarR size\n | size == 0 = primitiveScalarR\n | otherwise =\n let sub = genScalarR @default1D @default2D1 @default2D2 (size `div` 10)\n subC = genScalarC @default1D @default2D1 @default2D2 (size `div` 10)\n sub1D = gen1DR @default1D @default2D1 @default2D2 (size `div` 10)\n sub2D = gen2DR @default1D @default2D1 @default2D2 (size `div` 10)\n fromPiecewise = do\n numBranches <- elements [2 .. 4]\n branches <- vectorOf numBranches sub\n condition <- sub\n marks <- sort <$> vectorOfDifferent (numBranches - 1) arbitrary\n let vars = mergeVars $ map snd branches ++ [snd condition]\n exp = piecewise marks (fst condition) $ map fst branches\n return (exp, vars)\n binary op = liftE2 op <$> sub <*> sub\n unary op = liftE1 op <$> sub\n in oneof\n [ fromPiecewise,\n binary (+),\n binary (*),\n binary (*.),\n binary (-),\n binary (<.>),\n unary negate,\n unary (^ 2),\n liftE1 xRe <$> subC,\n liftE1 xIm <$> subC,\n liftE2 (<.>) <$> sub1D <*> sub1D,\n liftE2 (<.>) <$> sub2D <*> sub2D\n ]\n\n-------------------------------------------------------------------------------\ngenScalarC ::\n forall default1D default2D1 default2D2.\n (KnownNat default1D, KnownNat default2D1, KnownNat default2D2) =>\n Int ->\n Gen (Expression Scalar C, Vars)\ngenScalarC size\n | size == 0 = primitiveScalarC\n | otherwise =\n let sub = genScalarC @default1D @default2D1 @default2D2 (size `div` 10)\n subR = genScalarR @default1D @default2D1 @default2D2 (size `div` 10)\n sub1D = gen1DC @default1D @default2D1 @default2D2 (size `div` 10)\n sub2D = gen2DC @default1D @default2D1 @default2D2 (size `div` 10)\n fromPiecewise = do\n numBranches <- elements [2 .. 4]\n branches <- vectorOf numBranches sub\n condition <- subR\n marks <- sort <$> vectorOfDifferent (numBranches - 1) arbitrary\n let vars = mergeVars $ map snd branches ++ [snd condition]\n exp = piecewise marks (fst condition) $ map fst branches\n return (exp, vars)\n binary op = liftE2 op <$> sub <*> sub\n unary op = liftE1 op <$> sub\n in oneof\n [ fromPiecewise,\n binary (+),\n binary (*),\n binary (*.),\n binary (-),\n binary (<.>),\n unary negate,\n unary (^ 2),\n liftE2 (+:) <$> subR <*> subR,\n liftE2 (<.>) <$> sub1D <*> sub1D,\n liftE2 (<.>) <$> sub2D <*> sub2D\n ]\n\n-------------------------------------------------------------------------------\ngen1DR ::\n forall n default2D1 default2D2.\n (KnownNat n, KnownNat default2D1, KnownNat default2D2) =>\n Int ->\n Gen (Expression n R, Vars)\ngen1DR size\n | size == 0 = primitive1DR\n | otherwise =\n let sub = gen1DR @n @default2D1 @default2D2 (size `div` 10)\n subC = gen1DC @n @default2D1 @default2D2 (size `div` 10)\n subScalar = genScalarR @n @default2D1 @default2D2 (size `div` 10)\n fromPiecewise = do\n numBranches <- elements [2 .. 4]\n branches <- vectorOf numBranches sub\n condition <- sub\n marks <- sort <$> vectorOfDifferent (numBranches - 1) arbitrary\n let vars = mergeVars $ map snd branches ++ [snd condition]\n exp = piecewise marks (fst condition) $ map fst branches\n return (exp, vars)\n fromRotate = do\n amount <- elements [- (valueFromNat @n) .. valueFromNat @n]\n liftE1 (rotate amount) <$> sub\n binary op = liftE2 op <$> sub <*> sub\n unary op = liftE1 op <$> sub\n in oneof\n [ fromPiecewise,\n binary (+),\n binary (*),\n binary (-),\n unary negate,\n unary (^ 2),\n liftE1 xRe <$> subC,\n liftE1 xIm <$> subC,\n liftE2 (*.) <$> subScalar <*> sub,\n fromRotate,\n liftE1 (xRe . ft) <$> sub,\n liftE1 (xIm . ft) <$> sub\n ]\n\n-------------------------------------------------------------------------------\ngen1DC ::\n forall n default2D1 default2D2.\n (KnownNat n, KnownNat default2D1, KnownNat default2D2) =>\n Int ->\n Gen (Expression n C, Vars)\ngen1DC size\n | size == 0 = primitive1DC\n | otherwise =\n let sub = gen1DC @n @default2D1 @default2D2 (size `div` 10)\n subR = gen1DR @n @default2D1 @default2D2 (size `div` 10)\n subScalar = genScalarC @n @default2D1 @default2D2 (size `div` 10)\n fromPiecewise = do\n numBranches <- elements [2 .. 4]\n branches <- vectorOf numBranches sub\n condition <- subR\n marks <- sort <$> vectorOfDifferent (numBranches - 1) arbitrary\n let vars = mergeVars $ map snd branches ++ [snd condition]\n exp = piecewise marks (fst condition) $ map fst branches\n return (exp, vars)\n fromRotate = do\n amount <- elements [- (valueFromNat @n) .. valueFromNat @n]\n liftE1 (rotate amount) <$> sub\n binary op = liftE2 op <$> sub <*> sub\n unary op = liftE1 op <$> sub\n in oneof\n [ fromPiecewise,\n binary (+),\n binary (*),\n binary (-),\n unary negate,\n unary (^ 2),\n liftE2 (+:) <$> subR <*> subR,\n liftE2 (*.) <$> subScalar <*> sub,\n liftE1 ft <$> sub,\n fromRotate\n ]\n\n-------------------------------------------------------------------------------\ngen2DR ::\n forall default1D m n.\n (KnownNat default1D, KnownNat m, KnownNat n) =>\n Int ->\n Gen (Expression '(m, n) R, Vars)\ngen2DR size\n | size == 0 = primitive2DR\n | otherwise =\n let sub = gen2DR @default1D @m @n (size `div` 10)\n subC = gen2DC @default1D @m @n (size `div` 10)\n subScalar = genScalarR @default1D @m @n (size `div` 10)\n fromPiecewise = do\n numBranches <- elements [2 .. 4]\n branches <- vectorOf numBranches sub\n condition <- sub\n marks <- sort <$> vectorOfDifferent (numBranches - 1) arbitrary\n let vars = mergeVars $ map snd branches ++ [snd condition]\n exp = piecewise marks (fst condition) $ map fst branches\n return (exp, vars)\n fromRotate = do\n amount1 <- elements [- (valueFromNat @m) .. valueFromNat @m]\n amount2 <- elements [- (valueFromNat @n) .. valueFromNat @n]\n liftE1 (rotate (amount1, amount2)) <$> sub\n binary op = liftE2 op <$> sub <*> sub\n unary op = liftE1 op <$> sub\n in oneof\n [ fromPiecewise,\n binary (+),\n binary (*),\n binary (-),\n unary negate,\n unary (^ 2),\n liftE1 xRe <$> subC,\n liftE1 xIm <$> subC,\n liftE2 (*.) <$> subScalar <*> sub,\n fromRotate,\n liftE1 (xRe . ft) <$> sub,\n liftE1 (xIm . ft) <$> sub\n ]\n\n-------------------------------------------------------------------------------\ngen2DC ::\n forall default1D m n.\n (KnownNat default1D, KnownNat m, KnownNat n) =>\n Int ->\n Gen (Expression '(m, n) C, Vars)\ngen2DC size\n | size == 0 = primitive2DC\n | otherwise =\n let sub = gen2DC @default1D @m @n (size `div` 10)\n subR = gen2DR @default1D @m @n (size `div` 10)\n subScalar = genScalarC @default1D @m @n (size `div` 10)\n fromPiecewise = do\n numBranches <- elements [2 .. 4]\n branches <- vectorOf numBranches sub\n condition <- subR\n marks <- sort <$> vectorOfDifferent (numBranches - 1) arbitrary\n let vars = mergeVars $ map snd branches ++ [snd condition]\n exp = piecewise marks (fst condition) $ map fst branches\n return (exp, vars)\n fromRotate = do\n amount1 <- elements [- (valueFromNat @m) .. valueFromNat @m]\n amount2 <- elements [- (valueFromNat @n) .. valueFromNat @n]\n liftE1 (rotate (amount1, amount2)) <$> sub\n binary op = liftE2 op <$> sub <*> sub\n unary op = liftE1 op <$> sub\n in oneof\n [ fromPiecewise,\n binary (+),\n binary (*),\n binary (-),\n unary negate,\n unary (^ 2),\n liftE2 (+:) <$> subR <*> subR,\n liftE2 (*.) <$> subScalar <*> sub,\n liftE1 ft <$> sub,\n fromRotate\n ]\n\n-------------------------------------------------------------------------------\ndata Suite (size1D :: Nat) (size2D1 :: Nat) (size2D2 :: Nat) d et\n = Suite (Expression d et) ValMaps\n deriving (Show)\n\n-------------------------------------------------------------------------------\ntype TestSuite = Suite Default1D Default2D1 Default2D2\n\ntype SuiteScalarR = TestSuite Scalar R\n\ntype SuiteScalarC = TestSuite Scalar C\n\ntype SuiteOneR = TestSuite Default1D R\n\ntype SuiteOneC = TestSuite Default1D C\n\ntype SuiteTwoR = TestSuite '(Default2D1, Default2D2) R\n\ntype SuiteTwoC = TestSuite '(Default2D1, Default2D2) C\n\n-------------------------------------------------------------------------------\ninstance\n (KnownNat size1D, KnownNat size2D1, KnownNat size2D2) =>\n Arbitrary (Suite size1D size2D1 size2D2 Scalar R)\n where\n arbitrary = do\n (exp, vars) <- sized $ genScalarR @size1D @size2D1 @size2D2\n valMaps <- genValMap @size1D @size2D1 @size2D2 vars\n return $ Suite exp valMaps\n\ninstance\n (KnownNat size1D, KnownNat size2D1, KnownNat size2D2) =>\n Arbitrary (Suite size1D size2D1 size2D2 Scalar C)\n where\n arbitrary = do\n (exp, vars) <- sized $ genScalarC @size1D @size2D1 @size2D2\n valMaps <- genValMap @size1D @size2D1 @size2D2 vars\n return $ Suite exp valMaps\n\ninstance\n (KnownNat size1D, KnownNat size2D1, KnownNat size2D2) =>\n Arbitrary (Suite size1D size2D1 size2D2 size1D R)\n where\n arbitrary = do\n (exp, vars) <- sized $ gen1DR @size1D @size2D1 @size2D2\n valMaps <- genValMap @size1D @size2D1 @size2D2 vars\n return $ Suite exp valMaps\n\ninstance\n (KnownNat size1D, KnownNat size2D1, KnownNat size2D2) =>\n Arbitrary (Suite size1D size2D1 size2D2 size1D C)\n where\n arbitrary = do\n (exp, vars) <- sized $ gen1DC @size1D @size2D1 @size2D2\n valMaps <- genValMap @size1D @size2D1 @size2D2 vars\n return $ Suite exp valMaps\n\ninstance\n (KnownNat size1D, KnownNat size2D1, KnownNat size2D2) =>\n Arbitrary (Suite size1D size2D1 size2D2 '(size2D1, size2D2) R)\n where\n arbitrary = do\n (exp, vars) <- sized $ gen2DR @size1D @size2D1 @size2D2\n valMaps <- genValMap @size1D @size2D1 @size2D2 vars\n return $ Suite exp valMaps\n\ninstance\n (KnownNat size1D, KnownNat size2D1, KnownNat size2D2) =>\n Arbitrary (Suite size1D size2D1 size2D2 '(size2D1, size2D2) C)\n where\n arbitrary = do\n (exp, vars) <- sized $ gen2DC @size1D @size2D1 @size2D2\n valMaps <- genValMap @size1D @size2D1 @size2D2 vars\n return $ Suite exp valMaps\n\n-------------------------------------------------------------------------------\ninstance Arbitrary (Expression Scalar R) where\n arbitrary = fst <$> sized (genScalarR @Default1D @Default2D1 @Default2D2)\n\ninstance Arbitrary (Expression Scalar C) where\n arbitrary = fst <$> sized (genScalarC @Default1D @Default2D1 @Default2D2)\n\ninstance KnownNat n => Arbitrary (Expression n R) where\n arbitrary = fst <$> sized (gen1DR @n @Default2D1 @Default2D2)\n\ninstance KnownNat n => Arbitrary (Expression n C) where\n arbitrary = fst <$> sized (gen1DC @n @Default2D1 @Default2D2)\n\ninstance (KnownNat m, KnownNat n) => Arbitrary (Expression '(m, n) R) where\n arbitrary = fst <$> sized (gen2DR @Default1D @m @n)\n\ninstance (KnownNat m, KnownNat n) => Arbitrary (Expression '(m, n) C) where\n arbitrary = fst <$> sized (gen2DC @Default1D @m @n)\n\n-------------------------------------------------------------------------------\ndata ArbitraryExpresion = forall d et. (DimensionType d, ElementType et) => ArbitraryExpresion (Expression d et)\n\ninstance Show ArbitraryExpresion where\n show (ArbitraryExpresion exp) = show exp\n\ninstance Arbitrary ArbitraryExpresion where\n arbitrary =\n let option1 =\n fmap ArbitraryExpresion (arbitrary :: Gen (Expression Scalar R))\n option2 =\n fmap ArbitraryExpresion (arbitrary :: Gen (Expression Scalar C))\n option3 =\n fmap\n ArbitraryExpresion\n (arbitrary :: Gen (Expression Default1D R))\n option4 =\n fmap\n ArbitraryExpresion\n (arbitrary :: Gen (Expression Default1D C))\n option5 =\n fmap\n ArbitraryExpresion\n (arbitrary :: Gen (Expression '(Default2D1, Default2D2) R))\n option6 =\n fmap\n ArbitraryExpresion\n (arbitrary :: Gen (Expression '(Default2D1, Default2D2) C))\n in oneof [option1, option2, option3, option4, option5, option6]\n\n-- |\ngetWrappedExp :: ArbitraryExpresion -> (ExpressionMap, NodeID)\ngetWrappedExp (ArbitraryExpresion (Expression n mp)) = (mp, n)\n\n-------------------------------------------------------------------------------\n\n-- |\nsz :: Expression d et -> Int\nsz = IM.size . exMap\n\ninfix 1 `shouldNormalizeTo`\n\nshouldNormalizeTo ::\n (HasCallStack, DimensionType d, ElementType et, Typeable et, Typeable d) =>\n Expression d et ->\n Expression d et ->\n IO ()\nshouldNormalizeTo exp1 exp2 = do\n prettify (normalize exp1) `shouldBe` prettify (normalize exp2)\n normalize exp1 `shouldBe` normalize exp2\n", "meta": {"hexsha": "b3f403fa9d970c119ec28551422afa8a967a1c1a", "size": 18962, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "test/Commons.hs", "max_stars_repo_name": "Turboscient/HashedExpression", "max_stars_repo_head_hexsha": "cbdc06506f5f9decb3712bf2d13ebc52da2d8e03", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 4, "max_stars_repo_stars_event_min_datetime": "2019-05-30T00:10:54.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-12T21:31:19.000Z", "max_issues_repo_path": "test/Commons.hs", "max_issues_repo_name": "Turboscient/HashedExpression", "max_issues_repo_head_hexsha": "cbdc06506f5f9decb3712bf2d13ebc52da2d8e03", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 34, "max_issues_repo_issues_event_min_datetime": "2019-05-23T19:22:16.000Z", "max_issues_repo_issues_event_max_datetime": "2020-05-26T18:47:55.000Z", "max_forks_repo_path": "test/Commons.hs", "max_forks_repo_name": "Turboscient/HashedExpression", "max_forks_repo_head_hexsha": "cbdc06506f5f9decb3712bf2d13ebc52da2d8e03", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 6, "max_forks_repo_forks_event_min_datetime": "2019-05-25T00:27:22.000Z", "max_forks_repo_forks_event_max_datetime": "2020-06-02T00:37:36.000Z", "avg_line_length": 34.4137931034, "max_line_length": 112, "alphanum_fraction": 0.5678198502, "num_tokens": 5416, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.5389832206876841, "lm_q2_score": 0.6261241772283034, "lm_q1q2_score": 0.3374704255929373}} {"text": "{-# LANGUAGE BangPatterns #-}\n{-# LANGUAGE ConstraintKinds #-}\n{-# LANGUAGE CPP #-}\n{-# LANGUAGE DataKinds #-}\n{-# LANGUAGE FlexibleContexts #-}\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE KindSignatures #-}\n{-# LANGUAGE LambdaCase #-}\n{-# LANGUAGE Rank2Types #-}\n{-# LANGUAGE ScopedTypeVariables #-}\n#if __GLASGOW_HASKELL__ >= 805\n{-# LANGUAGE ExplicitNamespaces #-}\n{-# LANGUAGE NoStarIsType #-}\n#endif\n{-# LANGUAGE TypeApplications #-}\n{-# LANGUAGE TypeFamilies #-}\n{-# LANGUAGE TypeOperators #-}\n\nmodule Eigen.Matrix\n ( \n -- * Types \n Matrix(..)\n , Vec(..)\n , MatrixXf\n , MatrixXd\n , MatrixXcf\n , MatrixXcd\n\n -- * Common API\n , Elem\n , C\n , natToInt\n , Row(..)\n , Col(..)\n\n -- * Encode/Decode a Matrix\n , encode\n , decode\n\n -- * Querying a Matrix\n , null\n , square\n , rows\n , cols\n , dims\n \n -- * Constructing a Matrix\n , empty\n , constant\n , zero\n , ones\n , identity\n , random\n , diagonal\n\n , (!)\n , coeff\n , generate\n , sum\n , prod\n , mean\n , trace\n , all\n , any\n , count\n , norm\n , squaredNorm\n , blueNorm\n , hypotNorm\n , determinant\n , add\n , sub\n , mul\n , map\n , imap\n , TriangularMode(..)\n , triangularView\n , filter\n , ifilter\n , length\n , foldl\n , foldl'\n , inverse\n , adjoint\n , transpose\n , conjugate\n , normalize\n , modify\n , block\n , unsafeFreeze\n , unsafeWith\n , fromList\n , toList\n ) where\n\nimport Control.Monad (when)\nimport Control.Monad.ST (ST)\nimport Prelude hiding\n (map, null, filter, length, foldl, any, all, sum)\nimport Control.Monad (forM_)\nimport Control.Monad.Primitive (PrimMonad(..))\nimport Data.Binary (Binary(..))\nimport qualified Data.Binary as Binary\nimport qualified Data.ByteString.Lazy as BSL\nimport Data.Complex (Complex)\nimport Data.Constraint.Nat\nimport Eigen.Internal\n ( Elem\n , Cast(..)\n , natToInt\n , Row(..)\n , Col(..)\n )\nimport qualified Eigen.Internal as Internal\nimport qualified Eigen.Matrix.Mutable as M\nimport qualified Data.List as List\nimport Data.Kind (Type)\nimport GHC.TypeLits (Nat, type (*), type (<=), KnownNat)\nimport Foreign.C.Types (CInt)\nimport Foreign.C.String (CString)\nimport Foreign.Marshal.Alloc (alloca)\nimport Foreign.Ptr (Ptr)\nimport Foreign.Storable (peek)\n\nimport qualified Data.Vector.Storable as VS\nimport qualified Data.Vector.Storable.Mutable as VSM\n\n-- | Matrix to be used in pure computations.\n--\n-- * Uses column majour memory layout.\n--\n-- * Has a copy-free FFI using the library.\n--\nnewtype Matrix :: Nat -> Nat -> Type -> Type where\n Matrix :: Vec (n * m) a -> Matrix n m a\n\n-- | Used internally to track the size and corresponding C type of the matrix.\nnewtype Vec :: Nat -> Type -> Type where\n Vec :: VS.Vector (C a) -> Vec n a\n\ninstance forall n m a. (Elem a, Show a, KnownNat n, KnownNat m) => Show (Matrix n m a) where\n show m = List.concat\n [ \"Matrix \", show (rows m), \"x\", show (cols m)\n , \"\\n\", List.intercalate \"\\n\" $ List.map (List.intercalate \"\\t\" . List.map show) $ toList m, \"\\n\"\n ]\n\ninstance forall n m a. (KnownNat n, KnownNat m, Elem a) => Binary (Matrix n m a) where\n put (Matrix (Vec vals)) = do\n put $ Internal.magicCode (undefined :: C a)\n put $ natToInt @n\n put $ natToInt @m\n put vals\n\n get = do\n get >>= (`when` fail \"wrong matrix type\") . (/= Internal.magicCode (undefined :: C a))\n Matrix . Vec <$> get\n\n-- | Encode the sparse matrix as a lazy bytestring\nencode :: (Elem a, KnownNat n, KnownNat m) => Matrix n m a -> BSL.ByteString\nencode = Binary.encode\n\n-- | Decode the sparse matrix from a lazy bytestring\ndecode :: (Elem a, KnownNat n, KnownNat m) => BSL.ByteString -> Matrix n m a\ndecode = Binary.decode\n\n-- | Alias for single precision matrix\ntype MatrixXf n m = Matrix n m Float\n-- | Alias for double precision matrix\ntype MatrixXd n m = Matrix n m Double\n-- | Alias for single precision matrix of complex numbers\ntype MatrixXcf n m = Matrix n m (Complex Float)\n-- | Alias for double precision matrix of complex numbers\ntype MatrixXcd n m = Matrix n m (Complex Double)\n\n-- | Construct an empty 0x0 matrix\nempty :: Elem a => Matrix 0 0 a\n{-# INLINE empty #-}\nempty = Matrix (Vec (VS.empty))\n\n-- | Is matrix empty?\nnull :: (Elem a, KnownNat n, KnownNat m) => Matrix n m a -> Bool\n{-# INLINE null #-}\nnull m = cols m == 0 && rows m == 0\n\n-- | Is matrix square?\n--\nsquare :: forall n m a. (Elem a, KnownNat n, KnownNat m) => Matrix n m a -> Bool\n{-# INLINE square #-}\nsquare _ = natToInt @n == natToInt @m\n\n-- | Matrix where all coeffs are filled with the given value\nconstant :: forall n m a. (Elem a, KnownNat n, KnownNat m) => a -> Matrix n m a\n{-# INLINE constant #-}\nconstant !val =\n let !cval = toC val\n in withDims $ \\rs cs -> VS.replicate (rs * cs) cval\n\n-- | Matrix where all coeffs are filled with 0\nzero :: (Elem a, KnownNat n, KnownNat m) => Matrix n m a\n{-# INLINE zero #-}\nzero = constant 0\n\n-- | Matrix where all coeffs are filled with 1\nones :: (Elem a, KnownNat n, KnownNat m) => Matrix n m a\n{-# INLINE ones #-}\nones = constant 1\n\n-- | The identity matrix (not necessarily square)\nidentity :: forall n m a. (Elem a, KnownNat n, KnownNat m) => Matrix n m a\nidentity =\n Internal.performIO $ do\n m :: M.IOMatrix n m a <- M.new\n Internal.call $ M.unsafeWith m Internal.identity\n unsafeFreeze m\n\n-- | The random matrix of a given size\nrandom :: forall n m a. (Elem a, KnownNat n, KnownNat m) => IO (Matrix n m a)\nrandom = do\n m :: M.IOMatrix n m a <- M.new\n Internal.call $ M.unsafeWith m Internal.random\n unsafeFreeze m\n\nwithDims :: forall n m a. (Elem a, KnownNat n, KnownNat m) => (Int -> Int -> VS.Vector (C a)) -> Matrix n m a\n{-# INLINE withDims #-}\nwithDims f =\n let !r = natToInt @n\n !c = natToInt @m\n in Matrix $ Vec $ f r c\n\n-- | The number of rows in the matrix\nrows :: forall n m a. KnownNat n => Matrix n m a -> Int\n{-# INLINE rows #-}\nrows _ = natToInt @n\n\n-- | The number of colums in the matrix\ncols :: forall n m a. KnownNat m => Matrix n m a -> Int\n{-# INLINE cols #-}\ncols _ = natToInt @m\n\n-- | Return Matrix size as a pair of (rows, cols)\ndims :: forall n m a. (Elem a, KnownNat n, KnownNat m) => Matrix n m a -> (Int, Int)\n{-# INLINE dims #-}\ndims _ = (natToInt @n, natToInt @m)\n\n-- | Return the value at the given position.\n(!) :: forall n m a r c. (Elem a, KnownNat n, KnownNat r, KnownNat c, r <= n, c <= m) => Row r -> Col c -> Matrix n m a -> a\n{-# INLINE (!) #-}\n(!) = coeff\n\n-- | Return the value at the given position.\ncoeff :: forall n m a r c. (Elem a, KnownNat n, KnownNat r, KnownNat c, r <= n, c <= m) => Row r -> Col c -> Matrix n m a -> a\n{-# INLINE coeff #-}\ncoeff _ _ m@(Matrix (Vec vals)) =\n let !row = natToInt @r\n !col = natToInt @c\n in fromC $! VS.unsafeIndex vals $! col * rows m + row\n\nunsafeCoeff :: (Elem a, KnownNat n) => Int -> Int -> Matrix n m a -> a\n{-# INLINE unsafeCoeff #-}\nunsafeCoeff row col m@(Matrix (Vec vals)) = fromC $! VS.unsafeIndex vals $! col * rows m + row\n\n-- | Given a generation function `f :: Int -> Int -> a`, construct a Matrix of known size\n-- using points in the matrix as inputs.\ngenerate :: forall n m a. (Elem a, KnownNat n, KnownNat m) => (Int -> Int -> a) -> Matrix n m a\ngenerate f = withDims $ \\rs cs -> VS.create $ do\n vals :: VSM.MVector s (C a) <- VSM.new (rs * cs)\n forM_ [0 .. pred rs] $ \\r ->\n forM_ [0 .. pred cs] $ \\c ->\n VSM.write vals (c * rs + r) (toC $! f r c)\n pure vals\n\n-- | The sum of all coefficients in the matrix\nsum :: (Elem a, KnownNat n, KnownNat m) => Matrix n m a -> a\nsum = _prop Internal.sum\n\n-- | The product of all coefficients in the matrix\nprod :: (Elem a, KnownNat n, KnownNat m) => Matrix n m a -> a\nprod = _prop Internal.prod\n\n-- | The arithmetic mean of all coefficients in the matrix\nmean :: (Elem a, KnownNat n, KnownNat m) => Matrix n m a -> a\nmean = _prop Internal.mean\n\n-- | The trace of a matrix is the sum of the diagonal coefficients.\n-- \n-- 'trace' m == 'sum' ('diagonal' m)\ntrace :: (Elem a, KnownNat n, KnownNat m) => Matrix n m a -> a\ntrace = _prop Internal.trace\n\n-- | Given a predicate p, determine if all values in the Matrix satisfy p.\nall :: (Elem a, KnownNat n, KnownNat m) => (a -> Bool) -> Matrix n m a -> Bool\nall f (Matrix (Vec vals)) = VS.all (f . fromC) vals\n\n-- | Given a predicate p, determine if any values in the Matrix satisfy p.\nany :: (Elem a, KnownNat n, KnownNat m) => (a -> Bool) -> Matrix n m a -> Bool\nany f (Matrix (Vec vals)) = VS.any (f . fromC) vals\n\n-- | Given a predicate p, determine how many values in the Matrix satisfy p.\ncount :: (Elem a, KnownNat n, KnownNat m) => (a -> Bool) -> Matrix n m a -> Int\ncount f (Matrix (Vec vals)) = VS.foldl' (\\n x-> if f (fromC x) then (n + 1) else n) 0 vals\n\nnorm, squaredNorm, blueNorm, hypotNorm :: (Elem a, KnownNat n, KnownNat m) => Matrix n m a -> a\n\n{-| For vectors, the l2 norm, and for matrices the Frobenius norm.\n In both cases, it consists in the square root of the sum of the square of all the matrix entries.\n For vectors, this is also equals to the square root of the dot product of this with itself.\n-}\nnorm = _prop Internal.norm\n\n-- | For vectors, the squared l2 norm, and for matrices the Frobenius norm. In both cases, it consists in the sum of the square of all the matrix entries. For vectors, this is also equals to the dot product of this with itself.\nsquaredNorm = _prop Internal.squaredNorm\n\n-- | The l2 norm of the matrix using the Blue's algorithm. A Portable Fortran Program to Find the Euclidean Norm of a Vector, ACM TOMS, Vol 4, Issue 1, 1978.\nblueNorm = _prop Internal.blueNorm\n\n-- | The l2 norm of the matrix avoiding undeflow and overflow. This version use a concatenation of hypot calls, and it is very slow.\nhypotNorm = _prop Internal.hypotNorm\n\n-- | The determinant of the matrix\ndeterminant :: forall n a. (Elem a, KnownNat n) => Matrix n n a -> a\ndeterminant m = _prop Internal.determinant m\n\n-- | Add two matrices.\nadd :: (Elem a, KnownNat n, KnownNat m) => Matrix n m a -> Matrix n m a -> Matrix n m a\nadd m1 m2 = _binop Internal.add m1 m2\n\n-- | Subtract two matrices.\nsub :: (Elem a, KnownNat n, KnownNat m) => Matrix n m a -> Matrix n m a -> Matrix n m a\nsub m1 m2 = _binop Internal.sub m1 m2\n\n-- | Multiply two matrices.\nmul :: (Elem a, KnownNat p, KnownNat q, KnownNat r) => Matrix p q a -> Matrix q r a -> Matrix p r a\nmul m1 m2 = _binop Internal.mul m1 m2\n\n{- | Apply a given function to each element of the matrix.\nHere is an example how to implement scalar matrix multiplication:\n\n>>> let a = fromList [[1,2],[3,4]] :: MatrixXf 2 2\n>>> a\nMatrix 2x2\n1.0 2.0\n3.0 4.0\n>>> map (*10) a\nMatrix 2x2\n10.0 20.0\n30.0 40.0\n-}\nmap :: Elem a => (a -> a) -> Matrix n m a -> Matrix n m a\nmap f (Matrix (Vec vals)) = Matrix $ Vec $ VS.map (toC . f . fromC) vals\n\n{- | Apply a given function to each element of the matrix.\nHere is an example how upper triangular matrix can be implemented:\n>>> let a = fromList [[1,2,3],[4,5,6],[7,8,9]] :: MatrixXf\n>>> a\nMatrix 3x3\n1.0 2.0 3.0\n4.0 5.0 6.0\n7.0 8.0 9.0\n>>> imap (\\row col val -> if row <= col then val else 0) a\nMatrix 3x3\n1.0 2.0 3.0\n0.0 5.0 6.0\n0.0 0.0 9.0\n-}\nimap :: (Elem a, KnownNat n, KnownNat m) => (Int -> Int -> a -> a) -> Matrix n m a -> Matrix n m a\nimap f (Matrix (Vec vals)) =\n withDims $ \\rs _ ->\n VS.imap (\\n ->\n let (c,r) = divMod n rs\n in toC . f r c . fromC) vals\n\n-- | Provide a view of the matrix for extraction of a subset.\ndata TriangularMode\n -- | View matrix as a lower triangular matrix.\n = Lower\n -- | View matrix as an upper triangular matrix.\n | Upper\n -- | View matrix as a lower triangular matrix with zeros on the diagonal.\n | StrictlyLower\n -- | View matrix as an upper triangular matrix with zeros on the diagonal.\n | StrictlyUpper\n -- | View matrix as a lower triangular matrix with ones on the diagonal.\n | UnitLower\n -- | View matrix as an upper triangular matrix with ones on the diagonal.\n | UnitUpper\n deriving (Eq, Enum, Show, Read)\n\n-- | Triangular view extracted from the current matrix\ntriangularView :: (Elem a, KnownNat n, KnownNat m) => TriangularMode -> Matrix n m a -> Matrix n m a\ntriangularView = \\case\n Lower -> imap $ \\row col val -> case compare row col of { LT -> 0; _ -> val }\n Upper -> imap $ \\row col val -> case compare row col of { GT -> 0; _ -> val }\n StrictlyLower -> imap $ \\row col val -> case compare row col of { GT -> val; _ -> 0 }\n StrictlyUpper -> imap $ \\row col val -> case compare row col of { LT -> val; _ -> 0 }\n UnitLower -> imap $ \\row col val -> case compare row col of { GT -> val; LT -> 0; EQ -> 1 }\n UnitUpper -> imap $ \\row col val -> case compare row col of { LT -> val; GT -> 0; EQ -> 1 }\n\n-- | Filter elements in the matrix. Filtered elements will be replaced by 0.\nfilter :: Elem a => (a -> Bool) -> Matrix n m a -> Matrix n m a\nfilter f = map (\\x -> if f x then x else 0)\n\n-- | Filter elements in the matrix with an indexed predicate. Filtered elements will be replaces by 0.\nifilter :: (Elem a, KnownNat n, KnownNat m) => (Int -> Int -> a -> Bool) -> Matrix n m a -> Matrix n m a\nifilter f = imap (\\r c x -> if f r c x then x else 0)\n\n-- | The length of the matrix.\nlength :: forall n m a r. (Elem a, KnownNat n, KnownNat m, r ~ (n * m), KnownNat r) => Matrix n m a -> Int\nlength _ = natToInt @r\n\n-- | Left fold of a matrix, where accumulation is lazy.\nfoldl :: (Elem a, KnownNat n, KnownNat m) => (b -> a -> b) -> b -> Matrix n m a -> b\nfoldl f b (Matrix (Vec vals)) = VS.foldl (\\a x -> f a (fromC x)) b vals\n\n-- | Right fold of a matrix, where accumulation is strict.\nfoldl' :: Elem a => (b -> a -> b) -> b -> Matrix n m a -> b\nfoldl' f b (Matrix (Vec vals)) = VS.foldl' (\\ !a x -> f a (fromC x)) b vals\n\n-- | Return the diagonal of a matrix.\ndiagonal :: (Elem a, KnownNat n, KnownNat m, r ~ Min n m, KnownNat r) => Matrix n m a -> Matrix r 1 a\ndiagonal = _unop Internal.diagonal\n\n{- | Inverse of the matrix\nFor small fixed sizes up to 4x4, this method uses cofactors. In the general case, this method uses PartialPivLU decomposition\n-}\ninverse :: forall n a. (Elem a, KnownNat n) => Matrix n n a -> Matrix n n a\ninverse = _unop Internal.inverse\n\n-- | Adjoint of the matrix\nadjoint :: (Elem a, KnownNat n, KnownNat m) => Matrix n m a -> Matrix m n a\nadjoint = _unop Internal.adjoint\n\n-- | Transpose of the matrix\ntranspose :: (Elem a, KnownNat n, KnownNat m) => Matrix n m a -> Matrix m n a\ntranspose = _unop Internal.transpose\n\n-- | Conjugate of the matrix\nconjugate :: (Elem a, KnownNat n, KnownNat m) => Matrix n m a -> Matrix n m a\nconjugate = _unop Internal.conjugate\n\n-- | Normalise the matrix by dividing it on its 'norm'\nnormalize :: forall n m a. (Elem a, KnownNat n, KnownNat m) => Matrix n m a -> Matrix n m a\nnormalize (Matrix (Vec vals)) = Internal.performIO $ do\n vals' <- VS.thaw vals\n VSM.unsafeWith vals' $ \\p ->\n let !rs = natToInt @n\n !cs = natToInt @m\n in Internal.call $ Internal.normalize p (toC rs) (toC cs)\n Matrix . Vec <$> VS.unsafeFreeze vals'\n\n-- | Apply a destructive operation to a matrix. The operation will be performed in-place, if it is safe\n-- to do so - otherwise, it will create a copy of the matrix.\nmodify :: (Elem a, KnownNat n, KnownNat m) => (forall s. M.MMatrix n m s a -> ST s ()) -> Matrix n m a -> Matrix n m a\nmodify f (Matrix (Vec vals)) = Matrix $ Vec $ VS.modify (f . M.fromVector ) vals\n\n-- | Extract rectangular block from matrix defined by startRow startCol blockRows blockCols\nblock :: forall sr sc br bc n m a.\n (Elem a, KnownNat sr, KnownNat sc, KnownNat br, KnownNat bc, KnownNat n, KnownNat m)\n => (sr <= n, sc <= m, br <= n, bc <= m)\n => Row sr -- ^ starting row\n -> Col sc -- ^ starting col\n -> Row br -- ^ block of rows\n -> Col bc -- ^ block of cols\n -> Matrix n m a -- ^ extract from this\n -> Matrix br bc a -- ^ extraction\nblock _ _ _ _ m =\n let !startRow = natToInt @sr\n !startCol = natToInt @sc\n in generate $ \\row col -> unsafeCoeff (startRow + row) (startCol + col) m\n\n-- | Turn a mutable matrix into an immutable matrix without copying.\n-- The mutable matrix should not be modified after this conversion.\nunsafeFreeze :: (Elem a, KnownNat n, KnownNat m, PrimMonad p) => M.MMatrix n m (PrimState p) a -> p (Matrix n m a)\nunsafeFreeze m = VS.unsafeFreeze (M.vals m) >>= pure . Matrix . Vec\n \n-- | Pass a pointer to the matrix's data to the IO action. The data may not be modified through the pointer.\nunsafeWith :: (Elem a, KnownNat n, KnownNat m) => Matrix n m a -> (Ptr (C a) -> CInt -> CInt -> IO b) -> IO b\nunsafeWith m@(Matrix (Vec (vals))) f =\n VS.unsafeWith vals $ \\p ->\n let !rs = toC $! rows m\n !cs = toC $! cols m\n in f p rs cs\n\n_prop :: (Elem a, KnownNat n, KnownNat m) => (Ptr (C a) -> Ptr (C a) -> CInt -> CInt -> IO CString) -> Matrix n m a -> a\n{-# INLINE _prop #-}\n_prop f m = fromC $ Internal.performIO $ alloca $ \\p -> do\n Internal.call $ unsafeWith m (f p)\n peek p\n\n_binop :: forall n m n1 m1 n2 m2 a. (Elem a, KnownNat n, KnownNat m, KnownNat n1, KnownNat m1, KnownNat n2, KnownNat m2)\n => (Ptr (C a) -> CInt -> CInt -> Ptr (C a) -> CInt -> CInt -> Ptr (C a) -> CInt -> CInt -> IO CString)\n -> Matrix n m a\n -> Matrix n1 m1 a\n -> Matrix n2 m2 a\n{-# INLINE _binop #-}\n_binop g m1 m2 = Internal.performIO $ do\n m0 :: M.IOMatrix n2 m2 a <- M.new\n M.unsafeWith m0 $ \\vals0 rows0 cols0 ->\n unsafeWith m1 $ \\vals1 rows1 cols1 ->\n unsafeWith m2 $ \\vals2 rows2 cols2 ->\n Internal.call $ g\n vals0 rows0 cols0\n vals1 rows1 cols1\n vals2 rows2 cols2\n unsafeFreeze m0\n\n_unop :: forall n m n1 m1 a. (Elem a, KnownNat n, KnownNat m, KnownNat n1, KnownNat m1)\n => (Ptr (C a) -> CInt -> CInt -> Ptr (C a) -> CInt -> CInt -> IO CString)\n -> Matrix n m a\n -> Matrix n1 m1 a\n{-# INLINE _unop #-}\n_unop g m1 = Internal.performIO $ do\n m0 :: M.IOMatrix n1 m1 a <- M.new\n M.unsafeWith m0 $ \\vals0 rows0 cols0 ->\n unsafeWith m1 $ \\vals1 rows1 cols1 ->\n Internal.call $ g\n vals0 rows0 cols0\n vals1 rows1 cols1\n unsafeFreeze m0\n\n-- | Convert a matrix to a list.\ntoList :: (Elem a, KnownNat n, KnownNat m) => Matrix n m a -> [[a]]\n{-# INLINE toList #-}\ntoList m@(Matrix (Vec vals))\n | null m = []\n | otherwise = [[fromC $ vals `VS.unsafeIndex` (col * _rows + row) | col <- [0..pred _cols]] | row <- [0..pred _rows]]\n where\n !_rows = rows m\n !_cols = cols m\n\n-- | Convert a list to a matrix. Returns 'Nothing' if the dimensions of the list do not match that\n-- of the matrix.\nfromList :: forall n m a. (Elem a, KnownNat n, KnownNat m) => [[a]] -> Maybe (Matrix n m a)\nfromList list = do\n let myRows = natToInt @n\n let myCols = natToInt @m\n let _rows = List.length list\n let _cols = List.foldl' max 0 (List.map List.length list)\n if ((myRows /= _rows) || (myCols /= _cols))\n then Nothing\n else (Just . Matrix . Vec) $ VS.create $ do\n vm <- VSM.replicate (_rows * _cols) (toC (0 :: a))\n forM_ (zip [0..] list) $ \\(row,vals) ->\n forM_ (zip [0..] vals) $ \\(col, val) ->\n VSM.write vm (col * _rows + row) (toC val)\n pure vm", "meta": {"hexsha": "356ae29a0def31bdbde4c7f69a1b0b9c4899a7d9", "size": 19076, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/Eigen/Matrix.hs", "max_stars_repo_name": "nilsalex/eigen", "max_stars_repo_head_hexsha": "2b75b0ad40fa973982ef0f85ba7b79cd149db1df", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 14, "max_stars_repo_stars_event_min_datetime": "2018-07-17T08:14:06.000Z", "max_stars_repo_stars_event_max_datetime": "2021-05-17T10:27:07.000Z", "max_issues_repo_path": "src/Eigen/Matrix.hs", "max_issues_repo_name": "nilsalex/eigen", "max_issues_repo_head_hexsha": "2b75b0ad40fa973982ef0f85ba7b79cd149db1df", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 19, "max_issues_repo_issues_event_min_datetime": "2018-07-17T14:12:12.000Z", "max_issues_repo_issues_event_max_datetime": "2021-07-01T11:37:18.000Z", "max_forks_repo_path": "src/Eigen/Matrix.hs", "max_forks_repo_name": "nilsalex/eigen", "max_forks_repo_head_hexsha": "2b75b0ad40fa973982ef0f85ba7b79cd149db1df", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 5, "max_forks_repo_forks_event_min_datetime": "2018-11-22T08:11:53.000Z", "max_forks_repo_forks_event_max_datetime": "2021-04-28T07:40:02.000Z", "avg_line_length": 35.0018348624, "max_line_length": 227, "alphanum_fraction": 0.6349339484, "num_tokens": 5892, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.6297746074044135, "lm_q2_score": 0.5350984286266115, "lm_q1q2_score": 0.33699140281104284}} {"text": "{-# LANGUAGE Rank2Types #-}\nimport Control.Monad.ST (RealWorld)\nimport Data.Complex (Complex)\nimport Data.Vector.Storable (MVector(MVector))\nimport Foreign (Ptr, Storable, withForeignPtr)\nimport Text.Printf (printf)\nimport Blas.Generic.Unsafe (Numeric)\nimport qualified Data.Vector.Storable as Vector\nimport qualified Blas.Primitive.Types as Blas\nimport qualified Blas.Generic.Unsafe as Blas\nimport qualified TestUtils as T\n\nmain :: IO ()\nmain = T.runTest $ do\n sequence_ (mapNumericTypes testGemm)\n\nmapNumericTypes :: (forall a. (Eq a, Numeric a, Show a) => a -> b) -> [b]\nmapNumericTypes f =\n [ f (dummy :: Float)\n , f (dummy :: Double)\n , f (dummy :: Complex Float)\n , f (dummy :: Complex Double)\n ]\n\ndummy :: a\ndummy = error \"dummy value that shouldn't be used\"\n\nwithMVector :: MVector s a -> (Ptr a -> IO b) -> IO b\nwithMVector (MVector _ foreignPtr) = withForeignPtr foreignPtr\n\nmVectorFromList :: Storable a => [a] -> IO (MVector RealWorld a)\nmVectorFromList = Vector.thaw . Vector.fromList\n\ntestGemm :: (Eq a, Numeric a, Show a) => a -> T.Test ()\ntestGemm numType = do\n let order = Blas.RowMajor\n transa = Blas.NoTrans\n transb = Blas.Trans\n n = 2\n size = n * n\n alpha = 1.0 `asTypeOf` numType\n beta = 0.0\n a = Vector.fromList [1, 2, 3, 4]\n b = Vector.fromList [1, 2, 3, 5]\n expected = Vector.fromList [5, 13, 11, 29]\n\n c' <- T.liftIO $ do\n c <- mVectorFromList $ take size (repeat 0)\n Vector.unsafeWith a $ \\ pa ->\n Vector.unsafeWith b $ \\ pb ->\n withMVector c $ \\ pc ->\n Blas.gemm order transa transb n n n alpha pa n pb n beta pc n\n Vector.freeze c\n\n if c' == expected\n then T.passTest \"testGemm\"\n else T.failTest $ printf \"testGemm: c' does not match: %s != %s\"\n (show c') (show expected)\n", "meta": {"hexsha": "9f4d83527c36afae9b2d9af5a33ea0848b745b86", "size": 1850, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "tests/MainTest.hs", "max_stars_repo_name": "Rufflewind/blas-hs", "max_stars_repo_head_hexsha": "59fdc1c48b19024f9bb6283b4ddc90fe45383937", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2016-01-20T04:34:54.000Z", "max_stars_repo_stars_event_max_datetime": "2018-06-09T12:09:06.000Z", "max_issues_repo_path": "tests/MainTest.hs", "max_issues_repo_name": "Rufflewind/blas-hs", "max_issues_repo_head_hexsha": "59fdc1c48b19024f9bb6283b4ddc90fe45383937", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 3, "max_issues_repo_issues_event_min_datetime": "2016-04-25T05:53:19.000Z", "max_issues_repo_issues_event_max_datetime": "2020-11-28T22:27:04.000Z", "max_forks_repo_path": "tests/MainTest.hs", "max_forks_repo_name": "Rufflewind/blas-hs", "max_forks_repo_head_hexsha": "59fdc1c48b19024f9bb6283b4ddc90fe45383937", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 31.3559322034, "max_line_length": 73, "alphanum_fraction": 0.6313513514, "num_tokens": 558, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.6076631556226291, "lm_q2_score": 0.5544704649604273, "lm_q1q2_score": 0.3369312724373996}} {"text": "{-# LANGUAGE OverloadedStrings #-}\n{-# LANGUAGE DataKinds #-}\n{-# LANGUAGE ScopedTypeVariables #-}\n{-# LANGUAGE RankNTypes #-}\n{-# LANGUAGE TypeFamilies #-}\n{-# LANGUAGE PartialTypeSignatures #-}\nmodule Main where\n\nimport Test.Tasty\nimport Test.Tasty.HUnit\nimport Data.List\nimport qualified Data.Vector.Unboxed as U\nimport qualified Data.Vector.Storable as VS\nimport Bio.Data.Bed.Types\nimport Data.Maybe\nimport Conduit\nimport qualified Data.Matrix.Static.Dense as D\nimport qualified Data.Matrix.Static.Generic as D\nimport qualified Data.Matrix.Static.Sparse as S\nimport Data.Matrix.Dynamic (Dynamic(..), matrix)\nimport Data.Matrix.Static.LinearAlgebra\nimport Statistics.Sample hiding (covariance)\nimport System.Random.MWC (create)\n\nimport Bio.ChromVAR\nimport Bio.ChromVAR.Utils\n\nmain :: IO ()\nmain = defaultMain $ testGroup \"Main\"\n [ testCase \"sortBed\" test\n , testCase \"sortBed\" bgTest]\n --, testCase \"sortBed\" peakTest ]\n\ntest :: Assertion\ntest = (map round' $ concat dev', map round' $ concat z') @=?\n (map round' $ concat deviations, map round' $ concat z)\n where\n [(dev', z')] = runIdentity $ runConduit $ yieldMany [(4, cellByPeak)] .|\n computeDeviation 3 3 expectation bg peakBymotif .| sinkList\n expectation = let e = D.replicate 1 @@ (S.fromTriplet (U.fromList cellByPeak) :: SparseMatrix 4 3 Double) :: Matrix 1 3 Double\n s = VS.sum $ D.flatten e\n in D.toList $ D.map (/s) e\n round' :: Double -> Double\n round' x = fromIntegral (round (x * 1e4)) / 1e4\n\ncellByPeak :: [(Int, Int, Double)]\ncellByPeak = [(0,1,1), (0,2,2), (1,0,1), (1,1,1), (2,0,2), (2,2,1), (3,1,1), (3,2,1)]\n\npeakBymotif :: [(Int, Int, Double)]\npeakBymotif = [(0,0,1), (0,1,1), (1,0,1), (1,1,1), (1,2,1), (2,0,1), (2,2,1)]\n\npeaks :: [BED3]\npeaks = map (\\(chr, i) -> BED3 chr i (i + 500)) dat\n where\n dat = [ (\"chr1\", 76585873)\n , (\"chr2\", 42772928)\n , (\"chr2\", 100183786) ]\n\nbg :: [[Int]]\nbg = [ [1,0,1]\n , [1,0,1]\n , [1,2,0] ]\n\ndeviations = transpose [ [0.1728395, -0.4444444, 0.1728395, -0.07407407]\n , [-0.2910053, 0.3174603, 0.2116402, -0.19841270]\n , [0.7407407, -0.6349206, -0.7407407, 0.63492063] ]\n\nz = transpose [ [1.1547005, -1.1547005, 1.1547005, -1.1547005]\n , [-0.5773503, 0.5773503, 0.5773503, -0.5773503]\n , [3.2331615, -1.1547005, -4.0414519, 9.2376043] ]\n\nbgTest :: Assertion\nbgTest = do\n input <- readData \"tests/data/coordinates.tsv\"\n expected <- readData \"tests/data/transformed.tsv\"\n let actual = case matrix (map (\\(a,b) -> [a,b]) $ U.toList input) of\n Dynamic mat@(D.Matrix _) -> U.fromList $ map (\\[a,b] -> (a,b)) $\n map VS.toList $ D.toRows $ whiten Cholesky mat\n U.map (\\(x,y) -> (round' x, round' y)) actual @=?\n U.map (\\(x,y) -> (round' x, round' y)) expected\n where\n readData fl = U.fromList . map (f . words) . lines <$> readFile fl\n where\n f [x,y] = (read x, read y)\n round' :: Double -> Double\n round' x = fromIntegral (round (x * 1e4)) / 1e4\n\npeakTest :: Assertion\npeakTest = do\n coord <- readData \"tests/data/coordinates.tsv\"\n\n expected <- map (map (\\x -> coord U.! (read x - 1)) . words) .\n lines <$> readFile \"tests/data/background.tsv\"\n actual <- fmap (transpose . map (map (coord U.!) . U.toList)) $\n create >>= getBackgroundPeaks 50 coord\n\n print $ zipWith f expected actual\n\n --print $ flip map input' $ \\x -> meanVarianceUnb $ U.fromList $ map dist $ comb x\n return undefined\n where\n f xs ys = meanVarianceUnb $ U.fromList $ map dist $ map (\\[a,b] -> (a,b)) $ sequence [xs, ys]\n readData fl = U.fromList . map (f . words) . lines <$> readFile fl\n where\n f [x,y] = (read x, read y)\n comb (x:xs) = zip (repeat x) xs ++ comb xs\n comb _ = []\n dist ((x1,y1), (x2,y2)) = sqrt $ (x1 - x2)**2 + (y1-y2)**2", "meta": {"hexsha": "c023741f5fc5f601bb8ff4fb5e06224d6ae6e4df", "size": 3882, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "tests/test.hs", "max_stars_repo_name": "kaizhang/ChromVAR", "max_stars_repo_head_hexsha": "d64dd55579c8db9625028065b4cb3314e8f0c4a9", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "tests/test.hs", "max_issues_repo_name": "kaizhang/ChromVAR", "max_issues_repo_head_hexsha": "d64dd55579c8db9625028065b4cb3314e8f0c4a9", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "tests/test.hs", "max_forks_repo_name": "kaizhang/ChromVAR", "max_forks_repo_head_hexsha": "d64dd55579c8db9625028065b4cb3314e8f0c4a9", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 35.9444444444, "max_line_length": 130, "alphanum_fraction": 0.6035548686, "num_tokens": 1294, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.7690802370707281, "lm_q2_score": 0.4378234991142018, "lm_q1q2_score": 0.33672140049388605}} {"text": "{-# LANGUAGE BangPatterns #-}\n{-# LANGUAGE CPP #-}\n{-# LANGUAGE DataKinds #-}\n{-# LANGUAGE FlexibleContexts #-}\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE ScopedTypeVariables #-}\n\nimport Control.Monad\nimport Control.Monad.Random\nimport Data.Constraint (Dict (..))\nimport Data.List (foldl')\nimport Data.Serialize\nimport Data.Singletons\nimport Data.Singletons.Prelude.List\nimport qualified Data.Vector.Storable as V\nimport GHC.TypeLits\nimport qualified Numeric.LinearAlgebra.Static as SA\nimport Options.Applicative\nimport System.Random.MWC\nimport System.Random.MWC.Distributions\nimport Unsafe.Coerce (unsafeCoerce)\n\nimport Grenade\n\n-- | Choose a backend: 0 BLAS, 1 HMATRIX\n#define HMATRIX 0\n\n\nnetSpec :: SpecNet\nnetSpec = specFullyConnected 2 400 |=> specRelu1D 400 |=> specFullyConnected 400 1 |=> specLogit1D 1 |=> specNil1D 1\n\n-- netSpec :: SpecNet\n-- netSpec = specFullyConnected 2 4000 |=> specRelu1D 4000 |=> specFullyConnected 4000 1 |=> specLogit1D 1 |=> specNil1D 1\n\n\n-- netSpec :: SpecNet\n-- netSpec =\n-- specFullyConnected 2 4500\n-- |=> specTanh1D 4500\n-- |=> specFullyConnected 4500 750\n-- |=> specRelu1D 750\n-- |=> specFullyConnected 750 150\n-- |=> specRelu1D 150\n-- |=> specFullyConnected 150 150\n-- |=> specRelu1D 150\n-- |=> specFullyConnected 150 30\n-- |=> specRelu1D 30\n-- |=> specFullyConnected 30 20\n-- |=> specRelu1D 20\n-- |=> specFullyConnected 20 10\n-- |=> specRelu1D 10\n-- |=> specFullyConnected 10 1\n-- |=> specLogit1D 1\n-- |=> specNil1D 1\n\n\n-- -- -- | The definition for a feed forward network using the dynamic module. Note the nested networks. This network clearly is over-engeneered for this example!\n-- netSpec :: SpecNet\n-- netSpec =\n-- specFullyConnected 2 40 |=> specTanh1D 40 |=>\n-- specDropout 400 0.95 Nothing |=>\n-- netSpecInner |=>\n-- specFullyConnected 20 30 |=> specRelu1D 30 |=>\n-- specFullyConnected 30 20 |=> specRelu1D 20 |=>\n-- specFullyConnected 20 10 |=> specRelu1D 10 |=>\n-- specFullyConnected 10 1 |=> specLogit1D 1 |=> specNil1D 1\n-- where netSpecInner = specFullyConnected 40 30 |=> specRelu1D 30 |=> specFullyConnected 30 20 |=> specReshape1D2D 20 (2, 10) |=> specReshape2D1D (2, 10) 20 |=> specNil1D 20\n\ngoals :: [((RealNum, RealNum), RealNum)]\ngoals = [((0.50, 0.50), 0.25), ((-0.50, -0.50), 0.25)]\n\n\n-- | Specifications can be built using the following interface also. Here one does not have to carefully pay attention to match the dimension inputs and outputs as when using specification directly.\nbuildNetViaInterface :: IO SpecConcreteNetwork\nbuildNetViaInterface =\n buildModelWith (NetworkInitSettings UniformInit HMatrix (Just 10)) (DynamicBuildSetup { printResultingSpecification = False }) $\n inputLayer1D 2 >> -- 1. Every model has to start with an input dimension\n fullyConnected 10 >> dropout 0.89 >> relu >> -- 2. Layers are simply added as desired. The input of each layer is determined automatically,\n fullyConnected 20 >> relu >> -- whereas the output is specified as in `fullyConnected 20`. Thus, the layer empits 20 signals\n fullyConnected 4 >> tanhLayer >> -- which arethe input of the next layer.\n networkLayer (\n inputLayer1D 4 >> fullyConnected 10 >> relu >> fullyConnected 4 >> sinusoid\n ) >>\n reshape (4, 1, 1) >> -- 3. Reshape is ignored if the input and output is the same\n fullyConnected 1 -- 4. The output is simply the number of signals the alst layer emits.\n\n\nnetTrain :: forall shapes len1 len2 layers o .\n (SingI (Last shapes), KnownNat len1, KnownNat len2, Head shapes ~ 'D1 len1, Last shapes ~ 'D1 len2)\n => Network layers shapes\n -> Optimizer o\n -> Int\n -> IO (Network layers shapes)\nnetTrain net0 op n = do\n#if HMATRIX\n inps <- replicateM n $ do\n s <- getRandom\n return $ S1D (SA.randomVector s SA.Uniform * 2 - 1 :: SA.R len1)\n#else\n inps <- replicateM n $ do\n s <- getRandom\n return $ S1DV $ SA.extract (SA.randomVector s SA.Uniform * 2 - 1 :: SA.R len1)\n#endif\n let mkVal :: S ('D1 len1) -> Rational\n mkVal (S1D v) = mkVal (S1DV $ SA.extract v)\n mkVal (S1DV v) = if any (v `inCircleV`) goals\n then 1\n else 0\n#if HMATRIX\n constr = S1D . fromRational\n#else\n constr = S1DV . fromRational\n#endif\n let outs = map (constr . mkVal) inps\n let trained = foldl' trainEach net0 (zip inps outs)\n return trained\n\n where trainEach !network (i,o) = train op network i o\n\nnetScore :: (KnownNat len, Head shapes ~ 'D1 len, Last shapes ~ 'D1 1) => Network layers shapes -> IO ()\nnetScore network = do\n let testIns = [ [ (x,y) | x <- [0..50] ]\n | y <- [0..20] ]\n#if HMATRIX\n outMat = fmap (fmap (\\(x,y) -> (render (x/25-1) (y/10-1) . normx) $ runNet network (S1D $ SA.vector [x / 25 - 1,y / 10 - 1]))) testIns\n#else\n outMat = fmap (fmap (\\(x,y) -> (render (x/25-1) (y/10-1) . normx) $ runNet network (S1DV $ V.fromList [x / 25 - 1,y / 10 - 1]))) testIns\n#endif\n putStrLn $ unlines outMat\n\n where\n render x y n' | x == 0 && y == 0 = '+'\n | y == 0 = '-'\n | x == 0 = '|'\n | n' <= 0.2 = ' '\n | n' <= 0.4 = '.'\n | n' <= 0.6 = '-'\n | n' <= 0.8 = '='\n | otherwise = '#'\n\nnormx :: S ('D1 1) -> RealNum\nnormx (S1D r) = SA.mean r\nnormx (S1DV v) = V.sum v / fromIntegral (V.length v)\n\ntestValues :: forall len shapes layers . (KnownNat len, Head shapes ~ 'D1 len, Last shapes ~ 'D1 1) => Network layers shapes -> IO ()\ntestValues network = do\n let n = 1000\n#if HMATRIX\n inps <- replicateM n $ do\n s <- getRandom\n return $ S1D (SA.randomVector s SA.Uniform * 2 - 1 :: SA.R len)\n#else\n inps <- replicateM n $ do\n s <- getRandom\n return $ S1DV $ SA.extract (SA.randomVector s SA.Uniform * 2 - 1 :: SA.R len)\n#endif\n\n let mkVal :: S ('D1 len1) -> Integer\n mkVal (S1D v) = mkVal (S1DV $ SA.extract v :: S ('D1 len))\n mkVal (S1DV v) = if any (v `inCircleV`) goals\n then 1\n else 0\n let outs :: [Integer]\n outs = map mkVal inps\n let ress = zip outs (map (round . normx . runNet network) inps)\n correct = length $ filter id $ map (uncurry (==)) ress\n incorrect = length $ filter id $ map (uncurry (/=)) ress\n falsePositives = length $ filter id $ map (uncurry (\\shd nn -> shd == 0 && nn == 1)) ress\n falseNegatives = length $ filter id $ map (uncurry (\\shd nn -> shd == 1 && nn == 0)) ress\n putStr $ show correct ++ \" | \"\n putStr $ show incorrect ++ \" | \"\n putStr $ show falsePositives ++ \" | \"\n putStrLn $ show falseNegatives ++ \" | \"\n\n\ninCircle :: KnownNat n => SA.R n -> (SA.R n, RealNum) -> Bool\nv `inCircle` (o, r) = SA.norm_2 (v - o) <= r\n\ninCircleV :: V.Vector RealNum -> ((RealNum, RealNum), RealNum) -> Bool\nv `inCircleV` ((x,y), r) = norm (V.zipWith (-) v circle) <= r\n where\n circle = V.fromList [x,y]\n norm x = sqrt (V.sum $ V.map (^ (2 :: Int)) x)\n\n\ndata FeedForwardOpts = FeedForwardOpts Int (Optimizer 'Adam)\n\nfeedForward' :: Parser FeedForwardOpts\nfeedForward' =\n FeedForwardOpts <$> option auto (long \"examples\" <> short 'e' <> value 10000)\n <*> (OptAdam\n <$> option auto (long \"alpha\" <> short 'r' <> value 0.001)\n <*> option auto (long \"beta1\" <> value 0.9)\n <*> option auto (long \"beta2\" <> value 0.999)\n <*> option auto (long \"epsilon\" <> value 1e-4)\n <*> option auto (long \"lambda\" <> value 1e-3))\n\n\nmain :: IO ()\nmain = do\n\n\n FeedForwardOpts examples rate <- execParser (info (feedForward' <**> helper) idm)\n putStrLn \"| Nr | Correct | Incorrect | FalsePositives | FalseNegatives |\"\n putStrLn \"--------------------------------------------------------------\"\n let nr = 10 :: Int\n mapM_\n (\\n -> do\n putStr $ \"| \" ++ show n ++ \" | \"\n#if HMATRIX\n SpecConcreteNetwork1D1D (net0 :: Network layers shapes) <- networkFromSpecificationWith (NetworkInitSettings HeEtAl HMatrix Nothing) netSpec\n#else\n SpecConcreteNetwork1D1D (net0 :: Network layers shapes) <- networkFromSpecificationWith (NetworkInitSettings HeEtAl BLAS Nothing) netSpec\n#endif\n -- We need to specify the actual number of output nodes, as our functions requiere that!\n case (unsafeCoerce (Dict :: Dict ()) :: Dict (('D1 1) ~ Last shapes)) of\n Dict -> do\n net <- netTrain net0 rate examples\n unsafeCoerce $ -- only needed as GADTs are enabled, which disallowes the type to escape and thus prevents the type inference to work. The result is not needed anyways.\n testValues net)\n [1 .. nr]\n\n\n -- Features of dynamic networks:\n SpecConcreteNetwork1D1D (net' :: Network layers shapes) <- networkFromSpecificationWith (NetworkInitSettings HeEtAl BLAS (Just 50000)) netSpec\n net2 <- netTrain net' rate 0\n let spec' = networkToSpecification net2\n putStrLn \"String represenation of the network specification: \"\n print spec'\n let serializedSpec = encode spec' -- only the specification (not the weights) are serialized here! The weights can be serialized using the networks serialize instance!\n let _ = encode net2 -- E.g. like this.\n case decode serializedSpec of\n Left err -> print err\n Right spec2 -> do\n print spec2\n SpecConcreteNetwork1D1D (net3 :: Network layers3 shapes3) <- networkFromSpecificationWith (NetworkInitSettings HeEtAl BLAS (Just 50000)) spec2\n net4 <- foldM (\\n _ -> netTrain n rate examples) net3 [(1 :: Int)..30]\n case (unsafeCoerce (Dict :: Dict ()) :: Dict (('D1 1) ~ Last shapes3)) of\n Dict -> netScore net4\n\n -- -- There is a also nice interface available also\n -- SpecConcreteNetwork1D1D newNet <- buildNetViaInterface\n -- print (networkToSpecification newNet)\n", "meta": {"hexsha": "c6e195f608ec316f2c6ea36a39758e88d336cc37", "size": 10240, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "examples/main/feedforward-weightinit.hs", "max_stars_repo_name": "schnecki/grenade", "max_stars_repo_head_hexsha": "027e9c16899e2ca3685e89338a047488ac834249", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-01-11T15:05:38.000Z", "max_stars_repo_stars_event_max_datetime": "2021-01-11T15:05:38.000Z", "max_issues_repo_path": "examples/main/feedforward-weightinit.hs", "max_issues_repo_name": "schnecki/grenade", "max_issues_repo_head_hexsha": "027e9c16899e2ca3685e89338a047488ac834249", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "examples/main/feedforward-weightinit.hs", "max_forks_repo_name": "schnecki/grenade", "max_forks_repo_head_hexsha": "027e9c16899e2ca3685e89338a047488ac834249", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2018-07-02T01:04:29.000Z", "max_forks_repo_forks_event_max_datetime": "2021-01-08T13:08:47.000Z", "avg_line_length": 41.9672131148, "max_line_length": 198, "alphanum_fraction": 0.60078125, "num_tokens": 3009, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.749087201911703, "lm_q2_score": 0.44939263446475963, "lm_q1q2_score": 0.3366342711109355}} {"text": "-- | Helpers for testing\nmodule Tests.Helpers (\n -- * helpers\n T(..)\n , typeName\n , eq\n , eqC\n -- * Generic QC tests\n , monotonicallyIncreases\n -- * HUnit helpers\n , testAssertion\n , testEquality\n ) where\n\nimport Data.Complex\nimport Data.Typeable\n\nimport qualified Test.HUnit as HU\nimport Test.Framework\nimport Test.Framework.Providers.HUnit\n\nimport Numeric.MathFunctions.Comparison\n\n\n\n----------------------------------------------------------------\n-- Helpers\n----------------------------------------------------------------\n\n-- | Phantom typed value used to select right instance in QC tests\ndata T a = T\n\n-- | String representation of type name\ntypeName :: Typeable a => T a -> String\ntypeName = show . typeOf . typeParam\n where\n typeParam :: T a -> a\n typeParam _ = undefined\n\n-- | Approximate equality for 'Double'. Doesn't work well for numbers\n-- which are almost zero.\neq :: Double -- ^ Relative error\n -> Double -> Double -> Bool\neq = eqRelErr\n\n-- | Approximate equality for 'Complex Double'\neqC :: Double -- ^ Relative error\n -> Complex Double\n -> Complex Double\n -> Bool\neqC eps a@(ar :+ ai) b@(br :+ bi)\n | a == 0 && b == 0 = True\n | otherwise = abs (ar - br) <= eps * d\n && abs (ai - bi) <= eps * d\n where\n d = max (realPart $ abs a) (realPart $ abs b)\n\n\n\n----------------------------------------------------------------\n-- Generic QC\n----------------------------------------------------------------\n\n-- Check that function is nondecreasing\nmonotonicallyIncreases :: (Ord a, Ord b) => (a -> b) -> a -> a -> Bool\nmonotonicallyIncreases f x1 x2 = f (min x1 x2) <= f (max x1 x2)\n\n\n\n----------------------------------------------------------------\n-- HUnit helpers\n----------------------------------------------------------------\n\ntestAssertion :: String -> Bool -> Test\ntestAssertion str cont = testCase str $ HU.assertBool str cont\n\ntestEquality :: (Show a, Eq a) => String -> a -> a -> Test\ntestEquality msg a b = testCase msg $ HU.assertEqual msg a b\n", "meta": {"hexsha": "773046cb154d854f11276fb362bec87cf32aa9b2", "size": 2078, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "tests/Tests/Helpers.hs", "max_stars_repo_name": "Javran/math-functions", "max_stars_repo_head_hexsha": "11af626bc519c3cb340ce10069906b1b0dd7afaf", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "tests/Tests/Helpers.hs", "max_issues_repo_name": "Javran/math-functions", "max_issues_repo_head_hexsha": "11af626bc519c3cb340ce10069906b1b0dd7afaf", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "tests/Tests/Helpers.hs", "max_forks_repo_name": "Javran/math-functions", "max_forks_repo_head_hexsha": "11af626bc519c3cb340ce10069906b1b0dd7afaf", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 26.3037974684, "max_line_length": 70, "alphanum_fraction": 0.5048123195, "num_tokens": 479, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.519521321952093, "lm_q2_score": 0.6477982247516796, "lm_q1q2_score": 0.33654499008121164}} {"text": "{-# LANGUAGE DataKinds #-}\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE ScopedTypeVariables #-}\n{-# LANGUAGE MultiParamTypeClasses #-}\n\nmodule Utils where\n\nimport Data.Complex\nimport Data.IntMap.Strict\nimport Expression\nimport Hash\nimport Prelude hiding ((*), (+), lookup)\n\n-- | Auxiliary functions for operations\n--\nexpressionNumType :: (NumType rc) => Expression d rc -> RC\nexpressionNumType (Expression n mp) =\n case lookup n mp of\n Just (_, node) -> nodeNumType node\n _ -> error \"expression not in map\"\n\nexpressionShape :: (DimensionType d) => Expression d rc -> Shape\nexpressionShape (Expression n mp) =\n case lookup n mp of\n Just (dim, _) -> dim\n _ -> error \"expression not in map\"\n\nretrieveNode :: ExpressionMap -> Int -> Node\nretrieveNode mp n =\n case lookup n mp of\n Just (_, node) -> node\n _ -> error \"node not in map\"\n\nensureSameShape :: (Ring d rc) => Expression d rc -> Expression d rc -> a -> a\nensureSameShape e1 e2 after =\n if expressionShape e1 == expressionShape e2\n then after\n else error \"Ensure same shape failed\"\n\n\nfromReal :: Double -> Complex Double\nfromReal x = x :+ 0\n", "meta": {"hexsha": "cca8fe66b8e3686bbdfd6d4ac54d1f7206a8f8d1", "size": 1153, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/Utils.hs", "max_stars_repo_name": "dandoh/NeatExpression", "max_stars_repo_head_hexsha": "6e3ac12fea6db128f3bca6050e232fd1dc321164", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-01-07T02:38:17.000Z", "max_stars_repo_stars_event_max_datetime": "2020-01-07T02:38:17.000Z", "max_issues_repo_path": "src/Utils.hs", "max_issues_repo_name": "dandoh/NeatExpression", "max_issues_repo_head_hexsha": "6e3ac12fea6db128f3bca6050e232fd1dc321164", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/Utils.hs", "max_forks_repo_name": "dandoh/NeatExpression", "max_forks_repo_head_hexsha": "6e3ac12fea6db128f3bca6050e232fd1dc321164", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 26.8139534884, "max_line_length": 78, "alphanum_fraction": 0.6608846487, "num_tokens": 279, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.6477982179521103, "lm_q2_score": 0.519521321952093, "lm_q1q2_score": 0.3365449865486904}} {"text": "{-# LANGUAGE BangPatterns #-}\n{-# LANGUAGE ScopedTypeVariables #-}\n\n\nmodule ImageLoader\n(\n loadExamples\n, loadNonExamples\n)\n\nwhere\n\n--------------------------------------------------------------------------------\n\n\nimport Control.Exception ( Exception\n , try )\nimport Control.Monad ( sequence )\nimport System.FilePath ( FilePath\n , () )\nimport Vision.Image.Type ( manifestVector )\nimport Vision.Image.RGB.Type ( RGB )\nimport Vision.Image.Grey.Type ( Grey )\nimport Vision.Image.Storage.DevIL ( Autodetect (..)\n , load )\nimport Paths_img_neural ( getDataFileName )\n\n\nimport qualified Data.Vector.Storable as VS\nimport qualified Numeric.LinearAlgebra.Data as VD\n\n--------------------------------------------------------------------------------\n\ntype Samples = [(VD.Vector Double, VD.Vector Double)]\n\n\n-- Load the vectors which represent an example of the letter A\nloadExamples :: Exception e => IO (Either e Samples)\nloadExamples = try $ do\n images <- loadImages exampleImageNames\n return $ map (\\x -> (x, output)) images\n where output = VD.fromList [1 :: Double]\n\n\n-- Load the vectors which do not represent an example of the letter A\nloadNonExamples :: Exception e => IO (Either e Samples)\nloadNonExamples = try $ do\n images <- loadImages nonExampleImageNames\n return $ map (\\x -> (x, output)) images\n where output = VD.fromList [0 :: Double]\n\n--------------------------------------------------------------------------------\n\n-- Lists all images that are examples of the letter A\nexampleImageNames :: [FilePath]\nexampleImageNames = map (\"A\" ) [\n \"A1.png\"\n , \"A2.png\"\n , \"A3.png\"\n , \"A4.png\"\n , \"A5.png\"\n , \"A6.png\" ]\n\n\n-- Lists all images that are _not_ examples of the letter A\nnonExampleImageNames :: [FilePath]\nnonExampleImageNames = map (\"not-A\" ) [\n \"B1.png\"\n , \"B2.png\"\n , \"B3.png\"\n , \"B4.png\"\n , \"B5.png\"\n , \"B6.png\"\n , \"B7.png\" ]\n\n\n-- Loads images from the given list\nloadImages :: [FilePath] -> IO [VD.Vector Double]\nloadImages fp = do\n fnames <- map' getFileName fp\n vectors <- map' loadFile fnames\n return $ map convertToLinearVector vectors\n where map' f xs = sequence $ map f xs\n getFileName = getDataFileName . (\"res\" )\n\n\n-- Loads the given file to an image, converted to a Vector\nloadFile :: FilePath -> IO (VS.Vector Double)\nloadFile f = do\n dat <- load Autodetect f\n case dat\n of Left e -> error $ show e\n Right (i :: Grey) -> return $ greyManifestToVector i\n\n\n-- Converts a Grey into a Vector Int\ngreyManifestToVector :: Grey -> VS.Vector Double\ngreyManifestToVector m = VS.map (\\i -> 1 - (fromIntegral $ round $ (fromIntegral i)/256)) (manifestVector m)\n\n\n-- Converts a Data/Vector to a LinearAlgebra/Vector\nconvertToLinearVector :: VS.Storable a => VS.Vector a -> VD.Vector a\nconvertToLinearVector = VD.fromList . VS.toList\n", "meta": {"hexsha": "05c3fda5fee84cabee9be7eb59e13535d3d13af6", "size": 3259, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/ImageLoader.hs", "max_stars_repo_name": "robmcl4/A-Neural", "max_stars_repo_head_hexsha": "7eb283de2d5602787c7919e15da4f0d77af08844", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2016-05-13T06:21:09.000Z", "max_stars_repo_stars_event_max_datetime": "2020-03-06T05:07:55.000Z", "max_issues_repo_path": "src/ImageLoader.hs", "max_issues_repo_name": "robmcl4/A-Neural", "max_issues_repo_head_hexsha": "7eb283de2d5602787c7919e15da4f0d77af08844", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/ImageLoader.hs", "max_forks_repo_name": "robmcl4/A-Neural", "max_forks_repo_head_hexsha": "7eb283de2d5602787c7919e15da4f0d77af08844", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-08-31T14:56:23.000Z", "max_forks_repo_forks_event_max_datetime": "2021-08-31T14:56:23.000Z", "avg_line_length": 31.3365384615, "max_line_length": 108, "alphanum_fraction": 0.5418840135, "num_tokens": 711, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.66192288918838, "lm_q2_score": 0.5078118642792044, "lm_q1q2_score": 0.33613229636782854}} {"text": "{-# LANGUAGE DataKinds, RankNTypes, TypeFamilies #-}\nmodule TestMnistFCNN\n ( testTrees, shortTestForCITrees, mnistTestCase2T, mnistTestCase2D\n ) where\n\nimport Prelude\n\nimport Control.DeepSeq\nimport Control.Monad (foldM, when)\nimport Data.Array.Internal (valueOf)\nimport Data.Coerce (coerce)\nimport Data.List.Index (imap)\nimport Data.Proxy (Proxy (Proxy))\nimport Data.Time.Clock.POSIX (POSIXTime, getPOSIXTime)\nimport qualified Data.Vector.Generic as V\nimport GHC.TypeLits (KnownNat)\nimport qualified Numeric.LinearAlgebra as HM\nimport System.IO (hFlush, hPutStrLn, stderr)\nimport System.Random\nimport Test.Tasty\nimport Test.Tasty.HUnit hiding (assert)\nimport Test.Tasty.QuickCheck hiding (label, shuffle)\nimport Text.Printf\n\nimport HordeAd\nimport HordeAd.Core.OutdatedOptimizer\nimport HordeAd.Tool.MnistTools\n\nimport TestCommon\n\ntestTrees :: [TestTree]\ntestTrees = [ dumbMnistTests\n , bigMnistTests\n , vectorMnistTests\n , matrixMnistTests\n , fusedMnistTests\n ]\n\nshortTestForCITrees :: [TestTree]\nshortTestForCITrees = [ dumbMnistTests\n , shortCIMnistTests\n ]\n\nsgdShow :: HasDelta r\n => r\n -> (a -> DualNumberVariables 'DModeGradient r -> DualMonadGradient r (DualNumber 'DModeGradient r))\n -> [a] -- ^ training data\n -> Domain0 r -- ^ initial parameters\n -> r\nsgdShow gamma f trainData params0Init =\n let result =\n fst $ sgd gamma f trainData (params0Init, V.empty, V.empty, V.empty)\n in snd $ dReverse 1 (f $ head trainData) result\n\nsgdTestCase :: String\n -> IO [a]\n -> (Int\n -> Int\n -> a\n -> DualNumberVariables 'DModeGradient Double\n -> DualMonadGradient Double\n (DualNumber 'DModeGradient Double))\n -> Double\n -> Double\n -> TestTree\nsgdTestCase prefix trainDataIO trainWithLoss gamma expected =\n let widthHidden = 250\n widthHidden2 = 50\n nParams0 = fcnnMnistLen0 widthHidden widthHidden2\n vec = HM.randomVector 33 HM.Uniform nParams0 - HM.scalar 0.5\n name = prefix ++ \" \"\n ++ unwords [show widthHidden, show nParams0, show gamma]\n in testCase name $ do\n trainData <- trainDataIO\n sgdShow gamma (trainWithLoss widthHidden widthHidden2)\n trainData vec\n @?= expected\n\nmnistTestCase2\n :: String\n -> Int\n -> Int\n -> (Int\n -> Int\n -> MnistData Double\n -> DualNumberVariables 'DModeGradient Double\n -> DualMonadGradient Double (DualNumber 'DModeGradient Double))\n -> Int\n -> Int\n -> Double\n -> Double\n -> TestTree\nmnistTestCase2 prefix epochs maxBatches trainWithLoss widthHidden widthHidden2\n gamma expected =\n let nParams0 = fcnnMnistLen0 widthHidden widthHidden2\n params0Init = HM.randomVector 44 HM.Uniform nParams0 - HM.scalar 0.5\n name = prefix ++ \": \"\n ++ unwords [ show epochs, show maxBatches\n , show widthHidden, show widthHidden2\n , show nParams0, show gamma ]\n in testCase name $ do\n hPutStrLn stderr $ printf \"\\n%s: Epochs to run/max batches per epoch: %d/%d\"\n prefix epochs maxBatches\n trainData <- loadMnistData trainGlyphsPath trainLabelsPath\n testData <- loadMnistData testGlyphsPath testLabelsPath\n -- Mimic how backprop tests and display it, even though tests\n -- should not print, in principle.\n let runBatch :: Domain0 Double -> (Int, [MnistData Double])\n -> IO (Domain0 Double)\n runBatch !params0 (k, chunk) = do\n let f = trainWithLoss widthHidden widthHidden2\n (!res, _, _, _) =\n fst $ sgd gamma f chunk (params0, V.empty, V.empty, V.empty)\n !trainScore = fcnnMnistTest0 (Proxy @Double)\n widthHidden widthHidden2 chunk res\n !testScore = fcnnMnistTest0 (Proxy @Double)\n widthHidden widthHidden2 testData res\n !lenChunk = length chunk\n hPutStrLn stderr $ printf \"\\n%s: (Batch %d with %d points)\" prefix k lenChunk\n hPutStrLn stderr $ printf \"%s: Training error: %.2f%%\" prefix ((1 - trainScore) * 100)\n hPutStrLn stderr $ printf \"%s: Validation error: %.2f%%\" prefix ((1 - testScore ) * 100)\n return res\n let runEpoch :: Int -> Domain0 Double -> IO (Domain0 Double)\n runEpoch n params0 | n > epochs = return params0\n runEpoch n params0 = do\n hPutStrLn stderr $ printf \"\\n%s: [Epoch %d]\" prefix n\n let trainDataShuffled = shuffle (mkStdGen $ n + 5) trainData\n chunks = take maxBatches\n $ zip [1 ..] $ chunksOf 5000 trainDataShuffled\n !res <- foldM runBatch params0 chunks\n runEpoch (succ n) res\n res <- runEpoch 1 params0Init\n let testErrorFinal = 1 - fcnnMnistTest0 (Proxy @Double) widthHidden widthHidden2 testData res\n testErrorFinal @?= expected\n\nmnistTestCase2V\n :: String\n -> Int\n -> Int\n -> (Int\n -> Int\n -> MnistData Double\n -> DualNumberVariables 'DModeGradient Double\n -> DualMonadGradient Double (DualNumber 'DModeGradient Double))\n -> Int\n -> Int\n -> Double\n -> Double\n -> TestTree\nmnistTestCase2V prefix epochs maxBatches trainWithLoss widthHidden widthHidden2\n gamma expected =\n let (nParams0, nParams1, _, _) = fcnnMnistLen1 widthHidden widthHidden2\n params0Init = HM.randomVector 44 HM.Uniform nParams0 - HM.scalar 0.5\n params1Init = V.fromList $\n imap (\\i nPV -> HM.randomVector (44 + nPV + i) HM.Uniform nPV\n - HM.scalar 0.5)\n nParams1\n name = prefix ++ \": \"\n ++ unwords [ show epochs, show maxBatches\n , show widthHidden, show widthHidden2\n , show nParams0, show (length nParams1)\n , show (sum nParams1 + nParams0), show gamma ]\n in testCase name $ do\n hPutStrLn stderr $ printf \"\\n%s: Epochs to run/max batches per epoch: %d/%d\"\n prefix epochs maxBatches\n trainData <- loadMnistData trainGlyphsPath trainLabelsPath\n testData <- loadMnistData testGlyphsPath testLabelsPath\n -- Mimic how backprop tests and display it, even though tests\n -- should not print, in principle.\n let runBatch :: (Domain0 Double, Domain1 Double)\n -> (Int, [MnistData Double])\n -> IO (Domain0 Double, Domain1 Double)\n runBatch (!params0, !params1) (k, chunk) = do\n let f = trainWithLoss widthHidden widthHidden2\n (resS, resV, _, _) =\n fst $ sgd gamma f chunk (params0, params1, V.empty, V.empty)\n res = (resS, resV)\n !trainScore = fcnnMnistTest1\n widthHidden widthHidden2 chunk res\n !testScore = fcnnMnistTest1\n widthHidden widthHidden2 testData res\n !lenChunk = length chunk\n hPutStrLn stderr $ printf \"\\n%s: (Batch %d with %d points)\" prefix k lenChunk\n hPutStrLn stderr $ printf \"%s: Training error: %.2f%%\" prefix ((1 - trainScore) * 100)\n hPutStrLn stderr $ printf \"%s: Validation error: %.2f%%\" prefix ((1 - testScore ) * 100)\n return res\n let runEpoch :: Int -> (Domain0 Double, Domain1 Double)\n -> IO (Domain0 Double, Domain1 Double)\n runEpoch n params2 | n > epochs = return params2\n runEpoch n params2 = do\n hPutStrLn stderr $ printf \"\\n%s: [Epoch %d]\" prefix n\n let trainDataShuffled = shuffle (mkStdGen $ n + 5) trainData\n chunks = take maxBatches\n $ zip [1 ..] $ chunksOf 5000 trainDataShuffled\n !res <- foldM runBatch params2 chunks\n runEpoch (succ n) res\n res <- runEpoch 1 (params0Init, params1Init)\n let testErrorFinal =\n 1 - fcnnMnistTest1 widthHidden widthHidden2 testData res\n testErrorFinal @?= expected\n\nfcnnMnistLossTanh :: DualMonad 'DModeGradient Double m\n => Int\n -> Int\n -> MnistData Double\n -> DualNumberVariables 'DModeGradient Double\n -> m (DualNumber 'DModeGradient Double)\nfcnnMnistLossTanh widthHidden widthHidden2 (xs, targ) vec = do\n res <- fcnnMnist0 tanhAct softMaxAct widthHidden widthHidden2 xs vec\n lossCrossEntropy targ res\n\nfcnnMnistLossRelu :: DualMonad 'DModeGradient Double m\n => Int\n -> Int\n -> MnistData Double\n -> DualNumberVariables 'DModeGradient Double\n -> m (DualNumber 'DModeGradient Double)\nfcnnMnistLossRelu widthHidden widthHidden2 (xs, targ) vec = do\n res <- fcnnMnist0 reluAct softMaxAct widthHidden widthHidden2 xs vec\n lossCrossEntropy targ res\n\nmnistTestCase2L\n :: String\n -> Int\n -> Int\n -> (MnistData Double\n -> DualNumberVariables 'DModeGradient Double\n -> DualMonadGradient Double (DualNumber 'DModeGradient Double))\n -> Int\n -> Int\n -> Double\n -> Double\n -> TestTree\nmnistTestCase2L prefix epochs maxBatches trainWithLoss widthHidden widthHidden2\n gamma expected =\n let ((nParams0, nParams1, nParams2, _), totalParams, range, parameters0) =\n initializerFixed 44 0.5 (fcnnMnistLen2 widthHidden widthHidden2)\n name = prefix ++ \": \"\n ++ unwords [ show epochs, show maxBatches\n , show widthHidden, show widthHidden2\n , show nParams0, show nParams1, show nParams2\n , show totalParams, show gamma, show range]\n in testCase name $ do\n hPutStrLn stderr $ printf \"\\n%s: Epochs to run/max batches per epoch: %d/%d\"\n prefix epochs maxBatches\n trainData <- loadMnistData trainGlyphsPath trainLabelsPath\n testData <- loadMnistData testGlyphsPath testLabelsPath\n -- Mimic how backprop tests and display it, even though tests\n -- should not print, in principle.\n let runBatch :: Domains Double\n -> (Int, [MnistData Double])\n -> IO (Domains Double)\n runBatch (!params0, !params1, !params2, !paramsX) (k, chunk) = do\n let f = trainWithLoss\n res = fst $ sgd gamma f chunk\n (params0, params1, params2, paramsX)\n !trainScore = fcnnMnistTest2 @Double chunk res\n !testScore = fcnnMnistTest2 @Double testData res\n !lenChunk = length chunk\n hPutStrLn stderr $ printf \"\\n%s: (Batch %d with %d points)\" prefix k lenChunk\n hPutStrLn stderr $ printf \"%s: Training error: %.2f%%\" prefix ((1 - trainScore) * 100)\n hPutStrLn stderr $ printf \"%s: Validation error: %.2f%%\" prefix ((1 - testScore ) * 100)\n return res\n let runEpoch :: Int\n -> Domains Double\n -> IO (Domains Double)\n runEpoch n params2 | n > epochs = return params2\n runEpoch n params2 = do\n hPutStrLn stderr $ printf \"\\n%s: [Epoch %d]\" prefix n\n let trainDataShuffled = shuffle (mkStdGen $ n + 5) trainData\n chunks = take maxBatches\n $ zip [1 ..] $ chunksOf 5000 trainDataShuffled\n !res <- foldM runBatch params2 chunks\n runEpoch (succ n) res\n res <- runEpoch 1 parameters0\n let testErrorFinal = 1 - fcnnMnistTest2 testData res\n testErrorFinal @?= expected\n\nmnistTestCase2T\n :: Bool\n -> String\n -> Int\n -> Int\n -> (MnistData Double\n -> DualNumberVariables 'DModeGradient Double\n -> DualMonadGradient Double (DualNumber 'DModeGradient Double))\n -> Int\n -> Int\n -> Double\n -> Double\n -> TestTree\nmnistTestCase2T reallyWriteFile\n prefix epochs maxBatches trainWithLoss widthHidden widthHidden2\n gamma expected =\n let ((nParams0, nParams1, nParams2, _), totalParams, range, !parameters0) =\n initializerFixed 44 0.5 (fcnnMnistLen2 widthHidden widthHidden2)\n name = prefix ++ \" \"\n ++ unwords [ show epochs, show maxBatches\n , show widthHidden, show widthHidden2\n , show nParams0, show nParams1, show nParams2\n , show totalParams, show gamma, show range]\n in testCase name $ do\n hPutStrLn stderr $ printf \"\\n%s: Epochs to run/max batches per epoch: %d/%d\"\n prefix epochs maxBatches\n trainData0 <- loadMnistData trainGlyphsPath trainLabelsPath\n testData <- loadMnistData testGlyphsPath testLabelsPath\n let !trainData = force $ shuffle (mkStdGen 6) trainData0\n -- Mimic how backprop tests and display it, even though tests\n -- should not print, in principle.\n let runBatch :: (Domains Double, [(POSIXTime, Double)])\n -> (Int, [MnistData Double])\n -> IO (Domains Double, [(POSIXTime, Double)])\n runBatch ((!params0, !params1, !params2, !paramsX), !times)\n (k, chunk) = do\n when (k `mod` 100 == 0) $ do\n hPutStrLn stderr $ printf \"%s: %d \" prefix k\n hFlush stderr\n let f = trainWithLoss\n (!params0New, !value) =\n sgd gamma f chunk (params0, params1, params2, paramsX)\n time <- getPOSIXTime\n return (params0New, (time, value) : times)\n let runEpoch :: Int\n -> (Domains Double, [(POSIXTime, Double)])\n -> IO (Domains Double, [(POSIXTime, Double)])\n runEpoch n params2times | n > epochs = return params2times\n runEpoch n (!params2, !times2) = do\n hPutStrLn stderr $ printf \"\\n%s: [Epoch %d]\" prefix n\n let !trainDataShuffled =\n if n > 1\n then shuffle (mkStdGen $ n + 5) trainData\n else trainData\n chunks = take maxBatches\n $ zip [1 ..] $ chunksOf 1 trainDataShuffled\n res <- foldM runBatch (params2, times2) chunks\n runEpoch (succ n) res\n timeBefore <- getPOSIXTime\n (res, times) <- runEpoch 1 (parameters0, [])\n let ppTime (t, l) = init (show (t - timeBefore)) ++ \" \" ++ show l\n when reallyWriteFile $\n writeFile \"walltimeLoss.txt\" $ unlines $ map ppTime times\n let testErrorFinal = 1 - fcnnMnistTest2 testData res\n testErrorFinal @?= expected\n\nmnistTestCase2D\n :: Bool\n -> Int\n -> Bool\n -> String\n -> Int\n -> Int\n -> (MnistData Double\n -> DualNumberVariables 'DModeGradient Double\n -> DualMonadGradient Double (DualNumber 'DModeGradient Double))\n -> Int\n -> Int\n -> Double\n -> Double\n -> TestTree\nmnistTestCase2D reallyWriteFile miniBatchSize decay\n prefix epochs maxBatches trainWithLoss widthHidden widthHidden2\n gamma0 expected =\n let np = fcnnMnistLen2 widthHidden widthHidden2\n ((nParams0, nParams1, nParams2, _), totalParams, range, !parameters0) =\n initializerFixed 44 0.5 np\n name = prefix ++ \" \"\n ++ unwords [ show epochs, show maxBatches\n , show widthHidden, show widthHidden2\n , show nParams0, show nParams1, show nParams2\n , show totalParams, show gamma0, show range]\n in testCase name $ do\n hPutStrLn stderr $ printf \"\\n%s: Epochs to run/max batches per epoch: %d/%d\"\n prefix epochs maxBatches\n trainData0 <- loadMnistData trainGlyphsPath trainLabelsPath\n testData <- loadMnistData testGlyphsPath testLabelsPath\n let !trainData = force $ shuffle (mkStdGen 6) trainData0\n -- Mimic how backprop tests and display it, even though tests\n -- should not print, in principle.\n let runBatch :: (Domains Double, [(POSIXTime, Double)])\n -> (Int, [MnistData Double])\n -> IO (Domains Double, [(POSIXTime, Double)])\n runBatch ((!params0, !params1, !params2, !paramsX), !times)\n (k, chunk) = do\n when (k `mod` 100 == 0) $ do\n hPutStrLn stderr $ printf \"%s: %d \" prefix k\n hFlush stderr\n let f = trainWithLoss\n gamma = if decay\n then gamma0 * exp (- fromIntegral k * 1e-4)\n else gamma0\n (!params0New, !value) =\n sgdBatchForward (33 + k * 7) miniBatchSize gamma f chunk\n (params0, params1, params2, paramsX) np\n time <- getPOSIXTime\n return (params0New, (time, value) : times)\n let runEpoch :: Int\n -> (Domains Double, [(POSIXTime, Double)])\n -> IO (Domains Double, [(POSIXTime, Double)])\n runEpoch n params2times | n > epochs = return params2times\n runEpoch n (!params2, !times2) = do\n hPutStrLn stderr $ printf \"\\n%s: [Epoch %d]\" prefix n\n let !trainDataShuffled =\n if n > 1\n then shuffle (mkStdGen $ n + 5) trainData\n else trainData\n chunks = take maxBatches\n $ zip [1 ..]\n $ chunksOf miniBatchSize trainDataShuffled\n res <- foldM runBatch (params2, times2) chunks\n runEpoch (succ n) res\n timeBefore <- getPOSIXTime\n (res, times) <- runEpoch 1 (parameters0, [])\n let ppTime (t, l) = init (show (t - timeBefore)) ++ \" \" ++ show l\n when reallyWriteFile $\n writeFile \"walltimeLoss.txt\" $ unlines $ map ppTime times\n let testErrorFinal = 1 - fcnnMnistTest2 testData res\n testErrorFinal @?= expected\n\nmnistTestCase2F\n :: Bool\n -> Int\n -> Bool\n -> String\n -> Int\n -> Int\n -> (MnistData Double\n -> DualNumberVariables 'DModeDerivative Double\n -> DualMonadForward Double (DualNumber 'DModeDerivative Double))\n -> Int\n -> Int\n -> Double\n -> Double\n -> TestTree\nmnistTestCase2F reallyWriteFile miniBatchSize decay\n prefix epochs maxBatches trainWithLoss widthHidden widthHidden2\n gamma0 expected =\n let np = fcnnMnistLen2 widthHidden widthHidden2\n ((nParams0, nParams1, nParams2, _), totalParams, range, !parameters0) =\n initializerFixed 44 0.5 np\n name = prefix ++ \" \"\n ++ unwords [ show epochs, show maxBatches\n , show widthHidden, show widthHidden2\n , show nParams0, show nParams1, show nParams2\n , show totalParams, show gamma0, show range]\n in testCase name $ do\n hPutStrLn stderr $ printf \"\\n%s: Epochs to run/max batches per epoch: %d/%d\"\n prefix epochs maxBatches\n trainData0 <- loadMnistData trainGlyphsPath trainLabelsPath\n testData <- loadMnistData testGlyphsPath testLabelsPath\n let !trainData = coerce $ force $ shuffle (mkStdGen 6) trainData0\n -- Mimic how backprop tests and display it, even though tests\n -- should not print, in principle.\n let runBatch :: (Domains Double, [(POSIXTime, Double)])\n -> (Int, [MnistData Double])\n -> IO (Domains Double, [(POSIXTime, Double)])\n runBatch ((!params0, !params1, !params2, !paramsX), !times)\n (k, chunk) = do\n when (k `mod` 100 == 0) $ do\n hPutStrLn stderr $ printf \"%s: %d \" prefix k\n hFlush stderr\n let f = trainWithLoss\n gamma = if decay\n then gamma0 * exp (- fromIntegral k * 1e-4)\n else gamma0\n (!params0New, !value) =\n sgdBatchFastForward (33 + k * 7) miniBatchSize gamma f chunk\n (params0, params1, params2, paramsX) np\n time <- getPOSIXTime\n return (params0New, (time, value) : times)\n let runEpoch :: Int\n -> (Domains Double, [(POSIXTime, Double)])\n -> IO (Domains Double, [(POSIXTime, Double)])\n runEpoch n params2times | n > epochs = return params2times\n runEpoch n (!params2, !times2) = do\n hPutStrLn stderr $ printf \"\\n%s: [Epoch %d]\" prefix n\n let !trainDataShuffled =\n if n > 1\n then shuffle (mkStdGen $ n + 5) trainData\n else trainData\n chunks = take maxBatches\n $ zip [1 ..]\n $ chunksOf miniBatchSize trainDataShuffled\n res <- foldM runBatch (params2, times2) chunks\n runEpoch (succ n) res\n timeBefore <- getPOSIXTime\n (res, times) <- runEpoch 1 (parameters0, [])\n let ppTime (t, l) = init (show (t - timeBefore)) ++ \" \" ++ show l\n when reallyWriteFile $\n writeFile \"walltimeLoss.txt\" $ unlines $ map ppTime times\n let testErrorFinal = 1 - fcnnMnistTest2 testData res\n testErrorFinal @?= expected\n\nmnistTestCase2S\n :: forall widthHidden widthHidden2.\n (KnownNat widthHidden, KnownNat widthHidden2)\n => Proxy widthHidden -> Proxy widthHidden2\n -> String\n -> Int\n -> Int\n -> (forall d r m. DualMonad d r m\n => Proxy widthHidden -> Proxy widthHidden2\n -> MnistData r -> DualNumberVariables d r -> m (DualNumber d r))\n -> Double\n -> Double\n -> TestTree\nmnistTestCase2S proxy proxy2\n prefix epochs maxBatches trainWithLoss gamma expected =\n let ((_, _, _, nParamsX), totalParams, range, parametersInit) =\n initializerFixed 44 0.5 (fcnnMnistLenS @widthHidden @widthHidden2)\n name = prefix ++ \": \"\n ++ unwords [ show epochs, show maxBatches\n , show (valueOf @widthHidden :: Int)\n , show (valueOf @widthHidden2 :: Int)\n , show nParamsX, show totalParams\n , show gamma, show range ]\n in testCase name $ do\n hPutStrLn stderr $ printf \"\\n%s: Epochs to run/max batches per epoch: %d/%d\"\n prefix epochs maxBatches\n trainData <- loadMnistData trainGlyphsPath trainLabelsPath\n testData <- loadMnistData testGlyphsPath testLabelsPath\n let runBatch :: Domains Double\n -> (Int, [MnistData Double])\n -> IO (Domains Double)\n runBatch (!params0, !params1, !params2, !paramsX) (k, chunk) = do\n let f = trainWithLoss proxy proxy2\n res = fst $ sgd gamma f chunk\n (params0, params1, params2, paramsX)\n !trainScore = fcnnMnistTestS @widthHidden @widthHidden2\n chunk res\n !testScore = fcnnMnistTestS @widthHidden @widthHidden2\n testData res\n !lenChunk = length chunk\n hPutStrLn stderr $ printf \"\\n%s: (Batch %d with %d points)\" prefix k lenChunk\n hPutStrLn stderr $ printf \"%s: Training error: %.2f%%\" prefix ((1 - trainScore) * 100)\n hPutStrLn stderr $ printf \"%s: Validation error: %.2f%%\" prefix ((1 - testScore ) * 100)\n return res\n let runEpoch :: Int\n -> Domains Double\n -> IO (Domains Double)\n runEpoch n params2 | n > epochs = return params2\n runEpoch n params2 = do\n hPutStrLn stderr $ printf \"\\n%s: [Epoch %d]\" prefix n\n let trainDataShuffled = shuffle (mkStdGen $ n + 5) trainData\n chunks = take maxBatches\n $ zip [1 ..] $ chunksOf 5000 trainDataShuffled\n !res <- foldM runBatch params2 chunks\n runEpoch (succ n) res\n res <- runEpoch 1 parametersInit\n let testErrorFinal = 1 - fcnnMnistTestS @widthHidden @widthHidden2\n testData res\n testErrorFinal @?= expected\n\ndumbMnistTests :: TestTree\ndumbMnistTests = testGroup \"Dumb MNIST tests\"\n [ testCase \"1pretty-print in grey 3 2\" $ do\n let (nParams0, lParams1, lParams2, _) = fcnnMnistLen2 4 3\n vParams1 = V.fromList lParams1\n vParams2 = V.fromList lParams2\n params0 = V.replicate nParams0 (1 :: Float)\n params1 = V.map (`V.replicate` 2) vParams1\n params2 = V.map (HM.konst 3) vParams2\n blackGlyph = V.replicate sizeMnistGlyph 4\n blackLabel = V.replicate sizeMnistLabel 5\n trainData = (blackGlyph, blackLabel)\n output = prettyPrintDf False (fcnnMnistLoss2 trainData)\n (params0, params1, params2, V.empty)\n -- printf \"%s\" output\n length output @?= 13348\n , testCase \"2pretty-print in grey 3 2 fused\" $ do\n let (nParams0, lParams1, lParams2, _) = fcnnMnistLen2 4 3\n vParams1 = V.fromList lParams1\n vParams2 = V.fromList lParams2\n params0 = V.replicate nParams0 (1 :: Float)\n params1 = V.map (`V.replicate` 2) vParams1\n params2 = V.map (HM.konst 3) vParams2\n blackGlyph = V.replicate sizeMnistGlyph 4\n blackLabel = V.replicate sizeMnistLabel 5\n trainData = (blackGlyph, blackLabel)\n output = prettyPrintDf True (fcnnMnistLossFused2 trainData)\n (params0, params1, params2, V.empty)\n --- printf \"%s\" output\n length output @?= 12431\n , testCase \"3pretty-print on testset 3 2\" $ do\n let (_, _, _, parameters0) = initializerFixed 44 0.5 (fcnnMnistLen2 4 3)\n testData <- loadMnistData testGlyphsPath testLabelsPath\n let trainDataItem = head testData\n output = prettyPrintDf True (fcnnMnistLoss2 trainDataItem) parameters0\n -- printf \"%s\" output\n length output @?= 16449\n , let blackGlyph = V.replicate sizeMnistGlyph 0\n blackLabel = V.replicate sizeMnistLabel 0\n trainData = replicate 10 (blackGlyph, blackLabel)\n in sgdTestCase \"black\"\n (return trainData) fcnnMnistLoss0 0.02 (-0.0)\n , let whiteGlyph = V.replicate sizeMnistGlyph 1\n whiteLabel = V.replicate sizeMnistLabel 1\n trainData = replicate 20 (whiteGlyph, whiteLabel)\n in sgdTestCase \"white\"\n (return trainData) fcnnMnistLoss0 0.02 23.02585095418536\n , let blackGlyph = V.replicate sizeMnistGlyph 0\n whiteLabel = V.replicate sizeMnistLabel 1\n trainData = replicate 50 (blackGlyph, whiteLabel)\n in sgdTestCase \"black/white\"\n (return trainData) fcnnMnistLoss0 0.02 23.025850929940457\n , let glyph = V.unfoldrExactN sizeMnistGlyph (uniformR (0, 1))\n label = V.unfoldrExactN sizeMnistLabel (uniformR (0, 1))\n trainData = map ((\\g -> (glyph g, label g)) . mkStdGen) [1 .. 100]\n in sgdTestCase \"random 100\"\n (return trainData) fcnnMnistLoss0 0.02 11.089140063760212\n , sgdTestCase \"first 100 trainset samples only\"\n (take 100 <$> loadMnistData trainGlyphsPath trainLabelsPath)\n fcnnMnistLoss0 0.02 3.233123290489956\n , testCase \"fcnnMnistTest0 on 0.1 params0 300 100 width 10k testset\" $ do\n let nParams0 = fcnnMnistLen0 300 100\n params0 = V.replicate nParams0 0.1\n testData <- loadMnistData testGlyphsPath testLabelsPath\n (1 - fcnnMnistTest0 (Proxy @Double) 300 100 testData params0)\n @?= 0.902\n , testCase \"fcnnMnistTest2VV on 0.1 params0 300 100 width 10k testset\" $ do\n let (nParams0, nParams1, _, _) = fcnnMnistLen1 300 100\n params0 = V.replicate nParams0 0.1\n params1 = V.fromList $ map (`V.replicate` 0.1) nParams1\n testData <- loadMnistData testGlyphsPath testLabelsPath\n (1 - fcnnMnistTest1 300 100 testData (params0, params1))\n @?= 0.902\n , testCase \"fcnnMnistTest2LL on 0.1 params0 300 100 width 10k testset\" $ do\n let (nParams0, lParams1, lParams2, _) = fcnnMnistLen2 300 100\n vParams1 = V.fromList lParams1\n vParams2 = V.fromList lParams2\n params0 = V.replicate nParams0 0.1\n params1 = V.map (`V.replicate` 0.1) vParams1\n params2 = V.map (HM.konst 0.1) vParams2\n testData <- loadMnistData testGlyphsPath testLabelsPath\n (1 - fcnnMnistTest2 testData\n (params0, params1, params2, V.empty))\n @?= 0.902\n , testProperty \"Compare two forward derivatives and gradient for Mnist0\" $\n \\seed seedDs ->\n forAll (choose (1, 300)) $ \\widthHidden ->\n forAll (choose (1, 100)) $ \\widthHidden2 ->\n forAll (choose (0.01, 10)) $ \\range ->\n forAll (choose (0.01, 10)) $ \\rangeDs ->\n let createRandomVector n seedV = HM.randomVector seedV HM.Uniform n\n glyph = createRandomVector sizeMnistGlyph seed\n label = createRandomVector sizeMnistLabel seedDs\n mnistData :: MnistData Double\n mnistData = (glyph, label)\n nParams0 = fcnnMnistLen0 widthHidden widthHidden2\n paramShape = (nParams0, [], [], [])\n (_, _, _, parameters) = initializerFixed seed range paramShape\n (_, _, _, ds) = initializerFixed seedDs rangeDs paramShape\n (_, _, _, parametersPerturbation) =\n initializerFixed (seed + seedDs) 1e-7 paramShape\n f :: forall d r m. (DualMonad d r m, r ~ Double)\n => DualNumberVariables d r -> m (DualNumber d r)\n f = fcnnMnistLoss0 widthHidden widthHidden2 mnistData\n in\n qcPropDom f parameters ds parametersPerturbation 1\n , testProperty \"Compare two forward derivatives and gradient for Mnist1\" $\n \\seed seedDs ->\n forAll (choose (1, 2000)) $ \\widthHidden ->\n forAll (choose (1, 5000)) $ \\widthHidden2 ->\n forAll (choose (0.01, 0.5)) $ \\range -> -- large nn, so NaNs fast\n forAll (choose (0.01, 10)) $ \\rangeDs ->\n let createRandomVector n seedV = HM.randomVector seedV HM.Uniform n\n glyph = createRandomVector sizeMnistGlyph seed\n label = createRandomVector sizeMnistLabel seedDs\n mnistData :: MnistData Double\n mnistData = (glyph, label)\n paramShape = fcnnMnistLen1 widthHidden widthHidden2\n (_, _, _, parameters) = initializerFixed seed range paramShape\n (_, _, _, ds) = initializerFixed seedDs rangeDs paramShape\n (_, _, _, parametersPerturbation) =\n initializerFixed (seed + seedDs) 1e-7 paramShape\n f :: forall d r m. (DualMonad d r m, r ~ Double)\n => DualNumberVariables d r -> m (DualNumber d r)\n f = fcnnMnistLoss1 widthHidden widthHidden2 mnistData\n in\n qcPropDom f parameters ds parametersPerturbation 1\n , testProperty \"Compare two forward derivatives and gradient for Mnist2\" $\n \\seed ->\n forAll (choose (0, sizeMnistLabel - 1)) $ \\seedDs ->\n forAll (choose (1, 5000)) $ \\widthHidden ->\n forAll (choose (1, 1000)) $ \\widthHidden2 ->\n forAll (choose (0.01, 1)) $ \\range ->\n forAll (choose (0.01, 10)) $ \\rangeDs ->\n let createRandomVector n seedV = HM.randomVector seedV HM.Uniform n\n glyph = createRandomVector sizeMnistGlyph seed\n label = createRandomVector sizeMnistLabel seedDs\n labelOneHot = HM.konst 0 sizeMnistLabel V.// [(seedDs, 1)]\n mnistData, mnistDataOneHot :: MnistData Double\n mnistData = (glyph, label)\n mnistDataOneHot = (glyph, labelOneHot)\n paramShape = fcnnMnistLen2 widthHidden widthHidden2\n (_, _, _, parameters) = initializerFixed seed range paramShape\n (_, _, _, ds) = initializerFixed seedDs rangeDs paramShape\n (_, _, _, parametersPerturbation) =\n initializerFixed (seed + seedDs) 1e-7 paramShape\n f, fOneHot, fFused\n :: forall d r m. (DualMonad d r m, r ~ Double)\n => DualNumberVariables d r -> m (DualNumber d r)\n f = fcnnMnistLoss2 mnistData\n fOneHot = fcnnMnistLoss2 mnistDataOneHot\n fFused = fcnnMnistLossFused2 mnistDataOneHot\n in\n qcPropDom f parameters ds parametersPerturbation 1 .&&.\n qcPropDom fOneHot parameters ds parametersPerturbation 1 .&&.\n qcPropDom fFused parameters ds parametersPerturbation 1 .&&.\n cmpTwoSimple fOneHot fFused parameters ds\n ]\n\nbigMnistTests :: TestTree\nbigMnistTests = testGroup \"MNIST tests with a 2-hidden-layer nn\"\n [ mnistTestCase2 \"1 epoch, 1 batch\" 1 1 fcnnMnistLoss0 300 100 0.02\n 0.1269\n , mnistTestCase2 \"tanh: 1 epoch, 1 batch\" 1 1 fcnnMnistLossTanh 300 100 0.02\n 0.6406000000000001\n , mnistTestCase2 \"relu: 1 epoch, 1 batch\" 1 1 fcnnMnistLossRelu 300 100 0.02\n 0.7248\n , mnistTestCase2 \"1 epoch, 1 batch, wider\" 1 1 fcnnMnistLoss0 500 150 0.02\n 0.1269\n , mnistTestCase2 \"2 epochs, but only 1 batch\" 2 1 fcnnMnistLoss0 300 100 0.02\n 9.809999999999997e-2\n , mnistTestCase2 \"artificial 1 2 3 4 5\" 1 2 fcnnMnistLoss0 3 4 5\n 0.8972\n , mnistTestCase2 \"artificial 5 4 3 2 1\" 5 4 fcnnMnistLoss0 3 2 1\n 0.8991\n ]\n\nvectorMnistTests :: TestTree\nvectorMnistTests = testGroup \"MNIST VV tests with a 2-hidden-layer nn\"\n [ mnistTestCase2V \"1 epoch, 1 batch\" 1 1 fcnnMnistLoss1 300 100 0.02\n 0.12960000000000005\n , mnistTestCase2V \"1 epoch, 1 batch, wider\" 1 1 fcnnMnistLoss1 500 150 0.02\n 0.13959999999999995\n , mnistTestCase2V \"2 epochs, but only 1 batch\" 2 1 fcnnMnistLoss1 300 100 0.02\n 0.10019999999999996\n , mnistTestCase2V \"1 epoch, all batches\" 1 99 fcnnMnistLoss1 300 100 0.02\n 5.389999999999995e-2\n , mnistTestCase2V \"artificial 1 2 3 4 5\" 1 2 fcnnMnistLoss1 3 4 5\n 0.8972\n , mnistTestCase2V \"artificial 5 4 3 2 1\" 5 4 fcnnMnistLoss1 3 2 1\n 0.7756000000000001\n ]\n\nmatrixMnistTests :: TestTree\nmatrixMnistTests = testGroup \"MNIST LL tests with a 2-hidden-layer nn\"\n [ mnistTestCase2L \"1 epoch, 1 batch\" 1 1 fcnnMnistLoss2 300 100 0.02\n 0.12339999999999995\n , mnistTestCase2L \"1 epoch, 1 batch, wider\" 1 1 fcnnMnistLoss2 500 150 0.02\n 0.15039999999999998\n , mnistTestCase2L \"2 epochs, but only 1 batch\" 2 1 fcnnMnistLoss2 300 100 0.02\n 8.879999999999999e-2\n , mnistTestCase2L \"1 epoch, all batches\" 1 99 fcnnMnistLoss2 300 100 0.02\n 5.1100000000000034e-2\n , mnistTestCase2L \"artificial 1 2 3 4 5\" 1 2 fcnnMnistLoss2 3 4 5\n 0.8972\n , mnistTestCase2T False\n \"artificial TL 5 4 3 2 1\" 5 4 fcnnMnistLoss2 3 2 1\n 0.8865\n , mnistTestCase2D False 1 False\n \"artificial DL 5 4 3 2 1\" 5 4 fcnnMnistLoss2 3 2 1\n 0.8991\n , mnistTestCase2F False 1 False\n \"artificial FL 5 4 3 2 1\" 5 4 fcnnMnistLoss2 3 2 1\n 0.8991\n-- , mnistTestCase2T True False\n-- \"2 epochs, all batches, TL, wider, to file\"\n-- 2 60000 fcnnMnistLoss2 500 150 0.02\n-- 4.290000000000005e-2\n-- , mnistTestCase2D True 1 False\n-- \"2 epochs, all batches, DL, wider, to file\"\n-- 2 60000 fcnnMnistLoss2 500 150 0.02\n-- 0.9079\n-- , mnistTestCase2D True 64 False\n-- \"2 epochs, all batches, DL, wider, to file\"\n-- 2 60000 fcnnMnistLoss2 500 150 0.02\n-- 0.9261\n-- , mnistTestCase2D True 64 True\n-- \"2 epochs, all batches, DL, wider, to file\"\n-- 2 60000 fcnnMnistLoss2 500 150 0.02\n-- 0.8993\n-- , mnistTestCase2D True 64 True\n-- \"2 epochs, all batches, DL, wider, to file\"\n-- 2 60000 fcnnMnistLoss2 500 150 2e-5\n-- 0.9423\n-- , mnistTestCase2D True 64 True\n-- \"2 epochs, all batches, DL, wider, to file\"\n-- 2 60000 fcnnMnistLoss2 500 150 2e-4\n-- 0.8714\n-- , mnistTestCase2F True 64 True\n-- \"2 epochs, all batches, FL, wider, to file\"\n-- 2 60000 fcnnMnistLoss2 500 150 2e-4\n-- 0.8714\n-- , mnistTestCase2D True 64 True\n-- \"2 epochs, all batches, DL, wider, to file\"\n-- 2 60000 fcnnMnistLossFusedRelu2 1024 1024 2e-4\n-- 0.902\n-- , mnistTestCase2D False 64 True\n-- \"2 epochs, all batches, 1024DL\"\n-- 2 60000 fcnnMnistLoss2 1024 1024 2e-4\n-- 0.7465999999999999\n-- , mnistTestCase2F False 64 True\n-- \"2 epochs, all batches, 1024FL\"\n-- 2 60000 fcnnMnistLoss2 1024 1024 2e-4\n-- 0.7465999999999999\n ]\n\nfusedMnistTests :: TestTree\nfusedMnistTests = testGroup \"MNIST fused LL tests with a 2-hidden-layer nn\"\n [ mnistTestCase2L \"1 epoch, 1 batch\" 1 1 fcnnMnistLossFused2 300 100 0.02\n 0.12339999999999995\n , mnistTestCase2L \"1 epoch, 1 batch, wider\" 1 1\n fcnnMnistLossFused2 500 150 0.02\n 0.15039999999999998\n , mnistTestCase2L \"2 epochs, but only 1 batch\" 2 1\n fcnnMnistLossFused2 300 100 0.02\n 8.879999999999999e-2\n , mnistTestCase2L \"1 epoch, all batches\" 1 99 fcnnMnistLossFused2 300 100 0.02\n 5.1100000000000034e-2\n , mnistTestCase2L \"artificial 1 2 3 4 5\" 1 2 fcnnMnistLossFused2 3 4 5\n 0.8972\n , mnistTestCase2L \"artificial 5 4 3 2 1\" 5 4 fcnnMnistLossFused2 3 2 1\n 0.7033\n , mnistTestCase2S (Proxy @300) (Proxy @100)\n \"S 1 epoch, 1 batch\" 1 1 fcnnMnistLossFusedS 0.02\n 0.1311\n , mnistTestCase2S (Proxy @500) (Proxy @150)\n \"S 1 epoch, 1 batch, wider\" 1 1 fcnnMnistLossFusedS 0.02\n 0.12470000000000003\n , mnistTestCase2S (Proxy @300) (Proxy @100)\n \"S 2 epochs, but only 1 batch\" 2 1 fcnnMnistLossFusedS 0.02\n 9.630000000000005e-2\n , mnistTestCase2S (Proxy @300) (Proxy @100)\n \"S 1 epoch, all batches\" 1 99 fcnnMnistLossFusedS 0.02\n 5.620000000000003e-2\n , mnistTestCase2S (Proxy @3) (Proxy @4)\n \"S artificial 1 2 3 4 5\" 1 2 fcnnMnistLossFusedS 5\n 0.8972\n , mnistTestCase2S (Proxy @3) (Proxy @2)\n \"S artificial 5 4 3 2 1\" 5 4 fcnnMnistLossFusedS 1\n 0.8246\n , mnistTestCase2S (Proxy @300) (Proxy @100)\n \"SR 1 epoch, 1 batch\" 1 1 fcnnMnistLossFusedReluS 0.02\n 0.7068\n , mnistTestCase2S (Proxy @500) (Proxy @150)\n \"SR 1 epoch, 1 batch, wider\" 1 1\n fcnnMnistLossFusedReluS 0.02\n 0.8874\n , mnistTestCase2S (Proxy @300) (Proxy @100)\n \"SR 2 epochs, but 1 batch\" 2 1 fcnnMnistLossFusedReluS 0.02\n 0.8352999999999999\n , mnistTestCase2S (Proxy @300) (Proxy @100)\n \"SR 1 epoch, all batches\" 1 99 fcnnMnistLossFusedReluS 0.02\n 0.6415\n , mnistTestCase2S (Proxy @3) (Proxy @4)\n \"SR artificial 1 2 3 4 5\" 1 2 fcnnMnistLossFusedReluS 5\n 0.8972\n , mnistTestCase2S (Proxy @3) (Proxy @2)\n \"SR artificial 5 4 3 2 1\" 5 4 fcnnMnistLossFusedReluS 1\n 0.8991\n ]\n\nshortCIMnistTests :: TestTree\nshortCIMnistTests = testGroup \"Short CI MNIST tests\"\n [ mnistTestCase2 \"2 artificial 1 2 3 4 5\" 1 2 fcnnMnistLoss0 3 4 5\n 0.8972\n , mnistTestCase2 \"2 artificial 5 4 3 2 1\" 5 4 fcnnMnistLoss0 3 2 1\n 0.8991\n , mnistTestCase2V \"VV 1 epoch, 1 batch\" 1 1 fcnnMnistLoss1 300 100 0.02\n 0.12960000000000005\n , mnistTestCase2V \"VV artificial 1 2 3 4 5\" 1 2 fcnnMnistLoss1 3 4 5\n 0.8972\n , mnistTestCase2V \"VV artificial 5 4 3 2 1\" 5 4 fcnnMnistLoss1 3 2 1\n 0.7756000000000001\n , mnistTestCase2L \"LL 1 epoch, 1 batch\" 1 1 fcnnMnistLoss2 300 100 0.02\n 0.12339999999999995\n , mnistTestCase2L \"LL artificial 1 2 3 4 5\" 1 2 fcnnMnistLoss2 3 4 5\n 0.8972\n , mnistTestCase2L \"LL artificial 5 4 3 2 1\" 5 4 fcnnMnistLoss2 3 2 1\n 0.8085\n , mnistTestCase2L \"fused LL 1/1 batch\" 1 1 fcnnMnistLossFused2 300 100 0.02\n 0.12339999999999995\n , mnistTestCase2L \"fused LL artificial 1 2 3 4 5\" 1 2\n fcnnMnistLossFused2 3 4 5\n 0.8972\n , mnistTestCase2T False\n \"fused TL artificial 5 4 3 2 1\" 5 4\n fcnnMnistLossFused2 3 2 1\n 0.8865\n , mnistTestCase2D False 1 False\n \"fused DL artificial 5 4 3 2 1\" 5 4\n fcnnMnistLossFused2 3 2 1\n 0.8991\n , mnistTestCase2S (Proxy @300) (Proxy @100)\n \"S 1 epoch, 1 batch\" 1 1 fcnnMnistLossFusedS 0.02\n 0.1311\n , mnistTestCase2S (Proxy @3) (Proxy @4)\n \"S artificial 1 2 3 4 5\" 1 2 fcnnMnistLossFusedS 5\n 0.8972\n , mnistTestCase2S (Proxy @3) (Proxy @2)\n \"S artificial 5 4 3 2 1\" 5 4 fcnnMnistLossFusedS 1\n 0.8246\n , mnistTestCase2S (Proxy @3) (Proxy @4)\n \"SR artificial 1 2 3 4 5\" 1 2 fcnnMnistLossFusedReluS 5\n 0.8972\n , mnistTestCase2S (Proxy @3) (Proxy @2)\n \"SR artificial 5 4 3 2 1\" 5 4 fcnnMnistLossFusedReluS 1\n 0.8991\n ]\n", "meta": {"hexsha": "701a5253c007ba2336e1f17365d45b88c8e173cf", "size": 42315, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "test/common/TestMnistFCNN.hs", "max_stars_repo_name": "Mikolaj/horde-ad", "max_stars_repo_head_hexsha": "1629942418f584f6b332dac0a7053338dc3bca70", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "test/common/TestMnistFCNN.hs", "max_issues_repo_name": "Mikolaj/horde-ad", "max_issues_repo_head_hexsha": "1629942418f584f6b332dac0a7053338dc3bca70", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 22, "max_issues_repo_issues_event_min_datetime": "2022-01-27T11:10:21.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-31T12:03:54.000Z", "max_forks_repo_path": "test/common/TestMnistFCNN.hs", "max_forks_repo_name": "Mikolaj/horde-ad", "max_forks_repo_head_hexsha": "1629942418f584f6b332dac0a7053338dc3bca70", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 46.4489571899, "max_line_length": 107, "alphanum_fraction": 0.5822048919, "num_tokens": 12079, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6992544085240401, "lm_q2_score": 0.480478678047907, "lm_q1q2_score": 0.3359768338268019}} {"text": "{-# OPTIONS_GHC -fplugin GHC.TypeLits.KnownNat.Solver #-}\n\n{-# LANGUAGE CPP #-}\n{-# LANGUAGE DataKinds #-}\n{-# LANGUAGE FlexibleContexts #-}\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE RankNTypes #-}\n{-# LANGUAGE ScopedTypeVariables #-}\n{-# LANGUAGE StandaloneDeriving #-}\n{-# LANGUAGE TypeFamilies #-}\n{-# LANGUAGE TypeOperators #-}\n{-# LANGUAGE UndecidableInstances #-}\n{-|\nModule : Grenade.Core.Shape\nDescription : Dependently typed shapes of data which are passed between layers of a network\nCopyright : (c) Huw Campbell, 2016-2017\nLicense : BSD2\nStability : experimental\n\n\n-}\nmodule Grenade.Core.Shape (\n S (..)\n , Shape (..)\n#if MIN_VERSION_singletons(2,6,0)\n , SShape (..)\n#else\n , Sing (..)\n#endif\n\n , randomOfShape\n , fromStorable\n , fromStorableMatrix\n , nk\n , visualise2D\n , splitChannels\n , combineChannels\n ) where\n\n#if MIN_VERSION_singletons(2,6,0)\nimport Data.Kind (Type)\n#endif\n\nimport Control.DeepSeq (NFData (..))\nimport Data.List.Split (chunksOf)\nimport Data.Maybe (fromJust)\nimport Data.Proxy\nimport Data.Serialize\nimport Data.Singletons\nimport Data.Singletons.TypeLits\nimport Data.Vector.Storable (Vector)\nimport qualified Data.Vector.Storable as V\nimport GHC.TypeLits hiding (natVal)\nimport Numeric.LinearAlgebra (Matrix)\nimport qualified Numeric.LinearAlgebra as NLA\nimport qualified Numeric.LinearAlgebra.Data as NLAD\nimport Numeric.LinearAlgebra.Static\nimport qualified Numeric.LinearAlgebra.Static as H\n\nimport System.Random.MWC\n\nimport Grenade.Types\n\n-- | The current shapes we accept.\n-- at the moment this is just one, two, and three dimensional\n-- Vectors/Matricies.\n--\n-- These are only used with DataKinds, as Kind `Shape`, with Types 'D1, 'D2, 'D3.\ndata Shape\n = D1 Nat\n -- ^ One dimensional vector\n | D2 Nat Nat\n -- ^ Two dimensional matrix. Row, Column.\n | D3 Nat Nat Nat\n -- ^ Three dimensional matrix. Row, Column, Channels.\n | D4 Nat Nat Nat Nat\n -- ^ Four dimensional matrix. Depth, Channels, Row, Column\n\n-- | Concrete data structures for a Shape.\n--\n-- All shapes are held in contiguous memory.\n-- 3D is held in a matrix (usually row oriented) which has height depth * rows.\ndata S (n :: Shape) where\n S1D :: ( KnownNat len )\n => R len\n -> S ('D1 len)\n\n S2D :: ( KnownNat rows, KnownNat columns )\n => L rows columns\n -> S ('D2 rows columns)\n\n S3D :: ( KnownNat rows\n , KnownNat columns\n , KnownNat channels\n , KnownNat (rows * channels) )\n => L (rows * channels) columns\n -> S ('D3 rows columns channels)\n\n S4D :: ( KnownNat rows\n , KnownNat columns\n , KnownNat channels\n , KnownNat depth)\n => L (depth * channels * rows) columns\n -> S ('D4 depth channels rows columns)\n\nderiving instance Show (S n)\n\n-- Singleton instances.\n--\n-- These could probably be derived with template haskell, but this seems\n-- clear and makes adding the KnownNat constraints simple.\n-- We can also keep our code TH free, which is great.\n#if MIN_VERSION_singletons(2,6,0)\n-- In singletons 2.6 Sing switched from a data family to a type family.\ntype instance Sing = SShape\n\n-- | Datatype to allow \"pattern matching\" on shapes at the type level through\n-- the use the sing function from Singletons.\ndata SShape :: Shape -> Type where\n D1Sing :: Sing a -> SShape ('D1 a)\n D2Sing :: Sing a -> Sing b -> SShape ('D2 a b)\n D3Sing :: KnownNat (a * c) => Sing a -> Sing b -> Sing c -> SShape ('D3 a b c)\n D4Sing :: KnownNat (a * c * d) => Sing a -> Sing b -> Sing c -> Sing d -> SShape ('D4 a b c d)\n#else\ndata instance Sing (n :: Shape) where\n D1Sing :: Sing a -> Sing ('D1 a)\n D2Sing :: Sing a -> Sing b -> Sing ('D2 a b)\n D3Sing :: KnownNat (a * c) => Sing a -> Sing b -> Sing c -> Sing ('D3 a b c)\n D4Sing :: KnownNat (a * c * d) => Sing a -> Sing b -> Sing c -> Sing d -> Sing ('D4 a b c d)\n#endif\n\ninstance KnownNat a => SingI ('D1 a) where\n sing = D1Sing sing\ninstance (KnownNat a, KnownNat b) => SingI ('D2 a b) where\n sing = D2Sing sing sing\ninstance (KnownNat a, KnownNat b, KnownNat c, KnownNat (a * c)) => SingI ('D3 a b c) where\n sing = D3Sing sing sing sing\ninstance (KnownNat a, KnownNat b, KnownNat c, KnownNat d) => SingI ('D4 a b c d) where\n sing = D4Sing sing sing sing sing\n\ninstance SingI x => Num (S x) where\n (+) = n2 (+)\n (-) = n2 (-)\n (*) = n2 (*)\n abs = n1 abs\n signum = n1 signum\n fromInteger x = nk (fromInteger x)\n\ninstance SingI x => Fractional (S x) where\n (/) = n2 (/)\n recip = n1 recip\n fromRational x = nk (fromRational x)\n\ninstance SingI x => Floating (S x) where\n pi = nk pi\n exp = n1 exp\n log = n1 log\n sqrt = n1 sqrt\n (**) = n2 (**)\n logBase = n2 logBase\n sin = n1 sin\n cos = n1 cos\n tan = n1 tan\n asin = n1 asin\n acos = n1 acos\n atan = n1 atan\n sinh = n1 sinh\n cosh = n1 cosh\n tanh = n1 tanh\n asinh = n1 asinh\n acosh = n1 acosh\n atanh = n1 atanh\n\n--\n-- I haven't made shapes strict, as sometimes they're not needed\n-- (the last input gradient back for instance)\n--\ninstance NFData (S x) where\n rnf (S1D x) = rnf x\n rnf (S2D x) = rnf x\n rnf (S3D x) = rnf x\n rnf (S4D x) = rnf x\n\n-- | Generate random data of the desired shape\nrandomOfShape :: forall x . (SingI x) => IO (S x)\nrandomOfShape = do\n seed :: Int <- withSystemRandom . asGenST $ \\gen -> uniform gen\n return $ case (sing :: Sing x) of\n D1Sing SNat ->\n S1D (H.randomVector seed H.Uniform * 2 - 1)\n\n D2Sing SNat SNat ->\n S2D (H.uniformSample seed (-1) 1)\n\n D3Sing SNat SNat SNat ->\n S3D (H.uniformSample seed (-1) 1)\n\n D4Sing SNat SNat SNat SNat ->\n S4D (H.uniformSample seed (-1) 1)\n\n-- | Generate a shape from a Storable Vector.\n--\n-- Returns Nothing if the vector is of the wrong size.\nfromStorable :: forall x. SingI x => Vector RealNum -> Maybe (S x)\nfromStorable xs = case sing :: Sing x of\n D1Sing SNat ->\n S1D <$> H.create xs\n\n D2Sing SNat SNat ->\n S2D <$> mkL xs\n\n D3Sing SNat SNat SNat ->\n S3D <$> mkL xs\n\n D4Sing SNat SNat SNat SNat ->\n S4D <$> mkL xs\n where\n mkL :: forall rows columns. (KnownNat rows, KnownNat columns)\n => Vector RealNum -> Maybe (L rows columns)\n mkL v =\n let rows = fromIntegral $ natVal (Proxy :: Proxy rows)\n columns = fromIntegral $ natVal (Proxy :: Proxy columns)\n in if rows * columns == V.length v\n then H.create $ NLA.reshape columns v\n else Nothing\n\n-- | Generate a shape from a Storable Matrix.\n--\n-- Returns Nothing if the matrix is of the wrong size (or one dimensional)\nfromStorableMatrix :: forall x. SingI x => Matrix RealNum -> Maybe (S x)\nfromStorableMatrix xs = case sing :: Sing x of\n D1Sing SNat ->\n Nothing\n\n D2Sing SNat SNat ->\n S2D <$> mkL xs\n\n D3Sing SNat SNat SNat ->\n S3D <$> mkL xs\n\n D4Sing SNat SNat SNat SNat ->\n S4D <$> mkL xs\n where\n mkL :: forall rows columns. (KnownNat rows, KnownNat columns)\n => Matrix RealNum -> Maybe (L rows columns)\n mkL m =\n let rows = fromIntegral $ natVal (Proxy :: Proxy rows)\n columns = fromIntegral $ natVal (Proxy :: Proxy columns)\n (h, w) = NLA.size m\n in if rows == h && columns == w\n then H.create m\n else Nothing\n\ninstance SingI x => Serialize (S x) where\n put i = (case i of\n (S1D x) -> putListOf put . NLA.toList . H.extract $ x\n (S2D x) -> putListOf put . NLA.toList . NLA.flatten . H.extract $ x\n (S3D x) -> putListOf put . NLA.toList . NLA.flatten . H.extract $ x\n (S4D x) -> putListOf put . NLA.toList . NLA.flatten . H.extract $ x\n ) :: PutM ()\n\n get = do\n Just i <- fromStorable . V.fromList <$> getListOf get\n return i\n\n-- Helper function for creating the number instances\nn1 :: ( forall a. Floating a => a -> a ) -> S x -> S x\nn1 f (S1D x) = S1D (f x)\nn1 f (S2D x) = S2D (f x)\nn1 f (S3D x) = S3D (f x)\nn1 f (S4D x) = S4D (f x)\n\n-- Helper function for creating the number instances\nn2 :: ( forall a. Floating a => a -> a -> a ) -> S x -> S x -> S x\nn2 f (S1D x) (S1D y) = S1D (f x y)\nn2 f (S2D x) (S2D y) = S2D (f x y)\nn2 f (S3D x) (S3D y) = S3D (f x y)\nn2 f (S4D x) (S4D y) = S4D (f x y)\n\n-- | Helper function for creating the number instances\nnk :: forall x. SingI x => RealNum -> S x\nnk x = case (sing :: Sing x) of\n D1Sing SNat ->\n S1D (H.konst x)\n\n D2Sing SNat SNat ->\n S2D (H.konst x)\n\n D3Sing SNat SNat SNat ->\n S3D (H.konst x)\n\n D4Sing SNat SNat SNat SNat ->\n S4D (H.konst x)\n\n-- | Prints out the contents of a matrix with entries between zero and the max value\nvisualise2D :: S ('D2 a b) -- ^ input matrix\n -> RealNum -- ^ maximum element value\n -> String -- ^ pretty printed matrix\nvisualise2D (S2D mm) max =\n let m = H.extract mm\n ms = NLAD.toLists m\n render n' | n' <= 0.2 * max = ' '\n | n' <= 0.4 * max = '.'\n | n' <= 0.6 * max = '-'\n | n' <= 0.8 * max = '='\n | otherwise = '#'\n px = (fmap . fmap) render ms\n in unlines px\n\n-- | TODO Theo\nsplitChannels :: forall rows columns channels.\n (KnownNat rows, KnownNat columns)\n => S ('D3 rows columns channels) -> [S ('D2 rows columns)]\nsplitChannels (S3D x)\n = let r = fromIntegral $ natVal (Proxy :: Proxy rows)\n rs = NLA.toRows $ H.extract x\n rs' = chunksOf r rs\n ms = map (S2D . fromJust . H.create . NLA.fromRows) rs' :: [S ('D2 rows columns)]\n in ms\n\n-- | TODO Theo\ncombineChannels :: forall rows columns channels.\n (KnownNat rows, KnownNat columns, KnownNat channels)\n => [S ('D2 rows columns)] -> S ('D3 rows columns channels)\ncombineChannels xs\n = let xs' = map (\\(S2D x) -> NLA.toRows $ H.extract x) xs :: [[Vector RealNum]]\n xs'' = concat xs'\n in S3D $ fromJust . H.create . NLA.fromRows $ xs''\n", "meta": {"hexsha": "52a4a9e815284263ef527c7de1748922b2914b74", "size": 10217, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/Grenade/Core/Shape.hs", "max_stars_repo_name": "th-char/grenade", "max_stars_repo_head_hexsha": "0be658e7cf07562cd5e4170ed1e8875ccec14cdb", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-06-09T06:06:26.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-09T06:06:26.000Z", "max_issues_repo_path": "src/Grenade/Core/Shape.hs", "max_issues_repo_name": "th-char/grenade", "max_issues_repo_head_hexsha": "0be658e7cf07562cd5e4170ed1e8875ccec14cdb", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/Grenade/Core/Shape.hs", "max_forks_repo_name": "th-char/grenade", "max_forks_repo_head_hexsha": "0be658e7cf07562cd5e4170ed1e8875ccec14cdb", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 31.0547112462, "max_line_length": 96, "alphanum_fraction": 0.5924439659, "num_tokens": 3121, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.7341195269001831, "lm_q2_score": 0.45713671682749485, "lm_q1q2_score": 0.3355929902861035}} {"text": "{-# LANGUAGE FlexibleInstances #-}\n{-# LANGUAGE TypeApplications #-}\n{-# LANGUAGE BlockArguments #-}\n{-# LANGUAGE DataKinds #-}\n{-# LANGUAGE TypeFamilies #-}\n{-# LANGUAGE BangPatterns #-}\n-- | A music theory library for just intonation and other mathematically pure ideas.\nmodule Boopadoop \n (module Boopadoop\n ,module Boopadoop.Diagram\n ,module Boopadoop.Rhythm\n ,module Boopadoop.Interval\n ,module Boopadoop.Discrete\n ) where\n\nimport qualified Data.WAVE as WAVE\nimport Control.Monad.ST\nimport Control.Monad\nimport Control.Applicative\nimport Boopadoop.Diagram\nimport Boopadoop.Rhythm\nimport Boopadoop.Interval\nimport Boopadoop.Discrete\nimport Data.List\nimport Data.Int\nimport Data.Complex\nimport qualified Data.Vector.Fixed as FV\nimport qualified Data.Primitive.ByteArray as BA\nimport qualified Data.Vector.Unboxed as Vector\n\n-- | A 'Waveform' is a function (of time) that we can later sample.\nnewtype Waveform t a = Waveform \n {sample :: t -> a -- ^ 'sample' the 'Waveform' at a specified time\n }\n\ninstance Functor (Waveform t) where\n fmap f w = sampleFrom $ f . sample w\n\ninstance SummaryChar (Waveform t a) where\n sumUp _ = '~'\n\n-- | A 'Double' valued wave with time also in terms of 'Double'.\n-- This models a real-valued waveform which typically has values in @[-1,1]@ and\n-- is typically supported on either the entire real line ('sinWave') or on a compact subset ('compactWave')\ntype DWave = Waveform Double Double\n\n-- | Show a waveform by pretty printing some of the actual waveform in dot matrix form.\ninstance Show (Waveform Double Double) where\n show w = intercalate \"\\n\" . transpose $ map sampleToString waveSamples\n where\n sampleToString k = if k <= quantLevel && k >= -quantLevel\n then replicate (quantLevel - k) '.' ++ \"x\" ++ replicate (quantLevel + k) '.'\n else let m = \"k = \" ++ show k in m ++ replicate (quantLevel * 2 + 1 - length m) ' '\n waveSamples = map (floor . (* realToFrac quantLevel) . sample w . (/sampleRate)) [0 .. 115]\n quantLevel = 15 :: Int\n sampleRate = 6400\n\ninstance Show (Waveform Double Discrete) where\n show w = intercalate \"\\n\" . transpose $ map sampleToString waveSamples\n where\n sampleToString k = if k <= quantLevel && k >= -quantLevel\n then replicate (quantLevel - k) '.' ++ \"x\" ++ replicate (quantLevel + k) '.'\n else let m = \"k = \" ++ show k in m ++ replicate (quantLevel * 2 + 1 - length m) ' '\n waveSamples = map ((`quotRoundUp` (1 + (discFactor `quot` quantLevel))) . fromIntegral . unDiscrete . sample w . (/sampleRate)) [0 .. 115]\n quantLevel = 15 :: Int\n sampleRate = 6400\n\ninstance Show (Waveform Tick Discrete) where\n show w = intercalate \"\\n\" . transpose $ map sampleToString waveSamples\n where\n sampleToString k = if k <= quantLevel && k >= -quantLevel\n then replicate (quantLevel - k) '.' ++ \"x\" ++ replicate (quantLevel + k) '.'\n else let m = \"k = \" ++ show k in m ++ replicate (quantLevel * 2 + 1 - length m) ' '\n waveSamples = map ((`quotRoundUp` (1 + (discFactor `quot` quantLevel))) . fromIntegral . unDiscrete . sample (skipTicks 1 w)) [0 .. 115]\n quantLevel = 15 :: Int\n\ninstance Show (Waveform Tick Double) where\n show w = intercalate \"\\n\" . transpose $ map sampleToString waveSamples\n where\n sampleToString k = if k <= quantLevel && k >= -quantLevel\n then replicate (quantLevel - k) '.' ++ \"x\" ++ replicate (quantLevel + k) '.'\n else let m = \"k = \" ++ show k in m ++ replicate (quantLevel * 2 + 1 - length m) ' '\n waveSamples = map (floor . (* realToFrac quantLevel) . sample (skipTicks 1 w)) [0 .. 115]\n quantLevel = 15 :: Int\n\n-- | A version of @'quot'@ that rounds away from zero instead of towards it.\nquotRoundUp :: Int -> Int -> Int\nquotRoundUp a b = if a `mod` b == 0 then a `quot` b else (signum a * signum b) + (a `quot` b)\n\n-- | Build a 'Waveform' by sampling the given function.\nsampleFrom :: (t -> a) -> Waveform t a\nsampleFrom f = Waveform $ \\t -> {-t `seq`-} f t\n\n-- | Sample a 'Waveform' at specified time. @'sampleAt' = 'flip' 'sample'@\nsampleAt :: t -> Waveform t a -> a\nsampleAt = flip sample\n\n-- | Pure sine wave of the given frequency\n--sinWave :: Floating a => a -> Waveform a a\nsinWave :: Double -> DWave\nsinWave f = if sinHack -- speedy fast sin hack from https://www.gamedev.net/forums/topic/621589-extremely-fast-sin-approximation/ due to nightcracker\n then sampleFrom $ \\t -> let \n x = pi * ((2 * f * t) - fromIntegral k) \n x2 = x * x\n k = spookyFastTruncate (2 * f * t)\n in (if odd k then negate else id) (x * (c + x2 * (b + a * x2)))\n else sampleFrom $ \\t -> sin (freq * t)\n where\n sinHack = True\n !freq = 2 * pi * f\n a = 0.00735246819687011731341356165096815\n b = -0.16528911397014738207016302002888890\n c = 0.99969198629596757779830113868360584\n\n-- | Pure sine wave of the given frequency and initial phase\nsinWaveWithPhase :: Floating a => a -> a -> Waveform a a\nsinWaveWithPhase f phi0 = sampleFrom $ \\t -> let !freq = 2 * pi * f in sin (freq * t + phi0)\n\n-- | Sine wave that is optimized to store only a small @'CompactWavetable'@.\n-- The period is given in ticks because non-tick-multiple period sin waves will have aliasing under this optimization!\nfastSin :: Tick -> Wavetable\nfastSin per = exploitPeriodicity per $ tickTable (fromIntegral per) $ discretize $ sinWave 1\n\n-- | @'compactWave' (l,h)@ is a wave which is @'True'@ on @[l,h)@ and @'False'@ elsewhere\ncompactWave :: (Ord t,Num t) => (t,t) -> Waveform t Bool\ncompactWave (low,high) = sampleFrom $ \\t -> t >= low && t < high\n\n-- | @'muting' 'True'@ is @'id'@ while @'muting' 'False'@ is @'const' 0@.\nmuting :: Num a => Bool -> a -> a\nmuting b s = if b then s else 0\n\n-- | Modulate one wave with another according to the given function pointwise.\n-- This means you can't implement 'phaseModulate' using only this combinator because phase modulation\n-- requires information about the target wave at times other than the current time.\nmodulate :: (a -> b -> c) -> Waveform t a -> Waveform t b -> Waveform t c\nmodulate f a b = sampleFrom $ \\t -> f (sample a t) (sample b t)\n\n-- | Modulate the amplitude of one wave with another. This is simply pointwise multiplication:\n-- @\n-- 'amplitudeModulate' = 'modulate' ('*')\n-- @\namplitudeModulate :: Num a => Waveform t a -> Waveform t a -> Waveform t a\namplitudeModulate = modulate (*)\n\n-- | Control rate of speed of one waveform with another\nfreqModulate :: Waveform t' p -> Waveform p a -> Waveform t' a\nfreqModulate phaseSelect w = sampleFrom $ \\t -> sample w (sample phaseSelect t)\n\n-- | First argument is valued in sample time steps, so @1/stdtr@ is a good starting point.\nemuVCO :: Waveform Tick Double -> Waveform Double a -> [a]\nemuVCO freqSelect w = go 0 0\n where\n go !i sampPoint = let skip = sample freqSelect i in sample w sampPoint : go (i + 1) (sampPoint + skip)\n\nemuVCO' :: [Double] -> Waveform Double a -> [a]\nemuVCO' fs w = go fs 0\n where\n go freqSelect !sampPoint = let (skip:ss) = freqSelect in sample w sampPoint : go ss (sampPoint + skip)\n\nniceVCO :: Double -> [Double] -> Waveform Double a -> [a]\nniceVCO amp fs = emuVCO' (fmap (\\f -> (amp ** f)/stdtr) fs)\n\noscAboveZero :: Double -> Double -> Double\noscAboveZero amp = oscAbout (amp/2) amp\n\noscAbout :: Double -> Double -> Double -> Double\noscAbout z0 amp z = (amp * z) + z0\n\n-- | Piecewise linear reconstruction (interpolation) of a sampled signal\nlinearResample :: Double -> Waveform Tick Double -> Waveform Double Double\nlinearResample sampleRate w = sampleFrom $ \\t -> do\n let t' = t * sampleRate\n let (low,high) = (floor t',ceiling t')\n (fromIntegral high - t') * sample w low + (t' - fromIntegral low) * sample w high\n\nrecordStream :: [a] -> Waveform Tick a\nrecordStream xs = sampleFrom ((xs!!) . fromIntegral)\n\n-- | The output wavetables here have @sample (toConvolutionTableStream ds !! t) k = ds !! (t - k)@ for @k < windowSize@\ntoConvolutionTableStream :: Tick -> [Discrete] -> [Wavetable]\ntoConvolutionTableStream windowSize xs = fmap toWavetable . scanl stepSt (startTable xs) $ xs\n where\n toWavetable :: (BA.ByteArray,Int) -> Wavetable\n toWavetable (v,b) = sampleFrom $ \\k -> Discrete $ BA.indexByteArray v ((b - k) `mod` windowSize)\n startTable :: [Discrete] -> (BA.ByteArray,Int)\n startTable ds = (BA.byteArrayFromListN windowSize (fmap unDiscrete $ take windowSize ds),0)\n -- Table, breakpoint\n stepSt :: (BA.ByteArray, Int) -> Discrete -> (BA.ByteArray, Int)\n stepSt (!t,!b) x = runST $ do\n v <- BA.unsafeThawByteArray t\n BA.writeByteArray v (b `mod` windowSize) (unDiscrete x)\n v' <- BA.unsafeFreezeByteArray v\n pure (v',(b+1) `mod` windowSize)\n\nstreamWavetable :: Waveform Tick a -> [a]\nstreamWavetable w = map (sample w) [0..]\n\nmemorizeStream :: Int -> [Discrete] -> Wavetable\nmemorizeStream len = fromCompact . CompactWavetable . Vector.fromList . map unDiscrete . take len\n\n-- | Very slow\nintegrateWave :: Num a => Waveform Tick a -> Waveform Tick a\nintegrateWave w = sampleFrom $ \\t -> sum . map (sample w) $ [0 .. t]\n\n-- | Modulate the phase of one wave with another. Used in synthesis.\n-- @\n-- 'phaseModulate' beta ('setVolume' 0.2 $ 'sinWave' 'concertA') ('setVolume' 0.38 $ 'triWave' 'concertA')\n-- @\n-- (try beta=0.0005)\nphaseModulate :: Num t \n => t -- ^ Tuning parameter. Modulation signal is @'amplitudeModulate'@d by @('const' beta)@\n -> Waveform t t -- ^ Modulation signal. Outputs the phase shift to apply\n -> Waveform t a -- ^ Target wave to be modulated\n -> Waveform t a\nphaseModulate beta modulation target = sampleFrom $ \\t -> sample target (t + beta * sample modulation t)\n\n-- | Smoothly transition to playing a wave back at a different speed after some time\nchangeSpeed :: (Ord a,Fractional a) => a -> a -> a -> Waveform a a -> Waveform a a\nchangeSpeed startTime lerpTime newSpeed wave = sampleFrom $ \\t -> sample wave $ if t < startTime\n then t\n else if t > startTime + lerpTime\n then startTime + newSpeed * t\n -- Lerp between sampling at 1 and sampling at newSpeed\n else startTime + (1 + ((t - startTime)/lerpTime) * (newSpeed - 1)) * t\n\n-- | Play several waves on top of each other, normalizing so that e.g. playing three notes together doesn't triple the volume.\nbalanceChord :: Fractional a => [Waveform t a] -> Waveform t a\nbalanceChord notes = sampleFrom $ \\t -> foldr (\\x s -> s + factor * sample x t) 0 $ notes\n where\n factor = realToFrac . recip @Double . fromIntegral . length $ notes\n\n-- | Play several waves on top of each other, without worrying about the volume. See 'balanceChord' for\n-- a normalized version.\nmergeWaves :: Num a => [Waveform t a] -> Waveform t a\nmergeWaves notes = sampleFrom $ \\t -> foldr (\\x s -> s + sampleAt t x) 0 notes\n -- Average Frequency\n --,frequency = fmap (/(fromIntegral $ length notes)) . foldl (liftA2 (+)) (Just 0) . map frequency $ notes\n\n-- | @'waveformToWAVE' outputLength@ gives a @'WAVE'@ file object by sampling the given @'DWave'@ at @44100Hz@.\n-- May disbehave or clip based on behavior of @'doubleToSample'@ if the DWave takes values outside of @[-1,1]@.\nwaveformToWAVE :: Tick -> Int -> Wavetable -> WAVE.WAVE\nwaveformToWAVE outTicks sampleRate w = WAVE.WAVE\n {WAVE.waveHeader = WAVE.WAVEHeader\n {WAVE.waveNumChannels = 1\n ,WAVE.waveFrameRate = sampleRate\n ,WAVE.waveBitsPerSample = 32\n ,WAVE.waveFrames = Just $ fromIntegral outTicks\n }\n ,WAVE.waveSamples = [map (unDiscrete . sample w) [0 .. outTicks - 1]]\n }\n\n-- | Take a specified number of samples at the given sample rate from the stream and put them in a @'WAVE.WAVE'@.\nwavestreamToWAVE :: Tick -> Int -> [Discrete] -> WAVE.WAVE\nwavestreamToWAVE outTicks sampleRate ws = WAVE.WAVE\n {WAVE.waveHeader = WAVE.WAVEHeader\n {WAVE.waveNumChannels = 1\n ,WAVE.waveFrameRate = sampleRate\n ,WAVE.waveBitsPerSample = 32\n ,WAVE.waveFrames = Just $ fromIntegral outTicks\n }\n ,WAVE.waveSamples = [take outTicks $ map unDiscrete ws]\n }\n\n-- | Triangle wave of the given frequency\ntriWave :: Double -> Waveform Double Double\ntriWave f = sampleFrom $ \\t -> let r = t * f - fromIntegral (floor (t * f) :: Int) in if r < 0.25\n then 4 * r\n else if r < 0.75\n then 2 - (4 * r)\n else -4 + (4 * r)\n\n-- | Digital saw wave with given frequency\nsawWave :: Double -> Waveform Double Double\nsawWave f = sampleFrom $ \\t -> 2 * (t * f - fromIntegral (floor (t * f) :: Int)) - 1\n\n-- | Ramp from 0 to 1 over a time period\nramp :: Double -> Double -> Double\nramp = rampFrom 0\n\n-- | Ramp from @x0@ to 1 from time zero to the max time\nrampFrom :: Double -> Double -> (Double -> Double)\nrampFrom x0 time t = if t < time\n then x0 + (1 - x0) * (max t 0)/time\n else 1\n\n-- | Arbitrarily chosen standard tick rate, used in @'testWave'@\nstdtr :: Num a => a\nstdtr = 48000 --32000\n\n-- | Output the first @len@ seconds of the given @'Wavetable'@ to a @.wav@ file at the given path for testing.\n-- The volume is also attenuated by 50% to not blow out your eardrums.\n-- Also pretty prints the wave.\ntestWave :: Double -> String -> Wavetable -> IO ()\ntestWave len fp w = print w >> pure w >>= WAVE.putWAVEFile (fp ++ \".wav\") . waveformToWAVE (floor $ len*stdtr) stdtr . amplitudeModulate (sampleFrom $ const 0.5)\n\n-- | Output the first @len@ seconds of the given wave stream to a @.wav@ file at the given path for testing.\ntestWaveStream :: Double -> String -> [Discrete] -> IO ()\ntestWaveStream len fp = WAVE.putWAVEFile (fp ++ \".wav\") . wavestreamToWAVE (floor $ len*stdtr) stdtr\n\n-- | Concert A4 frequency is 440Hz\nconcertA :: Num a => a\nconcertA = 440\n\n-- | An envelope that suspends for @noteDuration@ before releasing\nsusEnvelope :: Envelope Tick Discrete -> Tick -> Wavetable\nsusEnvelope (Envelope del att hol dec sus rel) noteDuration = sampleFrom $ \\t -> if t < del\n then 0\n else if t - del < att\n then doubleToDiscrete $ (t - del) `divTD` att\n else if t - del - att < hol\n then 1\n else if t - del - att - hol < dec\n then doubleToDiscrete $ 1 + ((t - del - att - hol) `divTD` dec) * (discreteToDouble sus - 1)\n else if t < noteDuration\n then sus\n else if t - noteDuration < rel\n then sus * doubleToDiscrete (1 - (t - noteDuration) `divTD` rel)\n else 0\n where\n divTD a b = fromIntegral a / fromIntegral b\n\n-- | An envelope that suspends forever instead of releasing\nsuspendVelope :: Double -> Double -> Double -> Double -> Double -> DWave\nsuspendVelope del att hol dec sus = sampleFrom $ \\t -> if t < del\n then 0\n else if t - del < att\n then (t - del) / att\n else if t - del - att < hol\n then 1\n else if t - del - att - hol < dec\n then 1 + (t - del - att - hol)/dec * (sus - 1)\n else sus\n\n-- | Synthesize an envelope to a 'DWave'\nenvelope :: Envelope Double Double -> DWave\nenvelope (Envelope del att hol dec sus rel) = sampleFrom $ \\t -> if t < del\n then 0\n else if t - del < att\n then (t - del) / att\n else if t - del - att < hol\n then 1\n else if t - del - att - hol < dec\n then 1 + (t - del - att - hol)/dec * (sus - 1)\n else if t - del - att - hol - dec < rel\n then sus * (1 - (t - del - att - hol - dec)/rel)\n else 0\n\n-- | DAHDSR envelope with times @t@ and sustain level @b@\ndata Envelope t b = Envelope t t t t b t\n\n-- | Discretize an envelope by converting times into ticks\ndiscretizeEnvelope :: Double -> Envelope Double Double -> Envelope Tick Discrete\ndiscretizeEnvelope tickRate (Envelope del att hol dec sus rel) = Envelope (dd del) (dd att) (dd hol) (dd dec) (doubleToDiscrete sus) (dd rel)\n where\n dd = floor . (*tickRate)\n\n-- | Shift a wave in time to start at the specified time after its old start time\ntimeShift :: Num t => t -> Waveform t a -> Waveform t a\ntimeShift dt = sampleFrom . (. subtract dt) . sample\n\n-- | Shift a wave in time such that the new zero is at the specified position\nseekTo :: Num t => t -> Waveform t a -> Waveform t a\nseekTo dt = sampleFrom . (. (+dt)) . sample\n\n-- | Modify the amplitude of a wave by a constant multiple\nsetVolume :: Num a => a -> Waveform t a -> Waveform t a\nsetVolume = amplitudeModulate . sampleFrom . const\n\n-- | The empty wave that is always zero when sampled\nemptyWave :: Num a => Waveform t a\nemptyWave = sampleFrom $ const 0\n\n-- | Convolve with explicit discrete filter kernel weights.\ndiscreteConvolve :: (Num a, Num t) => Waveform t [(t,a)] -> Waveform t a -> Waveform t a\ndiscreteConvolve profile w = sampleFrom $ \\t -> sum . map (\\(dt,amp) -> amp * sample w (t + dt)) $ sample profile t\n\n-- | This operation is not convolution, but something kind of like it. Use for creative purposes? Should be fast!\n-- @wackyNotConvolution modf profile w = sampleFrom $ \\t -> sample (modulate modf (sample profile t) w) t@\nwackyNotConvolution :: (a -> b -> c) -> Waveform t (Waveform t a) -> Waveform t b -> Waveform t c\nwackyNotConvolution modf profile w = sampleFrom $ \\t -> sample (modulate modf (sample profile t) w) t\n\n-- | Perform a discrete convolution. The output waveform is @f(t) = \\int_{t-tickRadius}^{t+tickRadius} (kernel(t))(x) * w(t+x) dx@\n-- but is discretized such that @x@ is always a multiple of @skipRate@.\ntickConvolution :: (Show a,Fractional a)\n => Tick -- ^ @tickRadius@\n -> Tick -- ^ @skipRate@\n -> Waveform Tick (Waveform Tick a) -- ^ The kernel of the convolution at each @'Tick'@\n -> Waveform Tick a -- ^ w(t)\n -> Waveform Tick a\ntickConvolution tickRadius skipRate profile w = sampleFrom $ \\t -> let !kern = sample profile t in sum . map (\\dt -> (*0.01) . (*sample w (t + dt)) . sample kern $ dt) $ sampleDeltas\n where\n sampleDeltas = map (*skipRate) [-stepsPerSide.. stepsPerSide]\n stepsPerSide = tickRadius `div` skipRate\n -- !stepModifier = realToFrac . recip . fromIntegral $ stepsPerSide :: Double\n\n--accuCount :: IORef Integer\n--accuCount = unsafePerformIO $ newIORef 0\n\n-- | This computes a solid slice of a convolution much faster than sampling each point individually by using a convolution cache window.\nfastTickConvolutionFixedKern :: Double -> Tick -> Tick -> Wavetable -> Wavetable -> [Discrete]\nfastTickConvolutionFixedKern tickRate tickStart tickRadius kern w = kern `seq` go (vi,0) tickStart\n where\n vi = runST $ do\n v <- BA.newByteArray (windowSize * 4)\n forM_ [-tickRadius .. (tickRadius - 1)] $ \\dt -> BA.writeByteArray v (1 + tickRadius + dt) (unDiscrete $ sample w (tickStart + dt))\n BA.unsafeFreezeByteArray v\n -- Table, breakpoint, offset\n stepSt :: (BA.ByteArray, Int) -> Tick -> (Discrete, BA.ByteArray)\n stepSt (!t,!b) o = runST $ do\n v <- BA.unsafeThawByteArray t\n BA.writeByteArray v (b `mod` windowSize) (unDiscrete $ sample w (o + tickRadius))\n let \n accu !tot (dt:dts) = do\n --let !() = unsafePerformIO $ readIORef accuCount >>= \\x -> (if x `mod` 10000 == 0 then putStrLn (\"accu: \" ++ show x) else pure ()) >> writeIORef accuCount (x + 1)\n s <- BA.readByteArray v ((b + tickRadius + dt + 1) `mod` windowSize)\n let !toAdd = (0.01 * Discrete (BA.indexByteArray kernel dt)) * Discrete s\n accu (tot + toAdd) dts\n accu tot [] = pure tot\n k <- accu 0 sampleDeltas\n !v' <- BA.unsafeFreezeByteArray v\n pure (k,v')\n go (!t,!b) o = let (s,t') = stepSt (t,b) o in s `seq` (s : go (t',(b+1) `mod` windowSize) (o + 1))\n --accu :: BA.MutableByteArray s -> Int -> Tick -> Discrete -> Tick -> ST s Discrete\n windowSize = tickRadius * 2 + 1\n sampleDeltas = [-tickRadius .. tickRadius]\n !kernel = runST $ do\n v <- BA.newByteArray (windowSize * 4)\n forM_ [-tickRadius .. (tickRadius - 1)] $ \\dt -> BA.writeByteArray v (1 + tickRadius + dt) (unDiscrete . (* doubleToDiscrete (recip tickRate)) $ sample kern dt)\n BA.unsafeFreezeByteArray v\n\n-- | Same as @'tickConvolution'@ but for arbitarily valued waveforms. Works on @'DWave'@ for example.\nsampledConvolution :: (RealFrac t, Fractional a) \n => t -- ^ @convolutionSampleRate@, controls sampling for @x@\n -> t -- ^ @convolutionRadius@, continuous analogue of @tickRadius@\n -> Waveform t (Waveform t a) -- ^ Kernel of convolution for each time\n -> Waveform t a -> Waveform t a\nsampledConvolution convolutionSampleRate convolutionRadius profile w = sampleFrom $ \\t -> sum . map (\\dt -> (*(realToFrac . recip $ convolutionSampleRate * convolutionRadius)) . (* sample w (t + dt)) . sample (sample profile t) $ dt) $ sampleDeltas\n where\n sampleDeltas = map ((/convolutionSampleRate) . realToFrac) [-samplesPerSide .. samplesPerSide]\n samplesPerSide = floor (convolutionRadius * convolutionSampleRate) :: Int\n --sampleCount = 2 * samplesPerSide + 1\n\n-- | Makes a filter which selects frequencies near @bandCenter@ with tuning parameter @bandSize@.\n-- Try: @'optimizeFilter' 200 . 'tickTable' 'stdtr' $ 'bandpassFilter' 'concertA' 100@\nbandpassFilter :: Fractional a \n => Double -- ^ @bandCenter@\n -> Double -- ^ @bandSize@\n -> Waveform Double a\nbandpassFilter bandCenter bandSize = sampleFrom $ \\t -> if t == 0 then 1 else realToFrac $ (sin (bandFreq * t)) / (bandFreq * t) * (cos (centerFreq * t))\n where\n !bandFreq = 2 * pi * bandSize\n !centerFreq = 2 * pi * bandCenter\n\n-- | Ladder filter, adapted from VCV Rack\nladderFilter :: Double -> [Double] -> [Double] -> [Double] -> [(Double,Double,Double,Double)]\nladderFilter sampleRate reso cutoffs inputs = fmap (FV.convert :: FV.VecList 4 Double -> (Double,Double,Double,Double)) $ rkSolveStepSize (1/sampleRate) rkf (FV.mk4 1e-6 1e-6 1e-6 1e-6) (zip3 reso cutoffs inputs)\n where\n rkf (r,c,i) x = let cut = 2 * pi * c in FV.mk4 (cut * (i - r * (x FV.! 2) - (x FV.! 0))) (cut * (x FV.! 0 - x FV.! 1)) (cut * (x FV.! 1 - x FV.! 2)) (cut * (x FV.! 2 - x FV.! 3))\n\n-- | Use Runge-Kutta method to solve the diffeq\nrkSolve \n :: Applicative f => (i -> f Double -> f Double) -- ^ User suplied function mapping inputs to a coefficient matrix\n -> f Double -- ^ Initial value\n -> [i] -- ^ Stream of inputs\n -> [f Double] -- ^ Stream of outputs\nrkSolve rkf = scanl stepSt\n where\n stepSt x i = let\n k1 = rkf i x\n k2 = rkf i (liftA2 (\\k xi -> xi + k/2) k1 x)\n k3 = rkf i (liftA2 (\\k xi -> xi + k/2) k2 x)\n k4 = rkf i (liftA2 (+) k3 x)\n in liftA2 (\\xi ki -> xi + ki/6) x $ liftA2 (+) (liftA2 (+) (fmap (*2) k2) (fmap (*2) k3)) (liftA2 (+) k1 k4)\n\n-- | Like @'rkSolve'@ but using non-unit step size by multiplying the coefficient matrix by a factor\nrkSolveStepSize :: Applicative f => Double -> (i -> f Double -> f Double) -> f Double -> [i] -> [f Double]\nrkSolveStepSize h rkf = rkSolve ((fmap (* h) .) . rkf)\n\n-- | Drive scaling function adapted from VCV Rack\nscaledDrive :: Double -> Double\nscaledDrive drv = (1 + drv) ** 5\n\n-- | Uses @'ladderFilter'@ to low pass filter the input with the given resonance and cutoff\nlowPassFilter :: Double -> [Double] -> [Double] -> [Double] -> [Double]\nlowPassFilter rate res cut = fmap (\\(_,_,_,d) -> d) . ladderFilter rate res cut\n\n-- | Synthesize from a continuous profile by sampling frequencies.\n-- Doesn't work very well; prefer 'synthFromDisreteProfile'.\nsynthFromFreqProfile :: (Double,Double) -> Double -> DWave -> DWave\nsynthFromFreqProfile (f0,f1) fSampRate prof = sampleFrom $ \\t -> max (-1) $ min 1 $ sum . fmap ((/fromIntegral (length sampPoints)) . sampleAt t . getComponent) $ sampPoints\n where\n getComponent f = fmap (*sample prof f) $ sinWaveWithPhase f (pi/2)\n sampPoints = [f0, f0 + 1/fSampRate .. f1]\n --jitterFactor k = (fromIntegral (floor (((k - f0) / (f1 - f0)) * 81083) `mod` 115)) / 115\n --jitter k = k + (2/fSampRate) * jitterFactor k\n\n-- | Continuous saxopohone profile adapted from https://asa.scitation.org/doi/10.1121/1.396474\nsaxProfile :: DWave\nsaxProfile = sampleFrom $ \\f -> let x = f/fb in sqrt (n * x/(1 + x**7))\n where\n fb = 618\n n = 1.088910\n\n-- | Synthesize a wavetable from the specified relative strengths of various frequencies.\n-- Essentially an inverse fourier transform\nsynthFromDiscreteProfile :: [(Double,Double)] -> Wavetable\nsynthFromDiscreteProfile fs = {-solidSlice 0 (truncate $ stdtr/(1 :: Double)) .-} tickTable stdtr . discretize . mergeWaves . fmap (\\(f,amp) -> fmap (*(normFactor * amp)) $ sinWaveWithPhase f f) $ fs\n where\n normFactor = 0.9/(sum $ fmap snd fs)\n\n-- | Produces a discrete profile of relative harmonic strengths from the given functions.\n-- Try @'harmonicEquationToDiscreteProfile' (\\x -> 0.1894 / (x ** 1.02)) (\\x -> 0.0321 / (x ** 0.5669))@\nharmonicEquationToDiscreteProfile :: (Double -> Double) -> (Double -> Double) -> Double -> [(Double,Double)]\nharmonicEquationToDiscreteProfile oddF evenF f0 = go (15 :: Int)\n where\n go 0 = []\n go k = (fromIntegral k * f0,(if even k then evenF else oddF) $ fromIntegral k) : go (k-1)\n\n-- | Roughly resemebles the spectrum of a saxophone\ndiscSaxProfile :: [(Double,Double)]\ndiscSaxProfile = f1 ++ f2\n where\n f1 = \n [(588.6,0.0911)\n ,(1179,0.05463)\n ,(1767,0.03471)\n ,(2357,0.01109)\n ,(2946,0.01625)\n ] -- y=63/x ish\n f2 = \n [(294.9,0.03032)\n ,(884,0.02445)\n ,(1474,0.01172)\n ,(2062,0.008224)\n ,(2651,0.00881)\n ,(3241,0.005567)\n ]\n\n-- | Roughly resemebles the spectrum of a saxophone\ngenSaxProfile' :: Double -> [(Double,Double)]\ngenSaxProfile' f0 =\n [(1 * f0,0.0474475510012406)\n ,(2 * f0,0.0141427241744339)\n ,(3 * f0,0.00838229600425522)\n ,(4 * f0,0.00452452580892121)\n ,(5 * f0,0.0129662632033567)\n ,(6 * f0,0.0102954061023286)\n ,(7 * f0,0.00246665413386754)\n ,(8 * f0,0.00309631105551752)\n ,(9 * f0,0.00313836031805197)\n ,(10 * f0,0.00549688733850934)\n ,(11 * f0,0.00826471159302181)\n ,(12 * f0,0.00280485189554740)\n ]\n\n-- | Roughly resemebles the spectrum of a saxophone\ngenSaxProfile :: Double -> [(Double,Double)]\ngenSaxProfile f0 = f1 ++ f2\n where\n f1 = \n [(2 * f0,0.0911)\n ,(4 * f0,0.05463)\n ,(4 * f0,0.03471)\n ,(6 * f0,0.01109)\n ,(8 * f0,0.01625)\n ] -- y=63/x ish\n f2 = \n [(f0,0.03032)\n ,(3 * f0,0.02445)\n ,(5 * f0,0.01172)\n ,(7 * f0,0.008224)\n ,(9 * f0,0.00881)\n ,(11 * f0,0.005567)\n ]\n\n-- | Rough saxophone timbre from @'gen\nfakedSaxTimbre :: Double -> Wavetable\nfakedSaxTimbre = synthFromDiscreteProfile . genSaxProfile'\n\n-- | A timbre that consists of several sin wave voices at fixed chord intervals from each other\nchordSinTimbre :: ChordVoicing PitchFactorDiagram -> Double -> Wavetable\nchordSinTimbre c r = discretize . tickTable stdtr . balanceChord . fmap (sinWave . flip intervalOf r) $ getVoiceList c\n\n-- | Discretize the output of a @'Double'@ producing waveform\ndiscretize :: Functor f => f Double -> f Discrete\ndiscretize = fmap doubleToDiscrete\n\n-- | Discretize the input to a @'Double'@ consuming waveform\ntickTable :: Double -- ^ Sample rate. Each tick is @1/sampleRate@ seconds\n -> Waveform Double a -> Waveform Tick a\ntickTable tickrate w = sampleFrom $ \\t -> sample w (fromIntegral t/tickrate)\n\n-- | Discretize the input to a @'Double'@ consuming waveform\ntickTablePer :: Double -- ^ Sample period. Sampling rate is @1/period@\n -> Waveform Double a -> Waveform Tick a\ntickTablePer per w = sampleFrom $ \\t -> sample w (fromIntegral t * per)\n\n-- | A domain- and codomain-discretized @'Waveform'@ suitable for writing to a WAVE file.\n-- See @'waveformToWAVE'@.\ntype Wavetable = Waveform Tick Discrete\n\n-- | A data structure for storing the results of a @'Wavetable'@ on some subset of its domain.\n-- Used internally.\ndata CompactWavetable = CompactWavetable {getWavetable :: Vector.Vector Int32}\n\nfromCompact :: CompactWavetable -> Wavetable\nfromCompact cwt = sampleFrom $ \\t -> case getWavetable cwt Vector.!? t of\n Just d -> Discrete d\n Nothing -> error \"fromCompact Wavetable sampled outside size of compact table\"\n\n\n-- | Optimize a @'Wavetable'@ by storing its values in a particular range.\n-- Uses @(tickEnd - tickStart + 1) * sizeOf (_ :: 'Discrete')@ bytes of memory to do this.\nsolidSlice :: Tick -> Tick -> Wavetable -> Wavetable\nsolidSlice tickStart tickEnd w = sampleFrom $ \\t -> case getWavetable cwt Vector.!? (t-tickStart) of\n Just d -> Discrete d\n Nothing -> sample w t\n where\n cwt = CompactWavetable {getWavetable = Vector.generate (tickEnd - tickStart + 1) (unDiscrete . sample w . (+tickStart))}\n\n-- | Optimize a filter by doing @'solidSlice'@ around @t=0@ since those values are sampled repeatedly in a filter\noptimizeFilter :: Tick -> Wavetable -> Wavetable\noptimizeFilter tickRadius = solidSlice (-tickRadius) tickRadius\n\n-- | Take the Fourier Transform of a complex valued @'Tick'@ sampled waveform\nfourierTransform :: Tick -> Double -> Waveform Tick (Complex Double) -> Waveform Double (Complex Double)\nfourierTransform tickRadius fTickRate x = sampleFrom $ \\f -> sum . map (\\n -> sample x n / (fromIntegral tickRadius) * cis (2 * pi * f * (fromIntegral n / fTickRate))) $ [-tickRadius .. tickRadius]\n\n-- | Take the Fourier Transform of a @'Wavetable'@\nrealDFT :: Tick -- ^ Radius of Fourier Transform window in @'Tick'@s. Try 200\n -> Double -- ^ Sampling rate to use for the Fourier transform. Try the sample sample rate as the @'Wavetable'@\n -> Wavetable -> Wavetable\nrealDFT tickRadius fTickRate w = discretize $ tickTable 1 $ fmap ((min 1) . magnitude) $ fourierTransform tickRadius fTickRate ((\\x -> discreteToDouble x :+ 0) <$> solidSlice (-tickRadius) tickRadius w)\n\n-- | Skip every @n@ ticks in the in the given @'Waveform'@.\n-- @'sample' ('skipTicks' n w) k = 'sample' w (n*k)@\nskipTicks :: Tick -- ^ @n@\n -> Waveform Tick a -> Waveform Tick a\nskipTicks skipRate w = sampleFrom $ \\t -> sample w (skipRate * t)\n\nskipStream :: Tick -> [Discrete] -> [Discrete]\nskipStream skipRate (x:xs) = x : skipStream skipRate (drop skipRate xs)\nskipStream _ [] = []\n\n-- | Optimize a @'Wavetable'@ that we know to be periodic by storing it's values on one period.\n-- Takes @period * sizeOf (_ :: 'Discrete')@ bytes of memory to do this.\n--\n-- Warning: Causes clicking on period boundaries if the period isn't exactly the given value in ticks.\nexploitPeriodicity :: Tick -- ^ Period in @'Tick'@s of the @'Wavetable'@.\n -> Wavetable -> Wavetable\nexploitPeriodicity period x = sampleFrom $ \\t -> case getWavetable cwt Vector.!? (t `mod` period) of\n Just d -> Discrete d\n Nothing -> sample x t\n where\n cwt = CompactWavetable {getWavetable = Vector.generate period (unDiscrete . sample x)}\n\n-- | Attempts to do a fast fourier transform, but the units of the domain of the output are highly suspect.\n-- May be unreliable, use with caution.\nusingFFT :: Tick -> Wavetable -> Wavetable\nusingFFT tickRadius w = sampleFrom $ \\t -> if t < (fromIntegral $ length l)\n then (!! t) . fmap (doubleToDiscrete . magnitude) $ l\n else 0\n where\n l = fft (map ((\\x -> discreteToDouble x :+ 0) . sample w) [-tickRadius .. tickRadius])\n\n-- | Cooley-Tukey fft\nfft :: [Complex Double] -> [Complex Double]\nfft [] = []\nfft [x] = [x]\nfft xs = zipWith (+) ys ts ++ zipWith (-) ys ts\n where n = length xs\n ys = fft evens\n zs = fft odds \n (evens, odds) = split xs\n split [] = ([], [])\n split [x] = ([x], [])\n split (x:y:xss) = (x:xt, y:yt) where (xt, yt) = split xss\n ts = zipWith (\\z k -> exp' k n * z) zs [0..]\n exp' :: Int -> Int -> Complex Double\n exp' k a = cis $ -2 * pi * (fromIntegral k) / (fromIntegral a)\n", "meta": {"hexsha": "56c88e2536437718edd0234b79e5e614cff71372", "size": 31541, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/Boopadoop.hs", "max_stars_repo_name": "Lazersmoke/boopadoop", "max_stars_repo_head_hexsha": "40b1b0cb72c78ec356bd0cd95b9e88fde162f14d", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2020-05-26T17:10:06.000Z", "max_stars_repo_stars_event_max_datetime": "2021-02-15T17:07:23.000Z", "max_issues_repo_path": "src/Boopadoop.hs", "max_issues_repo_name": "Lazersmoke/boopadoop", "max_issues_repo_head_hexsha": "40b1b0cb72c78ec356bd0cd95b9e88fde162f14d", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/Boopadoop.hs", "max_forks_repo_name": "Lazersmoke/boopadoop", "max_forks_repo_head_hexsha": "40b1b0cb72c78ec356bd0cd95b9e88fde162f14d", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 46.315712188, "max_line_length": 248, "alphanum_fraction": 0.6541327161, "num_tokens": 9687, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.7341195269001831, "lm_q2_score": 0.4571367168274948, "lm_q1q2_score": 0.33559299028610345}} {"text": "{-# LANGUAGE CPP #-}\n{-# LANGUAGE DefaultSignatures, TypeOperators, FlexibleContexts, TypeSynonymInstances, FlexibleInstances #-}\nmodule Pure.Data.Default where\n\nimport Control.Applicative\n\nimport Data.Complex\nimport Data.Int\nimport Data.Monoid\nimport Data.Ratio\nimport Data.Word\n\nimport GHC.Generics\n\nclass Default a where\n def :: a\n default def :: (Generic a, GDefault (Rep a)) => a\n def = to gdef\n\ninstance Default Bool where def = False -- like other languages with construction defaults\n\ninstance Default () where def = ()\ninstance Default Ordering where def = EQ\ninstance Default Any where def = Any False\ninstance Default All where def = All True\ninstance Default (Last a) where def = Last Nothing\ninstance (Num a) => Default (Sum a) where def = Sum 0\ninstance (Num a) => Default (Product a) where def = Product 1\ninstance Default (Endo a) where def = Endo id\ninstance Default a => Default (Const a b) where def = Const def\ninstance Default (Maybe a) where def = Nothing\ninstance Default [a] where def = []\n\n-- Note that (def :: Try a) /= mempty\n-- instance Default (Try a) where def = Trying\n\n-- instance Default Txt where def = mempty\n\n-- instance (Eq a, Hashable a) => Default (HashMap.HashMap a b) where\n-- def = mempty\n\n-- instance Default Value where\n-- def =\n-- #ifdef __GHCJS__\n-- nullValue\n-- #else\n-- Null\n-- #endif\n\n-- instance Default Obj where def = mempty\n\n-- instance Default Micros where def = 0\n-- instance Default Millis where def = 0\ninstance Default Int where def = 0\ninstance Default Int8 where def = 0\ninstance Default Int16 where def = 0\ninstance Default Int32 where def = 0\ninstance Default Int64 where def = 0\ninstance Default Word where def = 0\ninstance Default Word8 where def = 0\ninstance Default Word16 where def = 0\ninstance Default Word32 where def = 0\ninstance Default Word64 where def = 0\ninstance Default Integer where def = 0\ninstance Default Float where def = 0\ninstance Default Double where def = 0\ninstance (Integral a) => Default (Ratio a) where def = 0\ninstance (Default a,RealFloat a) => Default (Complex a) where def = def :+ def\ninstance {-# OVERLAPPABLE #-} Default r => Default (x -> r) where def = const def\ninstance {-# OVERLAPPING #-} Default (a -> a) where def = id\ninstance Default a => Default (IO a) where def = return def\ninstance Default a => Default (Dual a) where def = Dual def\n\ninstance (Default a, Default b) => Default (a, b) where def = (def, def)\ninstance (Default a, Default b, Default c) => Default (a, b, c) where def = (def, def, def)\ninstance (Default a, Default b, Default c, Default d) => Default (a, b, c, d) where def = (def, def, def, def)\ninstance (Default a, Default b, Default c, Default d, Default e) => Default (a, b, c, d, e) where def = (def, def, def, def, def)\ninstance (Default a, Default b, Default c, Default d, Default e, Default f) => Default (a, b, c, d, e, f) where def = (def, def, def, def, def, def)\ninstance (Default a, Default b, Default c, Default d, Default e, Default f, Default g) => Default (a, b, c, d, e, f, g) where def = (def, def, def, def, def, def, def)\n\n-- Inspired by Lukas Mai's data-default-class with a default instance for\n-- sum types based on lexicographical order - similar to the Ord and Enum\n-- instances\nclass GDefault f where\n gdef :: f a\n\ninstance GDefault V1 where\n gdef = undefined\n\ninstance GDefault U1 where\n gdef = U1\n\ninstance (Default a) => GDefault (K1 i a) where\n gdef = K1 def\n\ninstance (GDefault a, GDefault b) => GDefault (a :*: b) where\n gdef = gdef :*: gdef\n\ninstance (GDefault a, GDefault b) => GDefault (a :+: b) where\n gdef = L1 gdef\n\ninstance (GDefault a) => GDefault (M1 i c a) where\n gdef = M1 gdef\n", "meta": {"hexsha": "d2d975a6ee2b921b8ce150359906f57222f5543a", "size": 3667, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/Pure/Data/Default.hs", "max_stars_repo_name": "grumply/pure-default", "max_stars_repo_head_hexsha": "7b51c5b6045248ccc852e0fd6ab6cf9c2d149ef5", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/Pure/Data/Default.hs", "max_issues_repo_name": "grumply/pure-default", "max_issues_repo_head_hexsha": "7b51c5b6045248ccc852e0fd6ab6cf9c2d149ef5", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/Pure/Data/Default.hs", "max_forks_repo_name": "grumply/pure-default", "max_forks_repo_head_hexsha": "7b51c5b6045248ccc852e0fd6ab6cf9c2d149ef5", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 35.2596153846, "max_line_length": 167, "alphanum_fraction": 0.7024815926, "num_tokens": 1043, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.588889130767832, "lm_q2_score": 0.5698526514141571, "lm_q1q2_score": 0.33558003255702734}} {"text": "-- | See Hoffman, Gelman (2011) The No U-Turn Sampler: Adaptively Setting Path\n-- Lengths in Hamiltonian Monte Carlo.\n\nmodule Numeric.MCMC.NUTS where\n\nimport Control.Monad\nimport Control.Monad.Loops\nimport Control.Monad.Primitive\nimport System.Random.MWC\nimport System.Random.MWC.Distributions hiding (gamma)\nimport Statistics.Distribution.Normal\n\ntype Parameters = [Double] \ntype Density = Parameters -> Double\ntype Gradient = Parameters -> Parameters\ntype Particle = (Parameters, Parameters)\ntype StateSpecs = ([Double], [Double], [Double], [Double], [Double], Int, Int)\n\nnewtype StateTree = StateTree { \n getStateTree :: StateSpecs\n }\n\ninstance Show StateTree where\n show (StateTree (tm, rm, tp, rp, t', n, s)) = \n \"\\n\" ++ \"tm: \" ++ show tm \n ++ \"\\n\" ++ \"tp: \" ++ show tp\n ++ \"\\n\" ++ \"t': \" ++ show t'\n ++ \"\\n\" ++ \"n : \" ++ show n\n ++ \"\\n\" ++ \"s : \" ++ show s\n\ndata DualAveragingParameters = DualAveragingParameters {\n mAdapt :: Int\n , delta :: Double\n , mu :: Double\n , gamma :: Double\n , tau0 :: Double\n , kappa :: Double\n } deriving Show\n\n-- | The NUTS sampler.\nnuts \n :: PrimMonad m\n => Density\n -> Gradient\n -> Int\n -> Double\n -> Parameters\n -> Gen (PrimState m)\n -> m [Parameters]\nnuts lTarget glTarget n e t g = go t 0 []\n where go position j acc\n | j >= n = return acc\n | otherwise = do\n nextPosition <- nutsKernel lTarget glTarget e position g\n go nextPosition (succ j) (nextPosition : acc)\n\n-- | The NUTS sampler with dual averaging.\nnutsDualAveraging\n :: PrimMonad m\n => Density\n -> Gradient\n -> Int\n -> Int\n -> Parameters\n -> Gen (PrimState m)\n -> m [Parameters]\nnutsDualAveraging lTarget glTarget n nAdapt t g = do\n e0 <- findReasonableEpsilon lTarget glTarget t g\n let daParams = basicDualAveragingParameters e0 nAdapt\n chain <- unfoldrM (kernel daParams) (1, e0, 1, 0, t)\n return $ drop nAdapt chain\n where\n kernel params (m, e, eAvg, h, t0) = do\n (eNext, eAvgNext, hNext, tNext) <- \n nutsKernelDualAvg lTarget glTarget e eAvg h m params t0 g\n return $ if m > n + nAdapt\n then Nothing\n else Just (t0, (succ m, eNext, eAvgNext, hNext, tNext))\n\n-- | Default DA parameters, given a base step size and burn in period.\nbasicDualAveragingParameters :: Double -> Int -> DualAveragingParameters\nbasicDualAveragingParameters step burnInPeriod = DualAveragingParameters {\n mu = log (10 * step)\n , delta = 0.5\n , mAdapt = burnInPeriod\n , gamma = 0.05\n , tau0 = 10\n , kappa = 0.75\n }\n\n-- | A single iteration of dual-averaging NUTS.\nnutsKernelDualAvg \n :: PrimMonad m \n => Density\n -> Gradient\n -> Double\n -> Double\n -> Double\n -> Int\n -> DualAveragingParameters\n -> [Double]\n -> Gen (PrimState m)\n -> m (Double, Double, Double, Parameters)\nnutsKernelDualAvg lTarget glTarget e eAvg h m daParams t g = do\n r0 <- replicateM (length t) (normal 0 1 g)\n z0 <- exponential 1 g\n let logu = log (auxilliaryTarget lTarget t r0) - z0\n\n let go (tn, tp, rn, rp, tm, j, n, s, a, na) g\n | s == 1 = do\n vj <- symmetricCategorical [-1, 1] g\n z <- uniform g\n\n (tnn, rnn, tpp, rpp, t1, n1, s1, a1, na1) <-\n if vj == -1\n then do\n (tnn', rnn', _, _, t1', n1', s1', a1', na1') <- \n buildTreeDualAvg lTarget glTarget g tn rn logu vj j e t r0\n return (tnn', rnn', tp, rp, t1', n1', s1', a1', na1')\n else do\n (_, _, tpp', rpp', t1', n1', s1', a1', na1') <- \n buildTreeDualAvg lTarget glTarget g tp rp logu vj j e t r0\n return (tn, rn, tpp', rpp', t1', n1', s1', a1', na1')\n\n let accept = s1 == 1 && (min 1 (fi n1 / fi n :: Double)) > z \n\n n2 = n + n1\n s2 = s1 * stopCriterion tnn tpp rnn rpp\n j1 = succ j\n t2 | accept = t1\n | otherwise = tm\n\n go (tnn, tpp, rnn, rpp, t2, j1, n2, s2, a1, na1) g\n\n | otherwise = return (tm, a, na)\n\n (nextPosition, alpha, nalpha) <- go (t, t, r0, r0, t, 0, 1, 1, 0, 0) g\n \n let (hNext, eNext, eAvgNext) =\n if m <= mAdapt daParams\n then (hm, exp logEm, exp logEbarM)\n else (h, eAvg, eAvg)\n where\n eta = 1 / (fromIntegral m + tau0 daParams)\n hm = (1 - eta) * h \n + eta * (delta daParams - alpha / fromIntegral nalpha)\n\n zeta = fromIntegral m ** (- (kappa daParams))\n\n logEm = mu daParams - sqrt (fromIntegral m) / gamma daParams * hm\n logEbarM = (1 - zeta) * log eAvg + zeta * logEm\n\n return (eNext, eAvgNext, hNext, nextPosition)\n\n-- | A single iteration of NUTS.\nnutsKernel \n :: PrimMonad m \n => Density\n -> Gradient\n -> Double\n -> Parameters\n -> Gen (PrimState m)\n -> m Parameters\nnutsKernel lTarget glTarget e t g = do\n r0 <- replicateM (length t) (normal 0 1 g)\n z0 <- exponential 1 g\n let logu = log (auxilliaryTarget lTarget t r0) - z0\n\n let go (tn, tp, rn, rp, tm, j, n, s) g\n | s == 1 = do\n vj <- symmetricCategorical [-1, 1] g\n z <- uniform g\n\n (tnn, rnn, tpp, rpp, t1, n1, s1) <- \n if vj == -1\n then do\n (tnn', rnn', _, _, t1', n1', s1') <- \n buildTree lTarget glTarget g tn rn logu vj j e\n return (tnn', rnn', tp, rp, t1', n1', s1')\n else do\n (_, _, tpp', rpp', t1', n1', s1') <- \n buildTree lTarget glTarget g tp rp logu vj j e\n return (tn, rn, tpp', rpp', t1', n1', s1')\n\n let accept = s1 == 1 && (min 1 (fi n1 / fi n :: Double)) > z\n\n n2 = n + n1\n s2 = s1 * stopCriterion tnn tpp rnn rpp\n j1 = succ j\n t2 | accept = t1\n | otherwise = tm\n\n go (tnn, tpp, rnn, rpp, t2, j1, n2, s2) g\n\n | otherwise = return tm\n\n go (t, t, r0, r0, t, 0, 1, 1) g\n\n-- | Build the 'tree' of candidate states.\nbuildTree \n :: PrimMonad m \n => Density\n -> Gradient\n -> Gen (PrimState m)\n -> Parameters\n -> Parameters\n -> Double\n -> Double\n -> Int\n -> Double\n -> m StateSpecs\nbuildTree lTarget glTarget g t r logu v 0 e = do\n let (t0, r0) = leapfrog glTarget (t, r) (v * e)\n joint = log $ auxilliaryTarget lTarget t0 r0\n n = indicate (logu < joint)\n s = indicate (logu - 1000 < joint)\n return (t0, r0, t0, r0, t0, n, s)\n\nbuildTree lTarget glTarget g t r logu v j e = do\n z <- uniform g\n (tn, rn, tp, rp, t0, n0, s0) <- \n buildTree lTarget glTarget g t r logu v (pred j) e\n\n if s0 == 1\n then do\n (tnn, rnn, tpp, rpp, t1, n1, s1) <- \n if v == -1\n then do\n (tnn', rnn', _, _, t1', n1', s1') <- \n buildTree lTarget glTarget g tn rn logu v (pred j) e\n return (tnn', rnn', tp, rp, t1', n1', s1')\n else do\n (_, _, tpp', rpp', t1', n1', s1') <- \n buildTree lTarget glTarget g tp rp logu v (pred j) e\n return (tn, rn, tpp', rpp', t1', n1', s1')\n\n let accept = (fi n1 / max (fi (n0 + n1)) 1) > (z :: Double)\n n2 = n0 + n1\n s2 = s0 * s1 * stopCriterion tnn tpp rnn rpp\n t2 | accept = t1\n | otherwise = t0 \n\n return (tnn, rnn, tpp, rpp, t2, n2, s2)\n else return (tn, rn, tp, rp, t0, n0, s0)\n\n-- | Determine whether or not to stop doubling the tree of candidate states.\nstopCriterion :: (Integral a, Num b, Ord b) => [b] -> [b] -> [b] -> [b] -> a\nstopCriterion tn tp rn rp = \n indicate (positionDifference `innerProduct` rn >= 0)\n * indicate (positionDifference `innerProduct` rp >= 0)\n where\n positionDifference = tp .- tn\n\n-- | Build the tree of candidate states under dual averaging.\nbuildTreeDualAvg\n :: PrimMonad m \n => Density\n -> Gradient\n -> Gen (PrimState m)\n -> Parameters\n -> Parameters\n -> Double\n -> Double\n -> Int\n -> Double\n -> Parameters\n -> Parameters\n -> m ([Double], [Double], [Double], [Double], [Double], Int, Int, Double, Int)\nbuildTreeDualAvg lTarget glTarget g t r logu v 0 e t0 r0 = do\n let (t1, r1) = leapfrog glTarget (t, r) (v * e)\n joint = log $ auxilliaryTarget lTarget t1 r1\n n = indicate (logu < joint)\n s = indicate (logu - 1000 < joint)\n a = min 1 (acceptanceRatio lTarget t0 t1 r0 r1)\n return (t1, r1, t1, r1, t1, n, s, a, 1)\n \nbuildTreeDualAvg lTarget glTarget g t r logu v j e t0 r0 = do\n z <- uniform g\n (tn, rn, tp, rp, t1, n1, s1, a1, na1) <- \n buildTreeDualAvg lTarget glTarget g t r logu v (pred j) e t0 r0\n\n if s1 == 1\n then do\n (tnn, rnn, tpp, rpp, t2, n2, s2, a2, na2) <-\n if v == -1\n then do \n (tnn', rnn', _, _, t1', n1', s1', a1', na1') <- \n buildTreeDualAvg lTarget glTarget g tn rn logu v (pred j) e t0 r0\n return (tnn', rnn', tp, rp, t1', n1', s1', a1', na1')\n else do\n (_, _, tpp', rpp', t1', n1', s1', a1', na1') <-\n buildTreeDualAvg lTarget glTarget g tp rp logu v (pred j) e t0 r0\n return (tn, rn, tpp', rpp', t1', n1', s1', a1', na1')\n\n let p = fi n2 / max (fi (n1 + n2)) 1\n accept = p > (z :: Double)\n n3 = n1 + n2\n a3 = a1 + a2\n na3 = na1 + na2\n s3 = s1 * s2 * stopCriterion tnn tpp rnn rpp\n\n t3 | accept = t2\n | otherwise = t1\n\n return (tnn, rnn, tpp, rpp, t3, n3, s3, a3, na3)\n else return (tn, rn, tp, rp, t1, n1, s1, a1, na1)\n\n-- | Heuristic for initializing step size.\nfindReasonableEpsilon \n :: PrimMonad m \n => Density\n -> Gradient\n -> Parameters\n -> Gen (PrimState m) \n -> m Double\nfindReasonableEpsilon lTarget glTarget t0 g = do\n r0 <- replicateM (length t0) (normal 0 1 g)\n let (t1, r1) = leapfrog glTarget (t0, r0) 1.0\n a = 2 * indicate (acceptanceRatio lTarget t0 t1 r0 r1 > 0.5) - 1\n\n go j e t r \n | j <= 0 = e -- no need to shrink this excessively\n | (acceptanceRatio lTarget t0 t r0 r) ^^ a > 2 ^^ (-a) = \n let (tn, rn) = leapfrog glTarget (t, r) e\n in go (pred j) (2 ^^ a * e) tn rn \n | otherwise = e\n\n return $ go 10 1.0 t1 r1\n\n-- | Simulate a single step of Hamiltonian dynamics.\nleapfrog :: Gradient -> Particle -> Double -> Particle\nleapfrog glTarget (t, r) e = (tf, rf)\n where \n rm = adjustMomentum glTarget e t r\n tf = adjustPosition e rm t\n rf = adjustMomentum glTarget e tf rm\n\n-- | Adjust momentum.\nadjustMomentum :: Fractional c => (t -> [c]) -> c -> t -> [c] -> [c]\nadjustMomentum glTarget e t r = r .+ ((e / 2) .* glTarget t)\n\n-- | Adjust position.\nadjustPosition :: Num c => c -> [c] -> [c] -> [c]\nadjustPosition e r t = t .+ (e .* r)\n\n-- | The MH acceptance ratio for a given proposal.\nacceptanceRatio :: Floating a => (t -> a) -> t -> t -> [a] -> [a] -> a\nacceptanceRatio lTarget t0 t1 r0 r1 = auxilliaryTarget lTarget t1 r1\n / auxilliaryTarget lTarget t0 r0\n\n-- | The negative potential. \nauxilliaryTarget :: Floating a => (t -> a) -> t -> [a] -> a\nauxilliaryTarget lTarget t r = exp (lTarget t - 0.5 * innerProduct r r)\n\n-- | Simple inner product.\ninnerProduct :: Num a => [a] -> [a] -> a\ninnerProduct xs ys = sum $ zipWith (*) xs ys\n\n-- | Vectorized multiplication.\n(.*) :: Num b => b -> [b] -> [b]\nz .* xs = map (* z) xs\n\n-- | Vectorized subtraction.\n(.-) :: Num a => [a] -> [a] -> [a]\nxs .- ys = zipWith (-) xs ys\n\n-- | Vectorized addition.\n(.+) :: Num a => [a] -> [a] -> [a]\nxs .+ ys = zipWith (+) xs ys\n\n-- | Indicator function.\nindicate :: Integral a => Bool -> a\nindicate True = 1\nindicate False = 0\n\n-- | A symmetric categorical (discrete uniform) distribution.\nsymmetricCategorical :: PrimMonad m => [a] -> Gen (PrimState m) -> m a\nsymmetricCategorical [] _ = error \"symmetricCategorical: no candidates\"\nsymmetricCategorical zs g = do\n j <- uniformR (0, length zs - 1) g\n return $ zs !! j\n\n-- | Alias for fromIntegral.\nfi :: (Integral a, Num b) => a -> b\nfi = fromIntegral\n\n", "meta": {"hexsha": "83169a6e9468268c97ae7d82a6882a030b717027", "size": 12092, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/Numeric/MCMC/NUTS.hs", "max_stars_repo_name": "jtobin/hnuts", "max_stars_repo_head_hexsha": "5fa71a62057073bfdb32bf1d0264a1da3c32f247", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 5, "max_stars_repo_stars_event_min_datetime": "2017-01-16T15:03:37.000Z", "max_stars_repo_stars_event_max_datetime": "2020-09-19T21:38:56.000Z", "max_issues_repo_path": "src/Numeric/MCMC/NUTS.hs", "max_issues_repo_name": "jtobin/hnuts", "max_issues_repo_head_hexsha": "5fa71a62057073bfdb32bf1d0264a1da3c32f247", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2017-01-25T14:08:57.000Z", "max_issues_repo_issues_event_max_datetime": "2017-01-28T12:34:50.000Z", "max_forks_repo_path": "src/Numeric/MCMC/NUTS.hs", "max_forks_repo_name": "jtobin/hnuts", "max_forks_repo_head_hexsha": "5fa71a62057073bfdb32bf1d0264a1da3c32f247", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 4, "max_forks_repo_forks_event_min_datetime": "2017-01-16T13:32:59.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-22T05:08:21.000Z", "avg_line_length": 31.2454780362, "max_line_length": 80, "alphanum_fraction": 0.5493714853, "num_tokens": 4131, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6926419704455589, "lm_q2_score": 0.48438008427698437, "lm_q1q2_score": 0.3355019760181963}} {"text": "{-# LANGUAGE FlexibleContexts #-}\n{-# LANGUAGE TypeOperators #-}\nmodule FokkerPlanck.Pinwheel\n ( module Filter.Pinwheel\n , module FokkerPlanck.Pinwheel\n ) where\n\nimport Data.Array.Repa as R\nimport Data.Complex\nimport Data.List as L\nimport Data.Vector.Unboxed as VU\nimport Filter.Pinwheel\nimport FokkerPlanck.Interpolation\nimport Numeric.LinearAlgebra.Data as NL\nimport Numeric.LinearAlgebra.HMatrix\nimport Types\nimport Utils.Array\nimport Utils.Coordinates\nimport Utils.Parallel\n\n{-# INLINE computeR2Z1T0ArrayRadial #-}\ncomputeR2Z1T0ArrayRadial ::\n (R.Source r Double)\n => R.Array r DIM3 Double\n -> Int\n -> Int\n -> Double\n -> [Double]\n -> [Double]\n -> R.Array D DIM4 (Complex Double)\ncomputeR2Z1T0ArrayRadial radialArr xLen yLen scaleFactor thetaFreqs theta0Freqs =\n let pinwheelArr =\n traverse2\n (fromListUnboxed (Z :. L.length thetaFreqs) thetaFreqs)\n (fromListUnboxed (Z :. L.length theta0Freqs) theta0Freqs)\n (\\(Z :. numThetaFreq) (Z :. numTheta0Freq) ->\n (Z :. numThetaFreq :. numTheta0Freq :. xLen :. yLen)) $ \\f f0 (Z :. k :. l :. i :. j) ->\n pinwheel\n (f (Z :. k) - f0 (Z :. l))\n 0\n (exp 1)\n 0\n (i - center xLen)\n (j - center yLen)\n in radialCubicInterpolation radialArr scaleFactor pinwheelArr\n\n\n{-# INLINE computeR2Z2T0S0ArrayRadial #-}\ncomputeR2Z2T0S0ArrayRadial ::\n (R.Source r Double)\n => PinwheelType\n -> R.Array r DIM5 Double\n -> Int\n -> Int\n -> Double\n -> Double\n -> [Double]\n -> [Double]\n -> [Double]\n -> [Double]\n -> R.Array D DIM6 (Complex Double)\ncomputeR2Z2T0S0ArrayRadial pinwheelType radialArr xLen yLen scaleFactor rMax thetaFreqs scaleFreqs theta0Freqs scale0Freqs =\n let pinwheelArr =\n traverse4\n (fromListUnboxed (Z :. L.length thetaFreqs) thetaFreqs)\n (fromListUnboxed (Z :. L.length scaleFreqs) scaleFreqs)\n (fromListUnboxed (Z :. L.length theta0Freqs) theta0Freqs)\n (fromListUnboxed (Z :. L.length scale0Freqs) scale0Freqs)\n (\\(Z :. numThetaFreq) (Z :. numScaleFreq) (Z :. numTheta0Freq) (Z :. numScale0Freq) ->\n (Z :. numThetaFreq :. numScaleFreq :. numTheta0Freq :.\n numScale0Freq :.\n xLen :.\n yLen)) $ \\ft fs ft0 fs0 (Z :. t :. s :. t0 :. s0 :. i :. j) ->\n pinwheelFunc\n pinwheelType\n (ft (Z :. t) - ft0 (Z :. t0))\n (fs (Z :. s) - fs0 (Z :. s0))\n rMax\n 0\n (i - center xLen)\n (j - center yLen)\n in radialCubicInterpolation radialArr scaleFactor pinwheelArr\n\n{-# INLINE computeR2Z2T0S0ArrayRadial' #-}\ncomputeR2Z2T0S0ArrayRadial' ::\n Int\n -> Int\n -> Double\n -> Double\n -> [Double]\n -> [Double]\n -> [Double]\n -> [Double]\n -> R.Array D DIM6 (Complex Double)\ncomputeR2Z2T0S0ArrayRadial' xLen yLen scaleFactor rMax thetaFreqs scaleFreqs theta0Freqs scale0Freqs =\n let pinwheelArr =\n traverse4\n (fromListUnboxed (Z :. L.length thetaFreqs) thetaFreqs)\n (fromListUnboxed (Z :. L.length scaleFreqs) scaleFreqs)\n (fromListUnboxed (Z :. L.length theta0Freqs) theta0Freqs)\n (fromListUnboxed (Z :. L.length scale0Freqs) scale0Freqs)\n (\\(Z :. numThetaFreq) (Z :. numScaleFreq) (Z :. numTheta0Freq) (Z :. numScale0Freq) ->\n (Z :. numThetaFreq :. numScaleFreq :. numTheta0Freq :.\n numScale0Freq :.\n xLen :.\n yLen)) $ \\ft fs ft0 fs0 (Z :. t :. s :. t0 :. s0 :. i :. j) ->\n pinwheel\n (ft (Z :. t) - ft0 (Z :. t0))\n (fs (Z :. s) - fs0 (Z :. s0))\n rMax\n 0\n (i - center xLen)\n (j - center yLen)\n in pinwheelArr\n\n{-# INLINE cutoff #-}\ncutoff :: (R.Source r Double) => Int -> R.Array r DIM5 Double -> R.Array D DIM5 Double\ncutoff r arr =\n R.traverse arr id $ \\f idx@(Z :. _ :. _ :. _ :. _ :. e) ->\n if e > r \n then 0\n else f idx\n\n{-# INLINE computeLocalEigenVector #-}\ncomputeLocalEigenVector ::\n (R.Source r Double)\n => ParallelParams\n -> (Double -> Double -> Double -> Double -> Int -> Int -> Complex Double)\n -> R.Array r DIM5 Double\n -> Int\n -> Int\n -> Double\n -> [Double]\n -> [Double]\n -> R.Array U DIM4 (Complex Double)\ncomputeLocalEigenVector parallelParams pinwheelFunc radialArr xLen yLen rMax thetaFreqs scaleFreqs =\n let (Z :. numThetaFreq :. numScaleFreq :. _ :. _ :. _) = extent radialArr\n len = numThetaFreq * numScaleFreq\n in computeS .\n rotate4D .\n rotate4D .\n fromUnboxed (Z :. xLen :. yLen :. numThetaFreq :. numScaleFreq) .\n VU.concat .\n parMapChunk\n parallelParams\n rdeepseq\n (\\(x, y) ->\n let r =\n sqrt $\n (fromIntegral $ x - center xLen) ^ 2 +\n (fromIntegral $ y - center yLen) ^ 2\n interpolatedArray = cubicInterpolation radialArr r\n interpolatedPinwheel =\n R.traverse3\n interpolatedArray\n (fromListUnboxed (Z :. numThetaFreq) thetaFreqs)\n (fromListUnboxed (Z :. numScaleFreq) scaleFreqs)\n (\\sh _ _ -> sh) $ \\f ft fs idx@(Z :. t :. s :. t0 :. s0) ->\n (f idx :+ 0) *\n pinwheelFunc\n (ft (Z :. t) - ft (Z :. t0))\n (fs (Z :. s) + fs (Z :. s0))\n rMax\n 0\n (x - center xLen)\n (y - center yLen)\n (eigVal, eigVec) =\n eig . (len >< len) . R.toList $ interpolatedPinwheel\n (val, vec) =\n L.head . L.reverse . L.sortOn (magnitude . fst) $\n L.zip (NL.toList eigVal) (toColumns $ eigVec)\n dominantVec = VU.fromList . L.map (* val) . NL.toList $ vec\n in -- VU.zipWith\n -- (*)\n -- (VU.fromList\n -- [ exp\n -- (0 :+\n -- (tf) *\n -- (angleFunctionRad\n -- (fromIntegral $ x - center xLen)\n -- (fromIntegral $ y - center yLen)))\n -- | tf <- thetaFreqs\n -- , sf <- scaleFreqs\n -- ])\n -- dominantVec\n dominantVec\n ) $\n [(x, y) | x <- [0 .. xLen - 1], y <- [0 .. yLen - 1]]\n \n{-# INLINE computeLocalEigenVectorSink #-}\ncomputeLocalEigenVectorSink ::\n (R.Source r Double)\n => ParallelParams\n -> (Double -> Double -> Double -> Double -> Int -> Int -> Complex Double)\n -> R.Array r DIM5 Double\n -> Int\n -> Int\n -> Double\n -> [Double]\n -> [Double]\n -> R.Array U DIM4 (Complex Double)\ncomputeLocalEigenVectorSink parallelParams pinwheelFunc radialArr xLen yLen rMax thetaFreqs scaleFreqs =\n let (Z :. numThetaFreq :. numScaleFreq :. _ :. _ :. _) = extent radialArr\n len = numThetaFreq * numScaleFreq\n in computeS .\n rotate4D .\n rotate4D .\n fromUnboxed (Z :. xLen :. yLen :. numThetaFreq :. numScaleFreq) .\n VU.concat .\n parMapChunk\n parallelParams\n rdeepseq\n (\\(x, y) ->\n let r =\n sqrt $\n (fromIntegral $ x - center xLen) ^ 2 +\n (fromIntegral $ y - center yLen) ^ 2\n interpolatedArray = cubicInterpolation radialArr r\n interpolatedPinwheel =\n R.traverse3\n interpolatedArray\n (fromListUnboxed (Z :. numThetaFreq) thetaFreqs)\n (fromListUnboxed (Z :. numScaleFreq) scaleFreqs)\n (\\sh _ _ -> sh) $ \\f ft fs idx@(Z :. t :. s :. t0 :. s0) ->\n (f idx :+ 0) * (exp (0 :+ (ft (Z :. t) - ft (Z :. t0)) * pi)) *\n pinwheelFunc \n (ft (Z :. t) - ft (Z :. t0))\n (fs (Z :. s) + fs (Z :. s0))\n rMax\n 0\n (x - center xLen)\n (y - center yLen)\n (eigVal, eigVec) =\n eig . (len >< len) . R.toList $ interpolatedPinwheel\n (val, vec) =\n L.head . L.reverse . L.sortOn (realPart . fst) $\n L.zip (NL.toList eigVal) (toColumns $ eigVec)\n in VU.fromList . L.map (* val) . NL.toList $ vec) $\n [(x, y) | x <- [0 .. xLen - 1], y <- [0 .. yLen - 1]]\n", "meta": {"hexsha": "c07bc90066134812cd29ee829abf8e90d5710c74", "size": 8692, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/FokkerPlanck/Pinwheel.hs", "max_stars_repo_name": "XinhuaZhang/Stochastic-Completion-Field", "max_stars_repo_head_hexsha": "494a49356e17288ce09864c64ba09d11a3e9e0a8", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/FokkerPlanck/Pinwheel.hs", "max_issues_repo_name": "XinhuaZhang/Stochastic-Completion-Field", "max_issues_repo_head_hexsha": "494a49356e17288ce09864c64ba09d11a3e9e0a8", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 4, "max_issues_repo_issues_event_min_datetime": "2019-07-25T20:48:32.000Z", "max_issues_repo_issues_event_max_datetime": "2019-09-04T20:46:48.000Z", "max_forks_repo_path": "src/FokkerPlanck/Pinwheel.hs", "max_forks_repo_name": "XinhuaZhang/Stochastic-Completion-Field", "max_forks_repo_head_hexsha": "494a49356e17288ce09864c64ba09d11a3e9e0a8", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2019-07-29T15:55:46.000Z", "max_forks_repo_forks_event_max_datetime": "2019-07-29T15:55:46.000Z", "avg_line_length": 36.2166666667, "max_line_length": 124, "alphanum_fraction": 0.5051771744, "num_tokens": 2514, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.7154240079185319, "lm_q2_score": 0.4687906266262437, "lm_q1q2_score": 0.3353840689755873}} {"text": "{-# LANGUAGE CPP #-}\n{-# LANGUAGE DataKinds #-}\n{-# LANGUAGE FlexibleContexts #-}\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE KindSignatures #-}\n{-# LANGUAGE ScopedTypeVariables #-}\n{-# LANGUAGE TemplateHaskell #-}\n{-# LANGUAGE TypeOperators #-}\n{-# OPTIONS_GHC -fno-warn-missing-signatures #-}\nmodule Test.Grenade.Layers.FullyConnected where\n\nimport Data.Constraint (Dict (..))\nimport Data.Kind (Type)\nimport Data.Proxy\nimport Data.Singletons ()\nimport qualified Data.Vector.Storable as V\nimport GHC.TypeLits\nimport Hedgehog\nimport qualified Numeric.LinearAlgebra.Static as LA\nimport Test.Hedgehog.Compat\nimport Test.Hedgehog.Hmatrix\nimport Unsafe.Coerce (unsafeCoerce)\n\nimport Grenade.Core\nimport Grenade.Layers.FullyConnected\nimport Grenade.Layers.Internal.BLAS\nimport Grenade.Utils.ListStore\n\ndata OpaqueFullyConnected :: Type where\n OpaqueFullyConnected :: (KnownNat i, KnownNat o, KnownNat (i * o)) => FullyConnected i o -> OpaqueFullyConnected\n\ninstance Show OpaqueFullyConnected where\n show (OpaqueFullyConnected n) = show n\n\ngenOpaqueFullyConnected :: Gen OpaqueFullyConnected\ngenOpaqueFullyConnected = do\n input :: Integer <- choose 2 100\n output :: Integer <- choose 1 100\n variant <- choose 1 2\n let Just input' = someNatVal input\n let Just output' = someNatVal output\n case (input', output') of\n (SomeNat (Proxy :: Proxy i'), SomeNat (Proxy :: Proxy o')) ->\n case (unsafeCoerce (Dict :: Dict ()) :: Dict (KnownNat (i' * o'))) of\n Dict -> do\n wB <- randomVector\n bM <- randomVector\n wN <- uniformSample\n kM <- uniformSample\n let wInTmp = V.replicate (fromIntegral input) 0\n wBTmp = V.replicate (fromIntegral output) 0\n wNTmp = V.replicate (fromIntegral $ input * output) 0\n return . OpaqueFullyConnected $ case variant of\n 1 -> (FullyConnected (FullyConnectedHMatrix wB wN) (ListStore 0 [Just $ FullyConnectedHMatrix bM kM]) (TempVectors wInTmp wBTmp wNTmp) :: FullyConnected i' o')\n 2 ->\n let wB' = LA.extract wB\n bM' = LA.extract bM\n ext m = V.concat $ map LA.extract (LA.toRows m)\n wN' = ext wN\n kM' = ext kM\n in (FullyConnected (FullyConnectedBLAS wB' wN') (ListStore 0 [Just $ FullyConnectedBLAS bM' kM']) (TempVectors wInTmp wBTmp wNTmp) :: FullyConnected i' o')\n _ -> error \"unexpected variant in genOpaqueFullyConnected in Test/FullyConnected.hs\"\n\nprop_fully_connected_forwards :: Property\nprop_fully_connected_forwards = property $ do\n OpaqueFullyConnected (fclayer :: FullyConnected i o) <- blindForAll genOpaqueFullyConnected\n input :: S ('D1 i) <- blindForAll (S1D <$> randomVector)\n let (tape, output :: S ('D1 o)) = runForwards fclayer input\n backed :: (Gradient (FullyConnected i o), S ('D1 i))\n = runBackwards fclayer tape output\n backed `seq` success\n\ntests :: IO Bool\ntests = checkParallel $$(discover)\n", "meta": {"hexsha": "dfaaf70f34ef0fb6a084b79821d5d02ee5885cef", "size": 3276, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "test/Test/Grenade/Layers/FullyConnected.hs", "max_stars_repo_name": "schnecki/grenade", "max_stars_repo_head_hexsha": "027e9c16899e2ca3685e89338a047488ac834249", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-01-11T15:05:38.000Z", "max_stars_repo_stars_event_max_datetime": "2021-01-11T15:05:38.000Z", "max_issues_repo_path": "test/Test/Grenade/Layers/FullyConnected.hs", "max_issues_repo_name": "schnecki/grenade", "max_issues_repo_head_hexsha": "027e9c16899e2ca3685e89338a047488ac834249", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "test/Test/Grenade/Layers/FullyConnected.hs", "max_forks_repo_name": "schnecki/grenade", "max_forks_repo_head_hexsha": "027e9c16899e2ca3685e89338a047488ac834249", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2018-07-02T01:04:29.000Z", "max_forks_repo_forks_event_max_datetime": "2021-01-08T13:08:47.000Z", "avg_line_length": 43.68, "max_line_length": 171, "alphanum_fraction": 0.6156898657, "num_tokens": 807, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO\n\n", "lm_q1_score": 0.685949467848392, "lm_q2_score": 0.48828339529583464, "lm_q1q2_score": 0.3349377351623838}} {"text": "{-\n Copyright 2016, Dominic Orchard, Andrew Rice, Mistral Contrastin, Matthew Danish\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n-}\n\n{-\n Units of measure extension to Fortran: backend\n-}\n\n{-# LANGUAGE TupleSections #-}\n{-# LANGUAGE ScopedTypeVariables #-}\n{-# LANGUAGE ForeignFunctionInterface #-}\n\nmodule Camfort.Specification.Units.InferenceBackendFlint where\n\nimport Control.Monad\nimport Data.List (partition)\n-- import Debug.Trace (trace, traceM, traceShowM)\nimport Foreign\nimport Foreign.C.Types\nimport Numeric.LinearAlgebra (atIndex, rows, cols)\nimport qualified Numeric.LinearAlgebra as H\nimport System.IO.Unsafe (unsafePerformIO)\n\nforeign import ccall unsafe \"flint/fmpz_mat.h fmpz_mat_init\" fmpz_mat_init :: Ptr FMPZMat -> CLong -> CLong -> IO ()\nforeign import ccall unsafe \"flint/fmpz_mat.h fmpz_mat_set\" fmpz_mat_set :: Ptr FMPZMat -> Ptr FMPZMat -> IO ()\nforeign import ccall unsafe \"flint/fmpz_mat.h fmpz_mat_entry\" fmpz_mat_entry :: Ptr FMPZMat -> CLong -> CLong -> IO (Ptr CLong)\nforeign import ccall unsafe \"flint/fmpz.h fmpz_set_si\" fmpz_set_si :: Ptr CLong -> CLong -> IO ()\nforeign import ccall unsafe \"flint/fmpz.h fmpz_get_si\" fmpz_get_si :: Ptr CLong -> IO CLong\nforeign import ccall unsafe \"flint/fmpz_mat.h fmpz_mat_clear\" fmpz_mat_clear :: Ptr FMPZMat -> IO ()\nforeign import ccall unsafe \"flint/fmpz_mat.h fmpz_mat_print_pretty\" fmpz_mat_print_pretty :: Ptr FMPZMat -> IO ()\nforeign import ccall unsafe \"flint/fmpz_mat.h fmpz_mat_mul\" fmpz_mat_mul :: Ptr FMPZMat -> Ptr FMPZMat -> Ptr FMPZMat -> IO ()\n\n-- fmpz_mat_window_init(fmpz_mat_t window, const fmpz_mat_t mat, slong r1, slong c1, slong r2, slong c2)\n--\n-- Initializes the matrix window to be an r2 - r1 by c2 - c1 submatrix\n-- of mat whose (0,0) entry is the (r1, c1) entry of mat. The memory\n-- for the elements of window is shared with mat.\nforeign import ccall unsafe \"flint/fmpz_mat.h fmpz_mat_window_init\" fmpz_mat_window_init :: Ptr FMPZMat -> Ptr FMPZMat -> CLong -> CLong -> CLong -> CLong -> IO ()\n\n-- Frees the window (leaving underlying matrix alone).\nforeign import ccall unsafe \"flint/fmpz_mat.h fmpz_mat_window_clear\" fmpz_mat_window_clear :: Ptr FMPZMat -> IO ()\n\n-- r <- fmp_mat_rref B den A\n--\n-- Uses fraction-free Gauss-Jordan elimination to set (B, den) to the\n-- reduced row echelon form of A and returns the rank of A. Aliasing\n-- of A and B is allowed. r is rank of A.\nforeign import ccall unsafe \"flint/fmpz_mat.h fmpz_mat_rref\" fmpz_mat_rref :: Ptr FMPZMat -> Ptr CLong -> Ptr FMPZMat -> IO CLong\n\n-- r <- fmp_mat_inv B den A\n--\nforeign import ccall unsafe \"flint/fmpz_mat.h fmpz_mat_inv\" fmpz_mat_inv :: Ptr FMPZMat -> Ptr CLong -> Ptr FMPZMat -> IO CLong\n\n-- fmpz_mat_hnf H A\n--\n-- H is the Hermite Normal Form of A.\nforeign import ccall unsafe \"flint/fmpz_mat.h fmpz_mat_hnf\" fmpz_mat_hnf :: Ptr FMPZMat -> Ptr FMPZMat -> IO ()\n\nforeign import ccall unsafe \"flint/fmpz_mat.h fmpz_mat_rank\" fmpz_mat_rank :: Ptr FMPZMat -> IO CLong\n\ndata FMPZMat\n\ninstance Storable FMPZMat where\n sizeOf _ = 4 * sizeOf (undefined :: CLong)\n alignment _ = alignment (undefined :: CLong)\n peek _ = undefined\n poke _ = undefined\n\n-- testFlint :: IO ()\n-- testFlint = do\n-- traceM \"***********************8 testFlint 8***********************\"\n-- alloca $ \\ a -> do\n-- alloca $ \\ b -> do\n-- alloca $ \\ den -> do\n-- let n = 10\n-- fmpz_mat_init a n n\n-- fmpz_mat_init b n n\n-- forM_ [0..n-1] $ \\ i -> do\n-- forM_ [0..n-1] $ \\ j -> do\n-- e <- fmpz_mat_entry a i j\n-- fmpz_set_si e (2 * i + j)\n\n-- -- fmpz_mat_mul b a a\n-- r <- fmpz_mat_rref b den a\n-- fmpz_mat_print_pretty a\n-- fmpz_mat_print_pretty b\n-- d <- peek den\n-- traceM $ \"r = \" ++ show r ++ \" den = \" ++ show d\n-- fmpz_mat_hnf b a\n-- fmpz_mat_print_pretty b\n-- fmpz_mat_clear a\n-- fmpz_mat_clear b\n\nrref :: H.Matrix Double -> (H.Matrix Double, Int, Int)\nrref m = unsafePerformIO $ do\n alloca $ \\ outputM -> do\n alloca $ \\ inputM -> do\n alloca $ \\ den -> do\n let numRows = fromIntegral $ rows m\n let numCols = fromIntegral $ cols m\n fmpz_mat_init outputM numRows numCols\n fmpz_mat_init inputM numRows numCols\n forM_ [0..numRows-1] $ \\ i -> do\n forM_ [0..numCols-1] $ \\ j -> do\n e <- fmpz_mat_entry inputM i j\n fmpz_set_si e (floor (m `atIndex` (fromIntegral i, fromIntegral j)))\n r <- fmpz_mat_rref outputM den inputM\n d <- peek den\n\n -- DEBUG:\n -- fmpz_mat_print_pretty outputM\n -- traceM $ \"r = \" ++ show r ++ \" den = \" ++ show d\n --\n\n lists <- forM [0..numRows-1] $ \\ i -> do\n forM [0..numCols-1] $ \\ j -> do\n e <- fmpz_mat_entry outputM i j\n fromIntegral `fmap` fmpz_get_si e\n let m' = H.fromLists lists\n fmpz_mat_clear inputM\n fmpz_mat_clear outputM\n return (m', fromIntegral d, fromIntegral r)\n\nhnf :: H.Matrix Double -> H.Matrix Double\nhnf m = unsafePerformIO $ do\n alloca $ \\ outputM -> do\n alloca $ \\ inputM -> do\n let numRows = fromIntegral $ rows m\n let numCols = fromIntegral $ cols m\n fmpz_mat_init outputM numRows numCols\n fmpz_mat_init inputM numRows numCols\n forM_ [0..numRows-1] $ \\ i -> do\n forM_ [0..numCols-1] $ \\ j -> do\n e <- fmpz_mat_entry inputM i j\n fmpz_set_si e (floor (m `atIndex` (fromIntegral i, fromIntegral j)))\n fmpz_mat_hnf outputM inputM\n r <- fmpz_mat_rank outputM\n\n -- DEBUG:\n -- fmpz_mat_print_pretty outputM\n -- traceM $ \"rank = \" ++ show r\n --\n\n lists <- forM [0..fromIntegral r-1] $ \\ i -> do\n forM [0..numCols-1] $ \\ j -> do\n e <- fmpz_mat_entry outputM i j\n fromIntegral `fmap` fmpz_get_si e\n let m' = H.fromLists lists\n fmpz_mat_clear inputM\n fmpz_mat_clear outputM\n return m'\n\ninv :: H.Matrix Double -> Maybe (H.Matrix Double, Int)\ninv m = unsafePerformIO $ do\n alloca $ \\ outputM -> do\n alloca $ \\ inputM -> do\n alloca $ \\ den -> do\n let numRows = fromIntegral $ rows m\n let numCols = fromIntegral $ cols m\n fmpz_mat_init outputM numRows numCols\n fmpz_mat_init inputM numRows numCols\n forM_ [0..numRows-1] $ \\ i -> do\n forM_ [0..numCols-1] $ \\ j -> do\n e <- fmpz_mat_entry inputM i j\n fmpz_set_si e (floor (m `atIndex` (fromIntegral i, fromIntegral j)))\n r <- fmpz_mat_inv outputM den inputM\n d <- peek den\n\n -- DEBUG:\n fmpz_mat_print_pretty outputM\n -- traceM $ \"r = \" ++ show r ++ \" den = \" ++ show d\n --\n\n lists <- forM [0..numRows-1] $ \\ i -> do\n forM [0..numCols-1] $ \\ j -> do\n e <- fmpz_mat_entry outputM i j\n fromIntegral `fmap` fmpz_get_si e\n let m' = H.fromLists lists\n fmpz_mat_clear inputM\n fmpz_mat_clear outputM\n if r == 1 then\n return $ Just (m', fromIntegral d)\n else\n return Nothing\n\nwithMatrix :: H.Matrix Double -> ((CLong, CLong, Ptr FMPZMat) -> IO b) -> IO b\nwithMatrix m f = do\n alloca $ \\ outputM -> do\n let numRows = fromIntegral $ rows m\n let numCols = fromIntegral $ cols m\n fmpz_mat_init outputM numRows numCols\n forM_ [0 .. numRows - 1] $ \\ i ->\n forM_ [0 .. numCols - 1] $ \\ j -> do\n e <- fmpz_mat_entry outputM i j\n fmpz_set_si e (floor (m `atIndex` (fromIntegral i, fromIntegral j)) :: CLong)\n x <- f (numRows, numCols, outputM)\n fmpz_mat_clear outputM\n return x\n\nwithBlankMatrix :: CLong -> CLong -> (Ptr FMPZMat -> IO b) -> IO b\nwithBlankMatrix numRows numCols f = do\n alloca $ \\ outputM -> do\n fmpz_mat_init outputM (fromIntegral numRows) (fromIntegral numCols)\n x <- f outputM\n fmpz_mat_clear outputM\n return x\n\nwithWindow :: Ptr FMPZMat -> CLong -> CLong -> CLong -> CLong -> (Ptr FMPZMat -> IO b) -> IO b\nwithWindow underM r1 c1 r2 c2 f = do\n alloca $ \\ window -> do\n fmpz_mat_window_init window underM r1 c1 r2 c2\n x <- f window\n fmpz_mat_window_clear window\n return x\n\nflintToHMatrix :: CLong -> CLong -> Ptr FMPZMat -> IO (H.Matrix Double)\nflintToHMatrix numRows numCols flintM = do\n lists <- forM [0..numRows-1] $ \\ i -> do\n forM [0..numCols-1] $ \\ j -> do\n e <- fmpz_mat_entry flintM i j\n fromIntegral `fmap` fmpz_get_si e\n return $ H.fromLists lists\n\npokeM :: Ptr FMPZMat -> CLong -> CLong -> CLong -> IO ()\npokeM flintM i j v = do\n e <- fmpz_mat_entry flintM i j\n fmpz_set_si e v\n\npeekM :: Ptr FMPZMat -> CLong -> CLong -> IO CLong\npeekM flintM i j = do\n e <- fmpz_mat_entry flintM i j\n fmpz_get_si e\n\ncopyMatrix :: Ptr FMPZMat -> Ptr FMPZMat -> CLong -> CLong -> CLong -> CLong -> IO ()\ncopyMatrix m1 m2 r1 c1 r2 c2 =\n forM_ [r1 .. r2-1] $ \\ i ->\n forM_ [c1 .. c2-1] $ \\ j ->\n peekM m2 i j >>= pokeM m1 i j\n\n\n-- copyMatrix' m1 m2 r1 c1 r2 c2 =\n-- withWindow m2 r1 c1 r2 c2 $ \\ w2 ->\n-- withWindow m1 r1 c1 r2 c2 $ \\ w1 -> do\n-- fmpz_mat_set w1 w2\n\n--------------------------------------------------\n-- 'normalising' Hermite Normal Form, for lack of a better name\n--\n-- The problem with HNF is that it will happily return a matrix where\n-- the leading-coefficient diagonal contains integers > 1.\n--\n-- In some cases the leading-coefficient does not divide some of the\n-- remaining numbers in the row.\n--\n-- This corresponds to the case where one of the solutions would be\n-- fractional if we were dealing with rational matrices.\n--\n-- But we don't want fractional solutions. We need to bump the matrix\n-- so that this situation does not arise.\n--\n-- This tends to happen due to implicit polymorphism.\n--\n-- We do this by adding another column that copies the column with the\n-- problematic leading-coefficient.\n--\n-- We then set up a new row expressing the constraint that the old\n-- column is equal to the new column, 1:1.\n--\n-- This prevents a 'fractional' solution.\n--\n-- Along the way we look for leading-coefficients > 1 that do divide\n-- their entire row. Then we simply apply elementary row scaling to\n-- the row so that the leading-coefficients is 1.\n--\n-- The result is a matrix where the leading-coefficients of all the\n-- rows that matter are 1. It's not quite a 'reduced' form though\n-- because it can be bigger than the original matrix.\n--\n-- As a result we also return a list of columns that were cloned this\n-- way.\n--\n-- The resulting matrix can have non-zeroes above the\n-- leading-coefficients in the same column, so I apply some elementary\n-- row operations to fix that and bring things into RREF.\n--\n-- Running time is computation of Hermite Normal Form twice, plus\n-- construction of a slightly larger matrix (possibly), plus scanning\n-- through the matrix for leading-coefficients, and then again to\n-- divide them out sometimes.\n\nnormHNF :: H.Matrix Double -> (H.Matrix Double, [Int])\nnormHNF m\n | (rows m, cols m) == (1, 1) = (H.ident (if H.atIndex m (0, 0) /= 0 then 1 else 0), [])\n | otherwise = (m', indices)\n where\n numCols = cols m\n indexLookup j | j < numCols = j\n | otherwise = indices !! (j `mod` numCols)\n indices = map indexLookup $ concatMap snd rs1\n (rs1, (m',[]):_) = break (null . snd) results\n results = tail $ iterate (normHNF' . fst) (m, [])\n\nnormHNF' :: H.Matrix Double -> (H.Matrix Double, [Int])\nnormHNF' m = fmap (map fromIntegral) . unsafePerformIO $ withMatrix m normhnf\n\nnormhnf :: (CLong, CLong, Ptr FMPZMat) -> IO (H.Matrix Double, [CLong])\nnormhnf (numRows, numCols, inputM) = do\n withBlankMatrix numRows numCols $ \\ outputM -> do\n fmpz_mat_hnf outputM inputM\n rank <- fmpz_mat_rank outputM\n -- scale the rows so that it is a RREF, returning the indices\n -- where leading-coefficients had to be scaled to 1.\n indices <- elemrowscale outputM rank numCols\n -- HNF allows non-zeroes above the leading-coefficients that\n -- were greater than 1, so also fix that to bring into RREF.\n elemrowadds outputM rank numCols indices\n\n -- column indices of leading co-efficients > 1\n lcoefs <- filter ((> 1) . head . snd) <$> forM [0 .. rank-1] (\\ i -> do\n cs <- zip [0..] `fmap` sequence [ peekM outputM i j | j <- [0 .. numCols-1] ]\n let (_, (j, lcoef):rest) = span ((== 0) . snd) cs\n return ((i, j), lcoef:map snd rest))\n\n -- split the identified rows into two categories: those that can\n -- be divided out by the leading co-efficient, and those that\n -- cannot.\n let (multCands, consCands) = partition (\\ (_, lcoef:rest) -> all ((== 0) . (`rem` lcoef)) rest) lcoefs\n\n -- apply elementary row scaling\n forM_ multCands $ \\ ((i, j), lcoef:_) ->\n forM_ [j..numCols - 1] $ \\ j' -> do\n x <- peekM outputM i j'\n pokeM outputM i j' $ x `div` lcoef\n\n -- identify columns that need additional constraints generated and\n -- their associated value d, which is the value of the non-leading\n -- co-efficient divided by the GCD of the row.\n let genColCons ((_, j), lcoef:rest) = (j, minNLcoef `div` gcd lcoef minNLcoef)\n where\n restABS = map abs rest\n minNLcoef = minimum (filter (/= 0) restABS)\n genColCons _ = error \"normhnf: genColCons: impossible: missing leading co-efficient\"\n\n let consCols = map genColCons consCands\n\n -- generate operations that poke 1.0 and -d into columns of the\n -- given row (matrix parameter supplied later); d is the value of\n -- the non-leading co-efficient that isn't divisible by the\n -- leading-coefficient, divided by the GCD of the row.\n let ops = [ \\ flintM i -> do pokeM flintM i j 1\n pokeM flintM i (numCols + k) (-d)\n | ((j, d), k) <- zip consCols [0..] ]\n let numOps = fromIntegral (length ops)\n let numRows' = numOps + rank\n let numCols' = numOps + numCols\n\n withBlankMatrix numRows' numCols' $ \\ outputM' -> do\n -- create larger matrix containing outputM as submatrix\n copyMatrix outputM' outputM 0 0 rank numCols\n\n -- apply the operations on the extra space to write the\n -- additional rows and columns providing the additional\n -- constraints\n forM_ (zip [rank..] ops) $ \\ (i, op) -> op outputM' i\n\n -- re-run HNF\n withBlankMatrix numRows' numCols' $ \\ outputM'' -> do\n fmpz_mat_hnf outputM'' outputM'\n rank' <- fmpz_mat_rank outputM''\n -- scale the rows so that it is a RREF, returning the indices\n -- where leading-coefficients had to be scaled to 1.\n indices' <- elemrowscale outputM'' rank' numCols'\n -- HNF allows non-zeroes above the leading-coefficients that\n -- were greater than 1, so also fix that to bring into RREF.\n elemrowadds outputM'' rank' numCols' indices'\n -- convert back to HMatrix form\n h <- flintToHMatrix rank' numCols' outputM''\n return (h, map fst consCols)\n\n-- find leading-coefficients that are greater than 1 and scale those\n-- rows accordingly to reach RREF\n--\n-- precondition: matrix outputM is in HNF\nelemrowscale :: Ptr FMPZMat -> CLong -> CLong -> IO [(CLong, CLong)]\nelemrowscale outputM rank numCols = do\n -- column indices of leading co-efficients > 1\n lcoefs <- filter ((> 1) . head . snd) <$> forM [0 .. rank-1] (\\ i -> do\n cs <- zip [0..] `fmap` sequence [ peekM outputM i j | j <- [0 .. numCols-1] ]\n let (_, (j, lcoef):rest) = span ((== 0) . snd) cs\n return ((i, j), lcoef:map snd rest))\n\n let multCands = filter (\\ (_, lcoef:rest) -> all ((== 0) . (`rem` lcoef)) rest) lcoefs\n\n -- apply elementary row scaling\n forM multCands $ \\ ((i, j), lcoef:_) -> do\n forM_ [j..numCols - 1] $ \\ j' -> do\n x <- peekM outputM i j'\n pokeM outputM i j' $ x `div` lcoef\n return (i, j)\n\n-- use indices to guide elementary row additions to reach RREF\n--\n-- precondition: matrix outputM is in HNF save for work done by\n-- elemrowscale, and indices is a list of coordinates where we have\n-- just scaled the leading-coefficient to 1 and now we must look to\n-- see if there are any non-zeroes in the column above the\n-- leading-coefficient, because that is allowed by HNF.\nelemrowadds :: Ptr FMPZMat -> CLong -> CLong -> [(CLong, CLong)] -> IO ()\nelemrowadds outputM _ numCols indices = do\n -- look for non-zero members of the columns above the\n -- leading-coefficient and wipe them out.\n forM_ indices $ \\ (lcI, lcJ) -> do\n let j = lcJ\n forM_ [0..lcI-1] $ \\ i -> do\n -- (i, j) ranges over the elements of the column above leading\n -- co-efficient (lcI, lcJ).\n x <- peekM outputM i j\n if x == 0 then\n pure () -- nothing to do at row i\n else do\n -- (i, j) is non-zero and row i must be cancelled x times\n let sf = x -- scaling factor = non-zero magnitude\n forM_ [lcJ..numCols-1] $ \\ j' -> do\n -- (i, j') ranges over the row where we discovered a non-zero\n -- (lcI, j') ranges over the row with the leading co-efficient\n x1 <- peekM outputM i j'\n x2 <- peekM outputM lcI j'\n -- add lower row scaled by sf to upper row\n pokeM outputM i j' (x1 - x2 * sf)\n\n--------------------------------------------------\n\n-- m1 :: H.Matrix Double\n-- m1 = (8><6)\n-- [ 1.0, 0.0, 0.0, -1.0, 0.0, 0.0\n-- , 0.0, 1.0, 0.0, 0.0, -1.0, 0.0\n-- , 0.0, 0.0, 1.0, 0.0, 0.0, -1.0\n-- , 1.0, 0.0, 0.0, -1.0, 0.0, 0.0\n-- , 0.0, 1.0, 0.0, 0.0, -1.0, 0.0\n-- , 0.0, 0.0, 1.0, 0.0, 0.0, -1.0\n-- , 0.0, 0.0, 0.0, 1.0, -4.0, 0.0\n-- , 0.0, 0.0, 0.0, 0.0, 4.0, -3.0 ]\n\n-- m2 :: H.Matrix Double\n-- m2 = (8><6)\n-- [ 1.0, 0.0, 0.0, -1.0, 0.0, 0.0\n-- , 0.0, 1.0, 0.0, 0.0, -1.0, 0.0\n-- , 0.0, 0.0, 1.0, 0.0, 0.0, -1.0\n-- , 1.0, 0.0, 0.0, -1.0, 0.0, 0.0\n-- , 0.0, 1.0, 0.0, 0.0, -1.0, 0.0\n-- , 0.0, 0.0, 1.0, 0.0, 0.0, -1.0\n-- , 0.0, 0.0, 0.0, 1.0, -6.0, 0.0\n-- , 0.0, 0.0, 0.0, 0.0, 6.0, -4.0 ]\n", "meta": {"hexsha": "cc43780bbd8132043773cb64b7c0037f96286e0a", "size": 18512, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/Camfort/Specification/Units/InferenceBackendFlint.hs", "max_stars_repo_name": "apthorpe/camfort", "max_stars_repo_head_hexsha": "1e307ae972b2fe6f63af6d3b0a3d106eec77e8a8", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-11-23T16:40:43.000Z", "max_stars_repo_stars_event_max_datetime": "2020-11-23T16:40:43.000Z", "max_issues_repo_path": "src/Camfort/Specification/Units/InferenceBackendFlint.hs", "max_issues_repo_name": "apthorpe/camfort", "max_issues_repo_head_hexsha": "1e307ae972b2fe6f63af6d3b0a3d106eec77e8a8", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/Camfort/Specification/Units/InferenceBackendFlint.hs", "max_forks_repo_name": "apthorpe/camfort", "max_forks_repo_head_hexsha": "1e307ae972b2fe6f63af6d3b0a3d106eec77e8a8", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 39.7253218884, "max_line_length": 163, "alphanum_fraction": 0.6224070873, "num_tokens": 5856, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.6039318337259583, "lm_q2_score": 0.5544704649604273, "lm_q1q2_score": 0.33486236465043556}} {"text": "{-# LANGUAGE FlexibleContexts #-}\n{-# LANGUAGE FlexibleInstances #-}\n{-# LANGUAGE MultiParamTypeClasses #-}\n{-# LANGUAGE OverloadedStrings #-}\n{-# LANGUAGE RecordWildCards #-}\n{-# LANGUAGE ScopedTypeVariables #-}\n{-# LANGUAGE TypeOperators #-}\n{-# LANGUAGE UndecidableInstances #-}\n{-# OPTIONS_GHC -Wno-orphans #-}\n{- Module : Text.Loquate.Instances\n Description : Default Loquate Instances\n-}\nmodule Text.Loquate.Instances\n (\n ) where\n\n--import qualified Data.ByteString as BS\n--import qualified Data.ByteString.Lazy as LBS\nimport qualified Control.Exception.Base as E\nimport Data.Array.Unboxed (Array, IArray, Ix, UArray, elems)\nimport Data.Complex (Complex(..))\nimport Data.Fixed\nimport Data.Foldable\nimport Data.Int (Int16, Int32, Int64, Int8)\nimport Data.List.NonEmpty (NonEmpty)\nimport Data.Ratio (Ratio, denominator, numerator)\nimport qualified Data.Text as T\nimport qualified Data.Text.Lazy as LT\nimport Data.Text.Prettyprint.Doc (Pretty(..))\nimport Data.Typeable\nimport Data.Version (Version, showVersion)\nimport Data.Void (Void)\nimport Data.Word (Word16, Word32, Word64, Word8)\nimport GHC.Stack\nimport Numeric.Natural\nimport Text.Loquate.Class\nimport Text.Loquate.Doc\n\n-- misc types\n\ninstance Lang l => Loquate l () where loq _ = pretty\ninstance Lang l => Loquate l Bool where loq _ = pretty\ninstance Lang l => Loquate l Version where loq _ = pretty . showVersion\ninstance Lang l => Loquate l Void where loq _ = pretty\n\n-- textual types\n\ninstance Lang l => Loquate l Char where loq _ = pretty\ninstance {-# OVERLAPS #-} Lang l => Loquate l String where loq _ = pretty\n-- instance Loquate l BS.ByteString where loq _ = pretty\n-- instance Loquate l LBS.ByteString where loq _ = pretty\ninstance Lang l => Loquate l T.Text where loq _ = pretty\ninstance Lang l => Loquate l LT.Text where loq _ = pretty\n\n-- numeric types\n\ninstance Lang l => Loquate l Double where loq _ = pretty\ninstance Lang l => Loquate l Float where loq _ = pretty\ninstance (Lang l, Typeable t, HasResolution t) => Loquate l (Fixed t) where loq _ = viaShow\n-- | Integral types should loquate via Integer\ninstance Lang l => Loquate l Integer where loq _ = pretty\ninstance (Lang l, Loquate l Integer) => Loquate l Natural where loq l = loq l . toInteger\n\ninstance (Lang l, Loquate l Integer) => Loquate l Int where loq l = loq l . toInteger\ninstance (Lang l, Loquate l Integer) => Loquate l Int8 where loq l = loq l . toInteger\ninstance (Lang l, Loquate l Integer) => Loquate l Int16 where loq l = loq l . toInteger\ninstance (Lang l, Loquate l Integer) => Loquate l Int32 where loq l = loq l . toInteger\ninstance (Lang l, Loquate l Integer) => Loquate l Int64 where loq l = loq l . toInteger\n\ninstance (Lang l, Loquate l Integer) => Loquate l Word where loq l = loq l . toInteger\ninstance (Lang l, Loquate l Integer) => Loquate l Word8 where loq l = loq l . toInteger\ninstance (Lang l, Loquate l Integer) => Loquate l Word16 where loq l = loq l . toInteger\ninstance (Lang l, Loquate l Integer) => Loquate l Word32 where loq l = loq l . toInteger\ninstance (Lang l, Loquate l Integer) => Loquate l Word64 where loq l = loq l . toInteger\n\n-- polymorphic numeric types\n\ninstance Loquate l t => Loquate l (Complex t) where\n loq l (a :+ b) = loq l a <+> \"+\" <+> loq l b <> \"i\"\n\ninstance Loquate l t => Loquate l (Ratio t) where\n loq l x = loq l (numerator x) <> \"/\" <> loq l (denominator x)\n\n-- polymorphic containers in dependencies of loquacious\n\ninstance Loquate l t => Loquate l (Maybe t) where\n loq _ Nothing = mempty\n loq l (Just x) = loq l x\n\ninstance (Loquate l t, Loquate l s) => Loquate l (t, s) where\n loq l (a, b) = align $ tupled [loq l a, loq l b]\n\ninstance (Loquate l t, Loquate l s, Loquate l r) => Loquate l (t, s, r) where\n loq l (a, b, c) = align $ tupled [loq l a, loq l b, loq l c]\n\ninstance (Loquate l t) => Loquate l [t] where\n loq l xs = align . list $ loq l <$> xs\n\ninstance (Loquate l t) => Loquate l (NonEmpty t) where\n loq l xs = align . list $ loq l <$> toList xs\n\ninstance (Typeable i, Loquate l t) => Loquate l (Array i t) where\n loq l xs = align . list $ loq l <$> toList xs\n\ninstance (Loquate l t, IArray UArray t, Ix i, Typeable i) => Loquate l (UArray i t) where\n loq l xs = align . list $ loq l <$> elems xs\n\ninstance (Loquate l t, Loquate l s) => Loquate l (Either t s) where\n loq l (Left x) = loq l x\n loq l (Right x) = loq l x\n\n-- showing types rather than values\n\ninstance Lang l => Loquate l TypeRep where loq _ = viaShow\n\ninstance (Lang l, Typeable a) => Loquate l (Proxy a) where\n loq l _ = loq l $ typeRep (Proxy :: Proxy (Proxy a))\n\ninstance (Lang l, Typeable a, Typeable b) => Loquate l (a -> b) where\n loq l f = loq l $ typeOf f\n\ninstance (Lang l, Typeable a, Typeable b) => Loquate l (a :~: b) where\n loq l _ = loq l (typeRep (Proxy :: Proxy a)) <+> \":~:\" <+> loq l (typeRep (Proxy :: Proxy b))\n\ninstance (Lang l, Typeable a, Typeable b) => Loquate l (a :~~: b) where\n loq l _ = loq l (typeRep (Proxy :: Proxy a)) <+> \":~~:\" <+> loq l (typeRep (Proxy :: Proxy b))\n\n-- call stacks!\n\ninstance Lang l => Loquate l CallStack where\n loq l = withFrozenCallStack ( align . vsep . fmap loqStack . getCallStack )\n where loqStack (func, srcLoc) = fromString func <+> \"\u2190\" <+> loq l srcLoc\n\ninstance Lang l => Loquate l SrcLoc where\n loq l SrcLoc{..} = locFile <+> parens locPackage\n where\n locFile = fromString srcLocFile <> colon <> loq l srcLocStartLine <> colon <> loq l srcLocStartCol\n locPackage = fromString srcLocPackage <> colon <> fromString srcLocModule\n\n-- Exception types\n\ninstance Lang l => Loquate l E.AllocationLimitExceeded where loq _ e = viaShow e\ninstance Lang l => Loquate l E.ArithException where loq _ e = viaShow e\ninstance Lang l => Loquate l E.ArrayException where loq _ e = viaShow e\ninstance Lang l => Loquate l E.AssertionFailed where loq _ e = viaShow e\ninstance Lang l => Loquate l E.AsyncException where loq _ e = viaShow e\ninstance Lang l => Loquate l E.BlockedIndefinitelyOnMVar where loq _ e = viaShow e\ninstance Lang l => Loquate l E.BlockedIndefinitelyOnSTM where loq _ e = viaShow e\ninstance Lang l => Loquate l E.CompactionFailed where loq _ e = viaShow e\ninstance Lang l => Loquate l E.Deadlock where loq _ e = viaShow e\ninstance Lang l => Loquate l E.FixIOException where loq _ e = viaShow e\ninstance Lang l => Loquate l E.IOException where loq _ e = viaShow e\ninstance Lang l => Loquate l E.NestedAtomically where loq _ e = viaShow e\ninstance Lang l => Loquate l E.NoMethodError where loq _ e = viaShow e\ninstance Lang l => Loquate l E.NonTermination where loq _ e = viaShow e\ninstance Lang l => Loquate l E.PatternMatchFail where loq _ e = viaShow e\ninstance Lang l => Loquate l E.RecConError where loq _ e = viaShow e\ninstance Lang l => Loquate l E.RecSelError where loq _ e = viaShow e\ninstance Lang l => Loquate l E.RecUpdError where loq _ e = viaShow e\ninstance Lang l => Loquate l E.SomeAsyncException where loq _ e = viaShow e\ninstance Lang l => Loquate l E.SomeException where loq _ e = viaShow e\ninstance Lang l => Loquate l E.TypeError where loq _ e = viaShow e\n", "meta": {"hexsha": "37f9fb6a6272d08df8c1ce44e53f796d29d3ad31", "size": 7221, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/Text/Loquate/Instances.hs", "max_stars_repo_name": "imuli/loquate", "max_stars_repo_head_hexsha": "b9fd96c2b462004a5bbd433ea48935d50640d9f7", "max_stars_repo_licenses": ["Unlicense"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/Text/Loquate/Instances.hs", "max_issues_repo_name": "imuli/loquate", "max_issues_repo_head_hexsha": "b9fd96c2b462004a5bbd433ea48935d50640d9f7", "max_issues_repo_licenses": ["Unlicense"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/Text/Loquate/Instances.hs", "max_forks_repo_name": "imuli/loquate", "max_forks_repo_head_hexsha": "b9fd96c2b462004a5bbd433ea48935d50640d9f7", "max_forks_repo_licenses": ["Unlicense"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 44.3006134969, "max_line_length": 104, "alphanum_fraction": 0.6885472926, "num_tokens": 2140, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.6442251201477016, "lm_q2_score": 0.519521321952093, "lm_q1q2_score": 0.33468868605387986}} {"text": "-- |\n-- Module : BattleHack.Types\n-- Description :\n-- Copyright : (c) Jonatan H Sundqvist, 2015\n-- License : MIT\n-- Maintainer : Jonatan H Sundqvist\n-- Stability : experimental\n-- Portability : POSIX\n\n-- Created September 12 2015\n\n-- TODO | -\n-- -\n\n-- SPEC | -\n-- -\n\n\n\n--------------------------------------------------------------------------------------------------------------------------------------------\n-- GHC pragmas\n--------------------------------------------------------------------------------------------------------------------------------------------\n\n\n\n--------------------------------------------------------------------------------------------------------------------------------------------\n-- API\n--------------------------------------------------------------------------------------------------------------------------------------------\nmodule BattleHack.Types where\n\n\n\n--------------------------------------------------------------------------------------------------------------------------------------------\n-- We'll need these\n--------------------------------------------------------------------------------------------------------------------------------------------\nimport Data.Complex\nimport qualified Data.Set as S\nimport qualified Data.Map as M\nimport Sound.OpenAL\n\n\n\n--------------------------------------------------------------------------------------------------------------------------------------------\n-- Types\n--------------------------------------------------------------------------------------------------------------------------------------------\n-- |\ntype Number = Double\ntype Vector = Complex Number\ntype Sample = Double\n\n\n-- |\ntype Command = IO ()\ntype KeyMap = M.Map String Command\n\n\n-- |\ndata KeyLayout = KeyLeft | KeyRight | KeyBoth | KeyAccidental deriving (Show)\n\n\n-- |\ntype Claviature = [(Source, Buffer)]\n\n\n-- |\n-- data Note = C Pitch | D Pitch | E Pitch | F Pitch | G Pitch | A Pitch | B Pitch deriving (Show)\n-- data Pitch = Sharp | Flat | Natural deriving (Show)\n\n\n-- |\n-- frame number, fps, etc.\ndata AnimationData = AnimationData { _frame :: Int,\n _fps :: Int }\n\n\n-- |\n-- TODO: Slightly less confusing names (piano vs claviature)\ndata AppState = AppState { _piano :: PianoSettings,\n -- _claviature :: Claviature,\n -- _source :: Source,\n _animation :: AnimationData,\n _bindings :: KeyMap,\n _inputstate :: InputState } -- deriving (Show)\n\n\n-- |\n-- TODO: Use custom key type or text (?)\ndata InputState = InputState { _mouse :: Vector,\n _keyboard :: S.Set String }\n\n\n-- |\ndata PianoSettings = PianoSettings { _origin :: Vector,\n _keysize :: Vector,\n _indent :: Number,\n _mid :: Number,\n _active :: Maybe Int,\n _keys :: [Bool] } deriving (Show)\n", "meta": {"hexsha": "8663e6e28f6f7e65c648ecac67e23df199dc5936", "size": 3176, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/BattleHack/Types.hs", "max_stars_repo_name": "SwiftsNamesake/BattleHack-2015", "max_stars_repo_head_hexsha": "14b47f3482dc80ee1469161a0cebb5a0e1b16a05", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/BattleHack/Types.hs", "max_issues_repo_name": "SwiftsNamesake/BattleHack-2015", "max_issues_repo_head_hexsha": "14b47f3482dc80ee1469161a0cebb5a0e1b16a05", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/BattleHack/Types.hs", "max_forks_repo_name": "SwiftsNamesake/BattleHack-2015", "max_forks_repo_head_hexsha": "14b47f3482dc80ee1469161a0cebb5a0e1b16a05", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 32.0808080808, "max_line_length": 140, "alphanum_fraction": 0.3271410579, "num_tokens": 472, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.6442251064863695, "lm_q2_score": 0.519521321952093, "lm_q1q2_score": 0.3346886789565266}} {"text": "{-# Language DeriveGeneric #-}\n{-# Language OverloadedStrings #-}\n{-# Language DeriveFunctor #-}\n{-# Language DeriveFoldable #-}\n{-# Language RecordWildCards #-}\n\nmodule Lib where\n\nimport Control.Arrow ( (&&&) )\nimport Data.Csv\nimport qualified Data.ByteString.Lazy as BL\nimport qualified Data.Vector as V\nimport Data.Either ( fromRight )\nimport GHC.Generics\nimport Statistics.Sample\nimport System.IO.Unsafe\nimport Data.Foldable ( toList\n , foldl'\n )\nimport Data.List ( transpose )\n\n-- The definition of a spambase entry.\n-- It is SpamEntry a as that allows me to be able to map over the data easily.\ntype SpamEntry = SpamE Double -- Alias for nicer type signatures\ndata SpamE a =\n S {\n _make :: !a\n , _address :: !a\n , _all :: !a\n , _3d :: !a\n , _our :: !a\n , _over :: !a\n , _remove :: !a\n , _internet :: !a\n , _order :: !a\n , _mail :: !a\n , _receive :: !a\n , _will :: !a\n , _people :: !a\n , _report :: !a\n , _addresses :: !a\n , _free :: !a\n , _business :: !a\n , _email :: !a\n , _you :: !a\n , _credit :: !a\n , _your :: !a\n , _font :: !a\n , _000 :: !a\n , _money :: !a\n , _hp :: !a\n , _hpl :: !a\n , _george :: !a\n , _650 :: !a\n , _lab :: !a\n , _labs :: !a\n , _telnet :: !a\n , _857 :: !a\n , _data :: !a\n , _415 :: !a\n , _85 :: !a\n , _technology :: !a\n , _1999 :: !a\n , _parts :: !a\n , _pm :: !a\n , _direct :: !a\n , _cs :: !a\n , _meeting :: !a\n , _original :: !a\n , _project :: !a\n , _re :: !a\n , _edu :: !a\n , _table :: !a\n , _conference :: !a\n , _semicolon :: !a\n , _lparen :: !a\n , _pipe :: !a\n , _bang :: !a\n , _dollarsign :: !a\n , _hash :: !a\n , _caps_avg :: !a\n , _caps_max :: !a\n , _caps_total :: !a\n , _spam :: !Int\n} deriving (Generic, Show, Functor, Foldable)\n -- Gives me mapping, toList, folding, decoding, etc., for free.\n\n-- CSV decoding instanes for free because of Generic\ninstance FromField a => FromRecord (SpamE a)\ninstance ToField a => ToRecord (SpamE a)\n\n--\n-- This is written in a semi unidiomatic haskell style where I don't really\n-- have a main function that assembles everything together. Instead, I use\n-- unsafePerformIO to grab the data and treat it as a pure value so I can just\n-- hardcode the assignment here. It allows for faster iteratino time.\n--\n\n-- Decodes the file into a vector of spambase entries\n{-# NOINLINE spamEntries #-}\nspamEntries :: V.Vector SpamEntry\nspamEntries = fromRight undefined . decode NoHeader $ mydata\n where\n -- Load the data from a file. Bit of a hacky way to do it, but it makes the\n -- rest of the code easier to incrementally write.\n mydata :: BL.ByteString\n mydata = unsafePerformIO $ BL.readFile \"spambase.data\"\n {-# NOINLINE mydata #-} -- if you inline this function, bad shit happens\n\n-- This works by indexing the vector of SpamEntry entries\n-- Then the vector is split into two vectors, one with all the even indices,\n-- one with all odd (this effectively splits the data sets equally)\n--\n-- Then the extra indices are stripped from both vectors\ntest, train :: V.Vector SpamEntry\n(test, train) = splitData spamEntries\n where\n splitData\n :: V.Vector SpamEntry\n -> (V.Vector SpamEntry, V.Vector SpamEntry)\n splitData e = both (snd <$>) $ V.partition (even . fst) (V.indexed e)\n\n--\n-- Probabilities of the prior\n--\nprobSpam :: V.Vector SpamEntry -> Double\nprobSpam s = V.length (fst $ splitSpam s) // V.length s\n\npSpamTrain, pSpamTest :: Double\n(pSpamTrain, pSpamTest) = both probSpam (train, test)\n\n-- Takes the spam entries and collects the (mean, standard deviation) of all 57\n-- features\nstats :: Foldable t => V.Vector (t Double) -> [(Double, Double)]\nstats entries = (mean &&& stdDev) <$> collectedStats\n where\n -- This is just data shuffling to get all 57 features from the different\n -- spamEntries into a list of feature-vectors\n collectedStats :: [V.Vector Double]\n collectedStats = V.fromList . normalize <$$> transpose $ toList <$> V.toList entries\n -- Normalize is a safety precaution to prevent zeroes\n normalize = fmap (\\x -> if x < 0.0001 then 0.0001 else x)\n\n-- Splits into a tuple of (spam, non spam)\nsplitSpam :: V.Vector SpamEntry -> (V.Vector SpamEntry, V.Vector SpamEntry)\nsplitSpam = V.partition ((== 1) . _spam)\n\n-- Just some globals to use the functions just defined above\ntrainSpamStat, trainNonStat, testSpamStat, testNonStat :: [(Double, Double)]\n(trainSpamStat, trainNonStat) = both stats $ splitSpam train\n(testSpamStat, testNonStat) = both stats $ splitSpam test\n\n-- This is the N(xi;\u03bc,\u03c3) function from the text\nnormal :: Floating a => (a, a) -> a -> a\nnormal (\u03bc, \u03c3) x = 1 / root * exp (-(x - \u03bc) ^ 2 / (2 * \u03c3 ^ 2))\n where root = sqrt (2 * pi) * \u03c3\n\n--\n-- The meat of the library. This classifies things as spam or nonSpam\n--\ndata Class = Spam | NonSpam deriving (Show)\n\nclassify :: SpamEntry -> Class\nclassify e = if testSpamLogs > testNonLogs then Spam else NonSpam\n where\n testSpamLogs = log pSpamTrain + sum (logify testSpamStat)\n testNonLogs = log (1 - pSpamTrain) + sum (logify testNonStat)\n\n logify :: [(Double, Double)] -> [Double]\n logify stat = log <$> zipWith ($) (normal <$> stat) (toList e)\n\nclassify' :: SpamEntry -> Accuracy\nclassify' e = case (guess, actual) of\n (Spam , Spam ) -> TruePos\n (NonSpam, NonSpam) -> TrueNeg\n (Spam , NonSpam) -> FalsePos\n (NonSpam, Spam ) -> FalseNeg\n where\n guess = classify e\n actual = if _spam e == 1 then Spam else NonSpam\n\n--\n-- Accuracy and analysis section\n--\ndata Accuracy = TruePos | TrueNeg | FalsePos | FalseNeg deriving (Show)\n\n-- The higher-ordered data structure is, again, so I can map over the data\n-- easily. foldl' (+) accuracyData 0 will sum up all of the items in this data\n-- structure, for example.\ntype AccuracyData = ACount Int\ndata ACount a =\n ACount {\n _truePos :: !a\n , _trueNeg :: !a\n , _falsePos :: !a\n , _falseNeg :: !a\n} deriving (Show, Functor, Foldable)\n\n-- Default starting point\naccuracyData :: AccuracyData\naccuracyData = ACount 0 0 0 0\n\n-- Updater functions: succ a <=> a+1\ntruePos :: AccuracyData -> AccuracyData\ntruePos a@ACount {..} = a { _truePos = succ _truePos }\n\ntrueNeg :: AccuracyData -> AccuracyData\ntrueNeg a@ACount {..} = a { _trueNeg = succ _trueNeg }\n\nfalsePos :: AccuracyData -> AccuracyData\nfalsePos a@ACount {..} = a { _falsePos = succ _falsePos }\n\nfalseNeg :: AccuracyData -> AccuracyData\nfalseNeg a@ACount {..} = a { _falseNeg = succ _falseNeg }\n\n-- Go over all of the classified data; categorize it into the confusion matrix,\n-- then tally up all of the results.\ntally :: AccuracyData\ntally = foldl' accum accuracyData classes\n where\n classes = classify' <$> test\n accum a e = case e of\n TruePos -> truePos a\n TrueNeg -> trueNeg a\n FalsePos -> falsePos a\n FalseNeg -> falseNeg a\n\n--\n-- The statistics:\n--\naccuracy :: Double\naccuracy = allPos // total\n where\n allPos = _truePos tally + _trueNeg tally\n total = foldl' (+) 0 tally\n\nrecall :: Double\nrecall = tp // (tp + _falseNeg tally) where tp = _truePos tally\n\nprecision :: Double\nprecision = tp // allPos\n where\n tp = _truePos tally\n allPos = tp + _falsePos tally\n\n\n--\n-- Main\n--\nmain = do\n putStrLn $ \"The accuracy is: \" ++ show accuracy\n putStrLn $ \"The recall is: \" ++ show recall\n putStrLn $ \"The precision is: \" ++ show precision\n putStrLn $ \"The confusion matrix is: \" ++ show tally\n\n--\n-- Helper functions\n--\n\n-- Apply a function to both sides of a tuple at once\nboth :: (t -> b) -> (t, t) -> (b, b)\nboth f (a, b) = (f a, f b)\n\n-- Nested mapping\ninfixl 5 <$$>\n(<$$>) :: (Functor f2, Functor f1) => (a -> b) -> f1 (f2 a) -> f1 (f2 b)\n(<$$>) = fmap fmap fmap\n\n-- Division with implicit number conversion\n(//) :: (Integral a1, Integral a, Fractional a2) => a -> a1 -> a2\na // b = fromIntegral a / fromIntegral b\n", "meta": {"hexsha": "c76ebc1864bde3202f07e18602bb1247142f44e2", "size": 8429, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/Lib.hs", "max_stars_repo_name": "jared-w/Haskell-Spambase", "max_stars_repo_head_hexsha": "56d087717de4cdbe33d40030923469ce6a6aff2d", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/Lib.hs", "max_issues_repo_name": "jared-w/Haskell-Spambase", "max_issues_repo_head_hexsha": "56d087717de4cdbe33d40030923469ce6a6aff2d", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/Lib.hs", "max_forks_repo_name": "jared-w/Haskell-Spambase", "max_forks_repo_head_hexsha": "56d087717de4cdbe33d40030923469ce6a6aff2d", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 30.9889705882, "max_line_length": 86, "alphanum_fraction": 0.5980543362, "num_tokens": 2536, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.6334102775181399, "lm_q2_score": 0.5273165233795671, "lm_q1q2_score": 0.33400770541375235}} {"text": "{-#Language TupleSections, MultiWayIf#-}\nmodule Stratification where\n\n-- \u0412\u043d\u0435\u0448\u043d\u0438\u0435 \u0438\u043c\u043f\u043e\u0440\u0442\u044b\nimport Data.Matrix (Matrix(..))\n\nimport Data\nimport Point\nimport Data.Array as A\nimport Data.Map as M\nimport Data.Complex\nimport SymbolicImage\nimport Jac (jac, e)\n\nstr :: F Point -> Imagination -> Int -> Stratification\nstr fp im i = iterate\n (stepStratification fp)\n (toStratification im) !! i\n\n\n-- \u041e\u0434\u0438\u043d \u0448\u0430\u0433 \u0441 \u043f\u043e\u0434\u0440\u0430\u0437\u0431\u0438\u0435\u043d\u0438\u0435\u043c.\nstepStratification :: F Point-> F Stratification\nstepStratification fp (Stratification d1 d2 ls) = Stratification\n d1 (d2*2) $ concatMap celling $ cyclics $\n (shiftCeil d1 d2 fp #=) <$> ls\n where\n\n{-\n where\n -- \u0441\u0447\u0438\u0442\u0430\u0435\u043c \u0433\u0440\u0430\u0444\n !gr = (shiftCeil d1 d2 fp ##=) <$> ls\n -- \u0438\u043d\u0434\u0435\u0445 \u0432\u0435\u0440\u0448\u0438\u043d\n !index = formArray gr\n -- \u043e\u0431\u0440\u0430\u0442\u043d\u044b\u0439 \u0438\u043d\u0434\u0435\u0445\n !indexR = formMap index\n\n unpack !gr = (index A.!) <$> gr\n pack !gr = do\n (a, b) <- gr\n let a' = fromJust $ a`M.lookup`indexR\n return (a', a', MB.mapMaybe (`M.lookup`indexR) b)\n\n(##=) !f !c = (c, f c)\n\n-}\n\n-- \u0432\u0441\u043f\u043e\u043c\u043e\u0433\u0430\u0442\u0435\u043b\u044c\u043d\u044b\u0435 \u0441\u0442\u0440\u0443\u043a\u0442\u0443\u0440\u044b \u0434\u0430\u043d\u043d\u044b\u0445\n-- \u043c\u0430\u0441\u0441\u0438\u0432 \u0441 \u044f\u0447\u0435\u0439\u043a\u0430\u043c\u0438 \u043f \u0438\u043d\u0434\u0435\u043a\u0441\u0430\u043c.\nformArray :: [(Ceil3, [Ceil3])] -> Array Int Ceil3\nformArray gr = array (1, length a) (zip [1..] a)\n where a = plat gr\n\n-- \u043d\u0430\u0445\u043e\u0434\u0438\u043c \u0438\u043d\u0434\u0435\u043a\u0441 \u043f\u043e \u044f\u0447\u0435\u0439\u043a\u0435.\nformMap :: Array Int Ceil3 -> Map Ceil3 Int\nformMap arr = M.fromList $ (\\(a,b) -> (b,a)) <$> A.assocs arr\n\n\nplat :: Ord c => [(c, [c])] -> [c]\nplat a = myNub.concat $ (\\(a, b) -> a:b) <$> a\n\n\ntoStratification :: Imagination -> Stratification\ntoStratification (Imagination d c) = Stratification d 1\n $ concatMap (\\c -> [Ceil3 c 1, Ceil3 c 0]) c\n\n\n-- \u043f\u043e\u0434\u0440\u0430\u0437\u0431\u0438\u0435\u043d\u0438\u0435 \u043d\u0430 \u0431\u043e\u043b\u0435\u0435 \u043c\u0435\u043b\u043a\u0438\u0435 \u0443\u0440\u043e\u0432\u043d\u0438\ncelling :: Ceil3 -> [Ceil3]\ncelling (Ceil3 c i) = [Ceil3 c (i*2), Ceil3 c (i*2-1)]\n\n-- \u0422\u0443\u0442 \u0447\u0442\u043e-\u0442\u043e \u043d\u0435 \u0442\u043e.\nshiftCeil :: Diameter -> Diameter -> F Point -> Ceil3 -> [Ceil3]\nshiftCeil d1 d2 fp (Ceil3 c l) = myNub $ do\n let Point x y = fromCeil d1 c\n func d1 d2 fp\n <$> mySequence x d1\n <*> mySequence y d1\n <*> mySequence (rad d2 l) (pi/2/d2)\n\n\nfunc :: Double -> Double -> F Point -> Double -> Double -> Double -> Ceil3\nfunc d1 d2 fp x y t = Ceil3 (ceil d1 fp x y) (int d2 (arcOf fp x y t))\n\n\narcOf :: F Point -> Double -> Double -> Double -> Double\narcOf fp x y t = arc $ toPoint $ jacobian fp x y * e t\n\n\nceil :: Double -> F Point -> Double -> Double -> Ceil\nceil d fp x y = toCeil d $ fp (Point x y)\n\n\njacobian :: F Point -> Double -> Double -> Matrix Double\njacobian fp x y = jac fp $ Point x y\n\n\narc :: Point -> Double\narc (Point x y) = if\n | x > 0 -> phase $ x :+ y\n | x == 0 -> abs $ phase $ x :+ y\n | otherwise -> phase $ negate $ x :+ y\n\n\nint :: Double -> Double -> Int\nint d r = ceiling $ r/pi*2*d\n\n\nrad :: Double -> Int ->Double\nrad d r = toEnum r * pi/2/d\n", "meta": {"hexsha": "2d1462edd8e4d95129ceaeddea7dfa0916b53eb0", "size": 2752, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/Stratification.hs", "max_stars_repo_name": "vojiranto/dsa", "max_stars_repo_head_hexsha": "0071c1a00db6c1cfffeca6020e3a7cb22a1aeade", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/Stratification.hs", "max_issues_repo_name": "vojiranto/dsa", "max_issues_repo_head_hexsha": "0071c1a00db6c1cfffeca6020e3a7cb22a1aeade", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/Stratification.hs", "max_forks_repo_name": "vojiranto/dsa", "max_forks_repo_head_hexsha": "0071c1a00db6c1cfffeca6020e3a7cb22a1aeade", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 25.0181818182, "max_line_length": 74, "alphanum_fraction": 0.5970203488, "num_tokens": 970, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.7826624789529375, "lm_q2_score": 0.4263215925474903, "lm_q1q2_score": 0.33366591445438293}} {"text": "module Statistics.Quantile.Util where\n\nimport Pipes\nimport qualified Pipes.Prelude as P\n\nimport Statistics.Quantile.Types\nimport System.IO\n\ntmpDir :: FilePath\ntmpDir = \"/var/tmp/\"\n\nselectFromHandle :: Quantile\n -> Selector IO\n -> Handle\n -> IO Double\nselectFromHandle q (Selector select) hin = do\n select q $ streamHandle hin\n\nstreamHandle :: Handle -> Stream IO\nstreamHandle hin = Stream (P.fromHandle hin >-> P.map read)\n\ntakeStream :: Int -> Stream IO -> Stream IO\ntakeStream n (Stream p) = Stream $ p >-> P.take n\n", "meta": {"hexsha": "d68b30d6ec2074c0ba9828e9fe1e4324ef9d05e2", "size": 567, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "2015-08-26-fp-syd-approx-quantiles/approx-quantile/src/Statistics/Quantile/Util.hs", "max_stars_repo_name": "fractalcat/slides", "max_stars_repo_head_hexsha": "338db16c6998dc4add9d1ebd511b3faf3a4420dc", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "2015-08-26-fp-syd-approx-quantiles/approx-quantile/src/Statistics/Quantile/Util.hs", "max_issues_repo_name": "fractalcat/slides", "max_issues_repo_head_hexsha": "338db16c6998dc4add9d1ebd511b3faf3a4420dc", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "2015-08-26-fp-syd-approx-quantiles/approx-quantile/src/Statistics/Quantile/Util.hs", "max_forks_repo_name": "fractalcat/slides", "max_forks_repo_head_hexsha": "338db16c6998dc4add9d1ebd511b3faf3a4420dc", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 23.625, "max_line_length": 59, "alphanum_fraction": 0.6666666667, "num_tokens": 135, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.5813031051514762, "lm_q2_score": 0.5736784074525096, "lm_q1q2_score": 0.33348103961049763}} {"text": "{-# OPTIONS_GHC -fno-warn-unused-binds -fno-warn-unused-matches -fno-warn-name-shadowing -fno-warn-missing-signatures #-}\n{-# LANGUAGE FlexibleInstances, ConstraintKinds, ExistentialQuantification, GADTs, RankNTypes, MultiParamTypeClasses #-}\n{-# LANGUAGE ImpredicativeTypes, RankNTypes, UndecidableInstances, FlexibleContexts, TypeSynonymInstances #-}\n\n\n---------------------------------------------------------------------------------------------------\n---------------------------------------------------------------------------------------------------\n-- | \n-- | Module : Count-Min Sketch\n-- | Creator: Xiao Ling\n-- | Created: 12/17/2015\n-- |\n---------------------------------------------------------------------------------------------------\n---------------------------------------------------------------------------------------------------\n\nmodule CountMinSketch where\n\nimport Control.Monad.Random.Class\nimport Control.Monad.Random\nimport Control.Monad.State\nimport Control.Monad.Reader\nimport Control.Monad.Identity\n\nimport Data.Matrix\nimport Data.Conduit\nimport qualified Data.Conduit.List as Cl\nimport qualified Data.Matrix as M\n\nimport Core\nimport Utils\nimport Statistics\n\n\n\nimport System.IO.Unsafe\n\n\n{-----------------------------------------------------------------------------\n Types \n------------------------------------------------------------------------------}\n\ntype W = Int -- * num cols\ntype D = Int -- * num rows\ntype P = Int -- * some prime --> change this to Integer\ntype Event = Int -- * some input event from\n -- * universe: {1, .., i, .. n}\n\ntype Sketch = Matrix Int -- * D x W matrix of counters\ntype ABs = Matrix Int -- * 2 x D matrix of a_j and b_j for j = 1..d\ntype ColIdx = [Int] -- * indices of counters to increment\ntype Hash = Event -> ColIdx -- * Maps event to d x 1 list of column indices\n\n\n-- * Algorithm State\ntype AState = (Sketch,Hash,(D,W,P))\n\n\n-- * the algorithm uses `some m` equipped with state and randomness\n-- * also consider `some'` `a`\ntype Some m = (MonadRandom m, MonadState AState m)\n\n{-----------------------------------------------------------------------------\n Count Min Sketch \n------------------------------------------------------------------------------}\n\nsk :: Batch Event IO AState\nsk = sketch' ed 50\n\nsketch' :: EpsDelta -> Event -> Batch Event IO AState\nsketch' t n = sketch t n `using` eval\n\n\nsketch :: Some m => EpsDelta -> Event -> Streaming Event m ()\nsketch t n = lift (initDwp t n) $= inits False $= update\n\n-- * there should be a combinator for this\nupdate :: Some m => Streaming Event m ()\nupdate = do\n mi <- await\n case mi of\n Nothing -> return ()\n Just i -> lift (update' i) >> update\n\n\n-- * there should be a combinator that does this\ninits :: Some m => Bool -> Conduit Event m Event\ninits False = lift inits' >> inits True\ninits _ = pass\n\n---- * a concrete `eval`uation of Some `m`\n-- * run with vacuous inital condition to be thrown away\neval :: StateT AState (Rand StdGen) () -> IO AState\neval m = evalRandIO $ execStateT m $ (ones 1 1, const [], (0,0,0))\n\n\n{-----------------------------------------------------------------------------\n Effectful Subroutines\n tenative conclusion, it works fine in here\n--------------------------------------------------------------------------------}\n\ninitDwp :: Some m => EpsDelta -> Event -> m ()\ninitDwp (ED e d) n = setParam $ (round $ log2(1/d), round $ 2/e, round $ 2^n -1)\n\n-- * initalize algorithm with zero counters and hash function\ninits' :: Some m => m ()\ninits' = do\n t <- askParam\n hash <- newHash t\n let sketch = newSketch t\n setHash hash\n setSketch sketch\n\n-- * on event `i`, update the `sketch`\nupdate' :: Some m => Event -> m ()\nupdate' i = do\n pm <- askParam\n sketch <- getSketch\n hash <- askHash\n let incr = toMask (hash i) pm\n setSketch $ incr .+. sketch\n\n\n-- * sketch1 == sketch1\n-- * IO (sketch1', hash', t')\nm1 = evalRandIO $ execStateT (update' i1) (sketch0, hash, tup)\nm2 = evalRandIO $ execStateT (update' i2) (sketch1, hash, tup)\n\n-- * Estimate\n--estimate :: Some m => Event -> m ()\n--estimate = do\n-- ()\n\n\n-- * intialize random cofficients a_j, b_j, for d x 2 matrix: \n-- * [ a_1 ... a_j ... a_d ]\n-- * [ b_1 ... b_j ... b_d ]\nnewAbs :: MonadRandom m => (D,W,P) -> m ABs\nnewAbs (d,_,p) = (M.fromList 2 d . take (2*d)) <$> getRandomRs (1,p)\n\n\n{-----------------------------------------------------------------------------\n Pure Subroutines\n------------------------------------------------------------------------------}\n\nnewDwp :: EpsDelta -> Event -> (D,W,P)\nnewDwp (ED e d) n = (round $ log2(1/d), round $ 2/e, round $ 2^n -1)\n\n-- * initalize the sketch\nnewSketch :: (D,W,P) -> Sketch\nnewSketch (d,w,_) = zeros d w\n\n-- * h_j (i) = (a_j x i + b_j mod p) mod w\n-- * sumRow-wise [ a_1 ... a_j ... a_d ] .*. [ i_1 ... i_d ] mod p mod w\n-- * [ b_1 ... b_j ... b_d ] [ 1 ... 1 ]\n-- * result: [ idx_1, ..., idx_d ]\n-- * where the indices start at 1\nnewHash :: MonadRandom m => (D,W,P) -> m Hash\nnewHash t = do\n ab <- newAbs t\n return $ toHash' t ab\n\n-- * Note `is` maps some `i` from event universe onto d x 2 matrix:\n-- * [ i_1 ... i_2 ]\n-- * [ 1 ... 1 ]\ntoHash' :: (D, W, P) -> ABs -> Hash\ntoHash' (d, w, p) ab i = go $ sumR (ab .*. is) ... (\\v -> v `mod` p `mod` w)\n where go = fmap (+1) . toList\n is = (i .+ (zeros 1 d)) <-> ones 1 d\n\n-- * given hash function, construct a binary mask of size `w` x `d`\n-- * to increment sketch\ntoMask :: ColIdx -> (D,W,P) -> Sketch\ntoMask ks (d,w,p) = go w ks\n where\n go w ks = let vec c w = zeros 1 (c-1) <|> single 1 <|> zeros 1 (w - c) in\n case ks of\n c:[] -> vec c w\n c:cs -> vec c w <-> go w cs\n\n\n{-----------------------------------------------------------------------------\n Ad hoc testing\n------------------------------------------------------------------------------}\n\n[i1,i2,i3] = [12,0,50]\n\ntup@(d,w,p) = newDwp ed 50\n\nhash = unsafePerformIO . evalRandIO $ newHash tup\nsketch0 = newSketch tup\n\n-- * update it once\nks1 = hash i1\nincr1 = toMask ks1 tup\nsketch1 = incr1 .+. sketch0\n\n-- * update again\nks2 = hash i2\nincr2 = toMask ks2 tup\nsketch2 = incr2 .+. sketch1\n\n\n\n{-----------------------------------------------------------------------------\n Managing State\n TODO : redesign so this is not necessary\n------------------------------------------------------------------------------}\n\naskParam :: Some m => m (D,W,P)\naskParam = get >>= \\(_,_,p) -> return p\n\nsetParam :: Some m => (D,W,P) -> m ()\nsetParam t = get >>= \\(s,h,_) -> put (s,h,t)\n\ngetSketch :: Some m => m Sketch\ngetSketch = get >>= \\(s,_,_) -> return s\n\nsetSketch :: Some m => Sketch -> m ()\nsetSketch s = get >>= \\(_,h,t) -> put (s,h,t)\n\naskHash :: Some m => m Hash\naskHash = get >>= \\(_,h,_) -> return h\n\nsetHash :: Some m => Hash -> m ()\nsetHash h = get >>= \\(s,_,t) -> put (s,h,t)\n\n{-----------------------------------------------------------------------------\n Find a lib function for this:\n------------------------------------------------------------------------------}\n\n-- * identity conduit, why can't I find this in the library?\npass :: Monad m => Conduit i m i\npass = do\n mx <- await\n case mx of\n Nothing -> return ()\n Just x -> yield x >> pass\n\n\n\n", "meta": {"hexsha": "d3bc2d5cf4b763bbdbeb3662e97e34e8da31f96b", "size": 7541, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "depricated/CountMinSketch4.hs", "max_stars_repo_name": "lingxiao/CIS700", "max_stars_repo_head_hexsha": "0aebe925c4b413a37d75b8c782a3dffd53851f8a", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "depricated/CountMinSketch4.hs", "max_issues_repo_name": "lingxiao/CIS700", "max_issues_repo_head_hexsha": "0aebe925c4b413a37d75b8c782a3dffd53851f8a", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "depricated/CountMinSketch4.hs", "max_forks_repo_name": "lingxiao/CIS700", "max_forks_repo_head_hexsha": "0aebe925c4b413a37d75b8c782a3dffd53851f8a", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 31.2904564315, "max_line_length": 122, "alphanum_fraction": 0.4643946426, "num_tokens": 1962, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6992544085240401, "lm_q2_score": 0.476579651063676, "lm_q1q2_score": 0.3332504220191242}} {"text": "{-# LANGUAGE BangPatterns #-}\n-- | The GenOptProblem module performs several passes on the translation generated\n-- by the Style compiler to generate the initial state (fields and GPIs) and optimization problem\n-- (objectives, constraints, and computations) specified by the Substance/Style pair.\n\n{-# OPTIONS_HADDOCK prune #-}\n{-# LANGUAGE AllowAmbiguousTypes, RankNTypes, UnicodeSyntax, NoMonomorphismRestriction #-}\n{-# LANGUAGE DeriveGeneric #-}\n-- Mostly for autodiff\n\nmodule GenOptProblem where\n\nimport Utils\nimport Shapes\nimport Transforms\nimport qualified SubstanceJSON as J\nimport qualified Substance as C\nimport Env\nimport Style\nimport Functions\nimport Text.Show.Pretty (ppShow, pPrint)\nimport System.Random\nimport Debug.Trace\nimport qualified Data.Map.Strict as M\nimport Control.Monad (foldM, forM_)\nimport Data.List (foldl', minimumBy, intercalate, partition)\nimport Data.Array (assocs)\nimport Data.Either (partitionEithers)\nimport System.Console.Pretty (Color (..), Style (..), bgColor, color, style, supportsPretty)\nimport qualified Data.Set as Set\nimport qualified Data.Graph as Graph\nimport GHC.Float (float2Double, double2Float)\nimport qualified Data.Maybe as DM (fromJust)\nimport qualified Data.Aeson as A\nimport GHC.Generics\nimport qualified Numeric.LinearAlgebra as L\n\ndefault (Int, Float)\n\n-------------------- Type definitions\n\ntype StyleOptFn = (String, [Expr]) -- Objective or constraint\n\ndata OptType = Objfn | Constrfn\n deriving (Show, Eq)\n\ndata Fn = Fn { fname :: String,\n fargs :: [Expr],\n optType :: OptType }\n deriving (Show, Eq)\n\ndata FnDone a = FnDone { fname_d :: String,\n fargs_d :: [ArgVal a],\n optType_d :: OptType }\n deriving (Show, Eq)\n\n-- A map from the varying path to its value, used to look up values in the translation\ntype VaryMap a = M.Map Path (TagExpr a)\n\n------- State type definitions\n\n-- Stores the last EP varying state (that is, the state when the unconstrained opt last converged)\ntype LastEPstate = [Float] -- Note: NOT polymorphic (due to system slowness with polymorphism)\n\ndata OptStatus = NewIter\n | UnconstrainedRunning LastEPstate\n | UnconstrainedConverged LastEPstate\n | EPConverged\n\ninstance Show OptStatus where\n show NewIter = \"New iteration\"\n show (UnconstrainedRunning lastEPstate) =\n \"Unconstrained running\" -- with last EP state:\\n\" ++ show lastEPstate\n show (UnconstrainedConverged lastEPstate) =\n \"Unconstrained converged\" -- with last EP state:\\n\" ++ show lastEPstate\n show EPConverged = \"EP converged\"\n\ninstance Eq OptStatus where\n x == y = case (x, y) of\n (NewIter, NewIter) -> True\n (EPConverged, EPConverged) -> True\n (UnconstrainedRunning a, UnconstrainedRunning b) -> a == b\n (UnconstrainedConverged a, UnconstrainedConverged b) -> a == b\n (_, _) -> False\n\ndata Params = Params { weight :: Float,\n optStatus :: OptStatus,\n overallObjFn :: forall a . (Autofloat a) => StdGen -> a -> [a] -> a,\n bfgsInfo :: BfgsParams\n }\n\ninstance Show Params where\n show p = \"Weight: \" ++ show (weight p) ++ \" | Opt status: \" ++ show (optStatus p)\n -- ++ \"\\nBFGS info:\\n\" ++ show (bfgsInfo p)\n\ndata BfgsParams = BfgsParams {\n lastState :: Maybe (L.Vector L.R), -- x_k\n lastGrad :: Maybe (L.Vector L.R), -- gradient of f(x_k)\n invH :: Maybe (L.Matrix L.R), -- (BFGS only) estimate of the inverse of the hessian, H_k (TODO: are these indices right?)\n s_list :: [L.Vector L.R], -- (L-BFGS only) s_i (state difference) from k-1 to k-m\n y_list :: [L.Vector L.R], -- (L-BFGS only) y_i (grad difference) from k-1 to k-m\n numUnconstrSteps :: Int, -- (L-BFGS only) number of steps so far, starting at 0\n memSize :: Int -- (L-BFGS only) number of vectors to retain\n}\n\ninstance Show BfgsParams where\n show s = \"\\nBFGS params:\\n\" ++\n \"\\nlastState: \\n\" ++ ppShow (lastState s) ++\n \"\\nlastGrad: \\n\" ++ ppShow (lastGrad s) ++\n \"\\ninvH: \\n\" ++ ppShow (invH s) ++\n -- This is a lot of output (can be 2 * defaultBfgsMemSize * state size)\n -- \"\\ns_list:\\n\" ++ ppShow (s_list s) ++\n -- \"\\ny_list:\\n\" ++ ppShow (y_list s) ++\n \"\\nlength of s_list:\\n\" ++ (show $ length $ s_list s) ++\n \"\\nlength of y_list:\\n\" ++ (show $ length $ y_list s) ++\n \"\\nnumUnconstrSteps:\\n\" ++ ppShow (numUnconstrSteps s) ++\n \"\\nmemSize:\\n\" ++ ppShow (memSize s) ++ \"\\n\\n\"\n\ndefaultBfgsMemSize :: Int\ndefaultBfgsMemSize = 17\n-- Shorter memory seems to work better in practice; Nocedal says between 3 and 30 is a good `m` (see p227)\n-- but the choice of `m` is also problem-dependent\n\ndefaultBfgsParams = BfgsParams { lastState = Nothing, lastGrad = Nothing, invH = Nothing,\n s_list = [], y_list = [], numUnconstrSteps = 0, memSize = defaultBfgsMemSize }\n\ntype PolicyState = String -- Should this include the functions that it returned last time?\ntype Policy = [Fn] -> [Fn] -> PolicyParams -> (Maybe [Fn], PolicyState)\n\ndata PolicyParams = PolicyParams { policyState :: String,\n policySteps :: Int,\n currFns :: [Fn]\n }\n\ninstance Show PolicyParams where\n show p = \"Policy state: \" ++ policyState p ++ \" | Policy steps: \" ++ show (policySteps p)\n -- ++ \"\\nFunctions:\\n\" ++ ppShow (currFns p)\n\ndata OptMethod = Newton | BFGS | LBFGS | GradientDescent\n deriving (Eq, Show, Generic)\n\ninstance A.ToJSON OptMethod where\n toEncoding = A.genericToEncoding A.defaultOptions\n\ninstance A.FromJSON OptMethod\n\ndata OptConfig = OptConfig {\n optMethod :: OptMethod\n } deriving (Eq, Show, Generic)\n\ndefaultOptConfig = OptConfig { optMethod = BFGS }\n\ninstance A.ToJSON OptConfig where\n toEncoding = A.genericToEncoding A.defaultOptions\n\ninstance A.FromJSON OptConfig\n\ndata State = State { shapesr :: forall a . (Autofloat a) => [Shape a],\n shapeNames :: [(String, Field)], -- TODO Sub name type\n shapeOrdering :: [String],\n shapeProperties :: [(String, Field, Property)],\n transr :: forall a . (Autofloat a) => Translation a,\n varyingPaths :: [Path],\n uninitializedPaths :: [Path],\n varyingState :: [Float], -- Note: NOT polymorphic\n paramsr :: Params,\n objFns :: [Fn],\n constrFns :: [Fn],\n rng :: StdGen,\n autostep :: Bool,\n policyFn :: Policy,\n policyParams :: PolicyParams,\n oConfig :: OptConfig }\n\ninstance Show State where\n show s = \"Shapes: \\n\" ++ ppShow (shapesr s) ++\n \"\\nShape names: \\n\" ++ ppShow (shapeNames s) ++\n \"\\nTranslation: \\n\" ++ ppShow (transr s) ++\n \"\\nVarying paths: \\n\" ++ ppShow (varyingPaths s) ++\n \"\\nUninitialized paths: \\n\" ++ ppShow (uninitializedPaths s) ++\n \"\\nVarying state: \\n\" ++ ppShow (varyingState s) ++\n \"\\nParams: \\n\" ++ ppShow (paramsr s) ++\n \"\\nObjective Functions: \\n\" ++ ppShowList (objFns s) ++\n \"\\nConstraint Functions: \\n\" ++ ppShowList (constrFns s) ++\n \"\\nAutostep: \\n\" ++ ppShow (autostep s)\n\n-- Reimplementation of 'ppShowList' from pretty-show. Not sure why it cannot be imported at all\nppShowList = concatMap ((++) \"\\n\" . ppShow)\n\n--------------- Constants\n\n-- For evaluating expressions\nstartingIteration, maxEvalIteration :: Int\nstartingIteration = 0\nmaxEvalIteration = 500 -- Max iteration depth in case of cycles\n\nevalIterRange :: (Int, Int)\nevalIterRange = (startingIteration, maxEvalIteration)\n\ninitRng :: StdGen\ninitRng = mkStdGen seed\n where seed = 17 -- deterministic RNG with seed\n\n--------------- Parameters used in optimization\n-- Should really be in Optimizer, but need to fix module import structure\n\nconstrWeight :: Floating a => a\nconstrWeight = 10 ^ 4\n\n-- for use in barrier/penalty method (interior/exterior point method)\n-- seems if the point starts in interior + weight starts v small and increases, then it converges\n-- not quite: if the weight is too small then the constraint will be violated\ninitWeight :: Autofloat a => a\n-- initWeight = 10 ** (-5)\n\n-- Converges very fast w/ constraints removed (function-composition.sub)\n-- initWeight = 0\n\n-- Steps very slowly with a higher weight; does not seem to converge but looks visually OK (function-composition.sub)\n-- initWeight = 1\ninitWeight = 10 ** (-3)\n\npolicyToUse :: Policy\npolicyToUse = optimizeSumAll\n-- policyToUse = optimizeConstraintsThenObjectives\n-- policyToUse = optimizeConstraints\n-- policyToUse = optimizeObjectives\n\n--------------- Utility functions\n\ndeclaredVarying :: (Autofloat a) => TagExpr a -> Bool\ndeclaredVarying (OptEval (AFloat Vary)) = True\ndeclaredVarying _ = False\n\nsumMap :: Floating b => (a -> b) -> [a] -> b -- common pattern in objective functions\nsumMap f l = sum $ map f l\n\n-- TODO: figure out what to do with sty vars\nmkPath :: [String] -> Path\nmkPath [name, field] = FieldPath (BSubVar (VarConst name)) field\nmkPath [name, field, property] = PropertyPath (BSubVar (VarConst name)) field property\n\npathToList :: Path -> [String]\npathToList (FieldPath (BSubVar (VarConst name)) field) = [name, field]\npathToList (PropertyPath (BSubVar (VarConst name)) field property) = [name, field, property]\npathToList _ = error \"pathToList should not handle Sty vars\"\n\nisFieldPath :: Path -> Bool\nisFieldPath (FieldPath _ _) = True\nisFieldPath (PropertyPath _ _ _) = False\n\nbvarToString :: BindingForm -> String\nbvarToString (BSubVar (VarConst s)) = s\nbvarToString (BStyVar (StyVar' s)) = s -- For namespaces\n -- error (\"bvarToString: cannot handle Style variable: \" ++ show v)\n\ngetShapeName :: String -> Field -> String\ngetShapeName subName field = subName ++ \".\" ++ field\n\n-- For varying values to be inserted into varyMap\nfloatToTagExpr :: (Autofloat a) => a -> TagExpr a\nfloatToTagExpr n = Done (FloatV n)\n\n-- | converting from Value to TagExpr\ntoTagExpr :: (Autofloat a) => Value a -> TagExpr a\ntoTagExpr v = Done v\n\n-- | converting from TagExpr to Value\ntoVal :: (Autofloat a) => TagExpr a -> Value a\ntoVal (Done v) = v\ntoVal (OptEval _) = error \"Shape properties were not fully evaluated\"\n\ntoFn :: OptType -> StyleOptFn -> Fn\ntoFn otype (name, args) = Fn { fname = name, fargs = args, optType = otype }\n\ntoFns :: ([StyleOptFn], [StyleOptFn]) -> ([Fn], [Fn])\ntoFns (objfns, constrfns) = (map (toFn Objfn) objfns, map (toFn Constrfn) constrfns)\n\nlist2 (a, b) = [a, b]\n\nmkVaryMap :: (Autofloat a) => [Path] -> [a] -> VaryMap a\nmkVaryMap varyPaths varyVals = M.fromList $ zip varyPaths (map floatToTagExpr varyVals)\n\n------------------- Translation helper functions\n\n------ Generic functions for folding over a translation\n\nfoldFields :: (Autofloat a) => (String -> Field -> FieldExpr a -> [b] -> [b]) ->\n Name -> FieldDict a -> [b] -> [b]\nfoldFields f name fieldDict acc =\n let name' = nameStr name in -- TODO do we need do anything with Sub vs Gen names?\n let res = M.foldrWithKey (f name') [] fieldDict in\n res ++ acc\n\nfoldSubObjs :: (Autofloat a) => (String -> Field -> FieldExpr a -> [b] -> [b]) -> Translation a -> [b]\nfoldSubObjs f trans = M.foldrWithKey (foldFields f) [] (trMap trans)\n\n------- Inserting into a translation\n\ninsertGPI :: (Autofloat a) =>\n Translation a -> String -> Field -> ShapeTypeStr -> PropertyDict a\n -> Translation a\ninsertGPI trans n field t propDict = case M.lookup (Sub n) $ trMap trans of\n Nothing -> error \"Substance ID does not exist\"\n Just fieldDict ->\n let fieldDict' = M.insert field (FGPI t propDict) fieldDict\n trMap' = M.insert (Sub n) fieldDict' $ trMap trans\n in trans { trMap = trMap' }\n\ninsertPath :: (Autofloat a) => Translation a -> (Path, TagExpr a) -> Either [Error] (Translation a)\ninsertPath trans (path, expr) =\n let overrideFlag = False in -- These paths should not exist in trans\n addPath overrideFlag trans path expr\n\ninsertPaths :: (Autofloat a) => [Path] -> [TagExpr a] -> Translation a -> Translation a\ninsertPaths varyingPaths varying trans =\n if length varying /= length varyingPaths\n then error \"not the same # varying paths as varying variables\"\n else case foldM insertPath trans (zip varyingPaths varying) of\n Left errs -> error $ \"Error while adding varying paths: \" ++ intercalate \"\\n\" errs\n Right tr -> tr\n\n------- Looking up fields/properties in a translation\n\n-- First check if the path is a varying path. If so then use the varying value\n-- (The value in the translation is stale and should be ignored)\n-- If not then use the expr in the translation\nlookupFieldWithVarying :: (Autofloat a) => BindingForm -> Field -> Translation a -> VaryMap a -> FieldExpr a\nlookupFieldWithVarying bvar field trans varyMap =\n case M.lookup (mkPath [bvarToString bvar, field]) varyMap of\n Just varyVal -> {-trace \"field lookup was vary\" $ -} FExpr varyVal\n Nothing -> {-trace \"field lookup was not vary\" $ -} lookupField bvar field trans\n\nlookupPropertyWithVarying :: (Autofloat a) => BindingForm -> Field -> Property\n -> Translation a -> VaryMap a -> TagExpr a\nlookupPropertyWithVarying bvar field property trans varyMap =\n case M.lookup (mkPath [bvarToString bvar, field, property]) varyMap of\n Just varyVal -> {-trace \"property lookup was vary\" $ -} varyVal\n Nothing -> {- trace \"property lookup was not vary\" $ -} lookupProperty bvar field property trans\n\nlookupProperty :: (Autofloat a) => BindingForm -> Field -> Property -> Translation a -> TagExpr a\nlookupProperty bvar field property trans =\n let name = trName bvar in\n case lookupField bvar field trans of\n FExpr e ->\n -- to deal with path synonyms, e.g. `y.f = some GPI with property p; z.f = y.f; z.f.p = some value`\n -- if we're looking for `z.f.p` and we find out that `z.f = y.f`, then look for `y.f.p` instead\n -- NOTE: this makes a recursive call!\n case e of\n OptEval (EPath (FieldPath bvarSynonym fieldSynonym)) ->\n if bvar == bvarSynonym && field == fieldSynonym\n then error (\"nontermination in lookupProperty with path '\" ++ pathStr3 name field property ++ \"' set to itself\")\n else lookupProperty bvarSynonym fieldSynonym property trans\n -- the only thing that might have properties is another field path\n _ -> error (\"path '\" ++ pathStr3 name field property ++ \"' has no properties\")\n FGPI ctor properties ->\n case M.lookup property properties of\n Nothing -> error (\"path '\" ++ pathStr3 name field property ++ \"'s property does not exist\")\n Just texpr -> texpr\n\nlookupPaths :: (Autofloat a) => [Path] -> Translation a -> [a]\nlookupPaths paths trans = map lookupPath paths\n where\n lookupPath p@(FieldPath v field) = case lookupField v field trans of\n FExpr (OptEval (AFloat (Fix n))) -> r2f n\n FExpr (Done (FloatV n)) -> r2f n\n xs -> error (\"varying path \\\"\" ++ pathStr p ++ \"\\\" is invalid: is '\" ++ show xs ++ \"'\")\n lookupPath p@(PropertyPath v field pty) = case lookupProperty v field pty trans of\n OptEval (AFloat (Fix n)) -> r2f n\n Done (FloatV n) -> n\n xs -> error (\"varying path \\\"\" ++ pathStr p ++ \"\\\" is invalid: is '\" ++ show xs ++ \"'\")\n\n-- TODO: resolve label logic here?\nshapeExprsToVals :: (Autofloat a) => (String, Field) -> PropertyDict a -> Properties a\nshapeExprsToVals (subName, field) properties =\n let shapeName = getShapeName subName field\n properties' = M.map toVal properties\n in M.insert \"name\" (StrV shapeName) properties'\n\ngetShapes :: (Autofloat a) => [(String, Field)] -> Translation a -> [Shape a]\ngetShapes shapenames trans = map (getShape trans) shapenames\n -- TODO: fix use of Sub/Sty name here\n where getShape trans (name, field) =\n let fexpr = lookupField (BSubVar $ VarConst name) field trans in\n case fexpr of\n FExpr _ -> error \"expected GPI, got field\"\n FGPI ctor properties -> (ctor, shapeExprsToVals (name, field) properties)\n\n----- GPI helper functions\n\nshapes2vals :: (Autofloat a) => [Shape a] -> [Path] -> [Value a]\nshapes2vals shapes paths = reverse $ foldl' (lookupPath shapes) [] paths\n where\n lookupPath shapes acc (PropertyPath s field property) =\n let subID = bvarToString s\n shapeName = getShapeName subID field in\n get (findShape shapeName shapes) property : acc\n lookupPath _ acc (FieldPath _ _) = acc\n\n-- Given a set of new shapes (from the frontend) and a varyMap (for varying field values):\n-- look up property values in the shapes and field values in the varyMap\n-- NOTE: varyState is constructed using a foldl, so to preserve its order, we must reverse the list of values!\nshapes2floats :: (Autofloat a) => [Shape a] -> VaryMap a -> [Path] -> [a]\nshapes2floats shapes varyMap varyingPaths = reverse $ foldl' (lookupPathFloat shapes varyMap) [] varyingPaths\n where\n lookupPathFloat :: (Autofloat a) => [Shape a] -> VaryMap a -> [a] -> Path -> [a]\n lookupPathFloat shapes _ acc (PropertyPath s field property) =\n let subID = bvarToString s\n shapeName = getShapeName subID field in\n getNum (findShape shapeName shapes) property : acc\n lookupPathFloat _ varyMap acc fp@(FieldPath _ _) =\n case M.lookup fp varyMap of\n Just (Done (FloatV num)) -> num : acc\n Just _ -> error (\"wrong type for varying field path (expected float): \" ++ show fp)\n Nothing -> error (\"could not find varying field path '\" ++ show fp ++ \"' in varyMap\")\n\n--------------------------------- Analyzing the translation\n\n--- Find varying (float) paths\n\n-- For now, don't optimize these float-valued properties of a GPI \n-- (use whatever they are initialized to in Shapes or set to in Style)\nunoptimizedFloatProperties :: [String]\nunoptimizedFloatProperties = [\"rotation\", \"strokeWidth\", \"thickness\", \n \"transform\", \"transformation\"]\n\n-- If any float property is not initialized in properties,\n-- or it's in properties and declared varying, it's varying\nfindPropertyVarying :: (Autofloat a) => String -> Field -> M.Map String (TagExpr a) ->\n String -> [Path] -> [Path]\nfindPropertyVarying name field properties floatProperty acc =\n case M.lookup floatProperty properties of\n Nothing -> if floatProperty `elem` unoptimizedFloatProperties then acc \n else mkPath [name, field, floatProperty] : acc\n Just expr -> if declaredVarying expr then mkPath [name, field, floatProperty] : acc\n else acc\n\nfindFieldVarying :: (Autofloat a) => String -> Field -> FieldExpr a -> [Path] -> [Path]\nfindFieldVarying name field (FExpr expr) acc =\n if declaredVarying expr\n then mkPath [name, field] : acc -- TODO: deal with StyVars\n else acc\nfindFieldVarying name field (FGPI typ properties) acc =\n let ctorFloats = propertiesOf FloatT typ\n varyingFloats = filter (not . isPending typ) ctorFloats\n vs = foldr (findPropertyVarying name field properties) [] varyingFloats\n in vs ++ acc\n\nfindVarying :: (Autofloat a) => Translation a -> [Path]\nfindVarying = foldSubObjs findFieldVarying\n\n--- Find uninitialized (non-float) paths\n\nfindPropertyUninitialized :: (Autofloat a) => String -> Field -> M.Map String (TagExpr a) ->\n String -> [Path] -> [Path]\nfindPropertyUninitialized name field properties nonfloatProperty acc =\n case M.lookup nonfloatProperty properties of\n -- nonfloatProperty is a non-float property that is NOT set by the user and thus we can sample it\n Nothing -> mkPath [name, field, nonfloatProperty] : acc\n Just expr -> acc\n\nfindFieldUninitialized :: (Autofloat a) => String -> Field -> FieldExpr a -> [Path] -> [Path]\n-- NOTE: we don't find uninitialized field because you can't leave them uninitialized. Plus, we don't know what types they are\nfindFieldUninitialized name field (FExpr expr) acc = acc\nfindFieldUninitialized name field (FGPI typ properties) acc =\n let ctorNonfloats = filter (/= \"name\") $ propertiesNotOf FloatT typ in\n -- TODO: add a separate field (e.g. pendingPaths) in State to store these special properties that needs frontend updates\n let uninitializedProps = pendingProperties typ ++ ctorNonfloats in\n let vs = foldr (findPropertyUninitialized name field properties) [] uninitializedProps in\n vs ++ acc\n\n-- | Find the paths to all uninitialized, non-float, non-name properties\nfindUninitialized :: (Autofloat a) => Translation a -> [Path]\nfindUninitialized = foldSubObjs findFieldUninitialized\n\n--- Find various kinds of functions\n\nfindObjfnsConstrs :: (Autofloat a) => Translation a -> [Either StyleOptFn StyleOptFn]\nfindObjfnsConstrs = foldSubObjs findFieldFns\n where findFieldFns :: (Autofloat a) => String -> Field -> FieldExpr a -> [Either StyleOptFn StyleOptFn]\n -> [Either StyleOptFn StyleOptFn]\n findFieldFns name field (FExpr (OptEval expr)) acc =\n case expr of\n ObjFn fname args -> Left (fname, args) : acc\n ConstrFn fname args -> Right (fname, args) : acc\n _ -> acc -- Not an optfn\n -- COMBAK: what should we do if there's a constant field?\n findFieldFns name field (FExpr (Done _)) acc = acc\n findFieldFns name field (FGPI _ _) acc = acc\n\nfindDefaultFns :: (Autofloat a) => Translation a -> [Either StyleOptFn StyleOptFn]\nfindDefaultFns = foldSubObjs findFieldDefaultFns\n where findFieldDefaultFns :: (Autofloat a) => String -> Field -> FieldExpr a ->\n [Either StyleOptFn StyleOptFn] -> [Either StyleOptFn StyleOptFn]\n findFieldDefaultFns name field gpi@(FGPI typ props) acc =\n let args = [EPath $ FieldPath (BSubVar (VarConst name)) field]\n objs = map (Left . addArgs args) $ defaultObjFnsOf typ\n constrs = map (Right . addArgs args) $ defaultConstrsOf typ\n in constrs ++ objs ++ acc\n where addArgs arguments f = (f, arguments)\n findFieldDefaultFns _ _ _ acc = acc\n\n--- Find shapes and their properties\n\nfindShapeNames :: (Autofloat a) => Translation a -> [(String, Field)]\nfindShapeNames = foldSubObjs findGPIName\n where findGPIName :: (Autofloat a) => String -> Field -> FieldExpr a ->\n [(String, Field)] -> [(String, Field)]\n findGPIName name field (FGPI _ _) acc = (name, field) : acc\n findGPIName _ _ (FExpr _) acc = acc\n\nfindShapesProperties :: (Autofloat a) => Translation a -> [(String, Field, Property)]\nfindShapesProperties = foldSubObjs findShapeProperties\n where findShapeProperties :: (Autofloat a) => String -> Field -> FieldExpr a -> [(String, Field, Property)]\n -> [(String, Field, Property)]\n findShapeProperties name field (FGPI ctor properties) acc =\n let paths = map (\\property -> (name, field, property)) (M.keys properties)\n in paths ++ acc\n findShapeProperties _ _ (FExpr _) acc = acc\n\n------------------------------ Evaluating the translation and expressions/GPIs in it\n\n-- TODO: write a more general typechecking mechanism\nevalUop :: (Autofloat a) => UnaryOp -> ArgVal a -> Value a\nevalUop UMinus v = case v of\n Val (FloatV a) -> FloatV (-a)\n Val (IntV i) -> IntV (-i)\n GPI _ -> error \"cannot negate a GPI\"\n Val _ -> error \"wrong type to negate\"\nevalUop UPlus v = error \"unary + doesn't make sense\" -- TODO remove from parser\n\nevalBinop :: (Autofloat a) => BinaryOp -> ArgVal a -> ArgVal a -> Value a\nevalBinop op v1 v2 =\n case (v1, v2) of\n (Val (FloatV n1), Val (FloatV n2)) ->\n case op of\n BPlus -> FloatV $ n1 + n2\n BMinus -> FloatV $ n1 - n2\n Multiply -> FloatV $ n1 * n2\n Divide -> if n2 == 0 then error \"divide by 0!\" else FloatV $ n1 / n2\n Exp -> FloatV $ n1 ** n2\n (Val (IntV n1), Val (IntV n2)) ->\n case op of\n BPlus -> IntV $ n1 + n2\n BMinus -> IntV $ n1 - n2\n Multiply -> IntV $ n1 * n2\n Divide -> if n2 == 0 then error \"divide by 0!\" else IntV $ n1 `quot` n2 -- NOTE: not float\n Exp -> IntV $ n1 ^ n2\n -- Cannot mix int and float\n (Val _, Val _) -> error (\"wrong field types for binary op: \" ++ show v1 ++ show op ++ show v2)\n (GPI _, Val _) -> error \"binop cannot operate on GPI\"\n (Val _, GPI _) -> error \"binop cannot operate on GPI\"\n (GPI _, GPI _) -> error \"binop cannot operate on GPIs\"\n\n-- | Given a path that is a computed property of a shape (e.g. A.shape.transformation), evaluate each of its arguments (e.g. A.shape.sizeX), pass the results to the property-computing function, and return the result (e.g. an HMatrix)\ncomputeProperty :: (Autofloat a) => (Int, Int) -> BindingForm -> Field -> Property -> VaryMap a -> Translation a -> StdGen -> ComputedValue a -> (ArgVal a, Translation a, StdGen)\ncomputeProperty limit bvar field property varyMap trans g (props, compFn) =\n let args = map (\\p -> EPath $ PropertyPath bvar field p) props\n (argVals, trans', g') = evalExprs limit args trans varyMap g\n propertyValue = compFn $ map fromGPI argVals in\n (Val propertyValue, trans', g')\n where fromGPI (Val x) = x\n fromGPI (GPI x) = error \"expected value as prop fn arg, got GPI\"\n\nevalProperty :: (Autofloat a)\n => (Int, Int) -> BindingForm -> Field -> VaryMap a -> ([(Property, TagExpr a)], Translation a, StdGen) -> (Property, TagExpr a)\n -> ([(Property, TagExpr a)], Translation a, StdGen)\nevalProperty (i, n) bvar field varyMap (propertiesList, trans, g) (property, expr) =\n let path = EPath $ PropertyPath bvar field property in -- factor out?\n let (res, trans', g') = evalExpr (i, n) path trans varyMap g in\n -- This check might be redundant with the later GPI conversion in evalExpr, TODO factor out\n case res of\n Val val -> {-trace (\"Evaled property \" ++ show path)-} ((property, Done val) : propertiesList, trans', g')\n GPI _ -> error \"GPI property should not evaluate to GPI argument\" -- TODO: true later? references?\n\nevalGPI_withUpdate :: (Autofloat a)\n => (Int, Int) -> BindingForm -> Field -> (GPICtor, PropertyDict a) -> Translation a -> VaryMap a -> StdGen\n -> ((GPICtor, PropertyDict a), Translation a, StdGen)\nevalGPI_withUpdate (i, n) bvar field (ctor, properties) trans varyMap g =\n -- Fold over the properties, evaluating each path, which will update the translation each time,\n -- and accumulate the new property-value list (WITH varying looked up)\n let (propertyList', trans', g') = foldl' (evalProperty (i, n) bvar field varyMap) ([], trans, g) (M.toList properties) in\n let properties' = M.fromList propertyList' in\n {-trace (\"Start eval GPI: \" ++ show properties ++ \" \" ++ \"\\n\\tctor: \" ++ \"\\n\\tfield: \" ++ show field)-}\n ((ctor, properties'), trans', g')\n\n-- recursively evaluate, tracking iteration depth in case there are cycles in graph\nevalExpr :: (Autofloat a) => (Int, Int) -> Expr -> Translation a -> VaryMap a -> StdGen -> (ArgVal a, Translation a, StdGen)\nevalExpr (i, n) arg trans varyMap g =\n if i >= n then error (\"evalExpr: iteration depth exceeded (\" ++ show n ++ \")\")\n else {-trace (\"Evaluating expression: \" ++ show arg ++ \"\\n(i, n): \" ++ show i ++ \", \" ++ show n)-} argResult\n where limit = (i + 1, n)\n argResult = case arg of\n -- Already done values; don't change trans\n IntLit i -> (Val $ IntV i, trans, g)\n StringLit s -> (Val $ StrV s, trans, g)\n BoolLit b -> (Val $ BoolV b, trans, g)\n AFloat (Fix f) -> (Val $ FloatV (r2f f), trans, g) -- TODO: note use of r2f here. is that ok?\n AFloat Vary -> error \"evalExpr should not encounter an uninitialized varying float!\"\n\n -- Inline computation, needs a recursive lookup that may change trans, but not a path\n -- TODO factor out eval / trans computation?\n UOp op e ->\n let (val, trans', g') = evalExpr limit e trans varyMap g in\n let compVal = evalUop op val in\n (Val compVal, trans', g')\n BinOp op e1 e2 ->\n let ([v1, v2], trans', g') = evalExprs limit [e1, e2] trans varyMap g in\n let compVal = evalBinop op v1 v2 in\n (Val compVal, trans', g')\n CompApp fname args ->\n -- NOTE: the goal of all the rng passing in this module is for invoking computations with randomization\n let (vs, trans', g') = evalExprs limit args trans varyMap g\n (compRes, g'') = invokeComp fname vs compSignatures g'\n in (compRes, trans', g'')\n -- -- TODO: invokeComp should be used here\n -- case M.lookup fname compDict of\n -- Nothing -> error (\"computation '\" ++ fname ++ \"' doesn't exist\")\n -- Just f -> let res = f vs in\n -- (res, trans')\n List es ->\n let (vs, trans', g') = evalExprs limit es trans varyMap g\n floatvs = map checkFloatType vs\n in (Val $ ListV floatvs, trans', g')\n\n ListAccess p i -> error \"TODO list accesses\"\n\n Tuple e1 e2 ->\n let (vs, trans', g') = evalExprs limit [e1, e2] trans varyMap g\n [v1, v2] = map checkFloatType vs\n in (Val $ TupV (v1, v2), trans', g')\n\n -- Needs a recursive lookup that may change trans. The path case is where trans is actually changed.\n EPath p ->\n case p of\n FieldPath bvar field ->\n -- Lookup field expr, evaluate it if necessary, cache the evaluated value in the trans,\n -- return the evaluated value and the updated trans\n let fexpr = lookupFieldWithVarying bvar field trans varyMap in\n case fexpr of\n FExpr (Done v) -> (Val v, trans, g)\n FExpr (OptEval e) ->\n let (v, trans', g') = evalExpr limit e trans varyMap g in\n case v of\n Val fval ->\n case insertPath trans' (p, Done fval) of\n Right trans' -> (v, trans', g')\n Left err -> error $ concat err\n gpiVal@(GPI _) -> (gpiVal, trans', g') -- to deal with path synonyms, e.g. \"y.f = some GPI; z.f = y.f\"\n FGPI ctor properties ->\n -- Eval each property in the GPI, storing each property result in a new dictionary\n -- No need to update the translation because each path should update the translation\n let (gpiVal@(ctor', propertiesVal), trans', g') =\n evalGPI_withUpdate limit bvar field (ctor, properties) trans varyMap g in\n (GPI (ctor', shapeExprsToVals (bvarToString bvar, field) propertiesVal), trans', g')\n\n PropertyPath bvar field property ->\n let gpiType = shapeType bvar field trans in\n case M.lookup (gpiType, property) computedProperties of \n Just computeValueInfo -> computeProperty limit bvar field property varyMap trans g computeValueInfo\n Nothing -> -- Compute the path as usual\n let texpr = lookupPropertyWithVarying bvar field property trans varyMap in\n case texpr of\n Done v -> (Val v, trans, g)\n OptEval e ->\n let (v, trans', g') = evalExpr limit e trans varyMap g in\n case v of\n Val fval ->\n case insertPath trans' (p, Done fval) of\n Right trans' -> (v, trans', g')\n Left err -> error $ concat err\n GPI _ -> error (\"path to property expr '\" ++ pathStr p ++ \"' evaluated to a GPI\")\n\n -- GPI argument\n Ctor ctor properties -> error \"no anonymous/inline GPIs allowed as expressions!\"\n\n -- Error\n Layering _ _ -> error \"layering should not be an objfn arg (or in the children of one)\"\n ObjFn _ _ -> error \"objfn should not be an objfn arg (or in the children of one)\"\n ConstrFn _ _ -> error \"constrfn should not be an objfn arg (or in the children of one)\"\n AvoidFn _ _ -> error \"avoidfn should not be an objfn arg (or in the children of one)\"\n PluginAccess _ _ _ -> error \"plugin access should not be evaluated at runtime\"\n -- xs -> error (\"unmatched case in evalExpr with argument: \" ++ show xs)\n\ncheckFloatType :: (Autofloat a) => ArgVal a -> a\ncheckFloatType (Val (FloatV x)) = x\ncheckFloatType _ = error \"expected float type\"\n\n-- Any evaluated exprs are cached in the translation for future evaluation\n-- The varyMap is not changed because its values are final (set by the optimization)\nevalExprs :: (Autofloat a)\n => (Int, Int) -> [Expr] -> Translation a -> VaryMap a -> StdGen\n -> ([ArgVal a], Translation a, StdGen)\nevalExprs limit args trans varyMap g =\n foldl' (evalExprF limit varyMap) ([], trans, g) args\n where evalExprF :: (Autofloat a) => (Int, Int) -> VaryMap a -> ([ArgVal a], Translation a, StdGen) -> Expr -> ([ArgVal a], Translation a, StdGen)\n evalExprF limit varyMap (argvals, trans, rng) arg =\n let (argVal, trans', rng') = evalExpr limit arg trans varyMap rng in\n (argvals ++ [argVal], trans', rng') -- So returned exprs are in same order\n\n------------------- Generating and evaluating the objective function\n\nevalFnArgs :: (Autofloat a) => (Int, Int) -> VaryMap a -> ([FnDone a], Translation a, StdGen) -> Fn -> ([FnDone a], Translation a, StdGen)\nevalFnArgs limit varyMap (fnDones, trans, g) fn =\n let args = fargs fn in\n let (argsVal, trans', g') = evalExprs limit (fargs fn) trans varyMap g in\n let fn' = FnDone { fname_d = fname fn, fargs_d = argsVal, optType_d = optType fn } in\n (fnDones ++ [fn'], trans', g') -- TODO factor out this pattern\n\nevalFns :: (Autofloat a)\n => (Int, Int) -> [Fn] -> Translation a -> VaryMap a -> StdGen\n -> ([FnDone a], Translation a, StdGen)\nevalFns limit fns trans varyMap g = foldl' (evalFnArgs limit varyMap) ([], trans, g) fns\n\napplyOptFn :: (Autofloat a) =>\n M.Map String (OptFn a) -> OptSignatures -> FnDone a -> a\napplyOptFn dict sigs finfo =\n let (name, args) = (fname_d finfo, fargs_d finfo)\n in invokeOptFn dict name args sigs\n\napplyCombined :: (Autofloat a) => a -> [FnDone a] -> a\napplyCombined penaltyWeight fns =\n let (objfns, constrfns) = partition (\\f -> optType_d f == Objfn) fns in\n sumMap (applyOptFn objFuncDict objSignatures) objfns\n + constrWeight * penaltyWeight * sumMap (applyOptFn constrFuncDict constrSignatures) constrfns\n\n-- Main function: generates the objective function, partially applying it with some info\n\ngenObjfn :: (Autofloat a)\n => Translation a -> [Fn] -> [Fn] -> [Path]\n -> StdGen -> a -> [a]\n -> a\ngenObjfn trans objfns constrfns varyingPaths =\n \\rng penaltyWeight varyingVals ->\n let varyMap = tr \"varyingMap: \" $ mkVaryMap varyingPaths varyingVals in\n let (fnsE, transE, rng') = evalFns evalIterRange (objfns ++ constrfns) trans varyMap rng in\n applyCombined penaltyWeight fnsE\n\n--------------- Generating an initial state (concrete values for all fields/properties needed to draw the GPIs)\n-- 1. Initialize all varying fields\n-- 2. Initialize all properties of all GPIs\n\n-- NOTE: since we store all varying paths separately, it is okay to mark the default values as Done -- they will still be optimized, if needed.\n-- TODO: document the logic here (e.g. only sampling varying floats) and think about whether to use translation here or [Shape a] since we will expose the sampler to users later\ninitProperty :: (Autofloat a) => (PropertyDict a, StdGen) -> String ->\n (ValueType, SampledValue a) -> (PropertyDict a, StdGen)\ninitProperty (properties, g) pID (typ, sampleF) =\n let (v, g') = sampleF g\n autoRndVal = Done v in\n case M.lookup pID properties of\n Just (OptEval (AFloat Vary)) -> (M.insert pID autoRndVal properties, g')\n Just (OptEval e) -> (properties, g)\n Just (Done v) -> (properties, g)\n Nothing -> (M.insert pID autoRndVal properties, g')\n\ninitShape :: (Autofloat a) => (Translation a, StdGen) -> (String, Field) -> (Translation a, StdGen)\ninitShape (trans, g) (n, field) =\n case lookupField (BSubVar (VarConst n)) field trans of\n FGPI shapeType propDict ->\n let def = findDef shapeType\n (propDict', g') = foldlPropertyMappings initProperty (propDict, g) def\n -- NOTE: getShapes resolves the names + we don't use the names of the shapes in the translation\n -- The name-adding logic can be removed but is left in for debugging\n shapeName = getShapeName n field\n propDict'' = M.insert \"name\" (Done $ StrV shapeName) propDict'\n in (insertGPI trans n field shapeType propDict'', g')\n _ -> error \"expected GPI but got field\"\n\ninitShapes :: (Autofloat a) =>\n Translation a -> [(String, Field)] -> StdGen -> (Translation a, StdGen)\ninitShapes trans shapePaths gen = foldl' initShape (trans, gen) shapePaths\n\nresampleFields :: (Autofloat a) => [Path] -> StdGen -> ([a], StdGen)\nresampleFields varyingPaths g =\n let varyingFields = filter isFieldPath varyingPaths in\n Functions.randomsIn g (fromIntegral $ length varyingFields) Shapes.canvasDims\n\n-- sample varying fields only (from the range defined by canvas dims) and store them in the translation\n-- example: A.val = OPTIMIZED\ninitFields :: (Autofloat a) => [Path] -> Translation a -> StdGen -> (Translation a, StdGen)\ninitFields varyingPaths trans g =\n let varyingFields = filter isFieldPath varyingPaths\n (sampledVals, g') = Functions.randomsIn g (fromIntegral $ length varyingFields) Shapes.canvasDims\n trans' = insertPaths varyingFields (map (Done . FloatV) sampledVals) trans in\n (trans', g')\n\n------------- Evaluating all shapes in a translation\n\nevalShape :: (Autofloat a) =>\n (Int, Int) -> VaryMap a\n -> ([Shape a], Translation a, StdGen) -> Path\n -> ([Shape a], Translation a, StdGen)\nevalShape limit varyMap (shapes, trans, g) shapePath =\n let (res, trans', g') = evalExpr limit (EPath shapePath) trans varyMap g in\n case res of\n GPI shape -> (shape : shapes, trans', g')\n _ -> error \"evaluating a GPI path did not result in a GPI\"\n\n-- recursively evaluate every shape property in the translation\nevalShapes :: (Autofloat a) => (Int, Int) -> [Path] -> Translation a -> VaryMap a -> StdGen -> ([Shape a], Translation a, StdGen)\nevalShapes limit shapeNames trans varyMap rng =\n let (shapes, trans', rng') = foldl' (evalShape limit varyMap) ([], trans, rng) shapeNames in\n (reverse shapes, trans', rng')\n\n-- Given the shape names, use the translation and the varying paths/values in order to evaluate each shape\n-- with respect to the varying values\nevalTranslation :: (Autofloat a) => State -> ([Shape a], Translation a, StdGen)\nevalTranslation s =\n let varyMap = mkVaryMap (varyingPaths s) (map r2f $ varyingState s) in\n evalShapes evalIterRange (map (mkPath . list2) $ shapeNames s) (transr s) varyMap (rng s)\n\n------------- Compute global layering of GPIs\n\nlookupGPIName :: (Autofloat a) => Path -> Translation a -> String\nlookupGPIName path@(FieldPath v field) trans =\n case lookupField v field trans of\n FExpr e -> \n -- to deal with path synonyms in a layering statement (see `lookupProperty` for more explanation)\n case e of\n OptEval (EPath pathSynonym@(FieldPath vSynonym fieldSynonym)) ->\n if v == vSynonym && field == fieldSynonym\n then error (\"nontermination in lookupGPIName w/ path '\" ++ show path ++ \"' set to itself\")\n else lookupGPIName pathSynonym trans\n _ -> notGPIError\n FGPI _ _ -> getShapeName (bvarToString v) field\n\nlookupGPIName _ _ = notGPIError\nnotGPIError = error \"Layering expressions can only operate on GPIs.\"\n\n-- | Walk the translation to find all layering statements.\nfindLayeringExprs :: (Autofloat a) => Translation a -> [Expr]\nfindLayeringExprs t = foldSubObjs findLayeringExpr t\n where findLayeringExpr :: (Autofloat a) => String -> Field -> FieldExpr a -> [Expr] -> [Expr]\n findLayeringExpr name field fexpr acc =\n case fexpr of\n FExpr (OptEval x@(Layering _ _)) -> x : acc\n _ -> acc\n\n-- | Calculates all the nodes that are part of cycles in a graph.\ncyclicNodes :: Graph.Graph -> [Graph.Vertex]\ncyclicNodes graph =\n map fst . filter isCyclicAssoc . assocs $ graph\n where\n isCyclicAssoc = uncurry $ reachableFromAny graph\n\n-- | In the specified graph, can the specified node be reached, starting out\n-- from any of the specified vertices?\nreachableFromAny :: Graph.Graph -> Graph.Vertex -> [Graph.Vertex] -> Bool\nreachableFromAny graph node =\n elem node . concatMap (Graph.reachable graph)\n\n-- | 'computeLayering' takes in a list of all GPI names and a list of directed edges [(a -> b)] representing partial layering orders as input and outputs a linear layering order of GPIs\ntopSortLayering :: [String] -> [(String, String)] -> [String]\ntopSortLayering names partialOrderings =\n let orderedNodes = nodesFromEdges partialOrderings\n freeNodes = Set.difference (Set.fromList names) orderedNodes\n edges = map (\\(x, y) -> (x, x, y)) $ adjList partialOrderings\n ++ (map (\\x -> (x, [])) $ Set.toList freeNodes)\n (graph, nodeFromVertex, vertexFromKey) = Graph.graphFromEdges edges\n cyclic = not . null $ cyclicNodes graph\n in if cyclic then error \"The graph is cyclic!\" else map (getNodePart . nodeFromVertex) $ Graph.topSort graph\n where\n getNodePart (n, _, _) = n\n\nnodesFromEdges edges = Set.fromList $ concatMap (\\(a, b) -> [a, b]) edges\n\nadjList :: [(String, String)] -> [(String, [String])]\nadjList edges =\n let nodes = Set.toList $ nodesFromEdges edges\n in map (\\x -> (x, findNeighbors x)) nodes\n where findNeighbors node = map snd $ filter ((==) node . fst) edges\n\ncomputeLayering :: (Autofloat a) => Translation a -> [String]\ncomputeLayering trans =\n let layeringExprs = findLayeringExprs trans\n partialOrderings = map findNames layeringExprs\n gpiNames = map (uncurry getShapeName) $ findShapeNames trans\n in topSortLayering gpiNames partialOrderings\n where\n unused = -1\n substitute res (block, substs) =\n let block' = (block, unused)\n substs' = map (\\s -> (s, unused)) substs\n in res ++ map (`substituteBlock` block') substs'\n findNames (Layering path1 path2) = (lookupGPIName path1 trans, lookupGPIName path2 trans)\n\n------------- Main function: what the Style compiler generates\n\ngenOptProblemAndState :: (forall a. (Autofloat a) => Translation a) -> OptConfig -> State\ngenOptProblemAndState trans optConfig =\n -- Save information about the translation\n let !varyingPaths = findVarying trans in\n -- NOTE: the properties in uninitializedPaths are NOT floats. Floats are included in varyingPaths already\n let uninitializedPaths = findUninitialized trans in\n let shapeNames = findShapeNames trans in\n\n -- sample varying fields\n let (transInitFields, g') = initFields varyingPaths trans initRng in\n\n -- sample varying vals and instantiate all the non-float base properties of every GPI in the translation\n let (!transInit, g'') = initShapes transInitFields shapeNames g' in\n let shapeProperties = transInit `seq` findShapesProperties transInit in\n\n let (objfns, constrfns) = (toFns . partitionEithers . findObjfnsConstrs) transInit in\n let (defaultObjFns, defaultConstrs) = (toFns . partitionEithers . findDefaultFns) transInit in\n let (!objFnsWithDefaults, !constrsWithDefaults) = (objfns ++ defaultObjFns, constrfns ++ defaultConstrs) in\n let overallFn = genObjfn transInit objFnsWithDefaults constrsWithDefaults varyingPaths in\n -- NOTE: this does NOT use transEvaled because it needs to be re-evaled at each opt step\n -- the varying values are re-inserted at each opt step\n\n -- Evaluate all expressions once to get the initial shapes\n let initVaryingMap = M.empty in -- No optimization has happened. Sampled varying vals are in transInit\n let (initialGPIs, transEvaled, _) = evalShapes evalIterRange (map (mkPath . list2) shapeNames) transInit initVaryingMap g'' in -- intentially discarding the new random feed, since we want the computation result to be consistent within one optimization session\n let initState = lookupPaths varyingPaths transEvaled in\n\n if null initState then error \"empty state in genopt\" else\n\n -- This is the final Style compiler output\n let s = trace \"genOptProblem init state: \" $\n State { shapesr = initialGPIs,\n shapeNames = shapeNames,\n shapeProperties = shapeProperties,\n shapeOrdering = [], -- NOTE: to be populated later\n transr = transInit, -- note: NOT transEvaled\n varyingPaths = varyingPaths,\n uninitializedPaths = uninitializedPaths,\n varyingState = initState,\n objFns = objFnsWithDefaults,\n constrFns = constrsWithDefaults,\n paramsr = Params { weight = initWeight,\n optStatus = NewIter,\n overallObjFn = overallFn,\n bfgsInfo = defaultBfgsParams },\n rng = g'',\n autostep = False, -- default\n policyParams = initPolicyParams,\n policyFn = policyToUse,\n oConfig = optConfig\n } in\n\n initPolicy s\n -- NOTE: we do not resample the very first initial state. Not sure why the shapes / labels are rendered incorrectly.\n -- resampleBest numStateSamples initFullState\n\n-- | 'compileStyle' runs the main Style compiler on the AST of Style and output from the Substance compiler and outputs the initial state for the optimization problem. This function is a top-level function used by \"Server\" and \"ShadowMain\"\n-- NOTE: this function also print information out to stdout\n-- TODO: enable logger\ncompileStyle :: StyProg -> C.SubOut -> [J.StyVal] -> OptConfig -> IO State\ncompileStyle styProg (C.SubOut subProg (subEnv, eqEnv) labelMap) styVals optConfig = do\n putStrLn \"Running Style semantics\\n\"\n let selEnvs = checkSels subEnv styProg\n\n putStrLn \"Selector static semantics and local envs:\\n\"\n forM_ selEnvs pPrint\n divLine\n\n let subss = find_substs_prog subEnv eqEnv subProg styProg selEnvs\n putStrLn \"Selector matches:\\n\"\n forM_ subss pPrint\n divLine\n\n let !trans = translateStyProg subEnv eqEnv subProg styProg labelMap styVals\n :: Either [Error] (Translation Float)\n -- NOT :: forall a . (Autofloat a) => Either [Error] (Translation a)\n -- We intentionally specialize/monomorphize the translation to Float so it can be fully evaluated\n -- and is not trapped under the lambda of the typeclass (Autofloat a) => ...\n -- This greatly improves the performance of the system. See #166 for more details.\n let transAuto = castTranslation $ fromRight trans\n :: forall a . (Autofloat a) => Translation a\n putStrLn \"Translated Style program:\\n\"\n pPrint trans\n divLine\n\n let initState = genOptProblemAndState transAuto optConfig\n putStrLn \"Generated initial state:\\n\"\n print initState\n divLine\n\n -- global layering order computation\n let gpiOrdering = computeLayering transAuto\n putStrLn \"Generated GPI global layering:\\n\"\n print gpiOrdering\n divLine\n\n let initState' = initState { shapeOrdering = gpiOrdering }\n\n putStrLn (bgColor Cyan $ style Italic \" Style program warnings \")\n let warns = warnings transAuto\n putStrLn (color Red $ intercalate \"\\n\" warns ++ \"\\n\")\n return initState'\n\n-- | After monomorphizing the translation's type (to make sure it's computed), we generalize the type again, which means\n-- | it's again under a typeclass lambda. (#166)\ncastTranslation :: Translation Float -> (forall a . Autofloat a => Translation a)\ncastTranslation t =\n let res = M.map castFieldDict (trMap t) in\n t { trMap = res }\n where\n castFieldDict :: FieldDict Float -> (forall a . Autofloat a => FieldDict a)\n castFieldDict dict = M.map castFieldExpr dict\n\n castFieldExpr :: FieldExpr Float -> (forall a . (Autofloat a) => FieldExpr a)\n castFieldExpr e =\n case e of\n FExpr te -> FExpr $ castTagExpr te\n FGPI n props -> FGPI n $ M.map castTagExpr props\n\n castTagExpr :: TagExpr Float -> (forall a . Autofloat a => TagExpr a)\n castTagExpr e =\n case e of\n Done v ->\n let res = case v of\n FloatV x -> FloatV (r2f x)\n PtV (x, y) -> PtV (r2f x, r2f y)\n PtListV pts -> PtListV $ map (app2 r2f) pts\n PathDataV d -> PathDataV $ map castPath d\n -- More boilerplate not involving floats\n IntV x -> IntV x\n BoolV x -> BoolV x\n StrV x -> StrV x\n FileV x -> FileV x\n StyleV x -> StyleV x\n in Done res\n OptEval e -> OptEval e -- Expr only contains floats\n\n castPath :: Path' Float -> (forall a . Autofloat a => Path' a)\n castPath p = case p of\n Closed elems -> Closed $ map castElem elems\n Open elems -> Open $ map castElem elems\n\n castElem :: Elem Float -> (forall a . Autofloat a => Elem a)\n castElem e = case e of\n Pt pt -> Pt $ app2 r2f pt\n CubicBez pts -> CubicBez $ app3 (app2 r2f) pts\n CubicBezJoin pts -> CubicBezJoin $ app2 (app2 r2f) pts\n QuadBez pts -> QuadBez $ app2 (app2 r2f) pts\n QuadBezJoin pt -> QuadBezJoin $ app2 r2f pt\n\n-------------------------------\n-- Sampling code\n-- TODO: should this code go in the optimizer?\n\nnumStateSamples :: Int\nnumStateSamples = 500\n\n-- | Resample the varying state.\n-- | We are intentionally using a monomorphic type (float) and NOT using the translation, to avoid slowness.\nresampleVState :: [Path] -> [Shape Double] -> StdGen -> (([Shape Double], [Double], [Double]), StdGen)\nresampleVState varyPaths shapes g =\n let (resampledShapes, rng') = sampleShapes g shapes\n (resampledFields, rng'') = resampleFields varyPaths rng'\n -- make varying map using the newly sampled fields (we do not need to insert the shape paths)\n varyMapNew = mkVaryMap (filter isFieldPath $ varyPaths) resampledFields\n varyingState = shapes2floats resampledShapes varyMapNew $ varyPaths\n in ((resampledShapes, varyingState, resampledFields), rng'')\n\n-- | Update the translation to get the full state.\nupdateVState :: State -> (([Shape Double], [Double], [Double]), StdGen) -> State\nupdateVState s ((resampledShapes, varyingState', fields'), g) =\n let polyShapes = toPolymorphics resampledShapes\n uninitVals = map toTagExpr $ shapes2vals polyShapes $ uninitializedPaths s\n trans' = insertPaths (uninitializedPaths s) uninitVals (transr s)\n -- TODO: shapes', rng' = sampleConstrainedState (rng s) (shapesr s) (constrs s)\n varyMapNew = mkVaryMap (filter isFieldPath $ varyingPaths s) fields'\n in s { shapesr = polyShapes,\n rng = g,\n transr = trans' { warnings = [] }, -- Clear the warnings, since they aren't relevant anymore\n varyingState = map r2f varyingState',\n paramsr = (paramsr s) { weight = initWeight, optStatus = NewIter } }\n -- NOTE: for now we do not update the new state with the new rng from eval.\n -- The results still look different because resampling updated the rng.\n -- Therefore, we do not have to update rng here.\n\n-- | Iterate a function that uses a generator, generating an infinite list of results with their corresponding updated generators.\niterateS :: (a -> (b, a)) -> a -> [(b, a)]\niterateS f g = let (res, g') = f g in\n (res, g') : iterateS f g'\n\n-- | Compare two states and return the one with less energy.\nlessEnergyOn :: ([Double] -> Double) -> (([Shape Double], [Double], [Double]), StdGen)\n -> (([Shape Double], [Double], [Double]), StdGen) -> Ordering\nlessEnergyOn f ((_, vs1, _), _) ((_, vs2, _), _) = compare (f vs1) (f vs2)\n\n-- | Resample the varying state some number of times (sampling each new state from the original state, but with an updated rng).\n-- | Pick the one with the lowest energy and update the original state with the lowest-energy-state's info.\nresampleBest :: Int -> State -> State\nresampleBest n s =\n if n < 2 then error \"Need to sample at least two states\" else\n let optInfo = paramsr s\n -- Take out the relevant information for resampling\n f = (overallObjFn optInfo) (rng s) (float2Double $ weight optInfo)\n (varyPaths, shapes, g) = (varyingPaths s, shapesr s, rng s)\n -- Partially apply resampleVState with the params that don't change over a resampling\n resampleVStateConst = resampleVState varyPaths shapes\n sampledResults = take n $ iterateS resampleVStateConst g\n res = minimumBy (lessEnergyOn f) sampledResults\n {- (trace (\"energies: \" ++ (show $ map (\\((_, x, _), _) -> f x) sampledResults)) -}\n in initPolicy $ updateVState s res\n\n------- Other possibly-useful utility functions (not currently used)\n\n-- | Evaluate the objective function on the varying state (with the penalty weight, which should be the same between state).\nevalFnOn :: State -> Double\nevalFnOn s = let optInfo = paramsr s\n f = (overallObjFn optInfo) (rng s) (float2Double $ weight optInfo)\n args = map float2Double $ varyingState s\n in f args\n\n-- | Compare two states and return the one with less energy.\nlessEnergy :: State -> State -> Ordering\nlessEnergy s1 s2 = compare (evalFnOn s1) (evalFnOn s2)\n\n---------- List of policies that can be used with the optimizer\n\n-- Policy stops when value is None\n-- Note: if there are no objectives/constraints, policy may return an empty list of functions\n-- Policy step = one optimization through to convergence\n-- TODO: factor out number of policy steps / other boilerplate? or let it remain dynamic?\n-- TODO: factor out the weights on the objective functions / method of combination (in genObjFn)\n\ninitPolicyParams :: PolicyParams\ninitPolicyParams = PolicyParams { policyState = \"\", policySteps = 0, currFns = [] }\n\ninitPolicy :: State -> State\ninitPolicy s = -- TODO: make this less verbose\n let (policyRes, pstate) = (policyFn s) (objFns s) (constrFns s) initPolicyParams in\n let newFns = DM.fromJust policyRes in\n let stateWithPolicy = s { paramsr = (paramsr s) { overallObjFn = genObjfn (transr s) (filter isObjFn newFns) \n (filter isConstr newFns) (varyingPaths s) }, \n policyParams = initPolicyParams { policyState = pstate, currFns = newFns } } in\n stateWithPolicy\n\noptimizeConstraints :: Policy\noptimizeConstraints objfns constrfns params = \n let (pstate, psteps) = (policyState params, policySteps params) in\n if psteps == 0 then (Just constrfns, \"\")\n else (Nothing, \"\") -- Take 1 policy step\n\noptimizeObjectives :: Policy\noptimizeObjectives objfns constrfns params =\n let (pstate, psteps) = (policyState params, policySteps params) in\n if psteps == 0 then (Just objfns, \"\")\n else (Nothing, \"\") -- Take 1 policy step\n\n-- This is the typical/old Penrose policy\noptimizeSumAll :: Policy\noptimizeSumAll objfns constrfns params =\n let (pstate, psteps) = (policyState params, policySteps params) in\n if psteps == 0 then (Just $ objfns ++ constrfns, \"\")\n else (Nothing, \"\") -- Take 1 policy step\n\noptimizeConstraintsThenObjectives :: Policy\noptimizeConstraintsThenObjectives objfns constrfns params =\n let (pstate, psteps) = (policyState params, policySteps params) in\n if psteps == 0 then (Just constrfns, \"Constraints\") -- Initial policy state\n else if psteps >= 2 then (Nothing, \"Done\") -- Just constraints then objectives for now, then done\n else if pstate == \"Constraints\" then (Just objfns, \"Objectives\")\n else if pstate == \"Objectives\" then (Just constrfns, \"Constraints\")\n else error \"invalid policy state\"\n\nisObjFn f = optType f == Objfn\nisConstr f = optType f == Constrfn\n\n-- TODO: does genObjFns work with an empty list?\n", "meta": {"hexsha": "ff66a1bf157da5d4639ebb0052b06aeb8d97a159", "size": 59369, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/GenOptProblem.hs", "max_stars_repo_name": "daodaoliang/penrose", "max_stars_repo_head_hexsha": "1a76b15640f962f4da52c8aab075a633a61885e1", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2019-05-30T07:55:04.000Z", "max_stars_repo_stars_event_max_datetime": "2019-05-30T07:55:04.000Z", "max_issues_repo_path": "src/GenOptProblem.hs", "max_issues_repo_name": "daodaoliang/penrose", "max_issues_repo_head_hexsha": "1a76b15640f962f4da52c8aab075a633a61885e1", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/GenOptProblem.hs", "max_forks_repo_name": "daodaoliang/penrose", "max_forks_repo_head_hexsha": "1a76b15640f962f4da52c8aab075a633a61885e1", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 50.9605150215, "max_line_length": 263, "alphanum_fraction": 0.6200710809, "num_tokens": 14880, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.787931185683219, "lm_q2_score": 0.4225046348141882, "lm_q1q2_score": 0.33290457786579875}} {"text": "module Main where\n\nimport Data.Either\nimport DistanceGeometry\nimport Generators\nimport Numeric.LinearAlgebra\nimport Numeric.LinearAlgebra.Data\nimport ReadWrite\nimport System.Directory\n\nidir = \"test/molecules\"\nodir = \"test/results\"\n\nmain :: IO ()\nmain = do\n putStrLn \"\"\n putStrLn \"generateOneMolecule: Begin\"\n generateOneMolecule idir odir \"example\" 16\n putStrLn \"generateOneMolecule: End\"\n putStrLn \"\"\n putStrLn \"generateManyMolecules: Begin\"\n generateManyMolecules idir odir \"methan\" 16 100\n putStrLn \"generateManyMolecules: End\"\n", "meta": {"hexsha": "ad8b2604d5257c0335ae1beb6d60fcfcc8349b5b", "size": 609, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "app/Main.hs", "max_stars_repo_name": "wurthel/distance-geometry", "max_stars_repo_head_hexsha": "b0b6146a1769781d750f99217168b6f4b06d2cb4", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "app/Main.hs", "max_issues_repo_name": "wurthel/distance-geometry", "max_issues_repo_head_hexsha": "b0b6146a1769781d750f99217168b6f4b06d2cb4", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "app/Main.hs", "max_forks_repo_name": "wurthel/distance-geometry", "max_forks_repo_head_hexsha": "b0b6146a1769781d750f99217168b6f4b06d2cb4", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 25.375, "max_line_length": 49, "alphanum_fraction": 0.697865353, "num_tokens": 147, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO\n\n", "lm_q1_score": 0.6654105587468139, "lm_q2_score": 0.5, "lm_q1q2_score": 0.33270527937340694}} {"text": "{-# OPTIONS_GHC -fno-warn-type-defaults #-}\n{-# LANGUAGE FlexibleInstances #-}\n{-# LANGUAGE TypeSynonymInstances #-}\n-- ProcessingTime.hs ---\n--\n-- Filename: ProcessingTime.hs\n-- Description:\n-- Author: Manuel Schneckenreither\n-- Maintainer:\n-- Created: Tue Nov 21 10:16:08 2017 (+0100)\n-- Version:\n-- Package-Requires: ()\n-- Last-Updated:\n-- By:\n-- Update #: 69\n-- URL:\n-- Doc URL:\n-- Keywords:\n-- Compatibility:\n--\n--\n\n-- Commentary:\n--\n--\n--\n--\n\n-- Change Log:\n--\n--\n--\n--\n--\n--\n--\n\n-- Code:\n\nmodule SimSim.ProcessingTime.Type where\n\nimport ClassyPrelude\nimport qualified Data.Map.Strict as M\nimport Statistics.Distribution\nimport Statistics.Distribution.Exponential\nimport System.Random.MWC\n\nimport SimSim.Block\nimport SimSim.ProductType\nimport SimSim.Time\n\n-- ^ Use for instance Statistics.Distribution.Exponential and Statistics.Distribution to generate random numbers.\ntype ProcessingTime = GenIO -> IO Time\n\ntype ProcessingTimes = M.Map Block (M.Map ProductType ProcessingTime)\n\ntype ProcTimes = [(Block, [(ProductType, ProcessingTime)])]\n\n\nfromProcTimes :: ProcTimes -> ProcessingTimes\nfromProcTimes xs = M.fromList $ fmap (second M.fromList) xs\n\n\n-- d :: ExponentialDistribution\n-- d = exponential (1/0.8)\n\n-- test :: IO [Double]\n-- test = do\n-- g <- createSystemRandom\n-- mapM (\\_ -> genContVar d g) [1..7000]\n\n\n--\n-- ProcessingTime.hs ends here\n", "meta": {"hexsha": "3b27809bca839fb493b53652354765cfb986055e", "size": 1468, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/SimSim/ProcessingTime/Type.hs", "max_stars_repo_name": "schnecki/simsim", "max_stars_repo_head_hexsha": "05ec1f05d7270e035553ae88cf26731a3637ee3e", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/SimSim/ProcessingTime/Type.hs", "max_issues_repo_name": "schnecki/simsim", "max_issues_repo_head_hexsha": "05ec1f05d7270e035553ae88cf26731a3637ee3e", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/SimSim/ProcessingTime/Type.hs", "max_forks_repo_name": "schnecki/simsim", "max_forks_repo_head_hexsha": "05ec1f05d7270e035553ae88cf26731a3637ee3e", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 19.5733333333, "max_line_length": 113, "alphanum_fraction": 0.6498637602, "num_tokens": 354, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.6076631698328916, "lm_q2_score": 0.546738151984614, "lm_q1q2_score": 0.3322326385035478}} {"text": "{-# LANGUAGE RecordWildCards #-}\nmodule DFA where\n\nimport qualified Data.Set as Set\nimport qualified Data.Map.Strict as Map\nimport Control.Monad.State\nimport Data.Maybe\nimport Data.Semigroup (stimes)\nimport Numeric.LinearAlgebra hiding (remap, (<>))\nimport NFA\nimport Utils\nimport qualified Partition as P\nimport LruCache\n\n-- | The DFA type is parameterized on the state type, so that we can use\n-- Sets during the subset construction and then map them to integers for\n-- better efficiency.\ndata DFA s c = DFA\n { dfaStart :: s\n , dfaFinal :: Set.Set s\n , dfaStates :: Set.Set s\n , dfaTransitions :: Set.Set (c, s, s)\n }\n deriving Show\n\n-- | At first, the DFA states are sets of NFA states\ntype DfaState1 = Set.Set NfaState\n\n-- | Then, the sets are mapped into integers\ntype DfaState2 = Int\n\n----------------------------------------------------------------------\n-- The subset construction\n----------------------------------------------------------------------\n\n-- | Return all epsilon-edges from an NFA state\nepsilonEdges :: Ord c => NFA (Maybe c) -> NfaState -> Set.Set NfaState\nepsilonEdges NFA{nfaTransitions} s =\n fromMaybe mempty . Map.lookup Nothing . fromMaybe mempty . Map.lookup s $\n transitionMap nfaTransitions\n\n-- | Compute an epsilon-closure\nepsilonClosure :: Ord c => NFA (Maybe c) -> Set.Set NfaState -> Set.Set NfaState\nepsilonClosure nfa = go mempty\n where\n go !seen0 !new0\n | Set.null new0 = seen0\n | otherwise =\n let\n seen1 = Set.union seen0 new0\n new1 = Set.difference (sconcatMap (epsilonEdges nfa) new0) seen0\n in go seen1 new1\n\n-- | @move nfa s a@ is a set of NFA states where we can get from one of the\n-- states in @s@ after receiving @a@ as an input\nmove :: Ord c => NFA (Maybe c) -> DfaState1 -> c -> DfaState1\nmove NFA{nfaTransitions} ss c = sconcatMap\n (\\s -> fromMaybe mempty . Map.lookup (Just c) .\n fromMaybe mempty . Map.lookup s $\n transitionMap nfaTransitions)\n ss\n\n-- | Build a DFA from an NFA\nnfaToDfa :: forall c . Ord c => [c] -> NFA (Maybe c) -> DFA DfaState1 c\nnfaToDfa alphabet nfa =\n let\n start :: DfaState1\n start = epsilonClosure nfa (nfaStart nfa)\n transitions = go Set.empty (Set.singleton $ start) Set.empty\n all_states = concat [ [s1,s2] | (_, s1, s2) <- Set.toList transitions ]\n contains_final :: DfaState1 -> Bool\n contains_final dfa_st = not . Set.null $ Set.intersection (nfaFinal nfa) dfa_st\n in\n DFA\n { dfaStart = start\n , dfaFinal = Set.fromList $ filter contains_final all_states\n , dfaStates = Set.fromList all_states\n , dfaTransitions = transitions\n }\n where\n go\n :: Set.Set DfaState1\n -> Set.Set DfaState1\n -> Set.Set (c, DfaState1, DfaState1)\n -> Set.Set (c, DfaState1, DfaState1)\n go !seen0 !new0 !transitions0\n | Set.null new0 = transitions0\n | otherwise =\n let\n seen1 = Set.union seen0 new0\n -- where can we get from the DFA states in new1?\n (transitions1, new1) =\n flip foldMap new0 $ \\s ->\n flip foldMap alphabet $ \\c ->\n let\n next :: DfaState1\n next = epsilonClosure nfa (move nfa s c)\n in (Set.singleton (c, s, next), Set.singleton next)\n\n transitions2 = transitions0 `Set.union` transitions1\n new2 = new1 `Set.difference` seen1\n in go seen1 new2 transitions2\n\n----------------------------------------------------------------------\n-- DFA optimization\n----------------------------------------------------------------------\n\n-- | Map all DFA states\nmapStates\n :: (Ord s1, Ord s2, Ord c)\n => (s1 -> s2)\n -> DFA s1 c\n -> DFA s2 c\nmapStates remap DFA{..} =\n DFA\n { dfaStart = remap dfaStart\n , dfaFinal = Set.map remap dfaFinal\n , dfaStates = Set.map remap dfaStates\n , dfaTransitions = Set.map (\\(c,s0,s1) -> (c, remap s0, remap s1)) dfaTransitions\n }\n\n-- | Convert all states of the DFA to consecutive integers starting from 0\nmapStatesToInt\n :: (Ord s, Ord c)\n => DFA s c\n -> DFA DfaState2 c\nmapStatesToInt dfa =\n let\n stateMap = Map.fromList $ zip (Set.toList . dfaStates $ dfa) [0..]\n remap = (stateMap Map.!)\n in\n mapStates remap dfa\n\nminimizeDfa\n :: forall s c . (Ord c, Ord s)\n => DFA s c\n -> DFA Int c\nminimizeDfa dfa@DFA{..} = flip evalState 0 $ do\n initialPartition <- liftM2 (<>)\n (P.singleton dfaFinal)\n (P.singleton $ dfaStates `Set.difference` dfaFinal)\n\n let\n transitionMap :: Map.Map s (Map.Map c s)\n transitionMap = Map.fromListWith Map.union\n [ (s0, Map.singleton c s1)\n | (c, s0, s1) <- Set.toList dfaTransitions\n ]\n\n classify :: P.Partition s -> s -> Map.Map c Int\n classify pt s = fmap (P.lookupState pt) $ transitionMap Map.! s\n\n finalPartition <- P.subpartitionFixpoint classify initialPartition\n\n return $ mapStates (P.lookupState finalPartition) dfa\n\n----------------------------------------------------------------------\n-- Transfer matrices and probabilities\n----------------------------------------------------------------------\n\ndata TransferMatrix = TransferMatrix\n { tmMatrix :: Matrix Double\n -- ^ transfer matrix itself\n , tmStart :: Vector Double\n -- ^ the indicator vector of the start state\n , tmFinal :: Vector Double\n -- ^ the indicator vector of the final states\n }\n deriving (Show)\n\n-- | Construct the DFA transfer matrix assuming the uniform distribution\n-- over nucleotides.\n--\n-- Return the matrix and the 0-based indices of the start and end states.\ndfaTransferMatrix\n :: (Ord c, Ord s)\n => Map.Map c Double -- ^ character probabilities\n -> DFA s c\n -> TransferMatrix\ndfaTransferMatrix freqs (mapStatesToInt -> DFA{..}) =\n -- we remap the DFA once again to make sure the numbers are consecutive\n let\n n = Set.size dfaStates\n elts =\n [ ((s0, s1), freqs Map.! c)\n | (c, s0, s1) <- Set.toList dfaTransitions\n ]\n in\n TransferMatrix\n { tmMatrix = (assoc (n,n) 0 . assocSum) elts\n , tmStart = assoc n 0 [ (dfaStart, 1) ]\n , tmFinal = assoc n 0 [ (st, 1) | st <- Set.toList dfaFinal ]\n }\n where\n assocSum = Map.toList . Map.fromListWith (+)\n\ndfaProbability\n :: TransferMatrix\n -> Int -- ^ length of the random string where they motif may occur\n -> Double\ndfaProbability TransferMatrix{..} len =\n (tmStart <# stimes len tmMatrix) <.> tmFinal\n\ndfaProbabilityCached\n :: MonadLru Int (Matrix Double) m\n => TransferMatrix\n -> Int -- ^ length of the random string where they motif may occur\n -> m Double\ndfaProbabilityCached TransferMatrix{..} len = do\n pw <- lruPow len tmMatrix\n return $ (tmStart <# pw) <.> tmFinal\n", "meta": {"hexsha": "97d2bad72c59adfc76d2aeca8ab2220c2bd5bff1", "size": 6654, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/DFA.hs", "max_stars_repo_name": "feuerbach/motif-stats", "max_stars_repo_head_hexsha": "6d2fb78a6fed68f0d7ccddfd9383427e339533c0", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 4, "max_stars_repo_stars_event_min_datetime": "2018-10-20T11:54:01.000Z", "max_stars_repo_stars_event_max_datetime": "2021-01-31T14:46:48.000Z", "max_issues_repo_path": "src/DFA.hs", "max_issues_repo_name": "feuerbach/motif-stats", "max_issues_repo_head_hexsha": "6d2fb78a6fed68f0d7ccddfd9383427e339533c0", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/DFA.hs", "max_forks_repo_name": "feuerbach/motif-stats", "max_forks_repo_head_hexsha": "6d2fb78a6fed68f0d7ccddfd9383427e339533c0", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 31.3867924528, "max_line_length": 83, "alphanum_fraction": 0.6101593027, "num_tokens": 1855, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.6113819591324416, "lm_q2_score": 0.5428632831725052, "lm_q1q2_score": 0.3318968176070757}} {"text": "{-# LANGUAGE BangPatterns #-}\n\nmodule Data.Benchmarks.UnorderedCollections.Distributions\n ( makeRandomData\n , makeRandomVariateData\n -- * Workloads\n , insertWorkload\n , deleteWorkload\n , uniformLookupWorkload\n , exponentialLookupWorkload\n\n , loadOnly\n , loadAndUniformLookup\n , loadAndSkewedLookup\n , loadAndDeleteAll\n , loadAndDeleteSome\n , uniformlyMixed\n ) where\n\n\nimport qualified Control.Concurrent.Thread as Th\nimport Control.DeepSeq\nimport Control.Monad\nimport Control.Monad.Reader\nimport Control.Monad.Trans (liftIO)\nimport Data.Benchmarks.UnorderedCollections.Types\nimport qualified Data.Vector as V\nimport qualified Data.Vector.Mutable as MV\nimport qualified Data.Vector.Unboxed as VU\nimport Data.Vector (Vector)\nimport qualified Data.Vector.Algorithms.Shuffle as V\nimport GHC.Conc (numCapabilities)\nimport Statistics.Distribution\nimport Statistics.Distribution.Exponential\nimport System.Random.MWC\n\nimport Criterion.Collection.Types\n\n\n------------------------------------------------------------------------------\ndebug :: (MonadIO m) => String -> m ()\ndebug s = liftIO $ putStrLn s\n\n\n------------------------------------------------------------------------------\nmakeRandomData :: (NFData k) =>\n (GenIO -> IO k)\n -> Int\n -> WorkloadMonad (Vector (k,Int))\nmakeRandomData !genFunc !n = do\n rng <- getRNG\n debug $ \"making \" ++ show n ++ \" data items\"\n keys <- liftIO $ vreplicateM n rng genFunc\n let !v = keys `V.zip` vals\n let !_ = forceVector v\n debug $ \"made \" ++ show n ++ \" data items\"\n return $! v\n\n where\n vals = V.enumFromN 0 n\n\n\n------------------------------------------------------------------------------\nmakeRandomVariateData :: (Ord k, NFData k, Variate k) =>\n Int\n -> WorkloadMonad (Vector (k,Int))\nmakeRandomVariateData = makeRandomData uniform\n\n\n------------------------------------------------------------------------------\ninsertWorkload :: (NFData k) => Vector (k,Int) -> Vector (Operation k)\ninsertWorkload = mapForce $ \\(k,v) -> Insert k v\n\n\n------------------------------------------------------------------------------\ndeleteWorkload :: (NFData k) => Vector (k,Int) -> Vector (Operation k)\ndeleteWorkload = mapForce $ \\(k,_) -> Delete k\n\n\n------------------------------------------------------------------------------\nuniformLookupWorkload :: (NFData k) =>\n Vector (k,Int)\n -> Int\n -> WorkloadMonad (Vector (Operation k))\nuniformLookupWorkload !vec !ntimes = do\n rng <- getRNG\n debug $ \"uniformLookupWorkload: generating \" ++ show ntimes ++ \" lookups\"\n v <- liftIO $ vreplicateM ntimes rng f\n debug $ \"uniformLookupWorkload: done\"\n return v\n\n where\n !n = V.length vec\n f r = do\n idx <- pick\n let (k,_) = V.unsafeIndex vec idx\n return $ Lookup k\n where\n pick = uniformR (0,n-1) r\n\n\n------------------------------------------------------------------------------\nexponentialLookupWorkload :: (NFData k) =>\n Double\n -> Vector (k,Int)\n -> Int\n -> WorkloadMonad (Vector (Operation k))\nexponentialLookupWorkload !lambda !vec !ntimes = do\n rng <- getRNG\n liftIO $ vreplicateM ntimes rng f\n where\n !dist = exponential lambda\n !n = V.length vec\n !n1 = n-1\n !nd = fromIntegral n\n\n f r = do\n x <- uniformR (0.1, 7.0) r\n let idx = max 0 . min n1 . round $ nd * density dist x\n let (k,_) = V.unsafeIndex vec idx\n return $! Lookup k\n\n\n------------------------------------------------------------------------------\nloadOnly :: (NFData k) =>\n (GenIO -> IO k) -- ^ rng for keys\n -> WorkloadGenerator (Operation k)\nloadOnly !genFunc !n = return $ Workload V.empty f\n where\n f _ = liftM insertWorkload $ makeRandomData genFunc n\n\n\n------------------------------------------------------------------------------\nloadAndUniformLookup :: (NFData k) =>\n (GenIO -> IO k) -- ^ rng for keys\n -> WorkloadGenerator (Operation k)\nloadAndUniformLookup !genFunc !n = do\n !vals <- makeRandomData genFunc n\n let !inserts = insertWorkload vals\n\n return $! Workload inserts $ uniformLookupWorkload vals\n\n\n------------------------------------------------------------------------------\nloadAndSkewedLookup :: (NFData k) =>\n (GenIO -> IO k) -- ^ rng for keys\n -> WorkloadGenerator (Operation k)\nloadAndSkewedLookup !genFunc !n = do\n !vals <- makeRandomData genFunc n\n let !inserts = insertWorkload vals\n return $! Workload inserts $ exponentialLookupWorkload 1.5 vals\n\n\n------------------------------------------------------------------------------\nloadAndDeleteAll :: (NFData k) =>\n (GenIO -> IO k) -- ^ key generator\n -> WorkloadGenerator (Operation k)\nloadAndDeleteAll !genFunc !n = do\n rng <- getRNG\n !vals <- makeRandomData genFunc n\n let !inserts = insertWorkload vals\n let !deletes = deleteWorkload $ V.shuffle rng vals\n\n return $ Workload inserts (const $ return deletes)\n\n\n------------------------------------------------------------------------------\nloadAndDeleteSome :: (NFData k) =>\n (GenIO -> IO k)\n -> WorkloadGenerator (Operation k)\nloadAndDeleteSome !genFunc !n = do\n !vals <- makeRandomData genFunc n\n let !inserts = insertWorkload vals\n\n return $ Workload inserts $ f vals\n\n where\n f vals k = do\n rng <- getRNG\n return $ deleteWorkload $ V.take k $ V.shuffle rng vals\n\n\n------------------------------------------------------------------------------\nuniformlyMixed :: (NFData k) =>\n (GenIO -> IO k)\n -> Double\n -> Double\n -> WorkloadGenerator (Operation k)\nuniformlyMixed !genFunc !lookupPercentage !deletePercentage !n = do\n let !numLookups = ceiling (fromIntegral n * lookupPercentage)\n let !numDeletes = ceiling (fromIntegral n * deletePercentage)\n\n !vals <- makeRandomData genFunc n\n let !inserts = insertWorkload vals\n !lookups <- uniformLookupWorkload vals numLookups\n\n rng <- getRNG\n let !deletes = deleteWorkload $ V.take numDeletes $ V.shuffle rng vals\n let !out = V.shuffle rng $ V.concat [inserts, lookups, deletes]\n\n return $! Workload V.empty $ const $ return $ forceVector out\n\n\n------------------------------------------------------------------------------\n-- utilities\n------------------------------------------------------------------------------\nforceVector :: (NFData k) => Vector k -> Vector k\nforceVector !vec = V.foldl' force () vec `seq` vec\n where\n force x v = x `deepseq` v `deepseq` ()\n\n\nmapForce :: (NFData b) => (a -> b) -> Vector a -> Vector b\nmapForce !f !vIn = let !vOut = V.map f vIn\n in forceVector vOut\n\n\n-- split a GenIO\nsplitGenIO :: GenIO -> IO GenIO\nsplitGenIO rng = VU.replicateM 256 (uniform rng) >>= initialize\n\n\n-- vector replicateM is slow as dogshit.\nvreplicateM :: Int -> GenIO -> (GenIO -> IO a) -> IO (Vector a)\nvreplicateM n origRng act = do\n rngs <- replicateM numCapabilities (splitGenIO origRng)\n mv <- MV.new n\n let actions = map (f mv) (parts `zip` rngs)\n results <- liftM (map snd) $ mapM Th.forkIO actions\n _ <- sequence results\n V.unsafeFreeze mv\n\n where\n parts = partition (n-1) numCapabilities\n\n f mv ((low,high),rng) = do\n f' low\n where\n f' !idx | idx > high = return ()\n | otherwise = do\n x <- act rng\n MV.unsafeWrite mv idx x\n f' (idx+1)\n\n\npartition :: Int -> Int -> [(Int,Int)]\npartition n k = ys `zip` xs\n where\n xs = map f [1..k]\n ys = 0:(map (+1) xs)\n f i = (i * n) `div` k\n", "meta": {"hexsha": "af4e0c7bff557bd4fdf98b549041c398e8426b3f", "size": 8096, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "benchmark/src/Data/Benchmarks/UnorderedCollections/Distributions.hs", "max_stars_repo_name": "sanjaymsh/hashtables", "max_stars_repo_head_hexsha": "5775cf6d01d759e76b56ee650ea5efdaa61531ca", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 78, "max_stars_repo_stars_event_min_datetime": "2015-01-01T17:01:05.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-22T00:48:31.000Z", "max_issues_repo_path": "benchmark/src/Data/Benchmarks/UnorderedCollections/Distributions.hs", "max_issues_repo_name": "sanjaymsh/hashtables", "max_issues_repo_head_hexsha": "5775cf6d01d759e76b56ee650ea5efdaa61531ca", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 48, "max_issues_repo_issues_event_min_datetime": "2015-01-09T01:03:00.000Z", "max_issues_repo_issues_event_max_datetime": "2022-02-24T08:07:06.000Z", "max_forks_repo_path": "benchmark/src/Data/Benchmarks/UnorderedCollections/Distributions.hs", "max_forks_repo_name": "sanjaymsh/hashtables", "max_forks_repo_head_hexsha": "5775cf6d01d759e76b56ee650ea5efdaa61531ca", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 29, "max_forks_repo_forks_event_min_datetime": "2015-06-13T09:47:46.000Z", "max_forks_repo_forks_event_max_datetime": "2021-10-31T19:18:40.000Z", "avg_line_length": 32.126984127, "max_line_length": 78, "alphanum_fraction": 0.5074110672, "num_tokens": 1894, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.658417487156366, "lm_q2_score": 0.5039061705290805, "lm_q1q2_score": 0.33178063456234447}} {"text": "{-# LANGUAGE CPP #-}\n{-# LANGUAGE TypeFamilies #-}\n{-# LANGUAGE TypeOperators #-}\n{-# LANGUAGE FlexibleContexts #-}\n{-# LANGUAGE FlexibleInstances #-}\n{-# LANGUAGE UndecidableInstances #-}\n{-# LANGUAGE MultiParamTypeClasses #-}\n{-# LANGUAGE ScopedTypeVariables #-}\n{-# LANGUAGE DeriveFunctor #-}\n{-# LANGUAGE ScopedTypeVariables #-}\n{-# LANGUAGE DefaultSignatures #-}\n{-# LANGUAGE Trustworthy #-}\n{-# LANGUAGE TypeOperators #-}\n{-# OPTIONS_GHC -fenable-rewrite-rules #-}\n----------------------------------------------------------------------\n-- |\n-- Copyright : (c) Edward Kmett 2011-2014\n-- License : BSD3\n--\n-- Maintainer : ekmett@gmail.com\n-- Stability : experimental\n--\n-- Representable endofunctors over the category of Haskell types are\n-- isomorphic to the reader monad and so inherit a very large number\n-- of properties for free.\n----------------------------------------------------------------------\n\nmodule Data.Functor.Rep\n (\n -- * Representable Functors\n Representable(..)\n , tabulated\n -- * Wrapped representable functors\n , Co(..)\n -- * Default definitions\n -- ** Functor\n , fmapRep\n -- ** Distributive\n , distributeRep\n , collectRep\n -- ** Apply/Applicative\n , apRep\n , pureRep\n , liftR2\n , liftR3\n -- ** Bind/Monad\n , bindRep\n -- ** MonadFix\n , mfixRep\n -- ** MonadZip\n , mzipRep\n , mzipWithRep\n -- ** MonadReader\n , askRep\n , localRep\n -- ** Extend\n , duplicatedRep\n , extendedRep\n -- ** Comonad\n , duplicateRep\n , extendRep\n , extractRep\n -- ** Comonad, with user-specified monoid\n , duplicateRepBy\n , extendRepBy\n , extractRepBy\n -- ** WithIndex\n , imapRep\n , ifoldMapRep\n , itraverseRep\n\n -- ** Generics\n , GRep\n , gindex\n , gtabulate\n , WrappedRep(..)\n ) where\n\nimport Control.Applicative\nimport Control.Applicative.Backwards\nimport Control.Arrow ((&&&))\n#if __GLASGOW_HASKELL__ >= 708\nimport Data.Coerce\n#endif\nimport Control.Comonad\nimport Control.Comonad.Trans.Class\nimport Control.Comonad.Trans.Traced\nimport Control.Comonad.Cofree\nimport Control.Monad.Trans.Identity\nimport Control.Monad.Reader\n#if MIN_VERSION_base(4,4,0)\nimport Data.Complex\n#endif\nimport Data.Distributive\nimport Data.Foldable (Foldable(fold))\nimport Data.Functor.Bind\nimport Data.Functor.Identity\nimport Data.Functor.Compose\nimport Data.Functor.Extend\nimport Data.Functor.Product\nimport Data.Functor.Reverse\nimport qualified Data.Monoid as Monoid\nimport Data.Profunctor.Unsafe\nimport Data.Proxy\nimport Data.Sequence (Seq)\nimport qualified Data.Sequence as Seq\nimport Data.Semigroup hiding (Product)\nimport Data.Tagged\nimport Data.Traversable (Traversable(sequenceA))\nimport Data.Void\nimport GHC.Generics hiding (Rep)\nimport Prelude hiding (lookup)\n\n-- | A 'Functor' @f@ is 'Representable' if 'tabulate' and 'index' witness an isomorphism to @(->) x@.\n--\n-- Every 'Distributive' 'Functor' is actually 'Representable'.\n--\n-- Every 'Representable' 'Functor' from Hask to Hask is a right adjoint.\n--\n-- @\n-- 'tabulate' . 'index' \u2261 id\n-- 'index' . 'tabulate' \u2261 id\n-- 'tabulate' . 'return' \u2261 'return'\n-- @\n\nclass Distributive f => Representable f where\n -- | If no definition is provided, this will default to 'GRep'.\n type Rep f :: *\n type Rep f = GRep f\n\n -- |\n -- @\n -- 'fmap' f . 'tabulate' \u2261 'tabulate' . 'fmap' f\n -- @\n --\n -- If no definition is provided, this will default to 'gtabulate'.\n tabulate :: (Rep f -> a) -> f a\n default tabulate :: (Generic1 f, GRep f ~ Rep f, GTabulate (Rep1 f))\n => (Rep f -> a) -> f a\n tabulate = gtabulate\n\n -- | If no definition is provided, this will default to 'gindex'.\n index :: f a -> Rep f -> a\n default index :: (Generic1 f, GRep f ~ Rep f, GIndex (Rep1 f))\n => f a -> Rep f -> a\n index = gindex\n\n-- | A default implementation of 'Rep' for a datatype that is an instance of\n-- 'Generic1'. This is usually composed of 'Either', tuples, unit tuples, and\n-- underlying 'Rep' values. For instance, if you have:\n--\n-- @\n-- data Foo a = MkFoo a (Bar a) (Baz (Quux a)) deriving ('Functor', 'Generic1')\n-- instance 'Representable' Foo\n-- @\n--\n-- Then you'll get:\n--\n-- @\n-- 'GRep' Foo = Either () (Either ('WrappedRep' Bar) ('WrappedRep' Baz, 'WrappedRep' Quux))\n-- @\n--\n-- (See the Haddocks for 'WrappedRep' for an explanation of its purpose.)\ntype GRep f = GRep' (Rep1 f)\n\n-- | A default implementation of 'tabulate' in terms of 'GRep'.\ngtabulate :: (Generic1 f, GRep f ~ Rep f, GTabulate (Rep1 f))\n => (Rep f -> a) -> f a\ngtabulate = to1 . gtabulate'\n\n-- | A default implementation of 'index' in terms of 'GRep'.\ngindex :: (Generic1 f, GRep f ~ Rep f, GIndex (Rep1 f))\n => f a -> Rep f -> a\ngindex = gindex' . from1\n\ntype family GRep' (f :: * -> *) :: *\nclass GTabulate f where\n gtabulate' :: (GRep' f -> a) -> f a\nclass GIndex f where\n gindex' :: f a -> GRep' f -> a\n\ntype instance GRep' (f :*: g) = Either (GRep' f) (GRep' g)\ninstance (GTabulate f, GTabulate g) => GTabulate (f :*: g) where\n gtabulate' f = gtabulate' (f . Left) :*: gtabulate' (f . Right)\ninstance (GIndex f, GIndex g) => GIndex (f :*: g) where\n gindex' (a :*: _) (Left i) = gindex' a i\n gindex' (_ :*: b) (Right j) = gindex' b j\n\ntype instance GRep' (f :.: g) = (WrappedRep f, GRep' g)\ninstance (Representable f, GTabulate g) => GTabulate (f :.: g) where\n gtabulate' f = Comp1 $ tabulate $ fmap gtabulate' $ fmap (curry f) WrapRep\ninstance (Representable f, GIndex g) => GIndex (f :.: g) where\n gindex' (Comp1 fg) (i, j) = gindex' (index fg (unwrapRep i)) j\n\ntype instance GRep' Par1 = ()\ninstance GTabulate Par1 where\n gtabulate' f = Par1 (f ())\ninstance GIndex Par1 where\n gindex' (Par1 a) () = a\n\ntype instance GRep' (Rec1 f) = WrappedRep f\n#if __GLASGOW_HASKELL__ >= 708\n-- Using coerce explicitly here seems a bit more readable, and\n-- likely a drop easier on the simplifier.\ninstance Representable f => GTabulate (Rec1 f) where\n gtabulate' = coerce (tabulate :: (Rep f -> a) -> f a)\n :: forall a . (WrappedRep f -> a) -> Rec1 f a\ninstance Representable f => GIndex (Rec1 f) where\n gindex' = coerce (index :: f a -> Rep f -> a)\n :: forall a . Rec1 f a -> WrappedRep f -> a\n#else\ninstance Representable f => GTabulate (Rec1 f) where\n gtabulate' = Rec1 #. tabulate .# (. WrapRep)\ninstance Representable f => GIndex (Rec1 f) where\n gindex' = (. unwrapRep) #. index .# unRec1\n#endif\n\ntype instance GRep' (M1 i c f) = GRep' f\ninstance GTabulate f => GTabulate (M1 i c f) where\n gtabulate' = M1 #. gtabulate'\ninstance GIndex f => GIndex (M1 i c f) where\n gindex' = gindex' .# unM1\n\n-- | On the surface, 'WrappedRec' is a simple wrapper around 'Rep'. But it plays\n-- a very important role: it prevents generic 'Representable' instances for\n-- recursive types from sending the typechecker into an infinite loop. Consider\n-- the following datatype:\n--\n-- @\n-- data Stream a = a :< Stream a deriving ('Functor', 'Generic1')\n-- instance 'Representable' Stream\n-- @\n--\n-- With 'WrappedRep', we have its 'Rep' being:\n--\n-- @\n-- 'Rep' Stream = 'Either' () ('WrappedRep' Stream)\n-- @\n--\n-- If 'WrappedRep' didn't exist, it would be:\n--\n-- @\n-- 'Rep' Stream = Either () (Either () (Either () ...))\n-- @\n--\n-- An infinite type! 'WrappedRep' breaks the potentially infinite loop.\nnewtype WrappedRep f = WrapRep { unwrapRep :: Rep f }\n\n{-# RULES\n\"tabulate/index\" forall t. tabulate (index t) = t #-}\n\n-- | 'tabulate' and 'index' form two halves of an isomorphism.\n--\n-- This can be used with the combinators from the @lens@ package.\n--\n-- @'tabulated' :: 'Representable' f => 'Iso'' ('Rep' f -> a) (f a)@\ntabulated :: (Representable f, Representable g, Profunctor p, Functor h)\n => p (f a) (h (g b)) -> p (Rep f -> a) (h (Rep g -> b))\ntabulated = dimap tabulate (fmap index)\n{-# INLINE tabulated #-}\n\n-- * Default definitions\n\nfmapRep :: Representable f => (a -> b) -> f a -> f b\nfmapRep f = tabulate . fmap f . index\n\npureRep :: Representable f => a -> f a\npureRep = tabulate . const\n\nbindRep :: Representable f => f a -> (a -> f b) -> f b\nbindRep m f = tabulate $ \\a -> index (f (index m a)) a\n\nmfixRep :: Representable f => (a -> f a) -> f a\nmfixRep = tabulate . mfix . fmap index\n\nmzipWithRep :: Representable f => (a -> b -> c) -> f a -> f b -> f c\nmzipWithRep f as bs = tabulate $ \\k -> f (index as k) (index bs k)\n\nmzipRep :: Representable f => f a -> f b -> f (a, b)\nmzipRep as bs = tabulate (index as &&& index bs)\n\naskRep :: Representable f => f (Rep f)\naskRep = tabulate id\n\nlocalRep :: Representable f => (Rep f -> Rep f) -> f a -> f a\nlocalRep f m = tabulate (index m . f)\n\napRep :: Representable f => f (a -> b) -> f a -> f b\napRep f g = tabulate (index f <*> index g)\n\ndistributeRep :: (Representable f, Functor w) => w (f a) -> f (w a)\ndistributeRep wf = tabulate (\\k -> fmap (`index` k) wf)\n\ncollectRep :: (Representable f, Functor w) => (a -> f b) -> w a -> f (w b)\ncollectRep f w = tabulate (\\k -> (`index` k) . f <$> w)\n\nduplicateRepBy :: Representable f => (Rep f -> Rep f -> Rep f) -> f a -> f (f a)\nduplicateRepBy plus w = tabulate (\\m -> tabulate (index w . plus m))\n\nextendRepBy :: Representable f => (Rep f -> Rep f -> Rep f) -> (f a -> b) -> f a -> f b\nextendRepBy plus f w = tabulate (\\m -> f (tabulate (index w . plus m)))\n\nextractRepBy :: Representable f => (Rep f) -> f a -> a\nextractRepBy = flip index\n\nduplicatedRep :: (Representable f, Semigroup (Rep f)) => f a -> f (f a)\nduplicatedRep = duplicateRepBy (<>)\n\nextendedRep :: (Representable f, Semigroup (Rep f)) => (f a -> b) -> f a -> f b\nextendedRep = extendRepBy (<>)\n\nduplicateRep :: (Representable f, Monoid (Rep f)) => f a -> f (f a)\nduplicateRep = duplicateRepBy mappend\n\nextendRep :: (Representable f, Monoid (Rep f)) => (f a -> b) -> f a -> f b\nextendRep = extendRepBy mappend\n\nextractRep :: (Representable f, Monoid (Rep f)) => f a -> a\nextractRep = extractRepBy mempty\n\nimapRep :: Representable r => (Rep r -> a -> a') -> (r a -> r a')\nimapRep f xs = tabulate (f <*> index xs)\n\nifoldMapRep :: forall r m a. (Representable r, Foldable r, Monoid m)\n => (Rep r -> a -> m) -> (r a -> m)\nifoldMapRep ix xs = fold (tabulate (\\(i :: Rep r) -> ix i $ index xs i) :: r m)\n\nitraverseRep :: forall r f a a'. (Representable r, Traversable r, Applicative f)\n => (Rep r -> a -> f a') -> (r a -> f (r a'))\nitraverseRep ix xs = sequenceA $ tabulate (ix <*> index xs)\n\n-- * Instances\n\ninstance Representable Proxy where\n type Rep Proxy = Void\n index Proxy = absurd\n tabulate _ = Proxy\n\ninstance Representable Identity where\n type Rep Identity = ()\n index (Identity a) () = a\n tabulate f = Identity (f ())\n\ninstance Representable (Tagged t) where\n type Rep (Tagged t) = ()\n index (Tagged a) () = a\n tabulate f = Tagged (f ())\n\ninstance Representable m => Representable (IdentityT m) where\n type Rep (IdentityT m) = Rep m\n index = index .# runIdentityT\n tabulate = IdentityT #. tabulate\n\ninstance Representable ((->) e) where\n type Rep ((->) e) = e\n index = id\n tabulate = id\n\ninstance Representable m => Representable (ReaderT e m) where\n type Rep (ReaderT e m) = (e, Rep m)\n index (ReaderT f) (e,k) = index (f e) k\n tabulate = ReaderT . fmap tabulate . curry\n\ninstance (Representable f, Representable g) => Representable (Compose f g) where\n type Rep (Compose f g) = (Rep f, Rep g)\n index (Compose fg) (i,j) = index (index fg i) j\n tabulate = Compose . tabulate . fmap tabulate . curry\n\ninstance Representable w => Representable (TracedT s w) where\n type Rep (TracedT s w) = (s, Rep w)\n index (TracedT w) (e,k) = index w k e\n tabulate = TracedT . unCo . collect (Co #. tabulate) . curry\n\ninstance (Representable f, Representable g) => Representable (Product f g) where\n type Rep (Product f g) = Either (Rep f) (Rep g)\n index (Pair a _) (Left i) = index a i\n index (Pair _ b) (Right j) = index b j\n tabulate f = Pair (tabulate (f . Left)) (tabulate (f . Right))\n\ninstance Representable f => Representable (Cofree f) where\n type Rep (Cofree f) = Seq (Rep f)\n index (a :< as) key = case Seq.viewl key of\n Seq.EmptyL -> a\n k Seq.:< ks -> index (index as k) ks\n tabulate f = f Seq.empty :< tabulate (\\k -> tabulate (f . (k Seq.<|)))\n\ninstance Representable f => Representable (Backwards f) where\n type Rep (Backwards f) = Rep f\n index = index .# forwards\n tabulate = Backwards #. tabulate\n\ninstance Representable f => Representable (Reverse f) where\n type Rep (Reverse f) = Rep f\n index = index .# getReverse\n tabulate = Reverse #. tabulate\n\ninstance Representable Monoid.Dual where\n type Rep Monoid.Dual = ()\n index (Monoid.Dual d) () = d\n tabulate f = Monoid.Dual (f ())\n\ninstance Representable Monoid.Product where\n type Rep Monoid.Product = ()\n index (Monoid.Product p) () = p\n tabulate f = Monoid.Product (f ())\n\ninstance Representable Monoid.Sum where\n type Rep Monoid.Sum = ()\n index (Monoid.Sum s) () = s\n tabulate f = Monoid.Sum (f ())\n\n#if MIN_VERSION_base(4,4,0)\ninstance Representable Complex where\n type Rep Complex = Bool\n index (r :+ i) key = if key then i else r\n tabulate f = f False :+ f True\n#endif\n\ninstance Representable U1 where\n type Rep U1 = Void\n index U1 = absurd\n tabulate _ = U1\n\ninstance (Representable f, Representable g) => Representable (f :*: g) where\n type Rep (f :*: g) = Either (Rep f) (Rep g)\n index (a :*: _) (Left i) = index a i\n index (_ :*: b) (Right j) = index b j\n tabulate f = tabulate (f . Left) :*: tabulate (f . Right)\n\ninstance (Representable f, Representable g) => Representable (f :.: g) where\n type Rep (f :.: g) = (Rep f, Rep g)\n index (Comp1 fg) (i, j) = index (index fg i) j\n tabulate = Comp1 . tabulate . fmap tabulate . curry\n\ninstance Representable Par1 where\n type Rep Par1 = ()\n index (Par1 a) () = a\n tabulate f = Par1 (f ())\n\ninstance Representable f => Representable (Rec1 f) where\n type Rep (Rec1 f) = Rep f\n index = index .# unRec1\n tabulate = Rec1 #. tabulate\n\ninstance Representable f => Representable (M1 i c f) where\n type Rep (M1 i c f) = Rep f\n index = index .# unM1\n tabulate = M1 #. tabulate\n\nnewtype Co f a = Co { unCo :: f a } deriving Functor\n\ninstance Representable f => Representable (Co f) where\n type Rep (Co f) = Rep f\n tabulate = Co #. tabulate\n index = index .# unCo\n\ninstance Representable f => Apply (Co f) where\n (<.>) = apRep\n\ninstance Representable f => Applicative (Co f) where\n pure = pureRep\n (<*>) = apRep\n\ninstance Representable f => Distributive (Co f) where\n distribute = distributeRep\n collect = collectRep\n\ninstance Representable f => Bind (Co f) where\n (>>-) = bindRep\n\ninstance Representable f => Monad (Co f) where\n return = pure\n (>>=) = bindRep\n\n#if defined(__GLASGOW_HASKELL__) && __GLASGOW_HASKELL__ >= 704\ninstance (Representable f, Rep f ~ a) => MonadReader a (Co f) where\n ask = askRep\n local = localRep\n#endif\n\ninstance (Representable f, Semigroup (Rep f)) => Extend (Co f) where\n extended = extendedRep\n\ninstance (Representable f, Monoid (Rep f)) => Comonad (Co f) where\n extend = extendRep\n extract = extractRep\n\ninstance ComonadTrans Co where\n lower (Co f) = f\n\nliftR2 :: Representable f => (a -> b -> c) -> f a -> f b -> f c\nliftR2 f fa fb = tabulate $ \\i -> f (index fa i) (index fb i)\n\nliftR3 :: Representable f => (a -> b -> c -> d) -> f a -> f b -> f c -> f d\nliftR3 f fa fb fc = tabulate $ \\i -> f (index fa i) (index fb i) (index fc i)\n", "meta": {"hexsha": "8ed34d60cc81eeb4b27789a5fefe5303a63d0b24", "size": 15325, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/Data/Functor/Rep.hs", "max_stars_repo_name": "bgamari/adjunctions", "max_stars_repo_head_hexsha": "bdf0fa5e9bec62b9ef14dfb1dc0c7e8847870f88", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/Data/Functor/Rep.hs", "max_issues_repo_name": "bgamari/adjunctions", "max_issues_repo_head_hexsha": "bdf0fa5e9bec62b9ef14dfb1dc0c7e8847870f88", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/Data/Functor/Rep.hs", "max_forks_repo_name": "bgamari/adjunctions", "max_forks_repo_head_hexsha": "bdf0fa5e9bec62b9ef14dfb1dc0c7e8847870f88", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 30.8971774194, "max_line_length": 101, "alphanum_fraction": 0.636867863, "num_tokens": 4826, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.6477982043529715, "lm_q2_score": 0.5117166047041654, "lm_q1q2_score": 0.33148909766495765}} {"text": "{-# LANGUAGE RecordWildCards #-}\n\nmodule HEP.Kinematics.Variable.M2\n (\n M2Solution (..)\n\n , mkInput\n\n , m2XXSQP\n , m2CXSQP\n , m2XCSQP\n , m2CCSQP\n\n , m2XXAugLag\n , m2CXAugLag\n , m2XCAugLag\n , m2CCAugLag\n ) where\n\nimport HEP.Kinematics\nimport HEP.Kinematics.Vector.LorentzVector (setXYZT)\n\nimport Numeric.LinearAlgebra (Vector, fromList, toList)\nimport Numeric.NLOPT\n\n-- import Numeric.GSL.Differentiation\n-- import Debug.Trace\n\n-- | All the components are rescaled by '_scale'.\ndata InputKinematics = InputKinematics\n { _p1 :: FourMomentum -- ^ p1 = a1 + b1\n , _p2 :: FourMomentum -- ^ p2 = a2 + b2\n , _q1 :: FourMomentum -- ^ q1 = b1\n , _q2 :: FourMomentum -- ^ q2 = b2\n , _ptmiss :: TransverseMomentum\n -- | squared mass of the invisible particle\n , _mInvSq :: !Double\n , _scale :: !Double }\n\n-- | creates the input for the process of\n--\n-- A1 + A2 --> a1 B1 + a2 B2 --> a1 b1 C1 + a2 b2 C2.\n--\nmkInput :: [FourMomentum] -- ^ [a1, a2]\n -> [FourMomentum] -- ^ [b1, b2]\n -> TransverseMomentum -- ^ pT(miss)\n -> Double -- ^ M_{invisible}\n -> Maybe InputKinematics\nmkInput as bs ptmiss mInv\n | length as /= 2 || length bs /= 2 = Nothing\n | otherwise = do\n let ps = zipWith (+) as bs\n p1 = head ps\n p2 = ps !! 1\n\n m1 = mass p1\n m2 = mass p2\n mInvSq = mInv * mInv\n scaleSq = m1 * m1 + m2 * m2 + 2 * mInvSq\n if scaleSq <= 0 -- why?\n then Nothing\n else do let scale = sqrt scaleSq\n p1' = p1 ^/ scale\n p2' = p2 ^/ scale\n q1' = head bs ^/ scale\n q2' = (bs !! 1) ^/ scale\n ptmiss' = ptmiss ^/ scale\n mInv' = mInv / scale\n return $ InputKinematics { _p1 = p1'\n , _p2 = p2'\n , _q1 = q1'\n , _q2 = q2'\n , _ptmiss = ptmiss'\n , _mInvSq = mInv' * mInv'\n , _scale = scale }\n\ndata M2Solution = M2Solution { _M2 :: Double\n , _k1sol :: FourMomentum\n , _k2sol :: FourMomentum\n } deriving Show\n\ngetM2Solution :: InputKinematics -> Either Result Solution -> Maybe M2Solution\ngetM2Solution inp@InputKinematics {..} sol =\n case sol of\n Left _ -> Nothing\n -- sol0@(Right (Solution m2 ks _)) -> do\n Right (Solution m2 ks _) -> do\n let Invisibles k1 k2 = mkInvisibles inp (vecToVars ks)\n -- traceM (\"sol = \" ++ show sol0)\n return $ M2Solution { _M2 = m2 * _scale\n , _k1sol = k1 ^* _scale\n , _k2sol = k2 ^* _scale }\n\n{-\ninitialGuess :: InputKinematics -> Vector Double\ninitialGuess InputKinematics { _ptmiss = ptmiss } =\n fromList [0.5 * px ptmiss, 0.5 * py ptmiss, 0, 0]\n-}\ninitialGuess :: InputKinematics -> Vector Double\ninitialGuess inp@InputKinematics {..} =\n let objf ks = let Invisibles k1 k2 = mkInvisibles inp (vecToVars ks)\n in invariantMass [_p1, _p2, k1, k2]\n ks0 = fromList [0.5 * px _ptmiss, 0.5 * py _ptmiss, 0, 0]\n eps' = eps * 0.1\n stop = MaximumEvaluations 1000\n :| [ ObjectiveAbsoluteTolerance eps'\n , ObjectiveRelativeTolerance eps']\n algorithm = NELDERMEAD objf [] Nothing\n problem = LocalProblem 4 stop algorithm\n sol = minimizeLocal problem ks0\n in case sol of\n Left _ -> ks0\n Right (Solution _ ksSol _) -> ksSol\n\neps :: Double\neps = 1e-3\n\nstopObjCond :: [StoppingCondition]\nstopObjCond = [ObjectiveAbsoluteTolerance eps', ObjectiveRelativeTolerance eps']\n where eps' = eps * 1e-3\n\ntype MultivarFunc = Vector Double -> (Double, Vector Double)\n\nm2SQP :: [InputKinematics -> MultivarFunc] -- ^ constraint functions\n -> Maybe InputKinematics\n -> Maybe M2Solution\nm2SQP _ Nothing = Nothing\nm2SQP cfs (Just inp@InputKinematics {..}) =\n let -- objective function with gradient\n objfD = m2ObjF inp\n\n -- constraint function with gradient\n constraints' = ($ inp) <$> cfs\n constraints = (\\cf -> EqualityConstraint (Scalar cf) eps)\n <$> constraints'\n\n stop = MaximumEvaluations 1000 :| stopObjCond\n algorithm = SLSQP objfD [] [] constraints\n problem = LocalProblem 4 stop algorithm\n\n sol = minimizeLocal problem (initialGuess inp)\n in getM2Solution inp sol\n\nm2XXSQP, m2CXSQP, m2XCSQP, m2CCSQP :: Maybe InputKinematics -> Maybe M2Solution\nm2XXSQP = m2SQP []\nm2CXSQP = m2SQP [constraintA]\nm2XCSQP = m2SQP [constraintB]\nm2CCSQP = m2SQP [constraintA, constraintB]\n\nm2AugLag :: [InputKinematics -> MultivarFunc] -- ^ constraint functions\n -> Maybe InputKinematics\n -> Maybe M2Solution\nm2AugLag _ Nothing = Nothing\nm2AugLag cfs (Just inp@InputKinematics {..}) =\n let -- objective function without gradient\n -- objf = m2ObjF inp\n objf = getResultOnly (m2ObjF inp)\n\n -- constraint function without gradient\n constraints' = ($ inp) <$> cfs\n -- constraints = (\\cf -> EqualityConstraint (Scalar cf) eps)\n -- <$> constraints'\n constraints = (\\cf -> EqualityConstraint (Scalar (getResultOnly cf))\n eps) <$> constraints'\n\n stop = MaximumEvaluations 5000 :| stopObjCond\n -- algorithm = VAR1 objf Nothing\n -- algorithm = LBFGS objf Nothing\n -- algorithm = SLSQP objf [] [] constraints\n algorithm = NELDERMEAD objf [] Nothing\n\n subproblem = LocalProblem 4 stop algorithm\n -- problem = AugLagProblem [] constraints (AUGLAG_EQ_LOCAL subproblem)\n problem = AugLagProblem constraints [] (AUGLAG_EQ_LOCAL subproblem)\n\n sol = minimizeAugLag problem (initialGuess inp)\n in getM2Solution inp sol\n where\n getResultOnly :: MultivarFunc -> Vector Double -> Double\n getResultOnly fD ks = let (result, _) = fD ks in result\n\nm2XXAugLag, m2CXAugLag, m2XCAugLag, m2CCAugLag\n :: Maybe InputKinematics -> Maybe M2Solution\nm2XXAugLag = m2AugLag []\nm2CXAugLag = m2AugLag [constraintA]\nm2XCAugLag = m2AugLag [constraintB]\nm2CCAugLag = m2AugLag [constraintA, constraintB]\n\n-- | (k1x, k1y, k1z, k2z).\ntype Variables = (Double, Double, Double, Double)\n\n-- | unsafe transformation, but it would be fine.\nvecToVars :: Vector Double -> Variables\nvecToVars ks = let [k1x, k1y, k1z, k2z] = toList ks in (k1x, k1y, k1z, k2z)\n\ndata Invisibles = Invisibles { _k1 :: FourMomentum , _k2 :: FourMomentum }\n\nmkInvisibles :: InputKinematics -> Variables -> Invisibles\nmkInvisibles InputKinematics {..} (k1x, k1y, k1z, k2z) = Invisibles k1 k2\n where\n eInv1 = sqrt (k1x * k1x + k1y * k1y + k1z * k1z + _mInvSq)\n k1 = eInv1 `seq` setXYZT k1x k1y k1z eInv1\n\n k2x = px _ptmiss - k1x\n k2y = py _ptmiss - k1y\n eInv2 = sqrt (k2x * k2x + k2y * k2y + k2z * k2z + _mInvSq)\n k2 = eInv2 `seq` setXYZT k2x k2y k2z eInv2\n\n-- | the unknowns are (k1x, k2x, k1z, k2z).\nm2ObjF :: InputKinematics -> MultivarFunc\nm2ObjF inp@InputKinematics {..} ks =\n if m1 < m2 then (m2, grad2) else (m1, grad1)\n where\n invs = mkInvisibles inp (vecToVars ks)\n (grad1, grad2, m1, m2) = m2Grad inp invs _p1 _p2 ks\n\nm2Grad :: InputKinematics\n -> Invisibles\n -> FourMomentum -- ^ p1 (or q1)\n -> FourMomentum -- ^ p2 (or q2)\n -> Vector Double\n -> (Vector Double, Vector Double, Double, Double)\nm2Grad InputKinematics {..} (Invisibles k1 k2) p1 p2 ks = (d1, d2, m1, m2)\n where\n (k1x, k1y, k1z, k2z) = vecToVars ks\n\n (e1, p1x, p1y, p1z) = epxpypz p1\n m1 = invariantMass [p1, k1]\n m1' = safeDivisor m1\n r1 = e1 / safeDivisor (energy k1)\n d1 = fromList $ ( / m1') <$> [ r1 * k1x - p1x\n , r1 * k1y - p1y\n , r1 * k1z - p1z\n , 0 ]\n\n (e2, p2x, p2y, p2z) = epxpypz p2\n m2 = invariantMass [p2, k2]\n m2' = safeDivisor m2\n r2 = e2 / safeDivisor (energy k2)\n d2 = fromList $ ( / m2') <$> [ r2 * (k1x - px _ptmiss) + p2x\n , r2 * (k1y - py _ptmiss) + p2y\n , 0\n , r2 * k2z - p2z ]\n\nconstraintF :: FourMomentum -> FourMomentum -> InputKinematics -> MultivarFunc\nconstraintF p1 p2 inp ks = (m1 - m2, grad1 - grad2)\n where\n invs = mkInvisibles inp (vecToVars ks)\n (grad1, grad2, m1, m2) = m2Grad inp invs p1 p2 ks\n\nconstraintA, constraintB :: InputKinematics -> MultivarFunc\nconstraintA inp@InputKinematics {..} = constraintF _p1 _p2 inp\nconstraintB inp@InputKinematics {..} = constraintF _q1 _q2 inp\n\nsafeDivisor :: Double -> Double\nsafeDivisor x | x >= 0 = max eps0 x\n | otherwise = min (-eps0) x\n where eps0 = 1.0e-8\n\n{-\nm2ObjF :: InputKinematics -> MultivarFunc\nm2ObjF inp ks = (m, d)\n where\n ks0 = vecToVars ks\n m = fst $ m2ObjF' inp ks0\n d = m2ObjFDNumeric inp ks0\n\nm2ObjF' :: InputKinematics -> Variables -> (Double, Vector Double)\nm2ObjF' inp@InputKinematics {..} ks =\n if m1 < m2 then (m2, grad2) else (m1, grad1)\n where\n invs@(Invisibles k1 k2) = mkInvisibles inp ks\n m1 = invariantMass [_p1, k1]\n m2 = invariantMass [_p2, k2]\n (k1x, k1y, k1z, k2z) = ks\n (grad1, grad2, _) = m2Grad inp invs _p1 _p2 (fromList [k1x, k1y, k1z, k2z])\n\nm2ObjFDNumeric :: InputKinematics -> Variables -> Vector Double\nm2ObjFDNumeric inp@InputKinematics {..} = fDNumeric f\n where f ks = fst (m2ObjF' inp ks)\n\nm2GradNumeric :: InputKinematics\n -> Invisibles\n -> FourMomentum -- ^ p1 (or q1)\n -> FourMomentum -- ^ p2 (or q2)\n -> Vector Double\n -> (Vector Double, Vector Double, Double)\nm2GradNumeric inp@(InputKinematics {..}) _ p1 p2 ks = (d1, d2, m1 - m2)\n where\n ks0 = vecToVars ks\n\n m1F ks' = let Invisibles k1 _ = mkInvisibles inp ks'\n in invariantMass [p1, k1]\n m1 = m1F ks0\n d1 = fDNumeric m1F ks0\n\n m2F ks' = let Invisibles _ k2 = mkInvisibles inp ks'\n in invariantMass [p2, k2]\n m2 = m2F ks0\n d2 = fDNumeric m2F ks0\n\nfDNumeric :: (Variables -> Double) -> Variables -> Vector Double\nfDNumeric f (k1x, k1y, k1z, k2z) = fromList [fk1xD, fk1yD, fk1zD, fk2zD]\n where\n fk1x a = f (a, k1y, k1z, k2z)\n fk1y a = f (k1x, a, k1z, k2z)\n fk1z a = f (k1x, k1y, a, k2z)\n fk2z a = f (k1x, k1y, k1z, a)\n\n epsN = 1e-8\n\n fk1xD = fst $ derivCentral epsN fk1x k1x\n fk1yD = fst $ derivCentral epsN fk1y k1y\n fk1zD = fst $ derivCentral epsN fk1z k1z\n fk2zD = fst $ derivCentral epsN fk2z k2z\n-}\n", "meta": {"hexsha": "3ac7bc0139b052fafd28bc3f5d8a940793bfed25", "size": 11388, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/HEP/Kinematics/Variable/M2.hs", "max_stars_repo_name": "cbpark/hyam2", "max_stars_repo_head_hexsha": "07fc829ebc5703ad042268a2ea160777bb00eae9", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/HEP/Kinematics/Variable/M2.hs", "max_issues_repo_name": "cbpark/hyam2", "max_issues_repo_head_hexsha": "07fc829ebc5703ad042268a2ea160777bb00eae9", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/HEP/Kinematics/Variable/M2.hs", "max_forks_repo_name": "cbpark/hyam2", "max_forks_repo_head_hexsha": "07fc829ebc5703ad042268a2ea160777bb00eae9", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 35.9242902208, "max_line_length": 80, "alphanum_fraction": 0.5524236038, "num_tokens": 3670, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.7772998611746912, "lm_q2_score": 0.42632159254749036, "lm_q1q2_score": 0.33137971470293753}} {"text": "-- | https://en.wikibooks.org/wiki/Write_Yourself_a_Scheme_in_48_Hours/Parsing\n\nmodule Main where\n\nimport Control.Monad\nimport Data.Char (digitToInt, isDigit)\nimport Data.Complex\nimport Data.Ratio (denominator, numerator, (%))\nimport Numeric (readDec, readFloat, readHex,\n readInt, readOct)\nimport System.Environment\nimport Text.ParserCombinators.Parsec hiding (spaces)\n\nsymbol :: Parser Char\nsymbol = oneOf \"!$%&|*+-/:<=>?@^_~\" \"a symbol\"\n\n-- readExpr :: String -> Either ParseError LispVal\n-- readExpr = parse parseExpr \"lisp\"\n\n-- Whitespace\nspaces :: Parser ()\nspaces = skipMany1 space\n\n-- Return Values\ndata LispVal = Atom String\n | List [LispVal]\n | DottedList [LispVal] LispVal\n | Number Integer\n | Float Double\n | Ratio Rational\n | Complex (Complex Double)\n | Character Char\n | String String\n | Bool Bool\n\nparseString :: Parser LispVal\nparseString = do\n char '\"'\n str <- many (parseHelper <|> noneOf \"\\\\\\\"\")\n char '\"'\n return $ String str\n \"a string for parseString\"\n where parseHelper :: Parser Char\n parseHelper = do\n char '\\\\'\n x <- oneOf \"\\\\\\\"nrt\"\n return $ case x of\n '\\\\' -> x\n '\"' -> x\n 'n' -> '\\n'\n 'r' -> '\\r'\n 't' -> '\\t'\n\nparseAtom :: Parser LispVal\nparseAtom = do\n first <- letter <|> symbol\n rest <- many $ letter <|> symbol <|> digit\n return $ Atom (first : rest)\n \"a atom for parseAtom\"\n\nparseBool :: Parser LispVal\nparseBool = do\n x <- try (string \"#t\") <|> string \"#f\"\n return $ if x == \"#t\"\n then Bool True\n else Bool False\n\nparseNumber :: Parser LispVal\nparseNumber = parseDigit <|> try parseOct <|> try parseDec <|> try parseHex <|> parseBin\n where parseOct = do\n char '#' >> oneOf \"oO\"\n str <- many1 octDigit\n let [(n, _)] = readOct str\n return $ Number n\n parseDec = do\n char '#' >> oneOf \"dD\"\n str <- many1 digit\n let [(n, _)] = readDec str\n return $ Number n\n parseHex = do\n char '#' >> oneOf \"xX\"\n str <- many1 hexDigit\n let [(n, _)] = readHex str\n return $ Number n\n parseBin = do\n char '#' >> oneOf \"bB\"\n str <- many1 $ oneOf \"01\"\n let [(n, _)] = readInt 2 (`elem` \"01\") digitToInt str\n return $ Number n\n parseDigit = do\n str <- many1 digit\n return $ (Number . read) str\n\nparseChar :: Parser LispVal\nparseChar = do\n string \"#\\\\\"\n x <- many $ letter <|> digit\n return $ case length x of\n 0 -> Character '\\n'\n 1 -> Character $ head x\n _ -> case x of\n \"newline\" -> Character '\\n'\n \"tab\" -> Character '\\t'\n \"space\" -> Character ' '\n\nparseFloat :: Parser LispVal\nparseFloat = do\n x <- many1 digit\n char '.'\n y <- many1 digit\n return $ let [(n, _)] = readFloat (x ++ '.' : y) in Float n\n\nparseRatio :: Parser LispVal\nparseRatio = do\n x <- many1 digit\n char '/'\n y <- many1 digit\n return $ Ratio (read x % read y)\n\nparseComplex :: Parser LispVal\nparseComplex = do\n x <- try parseFloat <|> parseNumber\n char '+'\n y <- try parseFloat <|> parseNumber\n char 'i'\n return $ Complex (toDouble x :+ toDouble y)\n where toDouble :: LispVal -> Double\n toDouble (Float f) = f\n toDouble (Number n) = fromIntegral n\n\n-- Recursive Parsers: Adding lists, dotted lists, and quoted datums\n\nparseList :: Parser LispVal\nparseList = do\n char '('\n x <- sepBy parseExpr spaces\n char ')'\n return $ List x\n\nparseDottedList :: Parser LispVal\nparseDottedList = do\n char '('\n x <- endBy parseExpr spaces\n y <- char '.' >> spaces >> parseExpr\n char ')'\n return $ DottedList x y\n\nparseQuoted :: Parser LispVal\nparseQuoted = do\n char '\\''\n x <- parseExpr\n return $ List [Atom \"quote\", x]\n\nparseBackquote :: Parser LispVal\nparseBackquote = do\n char '`'\n x <- parseExpr\n return $ List [Atom \"quasiquote\", x]\n\nparseUnquote :: Parser LispVal\nparseUnquote = do\n char ','\n y <- parseExpr\n return $ List [Atom \"unquote\", y]\n\nparseUnquoteSplicing :: Parser LispVal\nparseUnquoteSplicing = do\n char ',' >> char '@'\n y <- parseExpr\n return $ List [Atom \"unquote-splicing\", y]\n\nparseExpr :: Parser LispVal\nparseExpr = parseAtom\n <|> try parseBool\n <|> try parseRatio\n <|> try parseComplex\n <|> try parseFloat\n <|> try parseNumber\n <|> parseChar\n <|> parseString\n <|> try parseList\n <|> parseDottedList\n <|> parseQuoted\n <|> parseBackquote\n <|> try parseUnquoteSplicing\n <|> parseUnquote\n\n\n-- Beginning the Evaluator\nshowVal :: LispVal -> String\nshowVal (Atom x) = x\nshowVal (Bool True) = \"#t\"\nshowVal (Bool False) = \"#f\"\nshowVal (Ratio x) = show (numerator x) ++ ('/' : show (denominator x))\nshowVal (Complex x) = show (realPart x) ++ ('+' : show (imagPart x) ++ \"i\")\nshowVal (Float x) = show x\nshowVal (Number x) = show x\nshowVal (Character x) = \"#\\\\\" ++ show x\nshowVal (String x) = \"\\\"\" ++ x ++ \"\\\"\"\nshowVal (List x) = \"(\" ++ unwordsList x ++ \")\"\nshowVal (DottedList first rest)= \"(\" ++ unwordsList first ++ \" . \" ++ showVal rest ++ \")\"\n\nunwordsList :: [LispVal] -> String\nunwordsList = unwords . map showVal\n\ninstance Show LispVal where\n show = showVal\n\nreadExpr :: String -> LispVal\nreadExpr input = case parse parseExpr \"lisp\" input of\n Left err -> String $ \"No match: \" ++ show err\n Right val -> val\n\n-- Beginnings of an evaluator: Primitives\nmain :: IO ()\nmain = getArgs >>= print . eval . readExpr . head\n\neval :: LispVal -> LispVal\neval val@(String _) = val\neval val@(Bool _) = val\neval val@(Ratio _) = val\neval val@(Complex _) = val\neval val@(Float _) = val\neval val@(Number _) = val\neval val@(Character _) = val\neval (List [Atom \"quote\", val]) = val\n\n-- Adding basic primitives\neval (List (Atom func : args)) = apply func $ map eval args\n\napply :: String -> [LispVal] -> LispVal\napply func args = maybe (Bool False) ($ args) $ lookup func primitives\n\nprimitives :: [(String, [LispVal] -> LispVal)]\nprimitives = [(\"+\", numericBinop (+)),\n (\"-\", numericBinop (-)),\n (\"*\", numericBinop (*)),\n (\"/\", numericBinop div),\n (\"mod\", numericBinop mod),\n (\"quotient\", numericBinop quot),\n (\"remainder\", numericBinop rem),\n (\"symbol?\", unaryOp symbolp),\n (\"string?\", unaryOp stringp),\n (\"number?\", unaryOp numberp),\n (\"bool?\", unaryOp boolp),\n (\"list?\", unaryOp listp),\n (\"pair?\", unaryOp pairp)]\n\nnumericBinop :: (Integer -> Integer -> Integer) -> [LispVal] -> LispVal\nnumericBinop op args = Number $ foldl1 op $ map unpackNum args\n where unpackNum :: LispVal -> Integer\n unpackNum (Number n) = n\n unpackNum (String n) = let parsed = readDec n in\n if null parsed\n then 0\n else fst $ head parsed\n unpackNum (List [n]) = unpackNum n\n unpackNum _ = 0\n\nunaryOp :: (LispVal -> LispVal) -> [LispVal] -> LispVal\nunaryOp op [x] = op x\n\nsymbolp :: LispVal -> LispVal\nsymbolp (Atom _) = Bool True\nsymbolp _ = Bool False\n\nstringp :: LispVal -> LispVal\nstringp (String _) = Bool True\nstringp _ = Bool False\n\nnumberp :: LispVal -> LispVal\nnumberp (Number _) = Bool True\nnumberp _ = Bool False\n\nboolp :: LispVal -> LispVal\nboolp (Bool _) = Bool True\nboolp _ = Bool False\n\nlistp :: LispVal -> LispVal\nlistp (List _) = Bool True\nlistp _ = Bool False\n\npairp :: LispVal -> LispVal\npairp (List _) = Bool True\npairp (DottedList _ _) = Bool True\npairp _ = Bool False\n", "meta": {"hexsha": "5b9a3cde3f511bf511e0dcaca07aa32bba8a088b", "size": 7885, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "WriteYourselfAScheme/sec3-evaluation/exercises/ex1.hs", "max_stars_repo_name": "zeqing-guo/Haskell-Exercises", "max_stars_repo_head_hexsha": "54f84d2f3ab98469d2e670170f679c0bf51e9774", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "WriteYourselfAScheme/sec3-evaluation/exercises/ex1.hs", "max_issues_repo_name": "zeqing-guo/Haskell-Exercises", "max_issues_repo_head_hexsha": "54f84d2f3ab98469d2e670170f679c0bf51e9774", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "WriteYourselfAScheme/sec3-evaluation/exercises/ex1.hs", "max_forks_repo_name": "zeqing-guo/Haskell-Exercises", "max_forks_repo_head_hexsha": "54f84d2f3ab98469d2e670170f679c0bf51e9774", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 27.4738675958, "max_line_length": 89, "alphanum_fraction": 0.5682942295, "num_tokens": 2183, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.5736784074525098, "lm_q2_score": 0.5774953651858118, "lm_q1q2_score": 0.3312966214110021}} {"text": "{-# LANGUAGE DataKinds #-}\n{-# LANGUAGE FlexibleContexts #-}\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE OverloadedStrings #-}\n{-# LANGUAGE PolyKinds #-}\n{-# LANGUAGE ScopedTypeVariables #-}\n{-# LANGUAGE TypeApplications #-}\n{-# LANGUAGE TypeOperators #-}\n{-# LANGUAGE QuasiQuotes #-}\n{-# OPTIONS_GHC -fplugin=Polysemy.Plugin #-}\n--{-# LANGUAGE AllowAmbiguousTypes #-}\n\nimport qualified Control.Foldl as FL\n\nimport qualified Data.List as L\nimport qualified Data.Map as M\nimport qualified Data.Vector as VB\nimport qualified Data.Text as T\n\nimport qualified Text.Printf as PF\n\nimport qualified Data.Vinyl as V\nimport qualified Frames as F\nimport qualified Frames.CSV as F\n\nimport qualified Pipes as P\nimport qualified Pipes.Prelude as P\n\nimport qualified Numeric.LinearAlgebra as LA\n\nimport qualified Frames.Visualization.VegaLite.Data\n as FV\nimport qualified Frames.Visualization.VegaLite.StackedArea\n as FV\nimport qualified Frames.Visualization.VegaLite.LineVsTime\n as FV\nimport qualified Frames.Visualization.VegaLite.ParameterPlots\n as FV\nimport qualified Frames.Visualization.VegaLite.Correlation\n as FV\n\nimport qualified Frames.Transform as FT\nimport qualified Frames.Folds as FF\nimport qualified Frames.MapReduce as MR\nimport qualified Frames.Enumerations as FE\nimport qualified Frames.Utils as FU\n\nimport qualified Knit.Report as K\nimport Polysemy.Error ( Error )\n\nimport Data.String.Here ( here )\n\nimport BlueRipple.Configuration\nimport BlueRippleUtilitie.KnitUtils\nimport BlueRipple.Data.DataFrames\nimport BlueRipple.Data.MRP\nimport qualified BlueRipple.Model.TurnoutAdjustment\n as TA\n\ntemplateVars = M.fromList\n [ (\"lang\" , \"English\")\n , (\"author\" , \"Adam Conner-Sax & Frank David\")\n , (\"pagetitle\", \"Preference Model & Predictions\")\n-- , (\"tufte\",\"True\")\n ]\n\n{- TODO\n1. Why are rows still being dropped? Which col is missing? In general, write a diagnostic for showing what is missing...\nSome answers:\nThe boring: CountyFIPS. I don't want this anyway. Dropped\nThe weird: Missing voted_rep_party. These are non-voters or voters who didn't vote in house race. A bit more than 1/3 of\nsurvey responses. Maybe that's not weird??\n-}\n\nmain :: IO ()\nmain = do\n let template = K.FromIncludedTemplateDir \"mindoc-pandoc-KH.html\"\n-- let template = K.FullySpecifiedTemplatePath \"pandoc-templates/minWithVega-pandoc.html\"\n pandocWriterConfig <- K.mkPandocWriterConfig template\n templateVars\n K.mindocOptionsF\n eitherDocs <-\n K.knitHtmls (Just \"MRP_Basics.Main\") K.logAll pandocWriterConfig $ do\n K.logLE K.Info \"Loading data...\"\n let csvParserOptions =\n F.defaultParser { F.quotingMode = F.RFC4180Quoting ' ' }\n tsvParserOptions = csvParserOptions { F.columnSeparator = \"\\t\" }\n preFilterYears = FU.filterOnMaybeField @CCESYear (`L.elem` [2016])\n ccesMaybeRecs <- loadToMaybeRecs @CCES_MRP_Raw @(F.RecordColumns CCES)\n tsvParserOptions\n preFilterYears\n ccesTSV\n ccesFrame <-\n fmap transformCCESRow\n <$> maybeRecsToFrame fixCCESRow (const True) ccesMaybeRecs\n let firstFew = take 4 $ FL.fold FL.list ccesFrame\n K.logLE K.Diagnostic\n $ \"ccesFrame (first 4 rows):\\n\"\n <> (T.pack $ show firstFew)\n K.logLE K.Info \"Inferring...\"\n K.logLE K.Info \"Knitting docs...\"\n case eitherDocs of\n Right namedDocs ->\n K.writeAllPandocResultsWithInfoAsHtml \"reports/html/MRP_Basics\" namedDocs\n Left err -> putStrLn $ \"pandoc error: \" ++ show err\n", "meta": {"hexsha": "89a21480b3a2f76a00c2593c27568254f8b814fc", "size": 4362, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "reports/MRP_Basics.hs", "max_stars_repo_name": "blueripple/preference-model", "max_stars_repo_head_hexsha": "beae97c2d854830bc0e9027609e54166f93d976b", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2019-07-24T11:32:48.000Z", "max_stars_repo_stars_event_max_datetime": "2019-07-24T11:32:48.000Z", "max_issues_repo_path": "reports/MRP_Basics.hs", "max_issues_repo_name": "blueripple/preference-model", "max_issues_repo_head_hexsha": "beae97c2d854830bc0e9027609e54166f93d976b", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "reports/MRP_Basics.hs", "max_forks_repo_name": "blueripple/preference-model", "max_forks_repo_head_hexsha": "beae97c2d854830bc0e9027609e54166f93d976b", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 41.1509433962, "max_line_length": 123, "alphanum_fraction": 0.5843649702, "num_tokens": 944, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO\n\n", "lm_q1_score": 0.7122321964553657, "lm_q2_score": 0.46490157137338844, "lm_q1q2_score": 0.33111786731481946}} {"text": "module BondCalculus.StochPyExtraction\n (stochPyModel, generateStochPy, reaction, ReactionVect, reactions, ReactionSystem(..), extractReactionSystem, fromIVPToStochPyModel, simulateStochPy) where\n\nimport BondCalculus.Symbolic\nimport BondCalculus.Vector\nimport BondCalculus.AST\nimport BondCalculus.Base\nimport qualified BondCalculus.AST as AST\nimport BondCalculus.Transitions (MTS)\nimport Data.Bifunctor\nimport BondCalculus.Simulation (Trace)\n-- import qualified Data.HashMap.Strict as H\n-- import BondCalculus.Simulation (Trace)\n-- import Data.String.Utils\nimport BondCalculus.ODEExtraction (sympyExpr, IVP(..), sympySimplify, runPython)\n-- , runPython)\n\n-- import qualified Control.Exception as X\nimport qualified Data.Map as M\nimport qualified Data.List as L\nimport Data.Maybe\nimport BondCalculus.Processes\n\n--import qualified Numeric.LinearAlgebra as LA\n\n-- import System.IO.Unsafe\n-- import qualified System.Process as OS\n-- import System.Process (readProcess)\n-- import Data.Maybe\n\ntype ReactionVect k = Vect (Tensor (ProcessVect Conc) (ProcessVect Conc)) k\n\nreaction :: (Vector k (DirectionVect k), Vector k (ReactionVect k), Nullable (DirectionVect k), Expression k) =>\n [DirectionVect k] -> ReactionVect k\nreaction = multilinear react' <$> filter (/=vectZero)\n where react' xs = vect( sourceVect xs :* targetVect xs )\n source (spec :* _) = spec\n targetVect xs = embed $ concretify $ foldl (<|>) (mkAbsBase Nil) (map target xs)\n target (_ :* spec') = spec'\n sourceVect xs = foldl (+>) vectZero (map (embed.source) xs)\n\nreactions :: (Vector k (ProcessVect k), Show k, DoubleExpression k, ExpressionOver Double k) => (Species -> MTS) -> ConcreteAffinityNetwork Double -> ProcessVect k -> ReactionVect k\nreactions tr network p = simplify $ dPdt'' reaction tr network p\n\ntype ConcVect = Vect String Conc\nnewtype ReactionSystem = ReactionSystem ([String], [(SymbolicExpr Double, ConcVect, ConcVect)], [Double])\n deriving (Show, Eq, Ord)\n\nextractReactionSystem :: AST.Env -> ConcreteAffinityNetwork Double -> P' Double -> [Double] -> ReactionSystem\nextractReactionSystem env network p inits = ReactionSystem (vars, transitions, inits)\n where tr = tracesGivenNetwork network env\n vars = map (pretty.simplify.snd) (toList p)\n reacts = reactions tr network p\n transitions = [ (simplify coeff, toConcVect u, toConcVect v)\n | (coeff, u :* v) <- toList reacts]\n toConcVect = fromList . map (second (pretty.simplify)) . toList\n\nfromIVPToStochPyModel :: IVP Double -> Either String String\nfromIVPToStochPyModel ivp =\n if any isNothing exprs\n then Left \"An ODE equation has an unbound variable\"\n else Right $\n \"Output_In_Conc: True\\n\" ++\n \"Species_In_Conc: True\\n\\n\" ++\n L.intercalate \"\\n\" rules ++ \"\\n\" ++\n L.intercalate \"\\n\" initlines\n where\n species = [\"S\" ++ show i | i <- [(0::Integer)..]]\n varmap = M.fromList $ zip vars species\n IVP (vars,rhss,inits) = ivp\n mkgrowrule spec y =\n \"grow\" ++ spec ++ \":\\n\" ++\n \"\\t$pool > \" ++ spec ++ \"\\n\" ++\n \"\\t\" ++ mkgrowrate y ++ \"\\n\"\n mkgrowrate y = \"abs(\" ++ y ++ \" + abs(\" ++ y ++ \"))/2\"\n mkdecayrule spec y =\n \"decay\" ++ spec ++ \":\\n\" ++\n \"\\t\" ++ spec ++ \" > $pool\\n\" ++\n \"\\t\" ++ mkdecayrate y ++ \"\\n\"\n mkdecayrate y = \"abs(-\" ++ y ++ \" + abs(\" ++ y ++ \"))/2\"\n exprs = map (sympyExpr varmap) rhss\n growrules = zipWith mkgrowrule species (catMaybes exprs)\n decayrules = zipWith mkdecayrule species (catMaybes exprs)\n rules = zipWith (\\x y -> x ++ \"\\n\" ++ y) growrules decayrules\n initlines = [y ++ \" = \" ++ show y0 | (y,y0) <- zip species inits]\n\nstochPyModel :: ReactionSystem -> Double -> Either String String\nstochPyModel (ReactionSystem (vars, transitions, inits)) h =\n if any isNothing transitions'\n then Left \"An ODE equation has an unbound variable\"\n else Right $\n \"Output_In_Conc: True\\n\" ++\n \"Species_In_Conc: True\\n\\n\" ++\n L.intercalate \"\\n\" rules ++ \"\\n\" ++\n \"h = \" ++ show h ++ \"\\n\" ++\n L.intercalate \"\\n\" initlines\n where\n species = [\"S\" ++ show i | i <- [(0::Integer)..]]\n reacts = [\"R\" ++ show i | i <- [(0::Integer)..]]\n varmap = M.fromList $ zip vars species\n varmaph = fmap (\\s -> \"(\" ++ s ++ \"*h)\") varmap\n rules = [\n i ++ \":\\n\" ++\n \"\\t\" ++ formatVector u ++ \" > \" ++ formatVector v ++ \"\\n\" ++\n \"\\t\" ++ rate ++ \"\\n\"\n | (i, (rate, u, v)) <- reacts `zip` catMaybes transitions'\n ]\n transitions' = fmap (\\(rate,u,v) -> do\n rate' <- sympyExpr varmaph rate\n u' <- vectorVarLookup u\n v' <- vectorVarLookup v\n return (sympySimplify (\"(\" ++ rate' ++ \")/h\"),u',v')) transitions\n vectorVarLookup u =\n let us = map (second (`M.lookup` varmap)) $ toList u\n in if any (isNothing.snd) us\n then Nothing\n else Just (fromList [(k,v) | (k, Just v) <- us])\n formatVector u = if null us\n then \"$pool\"\n else L.intercalate \" + \"\n [\"{\" ++ show k ++ \"} \" ++ i | (k,i) <- us]\n where us = toList u\n initlines = [y ++ \" = \" ++ show (y0/h) | (y,y0) <- zip species inits]\n\n\ngenerateStochPy :: String -> AST.Env -> ConcreteAffinityNetwork Double -> P' Double -> Double -> [Double] -> IO String\ngenerateStochPy filename env network p h inits = case stochPyModel (extractReactionSystem env network p inits) h of\n Right script -> do\n -- putStrLn $ \"Python script:\\n\\n\" ++ script\n writeFile filename script\n return script\n Left _ -> undefined\n\nsimulateStochPy :: String -> Int -> AST.Env -> ConcreteAffinityNetwork Double -> P' Double -> Double -> [Double] -> IO Trace\nsimulateStochPy method steps env network p h inits = case stochPyModel (extractReactionSystem env network p inits) h of\n Right stochpy -> do\n -- putStrLn $ \"Python script:\\n\\n\" ++ script\n writeFile \"/tmp/stochpy.psc\" stochpy\n let script = \"import os, sys\\n\" ++\n \"f = open(os.devnull, 'w')\\n\" ++\n \"stdout = sys.stdout\\n\" ++\n \"sys.stdout = f\\n\" ++\n \"import stochpy\\n\" ++\n \"smod = stochpy.SSA()\\n\" ++\n \"smod.Model('/tmp/stochpy.psc')\\n\" ++\n \"smod.DoStochSim(method='\" ++ method ++ \"', end=\" ++\n show steps ++ \", mode='time')\\n\" ++\n \"sys.stdout=stdout\\n\" ++\n \"xss = smod.data_stochsim.getSimData(\" ++ L.intercalate \",\" [\"'S\" ++ show i ++ \"'\" | (i,_) <- [0..] `zip` kis] ++ \")\\n\" ++\n \"xss[:,1:] *= \" ++ show h ++ \"\\n\" ++\n \"for xs in xss:\\n\" ++\n \" print(' '.join(map('{:.18f}'.format, list(xs))))\\n\"\n writeFile \"stochpy_script.py\" script\n res <- runPython script\n let yss = (map (map read.words) $ lines res) :: [[Double]]\n return [ (head ys, toP (tail ys)) | ys <- yss ]\n Left _ -> undefined\n where toP ks = fromList [(k,i) | (k, (_,i)) <- ks `zip` kis]\n kis = toList p\n", "meta": {"hexsha": "07863240d465aa99f0bc430c91118e93cf373eb1", "size": 7115, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "bondlib/BondCalculus/StochPyExtraction.hs", "max_stars_repo_name": "twright/bondwb", "max_stars_repo_head_hexsha": "5557788f8cdf780fa2899ca29eb926ed5c3ab205", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2018-05-04T20:00:47.000Z", "max_stars_repo_stars_event_max_datetime": "2019-08-16T11:54:15.000Z", "max_issues_repo_path": "bondlib/BondCalculus/StochPyExtraction.hs", "max_issues_repo_name": "twright/bondwb", "max_issues_repo_head_hexsha": "5557788f8cdf780fa2899ca29eb926ed5c3ab205", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "bondlib/BondCalculus/StochPyExtraction.hs", "max_forks_repo_name": "twright/bondwb", "max_forks_repo_head_hexsha": "5557788f8cdf780fa2899ca29eb926ed5c3ab205", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 44.46875, "max_line_length": 181, "alphanum_fraction": 0.5914265636, "num_tokens": 2003, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.712232184238947, "lm_q2_score": 0.4649015713733885, "lm_q1q2_score": 0.3311178616353872}} {"text": "{-# LANGUAGE BangPatterns #-}\nmodule Polestar.Eval\n (termShift\n ,termTypeSubst\n ,termSubstD\n ,termSubst\n ,ValueBinding(..)\n ,getValueFromContext\n ,eval1\n ,eval\n ) where\nimport Polestar.Type\nimport Polestar.TypeCheck\nimport Data.Complex\nimport GHC.Float (expm1, log1p)\n\ntermSubstD :: Int -> Term -> Int -> Term -> Term\ntermSubstD !depth s !i t = case t of\n TmAbs name ty body -> TmAbs name (typeShift (-1) i ty) (termSubstD depth s (i + 1) body)\n TmTyAbs name bound body -> TmTyAbs name (typeShift (-1) i <$> bound) (termSubstD depth s (i + 1) body)\n TmRef j | j == i -> termShift depth 0 s\n | j > i -> TmRef (j - 1)\n | otherwise -> t\n TmApp u v -> TmApp (termSubstD depth s i u) (termSubstD depth s i v)\n TmTyApp u t -> TmTyApp (termSubstD depth s i u) (typeShift (-1) i t)\n TmLet name def body -> TmLet name (termSubstD depth s i def) (termSubstD depth s (i + 1) body) -- ?\n TmIf cond then_ else_ -> TmIf (termSubstD depth s i cond) (termSubstD depth s i then_) (termSubstD depth s i else_)\n TmPrim _ -> t\n TmCoerce x ty -> TmCoerce (termSubstD depth s i x) (typeShift (-1) i ty)\n TmAlt name tys body -> TmAlt name (map (typeShift (-1) i) tys) (termSubstD depth s (i + 1) body)\n TmTuple components -> TmTuple $ termSubstD depth s i <$> components\n TmProj tuple j -> TmProj (termSubstD depth s i tuple) j\n TmCoherentTuple components -> TmCoherentTuple $ termSubstD depth s i <$> components\n\n-- replaces occurrences of TRef j (j > i) with TRef (j-1), and TRef i with the given term\ntermSubst = termSubstD 0\n\nnatFromValue :: Term -> Either String Integer\nnatFromValue (TmPrim (PVZero)) = return 0\nnatFromValue (TmPrim (PVInt x)) | x >= 0 = return x\nnatFromValue _ = Left \"type error (expected a natural number)\"\n\nintFromValue :: Term -> Either String Integer\nintFromValue (TmPrim (PVZero)) = return 0\nintFromValue (TmPrim (PVInt x)) = return x\nintFromValue _ = Left \"type error (expected an integer)\"\n\nnnrealFromValue :: Term -> Either String Double\nnnrealFromValue (TmPrim (PVZero)) = return 0\nnnrealFromValue (TmPrim (PVInt x)) | x >= 0 = return (fromIntegral x)\nnnrealFromValue (TmPrim (PVReal x)) | x >= 0 = return x\nnnrealFromValue _ = Left \"type error (expected a non-negative real number)\"\n\nrealFromValue :: Term -> Either String Double\nrealFromValue (TmPrim (PVZero)) = return 0\nrealFromValue (TmPrim (PVInt x)) = return (fromIntegral x)\nrealFromValue (TmPrim (PVReal x)) = return x\nrealFromValue _ = Left \"type error (expected a real number)\"\n\nimaginaryFromValue :: Term -> Either String Double\nimaginaryFromValue (TmPrim (PVZero)) = return 0\nimaginaryFromValue (TmPrim (PVImaginary x)) = return x\nimaginaryFromValue _ = Left \"type error (expected an imaginary number)\"\n\ncomplexFromValue :: Term -> Either String (Complex Double)\ncomplexFromValue (TmPrim (PVZero)) = return 0\ncomplexFromValue (TmPrim (PVInt x)) = return (fromIntegral x)\ncomplexFromValue (TmPrim (PVReal x)) = return (x:+0)\ncomplexFromValue (TmPrim (PVImaginary x)) = return (0:+x)\ncomplexFromValue (TmPrim (PVComplex z)) = return z\ncomplexFromValue _ = Left \"type error (expected a complex number)\"\n\nboolFromValue :: Term -> Either String Bool\nboolFromValue (TmPrim (PVBool x)) = return x\nboolFromValue _ = Left \"type error (expected a boolean)\"\n\napplyBuiltinUnary :: Builtin -> Term -> Either String Term\napplyBuiltinUnary f v = case f of\n BNegate -> case v of\n TmPrim PVZero -> return v\n TmPrim (PVInt x) -> return (TmPrim $ PVInt $ negate x)\n TmPrim (PVReal x) -> return (TmPrim $ PVReal $ negate x)\n TmPrim (PVImaginary x) -> return (TmPrim $ PVImaginary $ negate x)\n TmPrim (PVComplex x) -> return (TmPrim $ PVComplex $ negate x)\n _ -> Left \"type error (expected an integer or a real number)\"\n BLogicalNot -> (TmPrim . PVBool . not) <$> boolFromValue v\n BNatToInt -> (TmPrim . PVInt) <$> natFromValue v\n BNatToNNReal -> (TmPrim . PVReal . fromIntegral) <$> natFromValue v\n BIntToNat -> (\\x -> if x >= 0 then TmPrim (PVInt x) else TmPrim PVZero) <$> intFromValue v\n BIntToReal -> (TmPrim . PVReal . fromIntegral) <$> intFromValue v\n BNNRealToReal -> (TmPrim . PVReal) <$> realFromValue v\n BRealToComplex -> (TmPrim . PVComplex . (:+0)) <$> realFromValue v\n BMkImaginary -> (TmPrim . PVImaginary) <$> realFromValue v\n BImaginaryToComplex -> (TmPrim . PVComplex . (0:+)) <$> imaginaryFromValue v\n BRealPart -> case v of\n TmPrim PVZero -> return v\n TmPrim (PVInt _) -> return v\n TmPrim (PVReal _) -> return v\n TmPrim (PVImaginary _) -> return $ TmPrim PVZero\n TmPrim (PVComplex z) -> return $ TmPrim (PVReal (realPart z))\n _ -> Left \"type error (expected a complex number)\"\n BImagPart -> case v of\n TmPrim PVZero -> return $ TmPrim PVZero\n TmPrim (PVInt _) -> return $ TmPrim PVZero\n TmPrim (PVReal _) -> return $ TmPrim PVZero\n TmPrim (PVImaginary x) -> return $ TmPrim (PVReal x)\n TmPrim (PVComplex z) -> return $ TmPrim (PVReal (imagPart z))\n _ -> Left \"type error (expected a complex number)\"\n BAbs -> case v of\n TmPrim PVZero -> return $ TmPrim PVZero\n TmPrim (PVInt x) -> return $ TmPrim (PVInt (abs x))\n TmPrim (PVReal x) -> return $ TmPrim (PVReal (abs x))\n TmPrim (PVImaginary x) -> return $ TmPrim (PVReal (abs x))\n TmPrim (PVComplex z) -> return $ TmPrim (PVReal (magnitude z))\n _ -> Left \"type error (expected a complex number)\"\n BSqrt -> case v of\n TmPrim PVZero -> return $ TmPrim PVZero\n TmPrim (PVInt x) | x >= 0 -> return $ TmPrim (PVReal (sqrt $ fromIntegral x))\n TmPrim (PVReal x) | x >= 0 -> return $ TmPrim (PVReal (sqrt x))\n TmPrim (PVImaginary x) -> return $ TmPrim (PVComplex (sqrt (0:+x)))\n TmPrim (PVComplex z) -> return $ TmPrim (PVComplex (sqrt z))\n _ -> Left \"type error (expected a complex number)\"\n BExp -> makeOverloadedFn [(TmPrim . PVReal . exp) <$> realFromValue v\n ,(TmPrim . PVComplex . exp) <$> complexFromValue v\n ]\n BExpm1 -> makeOverloadedFn [(TmPrim . PVReal . expm1) <$> realFromValue v\n ,(TmPrim . PVComplex . expm1) <$> complexFromValue v\n ]\n BLog -> makeOverloadedFn [(TmPrim . PVReal . log) <$> nnrealFromValue v\n ,(TmPrim . PVComplex . log) <$> complexFromValue v\n ]\n BLog1p -> makeOverloadedFn [(TmPrim . PVReal . log1p) <$> nnrealFromValue v\n ,(TmPrim . PVComplex . log1p) <$> complexFromValue v\n ]\n BSin -> makeOverloadedFn [(TmPrim . PVReal . sin) <$> realFromValue v\n ,(TmPrim . PVImaginary . sinh) <$> imaginaryFromValue v\n ,(TmPrim . PVComplex . sin) <$> complexFromValue v\n ]\n BCos -> makeOverloadedFn [(TmPrim . PVReal . cos) <$> realFromValue v\n ,(TmPrim . PVReal . cosh) <$> imaginaryFromValue v\n ,(TmPrim . PVComplex . cos) <$> complexFromValue v\n ]\n BTan -> makeOverloadedFn [(TmPrim . PVReal . tan) <$> realFromValue v\n ,(TmPrim . PVComplex . tan) <$> complexFromValue v\n ]\n BSinh -> makeOverloadedFn [(TmPrim . PVReal . sinh) <$> realFromValue v\n ,(TmPrim . PVImaginary . sin) <$> imaginaryFromValue v\n ,(TmPrim . PVComplex . sinh) <$> complexFromValue v\n ]\n BCosh -> makeOverloadedFn [(TmPrim . PVReal . cosh) <$> realFromValue v\n ,(TmPrim . PVReal . cos) <$> imaginaryFromValue v\n ,(TmPrim . PVComplex . cosh) <$> complexFromValue v\n ]\n BTanh -> makeOverloadedFn [(TmPrim . PVReal . tan) <$> realFromValue v\n ,(TmPrim . PVImaginary . tanh) <$> imaginaryFromValue v\n ,(TmPrim . PVComplex . tan) <$> complexFromValue v\n ]\n BAsin -> makeOverloadedFn [(TmPrim . PVImaginary . asinh) <$> imaginaryFromValue v\n ,(TmPrim . PVComplex . asin) <$> complexFromValue v\n ]\n BAcos -> makeOverloadedFn [(TmPrim . PVComplex . acos) <$> complexFromValue v\n ]\n BAtan -> makeOverloadedFn [(TmPrim . PVReal . atan) <$> realFromValue v\n ,(TmPrim . PVComplex . atan) <$> complexFromValue v\n ]\n BAsinh -> makeOverloadedFn [(TmPrim . PVReal . asinh) <$> realFromValue v\n ,(TmPrim . PVComplex . asinh) <$> complexFromValue v\n ]\n BAcosh -> makeOverloadedFn [(TmPrim . PVReal . acosh) <$> realFromValue v\n ]\n BAtanh -> makeOverloadedFn [(TmPrim . PVImaginary . atan) <$> imaginaryFromValue v\n ,(TmPrim . PVComplex . atanh) <$> complexFromValue v\n ]\n _ -> Left \"applyBuiltinUnary: not unary\"\n\nmakeOverloadedFn :: [Either String Term] -> Either String Term\nmakeOverloadedFn [] = Left \"no overload\"\nmakeOverloadedFn [x] = x\nmakeOverloadedFn (Left _ : xs) = makeOverloadedFn xs\nmakeOverloadedFn (Right x : xs) = Right x\n\nisZero :: Term -> Bool\nisZero (TmPrim PVZero) = True\nisZero _ = False\n\nisNonNegative :: Term -> Bool\nisNonNegative (TmPrim PVZero) = True\nisNonNegative (TmPrim (PVInt x)) = x >= 0\nisNonNegative (TmPrim (PVReal x)) = x >= 0\nisNonNegative _ = False\n\napplyBuiltinBinary :: Builtin -> Term -> Term -> Either String Term\napplyBuiltinBinary f u v = case f of\n BAdd -> makeOverloadedFn [if isZero u && isZero v then return (TmPrim PVZero) else Left \"not zero\"\n ,(TmPrim . PVInt) <$> ((+) <$> intFromValue u <*> intFromValue v)\n ,(TmPrim . PVReal) <$> ((+) <$> realFromValue u <*> realFromValue v)\n ,(TmPrim . PVImaginary) <$> ((+) <$> imaginaryFromValue u <*> imaginaryFromValue v)\n ,(TmPrim . PVComplex) <$> ((+) <$> complexFromValue u <*> complexFromValue v)\n ]\n BSub -> makeOverloadedFn [if isZero u && isZero v then return (TmPrim PVZero) else Left \"not zero\"\n ,(TmPrim . PVInt) <$> ((-) <$> intFromValue u <*> intFromValue v)\n ,(TmPrim . PVReal) <$> ((-) <$> realFromValue u <*> realFromValue v)\n ,(TmPrim . PVImaginary) <$> ((-) <$> imaginaryFromValue u <*> imaginaryFromValue v)\n ,(TmPrim . PVComplex) <$> ((-) <$> complexFromValue u <*> complexFromValue v)\n ]\n BMul -> makeOverloadedFn [if isZero u || isZero v then return (TmPrim PVZero) else Left \"not zero\"\n ,(TmPrim . PVInt) <$> ((*) <$> intFromValue u <*> intFromValue v)\n ,(TmPrim . PVReal) <$> ((*) <$> realFromValue u <*> realFromValue v)\n ,(TmPrim . PVImaginary) <$> ((*) <$> realFromValue u <*> imaginaryFromValue v)\n ,(TmPrim . PVImaginary) <$> ((*) <$> imaginaryFromValue u <*> realFromValue v)\n ,(TmPrim . PVReal . negate) <$> ((*) <$> imaginaryFromValue u <*> imaginaryFromValue v)\n ,(TmPrim . PVComplex) <$> ((*) <$> complexFromValue u <*> complexFromValue v)\n ]\n BDiv -> makeOverloadedFn [(TmPrim . PVReal) <$> ((/) <$> realFromValue u <*> realFromValue v)\n ,(TmPrim . PVImaginary) <$> ((/) <$> imaginaryFromValue u <*> realFromValue v)\n ,(TmPrim . PVImaginary . negate) <$> ((/) <$> realFromValue u <*> imaginaryFromValue v)\n ,(TmPrim . PVReal) <$> ((/) <$> imaginaryFromValue u <*> imaginaryFromValue v)\n ,(TmPrim . PVComplex) <$> ((/) <$> complexFromValue u <*> complexFromValue v)\n ]\n BPow -> makeOverloadedFn [if isZero v then return (TmPrim (PVInt 1)) else Left \"not zero\"\n ,(TmPrim . PVInt) <$> ((^) <$> intFromValue u <*> natFromValue v)\n ,(TmPrim . PVReal) <$> ((**) <$> nnrealFromValue u <*> realFromValue v)\n ,(TmPrim . PVReal) <$> ((^^) <$> realFromValue u <*> intFromValue v)\n ,(TmPrim . PVComplex) <$> ((**) <$> complexFromValue u <*> complexFromValue v)\n ]\n BTSubNat -> do u' <- natFromValue u\n v' <- natFromValue v\n let w | u' >= v' = u' - v'\n | otherwise = 0\n return (TmPrim (PVInt w))\n BLt -> (TmPrim . PVBool) <$> ((<) <$> realFromValue u <*> realFromValue v)\n BLe -> (TmPrim . PVBool) <$> ((<=) <$> realFromValue u <*> realFromValue v)\n BEqual -> (TmPrim . PVBool) <$> ((==) <$> complexFromValue u <*> complexFromValue v)\n BMax -> makeOverloadedFn [(TmPrim . PVInt) <$> (max <$> intFromValue u <*> intFromValue v)\n ,(TmPrim . PVReal) <$> (max <$> realFromValue u <*> realFromValue v)\n ]\n BMin -> makeOverloadedFn [if (isZero u && isNonNegative v) || (isZero v && isNonNegative u) then return (TmPrim PVZero) else Left \"not zero\"\n ,(TmPrim . PVInt) <$> (min <$> intFromValue u <*> intFromValue v)\n ,(TmPrim . PVReal) <$> (min <$> realFromValue u <*> realFromValue v)\n ]\n BIntDiv -> (TmPrim . PVInt) <$> (div <$> intFromValue u <*> intFromValue v)\n BIntMod -> (TmPrim . PVInt) <$> (mod <$> intFromValue u <*> intFromValue v)\n BGcd -> (TmPrim . PVInt) <$> (gcd <$> intFromValue u <*> intFromValue v)\n BLcm -> (TmPrim . PVInt) <$> (lcm <$> intFromValue u <*> intFromValue v)\n BLogicalAnd -> (TmPrim . PVBool) <$> ((&&) <$> boolFromValue u <*> boolFromValue v)\n BLogicalOr -> (TmPrim . PVBool) <$> ((||) <$> boolFromValue u <*> boolFromValue v)\n _ -> Left \"not implemented yet; sorry\"\n\ndata ValueBinding = ValueBind !Term\n | TypeBind\n deriving (Eq,Show)\n\ngetValueFromContext :: [ValueBinding] -> Int -> Term\ngetValueFromContext ctx i\n | i < length ctx = case ctx !! i of\n ValueBind x -> x\n b -> error (\"TRef: expected a variable binding, found \" ++ show b)\n | otherwise = error \"TRef: index out of bounds\"\n\neval1 :: [ValueBinding] -> Term -> Either String Term\neval1 ctx t = case t of\n TmPrim _ -> return t\n TmAbs _ _ _ -> return t\n TmTyAbs _ _ _ -> return t\n TmRef i -> return $ getValueFromContext ctx i\n TmApp u v\n | isValue u && isValue v -> case u of\n TmAbs _name _ty body -> return $ termSubst v 0 body -- no type checking here\n TmPrim (PVBuiltin f) | isUnary f -> applyBuiltinUnary f v\n TmPrim (PVBuiltin _) -> return t -- partial application\n TmApp (TmPrim (PVBuiltin f)) u' | isBinary f -> applyBuiltinBinary f u' v\n TmApp (TmApp (TmTyApp (TmPrim (PVBuiltin BIterate)) ty) n) z -> do\n n' <- natFromValue n\n if n' == 0\n then return $ z\n else return $ TmApp (TmApp (TmApp (TmTyApp (TmPrim (PVBuiltin BIterate)) ty) (TmPrim (PVInt (n' - 1)))) (TmApp v z)) v\n _ -> Left \"invalid function application (expected function type)\"\n | isValue u -> TmApp u <$> (eval1 ctx v)\n | otherwise -> TmApp <$> (eval1 ctx u) <*> pure v\n TmTyApp u ty\n | isValue u -> case u of\n TmTyAbs _name _bound body -> return $ termTypeSubst ty 0 body\n _ -> Left \"invalid type application (expected forall type)\"\n | otherwise -> TmTyApp <$> eval1 ctx u <*> pure ty\n TmLet name def body\n | isValue def -> return $ termSubst def 0 body\n | otherwise -> TmLet name <$> eval1 ctx def <*> pure body\n TmIf cond then_ else_\n | isValue cond -> case cond of\n TmPrim (PVBool True) -> return then_ -- no type checking here\n TmPrim (PVBool False) -> return else_ -- no type checking here\n _ -> Left \"if-then-else: condition must be boolean\"\n | otherwise -> TmIf <$> (eval1 ctx cond) <*> pure then_ <*> pure else_\n TmCoerce x ty\n | isValue x -> return x\n | otherwise -> TmCoerce <$> eval1 ctx x <*> pure ty\n TmAlt name tys x\n | isValue x -> return $ termTypeSubst TyUnit 0 x -- dummy type\n | otherwise -> TmAlt name tys <$> eval1 ctx x\n TmTuple components -> case span isValue components of\n (_,[]) -> return t\n (v,w:ws) -> eval1 ctx w >>= \\w' -> return (TmTuple (v ++ (w':ws)))\n TmProj tuple j\n | isValue tuple -> case tuple of\n TmTuple components | length components > j -> return $ components !! j\n | otherwise -> Left \"tuple too short\"\n _ -> Left \"projection: not a tuple\"\n | otherwise -> TmProj <$> eval1 ctx tuple <*> pure j\n TmCoherentTuple components -> Left \"coherenet tuple: not supported yet\"\n\neval :: [ValueBinding] -> Term -> Either String Term\neval ctx t | isValue t = return t\n | otherwise = eval1 ctx t >>= eval ctx\n", "meta": {"hexsha": "aec78765ea8928ad203c6734fadb5d4f78c04374", "size": 17036, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/Polestar/Eval.hs", "max_stars_repo_name": "minoki/polestar", "max_stars_repo_head_hexsha": "df73b793c65b1f6e7bc618b3175d6661a6722240", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/Polestar/Eval.hs", "max_issues_repo_name": "minoki/polestar", "max_issues_repo_head_hexsha": "df73b793c65b1f6e7bc618b3175d6661a6722240", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/Polestar/Eval.hs", "max_forks_repo_name": "minoki/polestar", "max_forks_repo_head_hexsha": "df73b793c65b1f6e7bc618b3175d6661a6722240", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 54.2547770701, "max_line_length": 142, "alphanum_fraction": 0.5809462315, "num_tokens": 4945, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6619228758499942, "lm_q2_score": 0.5, "lm_q1q2_score": 0.3309614379249971}} {"text": "module HNNWrapper\n (\n\n ) where\n\nimport AI.HNN.FF.Network\nimport Numeric.LinearAlgebra\nimport Numeric.LinearAlgebra.HMatrix\nimport Foreign.Storable\nimport System.Random\nimport qualified Data.Vector as V\n\n\n\n\nrandomizeMatrixValue :: V.Vector (Matrix a) -> IO (V.Vector (Matrix a))\nrandomizeMatrixValue = undefined\n\nsetMatrixValue :: (Element a) => (Int, Int) -> a -> Matrix a -> Matrix a\nsetMatrixValue (i,j) a matrix = fromRows newRows\n where\n oldRows = toRows matrix\n oldRow = oldRows !! i\n newRow = fromList $ replaceElement j a (toList oldRow)\n newRows = replaceElement i newRow oldRows\n \n(!!+) :: Maybe [a] -> Int -> Maybe a\n(!!+) Nothing _ = Nothing\n(!!+) (Just list) i = if i >= length list || i < 0 then Nothing else Just (list !! i)\n\nreplaceElement :: Int -> a -> [a] -> [a]\nreplaceElement i x xs = let (ys,zs) = splitAt i xs\n in if length zs > 0 then ys ++ [x] ++ (tail zs)\n else ys ++ [x]\n", "meta": {"hexsha": "3d52b4ab80ff9593d37c492778d8bc22e873e91f", "size": 970, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "local-dpp/src/HNNWrapper.hs", "max_stars_repo_name": "eklinkhammer/local-dpp", "max_stars_repo_head_hexsha": "d2ab7c6b4827d92d6a38bc3ab23069dab858e94f", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "local-dpp/src/HNNWrapper.hs", "max_issues_repo_name": "eklinkhammer/local-dpp", "max_issues_repo_head_hexsha": "d2ab7c6b4827d92d6a38bc3ab23069dab858e94f", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2016-10-06T02:09:26.000Z", "max_issues_repo_issues_event_max_datetime": "2016-10-10T05:26:27.000Z", "max_forks_repo_path": "local-dpp/src/HNNWrapper.hs", "max_forks_repo_name": "eklinkhammer/local-dpp", "max_forks_repo_head_hexsha": "d2ab7c6b4827d92d6a38bc3ab23069dab858e94f", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 27.7142857143, "max_line_length": 85, "alphanum_fraction": 0.6268041237, "num_tokens": 271, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6723317123102955, "lm_q2_score": 0.49218813572079556, "lm_q1q2_score": 0.3309136920679746}} {"text": "{-# LANGUAGE FlexibleInstances #-}\n-----------------------------------------------------------------------------\n-- |\n-- Module : Data.Elem.LAPACK.C\n-- Copyright : Copyright (c) , Patrick Perry \n-- License : BSD3\n-- Maintainer : Patrick Perry \n-- Stability : experimental\n--\n-- Low-level interface to LAPACK.\n--\n\nmodule Data.Elem.LAPACK.C\n where\n\nimport Control.Exception( assert )\nimport Control.Monad\nimport Data.Complex( Complex )\nimport Data.Elem.BLAS.Level3\nimport Data.Matrix.Class( TransEnum(..), SideEnum(..) )\nimport Foreign\nimport LAPACK.CTypes\n\nimport Data.Elem.LAPACK.Double\nimport Data.Elem.LAPACK.Zomplex\n\n-- | The LAPACK typeclass.\nclass (BLAS3 e) => LAPACK e where\n geqrf :: Int -> Int -> Ptr e -> Int -> Ptr e -> IO ()\n gelqf :: Int -> Int -> Ptr e -> Int -> Ptr e -> IO ()\n unmqr :: SideEnum -> TransEnum -> Int -> Int -> Int -> Ptr e -> Int -> Ptr e -> Ptr e -> Int -> IO ()\n unmlq :: SideEnum -> TransEnum -> Int -> Int -> Int -> Ptr e -> Int -> Ptr e -> Ptr e -> Int -> IO ()\n larfg :: Int -> Ptr e -> Ptr e -> Int -> IO e\n\ncallWithWork :: (Storable e) => (Ptr e -> Int -> IO a) -> IO a\ncallWithWork call =\n alloca $ \\pQuery -> do\n call pQuery (-1)\n ldWork <- peek (castPtr pQuery) :: IO Double\n let lWork = max 1 $ ceiling ldWork\n allocaArray lWork $ \\pWork -> do\n call pWork lWork\n\ncheckInfo :: Int -> IO ()\ncheckInfo info = assert (info == 0) $ return ()\n \ninstance LAPACK Double where\n geqrf m n pA ldA pTau =\n checkInfo =<< callWithWork (dgeqrf m n pA ldA pTau)\n gelqf m n pA ldA pTau =\n checkInfo =<< callWithWork (dgelqf m n pA ldA pTau)\n unmqr s t m n k pA ldA pTau pC ldC =\n checkInfo =<< callWithWork (dormqr (cblasSide s) (cblasTrans t) m n k pA ldA pTau pC ldC)\n unmlq s t m n k pA ldA pTau pC ldC =\n checkInfo =<< callWithWork (dormlq (cblasSide s) (cblasTrans t) m n k pA ldA pTau pC ldC)\n larfg n alpha x incx = with 0 $ \\pTau -> \n dlarfg n alpha x incx pTau >> peek pTau\n\ninstance LAPACK (Complex Double) where\n geqrf m n pA ldA pTau =\n checkInfo =<< callWithWork (zgeqrf m n pA ldA pTau)\n gelqf m n pA ldA pTau =\n checkInfo =<< callWithWork (zgelqf m n pA ldA pTau)\n unmqr s t m n k pA ldA pTau pC ldC =\n checkInfo =<< callWithWork (zunmqr (cblasSide s) (cblasTrans t) m n k pA ldA pTau pC ldC)\n unmlq s t m n k pA ldA pTau pC ldC =\n checkInfo =<< callWithWork (zunmlq (cblasSide s) (cblasTrans t) m n k pA ldA pTau pC ldC)\n larfg n alpha x incx = with 0 $ \\pTau -> \n zlarfg n alpha x incx pTau >> peek pTau\n", "meta": {"hexsha": "b15fac6ebfb56315de728619c64482fcba4a60c7", "size": 2668, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "lib/Data/Elem/LAPACK/C.hs", "max_stars_repo_name": "patperry/lapack", "max_stars_repo_head_hexsha": "e47271400903cc1e770e19af6487518e43278204", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2016-05-08T21:13:55.000Z", "max_stars_repo_stars_event_max_datetime": "2016-05-08T21:13:55.000Z", "max_issues_repo_path": "lib/Data/Elem/LAPACK/C.hs", "max_issues_repo_name": "patperry/lapack", "max_issues_repo_head_hexsha": "e47271400903cc1e770e19af6487518e43278204", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "lib/Data/Elem/LAPACK/C.hs", "max_forks_repo_name": "patperry/lapack", "max_forks_repo_head_hexsha": "e47271400903cc1e770e19af6487518e43278204", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 38.1142857143, "max_line_length": 105, "alphanum_fraction": 0.5989505247, "num_tokens": 869, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6723316991792861, "lm_q2_score": 0.49218813572079556, "lm_q1q2_score": 0.3309136856050476}} {"text": "{-|\nModule : HABQTlib.UnsafeAPI\n\nThis module contains functions for performing and simulating HABQT in Haskell.\n\n__Caution__: functions in this module perform no input validation and are partial. For a safe API refer to \"HABQTlib\".\n-}\nmodule HABQTlib.UnsafeAPI where\n\nimport Control.Applicative (liftA2)\nimport Control.Monad (replicateM)\nimport Control.Monad.State.Lazy\nimport Data.Maybe (fromJust)\nimport qualified Data.Vector as V\nimport HABQTlib.Data\nimport HABQTlib.Data.Particle\nimport HABQTlib.MeasurementProcessing\nimport HABQTlib.RandomStates\nimport qualified Numeric.LinearAlgebra as LA\nimport Streaming\nimport qualified Streaming.Prelude as S\nimport qualified System.Random.MWC as MWC\nimport Text.Printf (printf)\n\n-- | Tomography keeps track of the particle hierarchy and list of previous\n-- measurement results, IO is used for verbose output and assorted random state\n-- generation.\ntype TomState = StateT (ParticleHierarchy, [PureStateVector]) IO\n\n-- | Tomography function takes a measurement result and returns state-dependent\n-- Bayesian mean estimate of state and the optimal next POVM to perform.\ntype TomFun = PureStateVector -> TomState (DensityMatrix, PurePOVM)\n\n-- | Given parameters such as output verbosity level and number of quantum\n-- bits, set up the tomography function.\ntomographyFun' ::\n QBitNum -- ^ Number of quantum bits under tomography\n -> MHMCiter -- ^ Number of MHMC iterations to perform when resampling\n -> OptIter -- ^ Number of POVM optimisation steps to perform\n -> OutputVerb -- ^ Verbosity of stdout output\n -> MWC.GenIO -- ^ IO generator for variates from \"System.Random.MWC\"\n -> TomFun\ntomographyFun' nq mi oi outv gen nextResult = do\n (ph, ms) <- get\n let nextPH = updateParticleHierarchy nextResult ph\n dim = LA.rows . getStateVector $ nextResult\n effectiveSizes =\n V.map (liftA2 (/) effectiveSize (fromIntegral . ptsNumber)) nextPH\n ra = ResampleArgs outv gen dim mi\n resampleC es pts =\n if es < 0.5\n then resample ra (nextResult : ms) pts\n else return pts\n nextPH' <- lift $ V.zipWithM resampleC effectiveSizes nextPH\n sv0s <- liftIO $ replicateM nq (genPureSV 2)\n let nextEstimate = getMixedEstimate nextPH'\n nextPOVM = optimiseSingleQbPOVM oi sv0s nextPH'\n put (nextPH', nextResult : ms)\n return (nextEstimate, nextPOVM)\n\n-- | Given a true state's density matrix and parameters, set up a simulation of\n-- quantum tomography that outputs infidelity between mean estimates and true\n-- state.\nsimulatedTomography' ::\n DensityMatrix -- ^ True state's density matrix\n -> QBitNum -- ^ Number of quantum bits under tomography\n -> MHMCiter -- ^ Number of MHMC iterations to perform when resampling\n -> OptIter -- ^ Number of POVM optimisation steps to perform\n -> OutputVerb -- ^ Verbosity of stdout output\n -> MWC.GenIO -- ^ IO generator for variates from \"System.Random.MWC\"\n -> StateT PurePOVM TomState Double\nsimulatedTomography' trueDM nq mi oi outv gen = do\n povm <- get\n nextResult <- liftIO $ simulateMeasuremet trueDM povm gen\n (nextEstimate, nextPOVM) <- lift $ tomographyFun' nq mi oi outv gen nextResult\n (nextPH, _) <- lift get\n put nextPOVM\n let fid = fidelityDM trueDM nextEstimate\n when (outv > NoOutput) . liftIO $ do\n let dim = 2 ^ nq\n rankFids =\n V.map\n (fidelityDM trueDM . snd . getWDM . reduceParticlesToMean)\n nextPH\n weightsAndFids =\n V.zip3 (V.enumFromN (1 :: Rank) dim) (V.map ptsWeight nextPH) rankFids\n putStrLn \"\"\n V.mapM_\n (\\(a, b, c) ->\n printf \"(Rank: %4d, Weight: %10.9f, Fidelity: %10.9f)\\n\" a b c)\n weightsAndFids\n return $ 1 - fid\n\n-- | Stream simulated tomography results.\nstreamResults' ::\n QBitNum -- ^ Number of quantum bits under tomography\n -> Rank -- ^ Rank of true state\n -> NumberOfParticles -- ^ Number of particles (per rank) to use for tomography\n -> MHMCiter -- ^ Number of MHMC iterations to perform when resampling\n -> OptIter -- ^ Number of POVM optimisation steps to perform\n -> OutputVerb -- ^ Verbosity of stdout output\n -> Stream (Of Double) IO ()\nstreamResults' nq rank pn mi oi outv = do\n let dim = 2 ^ nq\n trueDM <- liftIO $ genDM dim rank\n ph <- liftIO $ initialiseParticleHierarchy dim pn\n gen <- liftIO MWC.createSystemRandom\n rPOVM <-\n liftIO $\n productPOVM <$>\n replicateM nq (mkAntipodalPOVM . fromJust . svToAngles <$> genPureSV 2)\n let tomS = S.repeatM (simulatedTomography' trueDM nq mi oi outv gen)\n tomS' = evalStateT (distribute tomS) rPOVM\n initInfid = 1 - fidelityDM trueDM (getMixedEstimate ph)\n S.yield initInfid\n evalStateT (distribute tomS') (ph, [])\n", "meta": {"hexsha": "1b36b2f577ec5b8e4556592a17665b045c7c26ea", "size": 4685, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/HABQTlib/UnsafeAPI.hs", "max_stars_repo_name": "Belinsky-L-V/HABQT", "max_stars_repo_head_hexsha": "3ca377c4afb198e33051927221cea17e56441fb0", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2019-01-23T03:07:07.000Z", "max_stars_repo_stars_event_max_datetime": "2020-08-16T08:45:58.000Z", "max_issues_repo_path": "src/HABQTlib/UnsafeAPI.hs", "max_issues_repo_name": "Belinsky-L-V/HABQT", "max_issues_repo_head_hexsha": "3ca377c4afb198e33051927221cea17e56441fb0", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/HABQTlib/UnsafeAPI.hs", "max_forks_repo_name": "Belinsky-L-V/HABQT", "max_forks_repo_head_hexsha": "3ca377c4afb198e33051927221cea17e56441fb0", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 40.0427350427, "max_line_length": 118, "alphanum_fraction": 0.7144076841, "num_tokens": 1285, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.782662489091802, "lm_q2_score": 0.4225046348141882, "lm_q1q2_score": 0.33067852913649537}} {"text": "-- Tasty makes it easy to test your code. It is a test framework that can\n-- combine many different types of tests into one suite. See its website for\n-- help: .\nimport Test.Tasty\n-- Hspec is one of the providers for Tasty. It provides a nice syntax for\n-- writing tests. Its website has more info: .\n-- import Test.Tasty.Hspec\nimport Test.Tasty.HUnit\n\nimport ExplicitSimplexStream\nimport Persistence\n\nimport Numeric.LinearAlgebra\n\n\n-- EXAMPLE STREAMS --\n\nstream1 :: Stream Int\nstream1 = addSimplex (addVertex (addVertex (addVertex initializeStream 1) 2) 3) (Simplex [1,2])\n\nstream2 :: Stream Int\nstream2 = addVertex (addSimplex (addVertex (addVertex initializeStream 1) 2) (Simplex [2,1])) 3\n\nstream3 :: Stream Int\nstream3 = addVertex (addVertex (addVertex (addVertex initializeStream 1) 2) 3) 4\n\nstream4 :: Stream Int\nstream4 = initializeStream \n\nstream5 :: Stream Int\nstream5 = addSimplex stream4 (Simplex [1,2,3,4])\n\n----\n\nmain :: IO ()\nmain = do\n defaultMain (testGroup \"SimplexStream tests\" [addSingleVertexTest, initializeStreamTest, streamEqualityTest, streamNumVerticesEmptyTest, streamNumVertices4CellTest, streamGetSizeEmptyTest, streamGetSize4CellTest, streamGetSize4VertexTest, streamToOrderedSimplexListFourVerticesTest, streamToOrderedSimplexListThreeVerticesOneEdgeTest, getBoundaryMapTest, getBoundaryMapTest2, getBoundaryMapTest3, getHomologyDimensionTest, persistenceTest, persistenceTest2, persistenceTest3, persistenceTest4])\n\n\naddSingleVertexTest :: TestTree\naddSingleVertexTest = testCase \"Testing addition of single vertex\"\n (assertEqual \"Should return true for search of vertex 5\" (True) (isVertexInStream (addVertex (initializeStream :: Stream Int) 5) 5))\n\ninitializeStreamTest :: TestTree\ninitializeStreamTest = testCase \"Testing initialization of stream\"\n (assertEqual \"Should return Simplices []\" (Simplices [Simplex []] :: Stream Int) (initializeStream :: Stream Int))\n\n-- Testing stream equality. \n-- Order of Simplex in Stream data type _should not matter_\nstreamEqualityTest :: TestTree \nstreamEqualityTest = testCase \"Testing quality of streams\"\n (assertEqual \"Should return Simplices []\" (True) (stream1 == stream2))\n\n-- Test numVertices\nstreamNumVerticesEmptyTest :: TestTree \nstreamNumVerticesEmptyTest = testCase \"Testing number of vertices in empty stream\"\n (assertEqual \"Should return 0\" (0) (numVertices stream4))\n\nstreamNumVertices4CellTest :: TestTree \nstreamNumVertices4CellTest = testCase \"Testing number of vertices in a 4-cell\"\n (assertEqual \"Should return 4\" (4) (numVertices stream5))\n\n-- Test getSize \nstreamGetSizeEmptyTest :: TestTree\nstreamGetSizeEmptyTest = testCase \"Testing get size on empty stream.\"\n (assertEqual \"Should return 1 (the null-cell)\" (1) (getSize stream4))\n\nstreamGetSize4CellTest :: TestTree\nstreamGetSize4CellTest = testCase \"Testing get size on 4-cell stream.\"\n (assertEqual \"Should return 16\" (16) (getSize stream5))\n\nstreamGetSize4VertexTest :: TestTree\nstreamGetSize4VertexTest = testCase \"Testing get size on stream with 4 vertices.\"\n (assertEqual \"Should return 5 (four vertices + 1 null cell).\" (5) (getSize stream3))\n\n-- Test streamToOrderedSimplexList \nstreamToOrderedSimplexListFourVerticesTest :: TestTree\nstreamToOrderedSimplexListFourVerticesTest = testCase \"Testing streamToOrderedSimplexList on stream with 4 vertices.\"\n (assertEqual \"Should return object with lengths 0 and 1 with four vertices inside the 1 key.\" (OrderedSimplexList [SimplexListByDegree 0 [(Simplex [])], SimplexListByDegree 1 [(Simplex [1]), (Simplex [2]), (Simplex [3]), (Simplex [4])]]) (streamToOrderedSimplexList stream3))\n\nstreamToOrderedSimplexListThreeVerticesOneEdgeTest :: TestTree\nstreamToOrderedSimplexListThreeVerticesOneEdgeTest = testCase \"Testing streamToOrderedSimplexList on stream with 3 vertices and one edge.\"\n (assertEqual \"Should return object with lengths 0, 1, and 2 with three vertices inside the 1 key and 1 edge inside the 2 key.\" (OrderedSimplexList [SimplexListByDegree 0 [(Simplex [])], SimplexListByDegree 1 [(Simplex [1]), (Simplex [2]), (Simplex [3])], SimplexListByDegree 2 [(Simplex [1,2])]]) (streamToOrderedSimplexList stream1))\n\n-- Test getBoundaryMap\nsimplexList1 :: SimplexListByDegree Int \nsimplexList2 :: SimplexListByDegree Int \nsimplexList1 = SimplexListByDegree 3 [(Simplex [1,2,3]), (Simplex [2,3,4])]\nsimplexList2 = SimplexListByDegree 2 [(Simplex [1,2]), (Simplex [2,3]), (Simplex [1,3]), (Simplex [2,4]), (Simplex [3,4])]\ngetBoundaryMapTest :: TestTree\ngetBoundaryMapTest = testCase \"Testing getBoundaryMap.\"\n (assertEqual \"Should return ...\" (fromLists [[1,0],[1,1],[-1,0],[0,-1],[0,1]]) (getBoundaryMap simplexList2 simplexList1))\n\nsimplexList3 :: SimplexListByDegree Int \nsimplexList4 :: SimplexListByDegree Int \nsimplexList3 = SimplexListByDegree 1 [(Simplex [1]), (Simplex [2]), (Simplex [3]), (Simplex [4])]\nsimplexList4 = SimplexListByDegree 2 [(Simplex [1,2]), (Simplex [1,3]), (Simplex [1,4]), (Simplex [2,3]), (Simplex [3,4])]\ngetBoundaryMapTest2 :: TestTree\ngetBoundaryMapTest2 = testCase \"Testing getBoundaryMap.\"\n (assertEqual \"Should return ...\" (fromLists [[-1,-1,-1,0,0],[1,0,0,-1,0],[0,1,0,1,-1],[0,0,1,0,1]]) (getBoundaryMap simplexList3 simplexList4))\n\nsimplexList5 :: SimplexListByDegree Int \nsimplexList6 :: SimplexListByDegree Int \nsimplexList5 = SimplexListByDegree 0 [(Simplex [])]\nsimplexList6 = SimplexListByDegree 1 [(Simplex [1]), (Simplex [2])]\ngetBoundaryMapTest3 :: TestTree\ngetBoundaryMapTest3 = testCase \"Testing trivial case for getBoundaryMap.\"\n (assertEqual \"Should return ...\" (fromLists [[1, 1]]) (getBoundaryMap simplexList5 simplexList6))\n\n-- Test getHomologyDimension \nsimplexList7 :: SimplexListByDegree Int \nsimplexList8 :: SimplexListByDegree Int \nsimplexList9 :: SimplexListByDegree Int \nsimplexList7 = SimplexListByDegree 0 [(Simplex [])]\nsimplexList8 = SimplexListByDegree 1 [(Simplex [1]), (Simplex [2]), (Simplex [3])]\nsimplexList9 = SimplexListByDegree 2 [(Simplex [1,2]), (Simplex [2,3]), (Simplex [1,3])]\nmap1 :: Matrix Double \nmap2 :: Matrix Double\nmap1 = getBoundaryMap simplexList7 simplexList8\nmap2 = getBoundaryMap simplexList8 simplexList9\ngetHomologyDimensionTest :: TestTree\ngetHomologyDimensionTest = testCase \"Testing getHomologyDimension function.\"\n (assertEqual \"Should return ...\" (1) (getHomologyDimension map2 map1 0))\n\n-- Test persistence\nstream6 :: Stream Int\nstream6 = addSimplex (addSimplex (addSimplex initializeStream (Simplex [1,2])) (Simplex [2,3])) (Simplex [1,3])\npersistenceTest :: TestTree\npersistenceTest = testCase \"Testing persistence function.\"\n (assertEqual \"Should return ...\" (BettiVector [1,1]) (persistence stream6 1))\n\npersistenceTest2 :: TestTree\npersistenceTest2 = testCase \"Testing persistence function on filled tetrahedron.\"\n (assertEqual \"Should return ...\" (BettiVector [1,0,0,0]) (persistence stream5 1))\n\npersistenceTest3 :: TestTree\npersistenceTest3 = testCase \"Testing persistence function on four vertices.\"\n (assertEqual \"Should return ...\" (BettiVector [4]) (persistence stream3 1))\n\nstream7 :: Stream Int\nstream7 = subtractSimplex (addSimplex initializeStream (Simplex [1,2,3,4])) (Simplex [1,2,3,4])\npersistenceTest4 :: TestTree\npersistenceTest4 = testCase \"Testing persistence function.\"\n (assertEqual \"Should return ...\" (BettiVector [1,0,1]) (persistence stream7 1))", "meta": {"hexsha": "2052990a4018dac898461e74e1e96765f58df323", "size": 7364, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "test-suite/Main.hs", "max_stars_repo_name": "Pomona-College-CS181-SP2020/HaskellPlex", "max_stars_repo_head_hexsha": "b609edd689d34eae013bc67257f75d4213dcc5aa", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "test-suite/Main.hs", "max_issues_repo_name": "Pomona-College-CS181-SP2020/HaskellPlex", "max_issues_repo_head_hexsha": "b609edd689d34eae013bc67257f75d4213dcc5aa", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "test-suite/Main.hs", "max_forks_repo_name": "Pomona-College-CS181-SP2020/HaskellPlex", "max_forks_repo_head_hexsha": "b609edd689d34eae013bc67257f75d4213dcc5aa", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 51.1388888889, "max_line_length": 496, "alphanum_fraction": 0.767789245, "num_tokens": 2085, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.5506073655352404, "lm_q2_score": 0.600188359260205, "lm_q1q2_score": 0.33046813131717984}} {"text": "--Hasquil registers\n--Copyright Laurence Emms 2018\n\nmodule Register (Quantum(..),\n Classical(..)) where\n\nimport Data.Complex\n\ndata Quantum = QubitRegister Int |\n MetaQubitRegister String\n\ninstance Show Quantum where\n show (QubitRegister i) = show i\n show (MetaQubitRegister s) = s\n\ndata Classical a = Register Int |\n Range Int Int |\n RealConstant a |\n ComplexConstant (Complex a) |\n MetaRegister String\n\ninstance (Floating a, Show a, Ord a) => Show (Classical a) where\n show (Register i) = \"[\" ++ (show i) ++ \"]\"\n show (Range i j) = \"[\" ++ (show i) ++ \"-\" ++ (show j) ++ \"]\"\n show (RealConstant r) = show r\n show (ComplexConstant (p :+ q))\n | q >= 0 = (show p) ++ \"+\" ++ (show q) ++ \"i\"\n | otherwise = (show p) ++ (show q) ++ \"i\"\n show (MetaRegister s) = s\n", "meta": {"hexsha": "bd1dfa95a4eabe5ba8b2825ee8c935c2878ef363", "size": 894, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/Register.hs", "max_stars_repo_name": "WhatTheFunctional/Hasquil", "max_stars_repo_head_hexsha": "e6b50fec6b779f8a8094ab5c52fdaa412b430829", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 11, "max_stars_repo_stars_event_min_datetime": "2018-06-08T09:02:24.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-18T14:09:15.000Z", "max_issues_repo_path": "src/Register.hs", "max_issues_repo_name": "WhatTheFunctional/Hasquil", "max_issues_repo_head_hexsha": "e6b50fec6b779f8a8094ab5c52fdaa412b430829", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/Register.hs", "max_forks_repo_name": "WhatTheFunctional/Hasquil", "max_forks_repo_head_hexsha": "e6b50fec6b779f8a8094ab5c52fdaa412b430829", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2018-06-08T09:06:08.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-15T16:06:08.000Z", "avg_line_length": 29.8, "max_line_length": 64, "alphanum_fraction": 0.5380313199, "num_tokens": 238, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO\n\n", "lm_q1_score": 0.727975460709318, "lm_q2_score": 0.45326184801538616, "lm_q1q2_score": 0.3299635026309576}} {"text": "{-# LANGUAGE DeriveDataTypeable #-}\n{-# LANGUAGE FlexibleContexts #-}\n{-# LANGUAGE FlexibleInstances #-}\n{-# LANGUAGE GeneralizedNewtypeDeriving #-}\n{-# LANGUAGE QuasiQuotes #-}\n{-# LANGUAGE ScopedTypeVariables #-}\n{-# LANGUAGE TypeFamilies #-}\n{-# LANGUAGE UndecidableInstances #-}\n\nmodule Main where\n\nimport Prelude hiding (map)\nimport qualified Prelude as P\n\nimport Control.Monad\nimport Criterion.Config\nimport Criterion.Main\nimport Criterion.Monad\nimport Criterion.Plot\nimport Data.Array.Vector\nimport Nikola\nimport Statistics.Function (minMax)\nimport Statistics.KernelDensity (epanechnikovPDF)\nimport Statistics.Types\nimport System.Environment (getArgs)\n\nmain :: IO ()\nmain = do\n (cfg, _) <- parseArgs defaultConfig defaultOptions =<< System.Environment.getArgs\n withNewContext $ \\_ -> do\n reify f >>= compileTopFun \"f\" >>= print\n samples <- withCompiledFunction f $ \\f -> do\n replicateM 10000 $ do\n timeKernel f $ \\f -> do\n call f [1..1024]\n withConfig cfg $\n plotAll [(\"map\", (toU . P.map (realToFrac . fst)) samples)]\n where\n f :: Exp [Int] -> Exp [Int]\n f = map (\\x -> x + 1)\n\nplotAll :: [(String, Sample)] -> Criterion ()\nplotAll descTimes = forM_ descTimes $ \\(desc,times) -> do\n plotWith Timing $ \\o -> plotTiming o desc times\n plotWith KernelDensity $ \\o -> uncurry (plotKDE o desc extremes)\n (epanechnikovPDF 100 times)\n where\n extremes = case descTimes of\n (_:_:_) -> toJust . minMax . concatU . P.map snd $ descTimes\n _ -> Nothing\n toJust r@(lo :*: hi)\n | lo == infinity || hi == -infinity = Nothing\n | otherwise = Just r\n where infinity = 1/0\n", "meta": {"hexsha": "967b19955a18ac8f12a3b60c4bd3abe740f81cf4", "size": 1780, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "tests/benchmark.hs", "max_stars_repo_name": "mainland/nikola", "max_stars_repo_head_hexsha": "d86398888c0a76f8ad1556a269a708de9dd92644", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": 9, "max_stars_repo_stars_event_min_datetime": "2015-03-14T01:58:07.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-08T15:56:49.000Z", "max_issues_repo_path": "tests/benchmark.hs", "max_issues_repo_name": "mainland/nikola", "max_issues_repo_head_hexsha": "d86398888c0a76f8ad1556a269a708de9dd92644", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "tests/benchmark.hs", "max_forks_repo_name": "mainland/nikola", "max_forks_repo_head_hexsha": "d86398888c0a76f8ad1556a269a708de9dd92644", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2019-02-07T19:04:55.000Z", "max_forks_repo_forks_event_max_datetime": "2019-02-07T19:04:55.000Z", "avg_line_length": 32.3636363636, "max_line_length": 85, "alphanum_fraction": 0.6191011236, "num_tokens": 429, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.6442251064863697, "lm_q2_score": 0.5117166047041654, "lm_q1q2_score": 0.32966068415638444}} {"text": "{-# LANGUAGE FlexibleContexts #-}\nmodule CW (parseOpts, run) where\n\nimport Control.Monad\nimport Control.Monad.Error.Class\nimport Data.Char\nimport Data.Complex\nimport Data.List\nimport qualified Filter as F\nimport IQ\nimport Options.Applicative\nimport Pipes\nimport qualified Pipes.Prelude as P\nimport Render\nimport System.IO\nimport ZeroStuff\n\ndata CWOptions = CWOptions\n { sampleRate :: Int\n , wpm :: Int\n , text :: String\n , outputFile :: String }\n\nparseOpts :: Parser CWOptions\nparseOpts = CWOptions\n <$> option auto\n ( long \"sample-rate\"\n <> short 's'\n <> metavar \"SAMPLE_RATE\"\n <> help \"Sample rate of the produced IQ file\" )\n <*> option auto\n ( long \"wpm\"\n <> short 'w'\n <> value 25\n <> showDefault\n <> metavar \"WPM_RATE\"\n <> help \"Rate of keying in Words per Minute\" )\n <*> strOption\n ( long \"in-text\"\n <> short 't'\n <> metavar \"INPUT_TEXT\"\n <> help \"Input text message\" )\n <*> strOption\n ( long \"out-file\"\n <> short 'o'\n <> metavar \"OUTPUT_FILE\"\n <> help \"Output IQ file\" )\n\ndata CW = Dah\n | Dit\n\ncwMap :: MonadError String m => Char -> m [CW]\ncwMap c\n | c == 'a' = pure [ Dah, Dit ]\n | c == 'b' = pure [ Dah, Dit, Dit, Dit ]\n | c == 'c' = pure [ Dah, Dit, Dah, Dit ]\n | c == 'd' = pure [ Dah, Dit, Dit ]\n | c == 'e' = pure [ Dit ]\n | c == 'f' = pure [ Dit, Dit, Dah, Dit ]\n | c == 'g' = pure [ Dah, Dah, Dit ]\n | c == 'h' = pure [ Dit, Dit, Dit, Dit ]\n | c == 'i' = pure [ Dit, Dit ]\n | c == 'j' = pure [ Dit, Dah, Dah, Dah ]\n | c == 'k' = pure [ Dah, Dit, Dah ]\n | c == 'l' = pure [ Dit, Dah, Dit, Dit ]\n | c == 'm' = pure [ Dah, Dah ]\n | c == 'n' = pure [ Dah, Dit ]\n | c == 'o' = pure [ Dah, Dah, Dah ]\n | c == 'p' = pure [ Dit, Dah, Dah, Dit ]\n | c == 'q' = pure [ Dah, Dah, Dit, Dah ]\n | c == 'r' = pure [ Dit, Dah, Dit ]\n | c == 's' = pure [ Dit, Dit, Dit ]\n | c == 't' = pure [ Dah ]\n | c == 'u' = pure [ Dit, Dit, Dah ]\n | c == 'v' = pure [ Dit, Dit, Dit, Dah ]\n | c == 'w' = pure [ Dit, Dah, Dah ]\n | c == 'x' = pure [ Dah, Dit, Dit, Dah ]\n | c == 'y' = pure [ Dah, Dit, Dah, Dah ]\n | c == 'z' = pure [ Dah, Dah, Dit, Dit ]\n | c == '1' = pure [ Dit, Dah, Dah, Dah, Dah ]\n | c == '2' = pure [ Dit, Dit, Dah, Dah, Dah ]\n | c == '3' = pure [ Dit, Dit, Dit, Dah, Dah ]\n | c == '4' = pure [ Dit, Dit, Dit, Dit, Dah ]\n | c == '5' = pure [ Dit, Dit, Dit, Dit, Dit ]\n | c == '6' = pure [ Dah, Dit, Dit, Dit, Dit ]\n | c == '7' = pure [ Dah, Dah, Dit, Dit, Dit ]\n | c == '8' = pure [ Dah, Dah, Dah, Dit, Dit ]\n | c == '9' = pure [ Dah, Dah, Dah, Dah, Dit ]\n | c == '0' = pure [ Dah, Dah, Dah, Dah, Dah ]\n | otherwise = throwError $ \"Unknown CW character: '\" ++ [c] ++ \"'\"\n\ndata KeyState = On | Off\ndata Keying = Keying\n { units :: Int\n , keyState :: KeyState }\n\ncwKeyingMap :: CW -> Keying\ncwKeyingMap Dah = Keying 3 On\ncwKeyingMap Dit = Keying 1 On\n\nkeyLetter :: MonadError String m => Char -> m [Keying]\nkeyLetter l = intersperse (Keying 1 Off) <$> (map cwKeyingMap <$> cwMap l)\n\nkeyWord :: MonadError String m => String -> m [Keying]\nkeyWord word = intercalate [Keying 3 Off] <$> sequence (keyLetter <$> word)\n\nkeyText :: String -> Either String [Keying]\nkeyText text = intercalate [Keying 7 Off] <$> sequence (keyWord <$> words text)\n\nsynthesizeKeying :: MonadIO m => Int -> Int -> Pipe Keying IQ m ()\nsynthesizeKeying sr wpm = forever $ do\n keying <- await\n\n let iq = case keying of\n Keying _ On -> 1.0 :+ 0.0\n Keying _ Off -> 0.0 :+ 0.0\n n = round $ fromIntegral sr * (60.0 / (50.0 * fromIntegral wpm)) * fromIntegral (units keying)\n replicateM_ n $ yield iq\n\nrun :: CWOptions -> IO ()\nrun opts = case keyText $ toLower <$> text opts of\n Left err -> putStr err\n Right keyings -> do\n putStr \"Synthesizing samples... \"\n hFlush stdout\n\n let kernel = F.lowPass (sampleRate opts) $ F.FilterOptions 100 1000\n\n withBinaryFile (outputFile opts) WriteMode $ \\f ->\n runEffect $ each keyings\n >-> synthesizeKeying (sampleRate opts) (wpm opts)\n >-> F.convolve kernel\n >-> cfileSink f\n\n putStrLn \"Done.\"\n\n", "meta": {"hexsha": "531980100cc02e23f6a6571631d53bb66a498860", "size": 4372, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/CW.hs", "max_stars_repo_name": "hexagonal-sun/ayeQ", "max_stars_repo_head_hexsha": "0dd484287ed785109867db4a06d1861cabb04062", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-07-25T11:41:05.000Z", "max_stars_repo_stars_event_max_datetime": "2021-07-25T11:41:05.000Z", "max_issues_repo_path": "src/CW.hs", "max_issues_repo_name": "hexagonal-sun/ayeQ", "max_issues_repo_head_hexsha": "0dd484287ed785109867db4a06d1861cabb04062", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/CW.hs", "max_forks_repo_name": "hexagonal-sun/ayeQ", "max_forks_repo_head_hexsha": "0dd484287ed785109867db4a06d1861cabb04062", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 31.9124087591, "max_line_length": 100, "alphanum_fraction": 0.5198993596, "num_tokens": 1388, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.629774621301746, "lm_q2_score": 0.523420348936324, "lm_q1q2_score": 0.32963685203300125}} {"text": "{-# LANGUAGE ForeignFunctionInterface #-}\n{-|\nModule : Grenade.Layers.Internal.Transpose\nDescription : Functions to quickly transpose a matrix\nMaintainer : Theo Charalambous\nLicense : BSD2\nStability : experimental\n-}\nmodule Grenade.Layers.Internal.Transpose (\n transpose4d\n) where\n\nimport qualified Data.Vector.Storable as U (unsafeFromForeignPtr0,\n unsafeToForeignPtr0)\n\nimport Foreign (mallocForeignPtrArray,\n withForeignPtr)\nimport Foreign.C.Types (CInt)\nimport Foreign.Ptr (Ptr)\nimport Numeric.LinearAlgebra (Matrix, Vector, cmap, flatten)\nimport qualified Numeric.LinearAlgebra.Data as D\nimport qualified Numeric.LinearAlgebra.Devel as U\nimport System.IO.Unsafe (unsafePerformIO)\n\nimport Grenade.Types\n\n-- | Transpose a 4d matrix, similarly to the tranpose function in numpy\ntranspose4d :: [Int] -- ^ original dimensions\n -> Vector RealNum -- ^ permutation vector\n -> Matrix RealNum -- ^ input matrix\n -> Matrix RealNum -- ^ transposed matrix\ntranspose4d dims@[n, c, h, w] permsV m\n = let outMatSize = n * c * h * w\n outW = dims !! (round $ permsV D.! 3)\n vec = flatten m\n permsV' = cmap (U.fi . round) permsV :: Vector CInt\n dimsV = D.fromList $ map U.fi dims :: Vector CInt\n in unsafePerformIO $ do\n outPtr <- mallocForeignPtrArray outMatSize\n let (inPtr, _) = U.unsafeToForeignPtr0 vec\n (pPtr, _) = U.unsafeToForeignPtr0 permsV'\n (dPtr, _) = U.unsafeToForeignPtr0 dimsV\n\n withForeignPtr inPtr $ \\inPtr' ->\n withForeignPtr pPtr $ \\pPtr' ->\n withForeignPtr dPtr $ \\dPtr' ->\n withForeignPtr outPtr $ \\outPtr' ->\n transpose_4d inPtr' dPtr' pPtr' outPtr'\n\n let matVec = U.unsafeFromForeignPtr0 outPtr outMatSize\n return (U.matrixFromVector U.RowMajor (div outMatSize outW) outW matVec)\n{-# INLINE transpose4d #-}\n\nforeign import ccall unsafe\n transpose_4d\n :: Ptr RealNum -> Ptr CInt -> Ptr CInt -> Ptr RealNum -> IO ()\n", "meta": {"hexsha": "eb311cc7b8ff1002606daf5db618831f2b49a57c", "size": 2265, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/Grenade/Layers/Internal/Transpose.hs", "max_stars_repo_name": "th-char/grenade", "max_stars_repo_head_hexsha": "0be658e7cf07562cd5e4170ed1e8875ccec14cdb", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-06-09T06:06:26.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-09T06:06:26.000Z", "max_issues_repo_path": "src/Grenade/Layers/Internal/Transpose.hs", "max_issues_repo_name": "th-char/grenade", "max_issues_repo_head_hexsha": "0be658e7cf07562cd5e4170ed1e8875ccec14cdb", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/Grenade/Layers/Internal/Transpose.hs", "max_forks_repo_name": "th-char/grenade", "max_forks_repo_head_hexsha": "0be658e7cf07562cd5e4170ed1e8875ccec14cdb", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 39.7368421053, "max_line_length": 78, "alphanum_fraction": 0.5995584989, "num_tokens": 561, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6688802735722128, "lm_q2_score": 0.49218813572079556, "lm_q1q2_score": 0.32921493486992315}} {"text": "{-# LANGUAGE TypeFamilies #-}\n\nmodule FPNLA.Operations.Parameters(\n -- * Elements\n Elt(..),\n -- * Strategies and contexts\n StratCtx(),\n\n -- * Result type\n -- | In BLAS it's common that operations in higher levels use operations in the lower levels, so, an operation in level three that by its signature manipulates matrices only, internally uses level two operations that manipulates vectors. In order to avoid the /show . read/ problem, the type of the vector (or any other internal data type) must appear in the signature of an operation.\n -- To solve the problem we use phantom types to pass the internally used types to the Haskell type system.\n ResM(),\n ResV(),\n ResS(),\n blasResultM,\n blasResultV,\n blasResultS,\n getResultDataM,\n getResultDataV,\n getResultDataS,\n\n -- * Miscellaneous\n TransType(..),\n UnitType(..),\n TriangType(..),\n unTransT,\n unUnitT,\n unTriangT,\n elemTrans_m,\n dimTrans_m,\n elemSymm,\n dimTriang,\n elemUnit_m,\n dimUnit_m,\n elemTransUnit_m,\n dimTransUnit_m,\n transTrans_m\n\n) where\n\nimport FPNLA.Matrix(Matrix(..))\nimport Data.Complex (Complex, conjugate)\nimport Data.Tuple (swap)\n\n\n-- | This class represents the elements that can be used in the BLAS operations.\n-- The elements in BLAS are real or complex numbers, so we provide default instances for the Haskell 'Double', 'Float' and 'Complex' types.\nclass (Eq e, Floating e) => Elt e where\n -- | Returns the conjugate of a number. For real numbers it's the identity function and for complex numbers it's the common 'Complex.conjugate' function.\n getConjugate :: e -> e\n getConjugate = id\n\ninstance Elt Double\ninstance Elt Float\ninstance (RealFloat e) => Elt (Complex e) where\n getConjugate = conjugate\n\n-- | This type family is used to represent the /context/ of an operation.\n-- A particular implementation is a combination of an algorithm and a parallelism technique, and we call it a /strategy/. A particular strategy may need particular information to execute. For example, an operation that computes the matrix-matrix multiplication by splitting the matrices in blocks must require the size of the blocks.\n-- With this context we allows to pass any additional information that the operation needs to execute as parameters, but maintaining a common signature.\n-- The /s/ type parameter is the strategy so, there must exist a Haskell data type to represent a particular strategy.\ntype family StratCtx s :: *\n\n-- | The 'ResM' data type is used as result of level three BLAS operations and returns a matrix /m/ of elements /e/ and contains the strategy /s/ and vector /v/ as phantom types.\ndata ResM s (v :: * -> *) m e = ResM { unResM :: m e } deriving (Show)\n-- | The 'ResV' data type is used as result of level two BLAS operations and returns a vector /v/ of elements /e/ and contains the strategy /s/ as phantom types.\ndata ResV s v e = ResV { unResV :: v e } deriving (Show)\n-- | The 'ResS' data type is used as result of level one BLAS operations and returns an scalar /e/ and contains the strategy /s/ as phantom types.\ndata ResS s e = ResS { unResS :: e } deriving (Show)\n\n\n-- | Wrap a matrix into a 'ResM'.\nblasResultM :: m e -> ResM s v m e\nblasResultM = ResM\n-- | Unwrap a matrix from a 'ResM'.\ngetResultDataM :: ResM s v m e -> m e\ngetResultDataM = unResM\n\n-- | Wrap a vector into a 'ResV'.\nblasResultV :: v e -> ResV s v e\nblasResultV = ResV\n-- | Unwrap a vector from a 'ResV'.\ngetResultDataV :: ResV s v e -> v e\ngetResultDataV = unResV\n\n-- | Wrap a scalar into a 'ResS'.\nblasResultS :: e -> ResS s e\nblasResultS = ResS\n-- | Unwrap a scalar from a 'ResS'.\ngetResultDataS :: ResS s e -> e\ngetResultDataS = unResS\n\n\n-- | Indicates if a matrix must be considered as normal, transposed or transposed conjugated.\n-- This is part of the common flags in the BLAS operation signatures and it's useful to work with a transposed matrix without really computing the transposed matrix.\ndata TransType m = Trans m | NoTrans m | ConjTrans m deriving (Eq, Show)\n-- | Indicates if a matrix must be considered as unitary or not. An unitary matrix is a matrix that contains ones in the diagonal.\n-- This is part of the common flags in the BLAS operation signatures.\ndata UnitType m = Unit m | NoUnit m deriving (Eq, Show)\n-- | Indicates that a matrix is symmetric and with which triangular part of the matrix the operation is going to work ('Upper' or 'Lower').\n-- The operation only will see the indicated part of the matrix and should not try to access the other part.\n-- This is part of the common flags in the BLAS operation signatures.\ndata TriangType m = Lower m | Upper m deriving (Eq, Show)\n\n-- | Given a data type flagged by a TransType, returns a pair containing the TransType constructor and the data type.\nunTransT :: TransType a -> (b -> TransType b, a)\nunTransT (Trans a) = (Trans, a)\nunTransT (NoTrans a) = (NoTrans, a)\nunTransT (ConjTrans a) = (ConjTrans, a)\n\n-- | Given a data type flagged by a UnitType, returns a pair containing the UnitType constructor and the data type.\nunUnitT :: UnitType a -> (b -> UnitType b, a)\nunUnitT (Unit a) = (Unit, a)\nunUnitT (NoUnit a) = (NoUnit, a)\n\n-- | Given a data type flagged by a TriangType, returns a pair containing the TriangType constructor and the data type.\nunTriangT :: TriangType a -> (b -> TriangType b, a)\nunTriangT (Lower a) = (Lower, a)\nunTriangT (Upper a) = (Upper, a)\n\n\n-- | Given an /i,j/ position and a TransType flagged matrix, returns the element in that position without computing the transpose.\nelemTrans_m :: (Elt e, Matrix m e) => Int -> Int -> TransType (m e) -> e\nelemTrans_m i j (NoTrans m) = elem_m i j m\nelemTrans_m i j (Trans m) = elem_m j i m\nelemTrans_m i j (ConjTrans m) = getConjugate $ elem_m j i m\n\n\n-- | Given a TransType flagged matrix, returns the dimension of the matrix without computing the transpose.\ndimTrans_m :: (Matrix m e) => TransType (m e) -> (Int, Int)\ndimTrans_m (NoTrans m) = dim_m m\ndimTrans_m (ConjTrans m) = swap $ dim_m m\ndimTrans_m (Trans m) = swap $ dim_m m\n\n\n-- | Given an /i,j/ position and a TransType flagged matrix, returns the element in that position only accessing the part indicated by the TransType.\nelemSymm :: (Matrix m e) => Int -> Int -> TriangType (m e) -> e\nelemSymm i j (Upper m)\n | i > j = elem_m j i m\n | otherwise = elem_m i j m\nelemSymm i j (Lower m)\n | i > j = elem_m i j m\n | otherwise = elem_m j i m\n\n-- | Given a TransType flagged matrix, returns the dimension of the matrix.\ndimTriang :: (Matrix m e) => TriangType (m e) -> (Int, Int)\ndimTriang = dim_m . snd . unTriangT\n\n-- | Given an /i,j/ position and a UnitType flagged matrix, returns the element in that position. If the matrix is flagged as Unit and /i == j/ (the element is in the diagonal) returns one.\nelemUnit_m :: (Elt e, Matrix m e) => Int -> Int -> UnitType (m e) -> e\nelemUnit_m i j (Unit m)\n | i == j = 1\n | otherwise = elem_m i j m\nelemUnit_m i j (NoUnit m) = elem_m i j m\n\n-- | Given a UnitType flagged matrix, returns the dimension of the matrix.\ndimUnit_m :: (Matrix m e) => UnitType (m e) -> (Int, Int)\ndimUnit_m (Unit m) = dim_m m\ndimUnit_m (NoUnit m) = dim_m m\n\n-- | Given an /i,j/ position and a TransType-UnitType flagged matrix, returns the element in that position without computing the transpose.\nelemTransUnit_m :: (Elt e, Matrix m e) => Int -> Int -> TransType (UnitType (m e)) -> e\nelemTransUnit_m i j (NoTrans pmA) = elemUnit_m i j pmA\nelemTransUnit_m i j (Trans pmA) = elemUnit_m j i pmA\nelemTransUnit_m i j (ConjTrans pmA) = getConjugate $ elemUnit_m j i pmA\n\n-- | Given a TransType-UnitType flagged matrix, returns the dimension of the matrix.\ndimTransUnit_m :: Matrix m e => TransType (UnitType (m e)) -> (Int, Int)\ndimTransUnit_m = dimUnit_m . snd . unTransT\n\n-- | Given a TransType flagged matrix, computes and returns its transpose.\ntransTrans_m :: (Elt e, Matrix m e) => TransType (m e) -> m e\ntransTrans_m (NoTrans m) = m\ntransTrans_m (ConjTrans m) = map_m getConjugate $ transpose_m m\ntransTrans_m (Trans m) = transpose_m m\n", "meta": {"hexsha": "e7ead850d254c3c04d86055ae013a8020781b7bf", "size": 8055, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/FPNLA/Operations/Parameters.hs", "max_stars_repo_name": "mauroblanco/fpnla", "max_stars_repo_head_hexsha": "f1429c59dba36eb81851fbefcac759c2581a8b92", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2016-07-06T03:07:30.000Z", "max_stars_repo_stars_event_max_datetime": "2016-07-06T03:07:30.000Z", "max_issues_repo_path": "src/FPNLA/Operations/Parameters.hs", "max_issues_repo_name": "mauroblanco/fpnla", "max_issues_repo_head_hexsha": "f1429c59dba36eb81851fbefcac759c2581a8b92", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/FPNLA/Operations/Parameters.hs", "max_forks_repo_name": "mauroblanco/fpnla", "max_forks_repo_head_hexsha": "f1429c59dba36eb81851fbefcac759c2581a8b92", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 45.7670454545, "max_line_length": 389, "alphanum_fraction": 0.7098696462, "num_tokens": 2234, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.6150878555160665, "lm_q2_score": 0.5350984286266115, "lm_q1q2_score": 0.32913254495395944}} {"text": "{-# LANGUAGE AllowAmbiguousTypes #-}\n{-# LANGUAGE BangPatterns #-}\n{-# LANGUAGE DefaultSignatures #-}\n{-# LANGUAGE DeriveGeneric #-}\n{-# LANGUAGE DerivingVia #-}\n{-# LANGUAGE FlexibleContexts #-}\n{-# LANGUAGE FlexibleInstances #-}\n{-# LANGUAGE FunctionalDependencies #-}\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE KindSignatures #-}\n{-# LANGUAGE LambdaCase #-}\n{-# LANGUAGE MultiParamTypeClasses #-}\n{-# LANGUAGE NoStarIsType #-}\n{-# LANGUAGE RankNTypes #-}\n{-# LANGUAGE ScopedTypeVariables #-}\n{-# LANGUAGE TupleSections #-}\n{-# LANGUAGE TypeApplications #-}\n{-# LANGUAGE TypeFamilyDependencies #-}\n{-# LANGUAGE TypeInType #-}\n{-# LANGUAGE TypeOperators #-}\n{-# LANGUAGE UndecidableInstances #-}\n{-# OPTIONS_GHC -fno-warn-orphans #-}\n\n-- |\n-- Module : Numeric.Opto.Ref\n-- Copyright : (c) Justin Le 2019\n-- License : BSD3\n--\n-- Maintainer : justin@jle.im\n-- Stability : experimental\n-- Portability : non-portable\n--\n-- Abstract over different types for mutable references of values.\nmodule Numeric.Opto.Ref (\n MR(..), ML(..)\n ) where\n\nimport Control.Monad.Primitive\nimport Data.Complex\nimport Data.Mutable\nimport GHC.TypeNats\nimport qualified Data.Vector.Generic as VG\nimport qualified Data.Vector.Generic.Mutable.Sized as SMVG\nimport qualified Data.Vector.Generic.Sized as SVG\nimport qualified Data.Vector.Storable as VS\nimport qualified Numeric.LinearAlgebra as HU\nimport qualified Numeric.LinearAlgebra.Devel as HU\nimport qualified Numeric.LinearAlgebra.Static as H\nimport qualified Numeric.LinearAlgebra.Static.Vector as H\n\ninstance VG.Vector v a => Mutable s (SVG.Vector v n a) where\n type Ref s (SVG.Vector v n a) = SVG.MVector (VG.Mutable v) n s a\n thawRef = SVG.thaw\n freezeRef = SVG.freeze\n copyRef = SVG.copy\n moveRef = SMVG.move\n cloneRef = SMVG.clone\n unsafeThawRef = SVG.unsafeThaw\n unsafeFreezeRef = SVG.unsafeFreeze\n\ninstance HU.Element a => Mutable s (HU.Matrix a) where\n type Ref s (HU.Matrix a) = HU.STMatrix s a\n thawRef x = stToPrim $ HU.thawMatrix x\n freezeRef v = stToPrim $ HU.freezeMatrix v\n copyRef v x = stToPrim $ HU.setMatrix v 0 0 x\n moveRef = undefined\n cloneRef = undefined\n unsafeThawRef = undefined\n unsafeFreezeRef = undefined\n\n-- | Mutable ref for hmatrix's statically sized vector types, 'H.R' and\n-- 'H.C'.\nnewtype MR s n a = MR { getMR :: SVG.MVector VS.MVector n s a }\n\ninstance KnownNat n => Mutable s (H.R n) where\n type Ref s (H.R n) = MR s n Double\n\n thawRef = fmap MR . thawRef . H.rVec\n freezeRef = fmap H.vecR . freezeRef . getMR\n copyRef (MR v) x = copyRef v (H.rVec x)\n moveRef = undefined\n cloneRef = undefined\n unsafeThawRef = undefined\n unsafeFreezeRef = undefined\n\ninstance KnownNat n => Mutable s (H.C n) where\n type Ref s (H.C n) = MR s n (Complex Double)\n\n thawRef = fmap MR . thawRef . H.cVec\n freezeRef = fmap H.vecC . freezeRef . getMR\n copyRef (MR v) x = copyRef v (H.cVec x)\n moveRef = undefined\n cloneRef = undefined\n unsafeThawRef = undefined\n unsafeFreezeRef = undefined\n\n-- | Mutable ref for hmatrix's statically sized matrix types, 'H.L' and\n-- 'H.M'.\nnewtype ML s n k a = ML { getML :: SVG.MVector VS.MVector (n * k) s a }\n\ninstance (KnownNat n, KnownNat k) => Mutable s (H.L n k) where\n type Ref s (H.L n k) = ML s n k Double\n\n thawRef = fmap ML . thawRef . H.lVec\n freezeRef = fmap H.vecL . freezeRef . getML\n copyRef (ML v) x = copyRef v (H.lVec x)\n moveRef = undefined\n cloneRef = undefined\n unsafeThawRef = undefined\n unsafeFreezeRef = undefined\n\ninstance (KnownNat n, KnownNat k) => Mutable s (H.M n k) where\n type Ref s (H.M n k) = ML s n k (Complex Double)\n\n thawRef = fmap ML . thawRef . H.mVec\n freezeRef = fmap H.vecM . freezeRef . getML\n copyRef (ML v) x = copyRef v (H.mVec x)\n moveRef = undefined\n cloneRef = undefined\n unsafeThawRef = undefined\n unsafeFreezeRef = undefined\n", "meta": {"hexsha": "6606b700814d658ee1a38d2d290f84b3a9ee0bab", "size": 4300, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/Numeric/Opto/Ref.hs", "max_stars_repo_name": "mstksg/opto", "max_stars_repo_head_hexsha": "ffdd862e858cd00581eee3b0b81e07d80d617cff", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 14, "max_stars_repo_stars_event_min_datetime": "2018-01-23T06:32:03.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-11T13:41:23.000Z", "max_issues_repo_path": "src/Numeric/Opto/Ref.hs", "max_issues_repo_name": "mstksg/opto", "max_issues_repo_head_hexsha": "ffdd862e858cd00581eee3b0b81e07d80d617cff", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2018-05-06T00:08:27.000Z", "max_issues_repo_issues_event_max_datetime": "2019-12-05T02:10:12.000Z", "max_forks_repo_path": "src/Numeric/Opto/Ref.hs", "max_forks_repo_name": "mstksg/opto", "max_forks_repo_head_hexsha": "ffdd862e858cd00581eee3b0b81e07d80d617cff", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 35.2459016393, "max_line_length": 71, "alphanum_fraction": 0.6225581395, "num_tokens": 1129, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.6477982179521103, "lm_q2_score": 0.5078118642792044, "lm_q1q2_score": 0.32895962073500756}} {"text": "module Main where\n\nimport Control.Arrow (first, (&&&))\n\nimport Criterion\nimport Criterion.IO (readRecords)\nimport Criterion.Main (defaultConfig,\n defaultMainWith)\nimport Criterion.Types\nimport Statistics.Resampling.Bootstrap (estPoint)\n\nimport qualified Data.ByteString.Lazy as BL\nimport Data.Csv as Csv\nimport Data.List (isPrefixOf, sortBy, zip4)\nimport Data.Ord (comparing)\nimport qualified Data.Vector.Unboxed as V\n\nimport Test.QuickCheck\n\nimport Graphics.Gnuplot.Advanced\nimport qualified Graphics.Gnuplot.Frame as Frame\nimport qualified Graphics.Gnuplot.Frame.Option as Opt\nimport qualified Graphics.Gnuplot.Frame.OptionSet as Opts\nimport qualified Graphics.Gnuplot.Graph.TwoDimensional as Graph2D\nimport qualified Graphics.Gnuplot.LineSpecification as LineSpec\nimport qualified Graphics.Gnuplot.Plot.TwoDimensional as Plot2D\nimport qualified Graphics.Gnuplot.Terminal.PNG as PNG\n\nimport Quickselect\n\nrange :: [Int]\nrange = [0, 1000 .. 50000]\n\ntestData :: [(Int, IO (V.Vector Int))]\ntestData = map f range\n where f n = (n, generate $ (V.fromList <$> vectorOf n arbitrary))\n\nrawOut = \"../data/kth-element-haskell.raw\"\ncsvOut = \"../data/kth-element-haskell.csv\"\npngOut = \"../data/kth-element-haskell.png\"\n\nconfig :: Config\nconfig = defaultConfig { resamples = 3, rawDataFile = Just rawOut }\n\nmain :: IO ()\nmain = do\n defaultMainWith config [\n bgroup \"main\" [\n bgroup \"find\" $ map (run quickselect) testData\n , bgroup \"cheat\" $ map (run sortselect) testData\n ]\n ]\n (Right records) <- readRecords rawOut\n let records' = map (\\(Analysed r) -> r) records\n let find' = extractOutcomes (filterReports \"main/find/\" records')\n cheat' = extractOutcomes (filterReports \"main/cheat/\" records')\n results = zip3 find' cheat' range\n BL.writeFile csvOut (encode results)\n plot (PNG.cons pngOut) resultPlot\n return ()\n where run f (n, xs) = env xs $ \\ ~(xs') -> bench (show n) $ nf (f n) xs'\n filterReports name = filter ((name `isPrefixOf`) . reportName)\n extractOutcomes = map (estPoint . anMean . reportAnalysis)\n\nresultPlot :: Frame.T (Graph2D.T Int Double)\nresultPlot =\n let lineSpec title =\n Graph2D.lineSpec $\n LineSpec.title title $\n LineSpec.deflt\n lineSpec1 = lineSpec \"find\"\n lineSpec2 = lineSpec \"cheat\"\n frameOpts =\n Opts.xLabel \"input size\" $\n Opts.yLabel \"execution time (seconds)\" $\n Opts.title \"Performance of Kth Element\" $\n Opts.add (Opt.custom \"datafile separator\" \"\") [\"\\\",\\\"\"] $\n Opts.deflt\n path1 = fmap lineSpec1 $ Plot2D.pathFromFile Graph2D.lines csvOut 3 1\n path2 = fmap lineSpec2 $ Plot2D.pathFromFile Graph2D.lines csvOut 3 2\n in Frame.cons frameOpts $ mconcat [path1, path2]\n", "meta": {"hexsha": "6c54a75a4a3b34e67f106542c8a962a10b2506fb", "size": 3149, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "haskell/bench/Main.hs", "max_stars_repo_name": "mooreniemi/BAM", "max_stars_repo_head_hexsha": "445e37454cd3e18e3a68e1783caca818649b944f", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "haskell/bench/Main.hs", "max_issues_repo_name": "mooreniemi/BAM", "max_issues_repo_head_hexsha": "445e37454cd3e18e3a68e1783caca818649b944f", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "haskell/bench/Main.hs", "max_forks_repo_name": "mooreniemi/BAM", "max_forks_repo_head_hexsha": "445e37454cd3e18e3a68e1783caca818649b944f", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 38.4024390244, "max_line_length": 81, "alphanum_fraction": 0.6135281042, "num_tokens": 764, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.5583269943353745, "lm_q2_score": 0.588889130767832, "lm_q1q2_score": 0.32879269837837494}} {"text": "{-# LANGUAGE DataKinds, RankNTypes, TypeFamilies #-}\n{-# OPTIONS_GHC -Wno-incomplete-uni-patterns #-}\nmodule TestSingleGradient (testTrees) where\n\nimport Prelude\n\nimport qualified Data.Array.ShapedS as OS\nimport qualified Data.Strict.Vector as Data.Vector\nimport qualified Data.Vector.Generic as V\nimport Numeric.LinearAlgebra (Vector)\nimport Test.Tasty\nimport Test.Tasty.HUnit hiding (assert)\n\nimport HordeAd hiding (sumElementsVectorOfDual)\nimport HordeAd.Core.DualClass (IsPrimal, dAdd, dScale)\n\nimport TestCommon\n\ntestTrees :: [TestTree]\ntestTrees = [ testDReverse0\n , testDReverse1\n , testPrintDf\n , testDForward\n , testDFastForward\n , quickCheckForwardAndBackward\n , readmeTests\n , readmeTestsV\n ]\n\ndReverse0\n :: HasDelta r\n => (DualNumberVariables 'DModeGradient r\n -> DualMonadGradient r (DualNumber 'DModeGradient r))\n -> [r]\n -> ([r], r)\ndReverse0 f deltaInput =\n let ((results, _, _, _), value) =\n dReverse 1 f (V.fromList deltaInput, V.empty, V.empty, V.empty)\n in (V.toList results, value)\n\nfX :: DualMonad 'DModeGradient Float m\n => DualNumberVariables 'DModeGradient Float\n -> m (DualNumber 'DModeGradient Float)\nfX variables = do\n let x = var0 variables 0\n return x\n\nfX1Y :: DualMonad 'DModeGradient Float m\n => DualNumberVariables 'DModeGradient Float\n -> m (DualNumber 'DModeGradient Float)\nfX1Y variables = do\n let x = var0 variables 0\n y = var0 variables 1\n x1 <- x +\\ 1\n x1 *\\ y\n\nfXXY :: DualMonad 'DModeGradient Float m\n => DualNumberVariables 'DModeGradient Float\n -> m (DualNumber 'DModeGradient Float)\nfXXY variables = do\n let x = var0 variables 0\n y = var0 variables 1\n xy <- x *\\ y\n x *\\ xy\n\nfXYplusZ :: DualMonad 'DModeGradient Float m\n => DualNumberVariables 'DModeGradient Float\n -> m (DualNumber 'DModeGradient Float)\nfXYplusZ variables = do\n let x = var0 variables 0\n y = var0 variables 1\n z = var0 variables 2\n xy <- x *\\ y\n xy +\\ z\n\nfXtoY :: DualMonad 'DModeGradient Float m\n => DualNumberVariables 'DModeGradient Float\n -> m (DualNumber 'DModeGradient Float)\nfXtoY variables = do\n let x = var0 variables 0\n y = var0 variables 1\n x **\\ y\n\nfreluX :: DualMonad 'DModeGradient Float m\n => DualNumberVariables 'DModeGradient Float\n -> m (DualNumber 'DModeGradient Float)\nfreluX variables = do\n let x = var0 variables 0\n reluAct x\n\ntestDReverse0 :: TestTree\ntestDReverse0 = testGroup \"Simple dReverse application tests\" $\n map (\\(txt, f, v, expected) ->\n testCase txt $ dReverse0 f v @?= expected)\n [ (\"fX\", fX, [99], ([1.0],99.0))\n , (\"fX1Y\", fX1Y, [3, 2], ([2.0,4.0],8.0))\n , (\"fXXY\", fXXY, [3, 2], ([12.0,9.0],18.0))\n , (\"fXYplusZ\", fXYplusZ, [1, 2, 3], ([2.0,1.0,1.0],5.0))\n , ( \"fXtoY\", fXtoY, [0.00000000000001, 2]\n , ([2.0e-14,-3.2236188e-27],9.9999994e-29) )\n , (\"fXtoY2\", fXtoY, [1, 2], ([2.0,0.0],1.0))\n , (\"freluX\", freluX, [-1], ([0.0],0.0))\n , (\"freluX2\", freluX, [0], ([0.0],0.0))\n , (\"freluX3\", freluX, [0.0001], ([1.0],1.0e-4))\n , (\"freluX4\", freluX, [99], ([1.0],99.0))\n , (\"fquad\", fquad, [2, 3], ([4.0,6.0],18.0))\n , (\"scalarSum\", vec_omit_scalarSum_aux, [1, 1, 3], ([1.0,1.0,1.0],5.0))\n ]\n\nvec_omit_scalarSum_aux\n :: DualMonad d r m\n => DualNumberVariables d r -> m (DualNumber d r)\nvec_omit_scalarSum_aux vec = returnLet $ foldlDual' (+) 0 vec\n\nsumElementsV\n :: DualMonad d r m\n => DualNumberVariables d r -> m (DualNumber d r)\nsumElementsV variables = do\n let x = var1 variables 0\n returnLet $ sumElements0 x\n\naltSumElementsV\n :: DualMonad d r m\n => DualNumberVariables d r -> m (DualNumber d r)\naltSumElementsV variables = do\n let x = var1 variables 0\n returnLet $ altSumElements0 x\n\n-- hlint would complain about spurious @id@, so we need to define our own.\nid2 :: a -> a\nid2 x = x\n\nsinKonst\n :: DualMonad d r m\n => DualNumberVariables d r -> m (DualNumber d r)\nsinKonst variables = do\n let x = var1 variables 0\n return $ sumElements0 $\n sin x + (id2 $ id2 $ id2 $ konst1 1 2)\n\nsinKonstOut\n :: ( DualMonad d r m\n , Floating (Out (DualNumber d (Vector r))) )\n => DualNumberVariables d r -> m (DualNumber d r)\nsinKonstOut variables = do\n let x = var1 variables 0\n return $ sumElements0 $\n unOut $ sin (Out x) + Out (id2 $ id2 $ id2 $ konst1 1 2)\n\nsinDelayed :: (Floating a, IsPrimal d a) => DualNumber d a -> DualNumber d a\nsinDelayed (D u u') = delayD (sin u) (dScale (cos u) u')\n\nplusDelayed :: (Floating a, IsPrimal d a)\n => DualNumber d a -> DualNumber d a -> DualNumber d a\nplusDelayed (D u u') (D v v') = delayD (u + v) (dAdd u' v')\n\nsinKonstDelay\n :: DualMonad d r m\n => DualNumberVariables d r -> m (DualNumber d r)\nsinKonstDelay variables = do\n let x = var1 variables 0\n return $ sumElements0 $\n sinDelayed x `plusDelayed` (id2 $ id2 $ id2 $ konst1 1 2)\n\npowKonst\n :: DualMonad d r m\n => DualNumberVariables d r -> m (DualNumber d r)\npowKonst variables = do\n let x = var1 variables 0\n return $ sumElements0 $\n x ** (sin x + (id2 $ id2 $ id2 $ konst1 (sumElements0 x) 2))\n\npowKonstOut\n :: ( DualMonad d r m\n , Floating (Out (DualNumber d (Vector r))) )\n => DualNumberVariables d r -> m (DualNumber d r)\npowKonstOut variables = do\n let x = var1 variables 0\n return $ sumElements0 $\n x ** unOut (sin (Out x)\n + Out (id2 $ id2 $ id2 $ konst1 (sumElements0 x) 2))\n\npowKonstDelay\n :: DualMonad d r m\n => DualNumberVariables d r -> m (DualNumber d r)\npowKonstDelay variables = do\n let x = var1 variables 0\n return $ sumElements0 $\n x ** (sinDelayed x\n `plusDelayed` (id2 $ id2 $ id2 $ konst1 (sumElements0 x) 2))\n\nsinKonstS\n :: forall d r m. DualMonad d r m\n => DualNumberVariables d r -> m (DualNumber d r)\nsinKonstS variables = do\n let x = varS variables 0\n return $ sumElements0 $ fromS1\n ((sin x + (id2 $ id2 $ id2 $ konstS 1))\n :: DualNumber d (OS.Array '[2] r))\n\nsinKonstOutS\n :: forall r d m. ( DualMonad d r m\n , Floating (Out (DualNumber d (OS.Array '[2] r))) )\n => DualNumberVariables d r -> m (DualNumber d r)\nsinKonstOutS variables = do\n let x = varS variables 0\n return $ sumElements0 $ fromS1\n (unOut (sin (Out x) + Out (id2 $ id2 $ id2 $ konstS 1))\n :: DualNumber d (OS.Array '[2] r))\n\nsinKonstDelayS\n :: forall d r m. DualMonad d r m\n => DualNumberVariables d r -> m (DualNumber d r)\nsinKonstDelayS variables = do\n let x = varS variables 0\n return $ sumElements0 $ fromS1\n ((sinDelayed x `plusDelayed` (id2 $ id2 $ id2 $ konstS 1))\n :: DualNumber d (OS.Array '[2] r))\n\ndReverse1\n :: (r ~ Float, d ~ 'DModeGradient)\n => (DualNumberVariables d r -> DualMonadGradient r (DualNumber d r))\n -> [[r]]\n -> ([[r]], r)\ndReverse1 f deltaInput =\n let ((_, results, _, _), value) =\n dReverse 1 f\n (V.empty, V.fromList (map V.fromList deltaInput), V.empty, V.empty)\n in (map V.toList $ V.toList results, value)\n\ntestDReverse1 :: TestTree\ntestDReverse1 = testGroup \"Simple dReverse application to vectors tests\" $\n map (\\(txt, f, v, expected) ->\n testCase txt $ dReverse1 f v @?= expected)\n [ (\"sumElementsV\", sumElementsV, [[1, 1, 3]], ([[1.0,1.0,1.0]],5.0))\n , (\"altSumElementsV\", altSumElementsV, [[1, 1, 3]], ([[1.0,1.0,1.0]],5.0))\n , ( \"sinKonst\", sinKonst, [[1, 3]]\n , ([[0.5403023,-0.9899925]],2.982591) )\n , ( \"sinKonstOut\", sinKonstOut, [[1, 3]]\n , ([[0.5403023,-0.9899925]],2.982591) )\n , ( \"sinKonstDelay\", sinKonstDelay, [[1, 3]]\n , ([[0.5403023,-0.9899925]],2.982591) )\n , ( \"powKonst\", powKonst, [[1, 3]]\n , ([[108.7523,131.60072]],95.58371) )\n , ( \"powKonstOut\", powKonstOut, [[1, 3]]\n , ([[108.7523,131.60072]],95.58371) )\n , ( \"powKonstDelay\", powKonstDelay, [[1, 3]]\n , ([[108.7523,131.60072]],95.58371) )\n ]\n\ntestPrintDf :: TestTree\ntestPrintDf = testGroup \"Pretty printing test\" $\n map (\\(txt, f, v, expected) ->\n testCase txt $ prettyPrintDf False f\n (V.empty, V.fromList (map V.fromList v), V.empty, V.empty)\n @?= expected)\n [ ( \"sumElementsV\", sumElementsV, [[1 :: Float, 1, 3]]\n , unlines\n [ \"let0 DeltaId_0 = SumElements0 (Var1 (DeltaId 0)) 3\"\n , \"in Var0 (DeltaId 0)\" ] )\n , ( \"altSumElementsV\", altSumElementsV, [[1, 1, 3]]\n , unlines\n [ \"let0 DeltaId_0 = Add0\"\n , \" (Index0 (Var1 (DeltaId 0)) 2 3)\"\n , \" (Add0\"\n , \" (Index0 (Var1 (DeltaId 0)) 1 3)\"\n , \" (Add0 (Index0 (Var1 (DeltaId 0)) 0 3) Zero0))\"\n , \"in Var0 (DeltaId 0)\" ] )\n , ( \"sinKonst\", sinKonst, [[1, 3]]\n , unlines\n [ \"in SumElements0\"\n , \" (Add1\"\n , \" (Scale1 [ 0.5403023 , -0.9899925 ] (Var1 (DeltaId 0)))\"\n , \" (Konst1 Zero0 2))\"\n , \" 2\" ] )\n , ( \"sinKonstOut\", sinKonstOut, [[1, 3]]\n , unlines\n [ \"in SumElements0\"\n , \" (Outline1\"\n , \" PlusOut\"\n , \" [ [ 0.84147096 , 0.14112 ] , [ 1.0 , 1.0 ] ]\"\n , \" [ Outline1 SinOut [ [ 1.0 , 3.0 ] ] [ Var1 (DeltaId 0) ]\"\n , \" , Konst1 Zero0 2\"\n , \" ])\"\n , \" 2\" ] )\n , ( \"powKonst\", powKonst, [[1, 3]]\n , unlines\n [ \"in SumElements0\"\n , \" (Add1\"\n , \" (Scale1 [ 4.8414707 , 130.56084 ] (Var1 (DeltaId 0)))\"\n , \" (Scale1\"\n , \" [ 0.0 , 103.91083 ]\"\n , \" (Add1\"\n , \" (Scale1 [ 0.5403023 , -0.9899925 ] (Var1 (DeltaId 0)))\"\n , \" (Konst1 (SumElements0 (Var1 (DeltaId 0)) 2) 2))))\"\n , \" 2\" ] )\n , ( \"powKonstOut\", powKonstOut, [[1, 3]]\n , unlines\n [ \"in SumElements0\"\n , \" (Add1\"\n , \" (Scale1 [ 4.8414707 , 130.56084 ] (Var1 (DeltaId 0)))\"\n , \" (Scale1\"\n , \" [ 0.0 , 103.91083 ]\"\n , \" (Outline1\"\n , \" PlusOut\"\n , \" [ [ 0.84147096 , 0.14112 ] , [ 4.0 , 4.0 ] ]\"\n , \" [ Outline1 SinOut [ [ 1.0 , 3.0 ] ] [ Var1 (DeltaId 0) ]\"\n , \" , Konst1 (SumElements0 (Var1 (DeltaId 0)) 2) 2\"\n , \" ])))\"\n , \" 2\" ] )\n ]\n\ntestDForward :: TestTree\ntestDForward =\n testGroup \"Simple dForward application tests\" $\n map (\\(txt, f, v, expected) ->\n let vp = listsToParameters v\n in testCase txt $ dForward f vp vp @?= expected)\n [ (\"fquad\", fquad, ([2 :: Double, 3], []), (26.0, 18.0))\n , ( \"atanReadmeM\", atanReadmeM, ([1.1, 2.2, 3.3], [])\n , (7.662345305800865, 4.9375516951604155) )\n , ( \"vatanReadmeM\", vatanReadmeM, ([], [1.1, 2.2, 3.3])\n , (7.662345305800865, 4.9375516951604155) )\n ]\n\ntestDFastForward :: TestTree\ntestDFastForward =\n testGroup \"Simple dFastForward application tests\" $\n map (\\(txt, f, v, expected) ->\n let vp = listsToParameters v\n in testCase txt $ dFastForward f vp vp @?= expected)\n [ (\"fquad\", fquad, ([2 :: Double, 3], []), (26.0, 18.0))\n , ( \"atanReadmeM\", atanReadmeM, ([1.1, 2.2, 3.3], [])\n , (7.662345305800865, 4.9375516951604155) )\n , ( \"vatanReadmeM\", vatanReadmeM, ([], [1.1, 2.2, 3.3])\n , (7.662345305800865, 4.9375516951604155) )\n ]\n\n-- The formula for comparing derivative and gradient is due to @awf\n-- at https://github.com/Mikolaj/horde-ad/issues/15#issuecomment-1063251319\nquickCheckForwardAndBackward :: TestTree\nquickCheckForwardAndBackward =\n testGroup \"Simple QuickCheck of gradient vs derivative vs perturbation\"\n [ quickCheckTest0 \"fquad\" fquad (\\(x, y, _z) -> ([x, y], [], [], []))\n , quickCheckTest0 \"atanReadmeM\" atanReadmeM\n (\\(x, y, z) -> ([x, y, z], [], [], []))\n , quickCheckTest0 \"vatanReadmeM\" vatanReadmeM\n (\\(x, y, z) -> ([], [x, y, z], [], []))\n , quickCheckTest0 \"sinKonst\" sinKonst -- powKonst NaNs immediately\n (\\(x, _, z) -> ([], [x, z], [], []))\n , quickCheckTest0 \"sinKonstOut\" sinKonstOut\n (\\(x, _, z) -> ([], [x, z], [], []))\n , quickCheckTest0 \"sinKonstDelay\" sinKonstDelay\n (\\(x, _, z) -> ([], [x, z], [], []))\n , quickCheckTest0 \"sinKonstS\" sinKonstS\n (\\(x, _, z) -> ([], [], [], [x, z]))\n , quickCheckTest0 \"sinKonstOutS\" sinKonstOutS\n (\\(x, _, z) -> ([], [], [], [x, z]))\n , quickCheckTest0 \"sinKonstDelayS\" sinKonstDelayS\n (\\(x, _, z) -> ([], [], [], [x, z]))\n ]\n\n-- A function that goes from `R^3` to `R^2`, with a representation\n-- of the input and the output tuple that is convenient for interfacing\n-- with the library.\natanReadmeOriginal :: RealFloat a => a -> a -> a -> Data.Vector.Vector a\natanReadmeOriginal x y z =\n let w = x * sin y\n in V.fromList [atan2 z w, z * x]\n\n-- Here we instantiate the function to dual numbers\n-- and add a glue code that selects the function inputs from\n-- a uniform representation of objective function parameters\n-- represented as delta-variables (`DualNumberVariables`).\natanReadmeVariables\n :: IsScalar d r\n => DualNumberVariables d r -> Data.Vector.Vector (DualNumber d r)\natanReadmeVariables variables =\n let x : y : z : _ = vars variables\n in atanReadmeOriginal x y z\n\n-- According to the paper, to handle functions with non-scalar results,\n-- we dot-product them with dt which, for simplicity, we here set\n-- to a record containing only ones. We could also apply the dot-product\n-- automatically in the library code (though perhaps we should\n-- emit a warning too, in case the user just forgot to apply\n-- a loss function and that's the only reason the result is not a scalar?).\n-- For now, let's perform the dot product in user code.\n\n-- Here is the function for dot product with ones, which is just the sum\n-- of elements of a vector.\nsumElementsOfDualNumbers\n :: IsScalar d r\n => Data.Vector.Vector (DualNumber d r) -> DualNumber d r\nsumElementsOfDualNumbers = V.foldl' (+) 0\n\n-- Here we apply the function.\natanReadmeScalar\n :: IsScalar d r\n => DualNumberVariables d r -> DualNumber d r\natanReadmeScalar = sumElementsOfDualNumbers . atanReadmeVariables\n\n-- Here we introduce a single delta-let binding (`returnLet`) to ensure\n-- that if this code is used in a larger context and repeated,\n-- no explosion of delta-expressions can happen.\n-- If the code above had any repeated non-variable expressions\n-- (e.g., if @w@ appeared twice) the user would need to make it monadic\n-- and apply @returnLet@ already there.\natanReadmeM\n :: DualMonad d r m\n => DualNumberVariables d r -> m (DualNumber d r)\natanReadmeM = returnLet . atanReadmeScalar\n\n-- The underscores and empty vectors are placeholders for the vector,\n-- matrix and arbitrary tensor components of the parameters tuple,\n-- which we here don't use (above we construct a vector output,\n-- but it's a vector of scalar parameters, not a single parameter\n-- of rank 1).\natanReadmeDReverse :: HasDelta r\n => Domain0 r -> (Domain0 r, r)\natanReadmeDReverse ds =\n let ((result, _, _, _), value) =\n dReverse 1 atanReadmeM (ds, V.empty, V.empty, V.empty)\n in (result, value)\n\nreadmeTests :: TestTree\nreadmeTests = testGroup \"Simple tests for README\"\n [ testCase \" Float (1.1, 2.2, 3.3)\"\n $ atanReadmeDReverse (V.fromList [1.1 :: Float, 2.2, 3.3])\n @?= (V.fromList [3.0715904, 0.18288425, 1.1761366], 4.937552)\n , testCase \" Double (1.1, 2.2, 3.3)\"\n $ atanReadmeDReverse (V.fromList [1.1 :: Double, 2.2, 3.3])\n @?= ( V.fromList [ 3.071590389300859\n , 0.18288422990948425\n , 1.1761365368997136 ]\n , 4.9375516951604155 )\n ]\n\n-- And here's a version of the example that uses vector parameters\n-- (quite wasteful in this case) and transforms intermediate results\n-- via a primitive differentiable type of vectors instead of inside\n-- vectors of primitive differentiable scalars.\n\nvatanReadmeM\n :: DualMonad d r m\n => DualNumberVariables d r -> m (DualNumber d r)\nvatanReadmeM variables = do\n let xyzVector = var1 variables 0\n [x, y, z] = map (index0 xyzVector) [0, 1, 2]\n v = seq1 $ atanReadmeOriginal x y z\n returnLet $ sumElements0 v\n\nvatanReadmeDReverse :: HasDelta r\n => Domain1 r -> (Domain1 r, r)\nvatanReadmeDReverse dsV =\n let ((_, result, _, _), value) =\n dReverse 1 vatanReadmeM (V.empty, dsV, V.empty, V.empty)\n in (result, value)\n\nreadmeTestsV :: TestTree\nreadmeTestsV = testGroup \"Simple tests of vector-based code for README\"\n [ testCase \"V Float (1.1, 2.2, 3.3)\"\n $ vatanReadmeDReverse (V.singleton $ V.fromList [1.1 :: Float, 2.2, 3.3])\n @?= ( V.singleton $ V.fromList [3.0715904, 0.18288425, 1.1761366]\n , 4.937552 )\n , testCase \"V Double (1.1, 2.2, 3.3)\"\n $ vatanReadmeDReverse (V.singleton $ V.fromList [1.1 :: Double, 2.2, 3.3])\n @?= ( V.singleton $ V.fromList [ 3.071590389300859\n , 0.18288422990948425\n , 1.1761365368997136 ]\n , 4.9375516951604155 )\n ]\n", "meta": {"hexsha": "a17c18bea820fed083771edd6b1343252bf652b3", "size": 17012, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "test/common/TestSingleGradient.hs", "max_stars_repo_name": "Mikolaj/horde-ad", "max_stars_repo_head_hexsha": "1629942418f584f6b332dac0a7053338dc3bca70", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "test/common/TestSingleGradient.hs", "max_issues_repo_name": "Mikolaj/horde-ad", "max_issues_repo_head_hexsha": "1629942418f584f6b332dac0a7053338dc3bca70", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 22, "max_issues_repo_issues_event_min_datetime": "2022-01-27T11:10:21.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-31T12:03:54.000Z", "max_forks_repo_path": "test/common/TestSingleGradient.hs", "max_forks_repo_name": "Mikolaj/horde-ad", "max_forks_repo_head_hexsha": "1629942418f584f6b332dac0a7053338dc3bca70", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 35.9661733615, "max_line_length": 79, "alphanum_fraction": 0.6000470256, "num_tokens": 5786, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.6187804337438501, "lm_q2_score": 0.5312093733737563, "lm_q1q2_score": 0.3287019664650117}} {"text": "module Main where\n\nimport Data.Complex\nimport qualified ExampleSeeds as E\nimport Graphics.Gloss\nimport Seed ( drawSeed )\n\nmain :: IO ()\nmain = animate FullScreen (greyN 0.05) (drawSeed E.heartSeed)\n", "meta": {"hexsha": "9641a1649fc4a354babf73388f3623ff31dfe13c", "size": 271, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "app/Main.hs", "max_stars_repo_name": "juliagracedefoor/fourier-visualizer", "max_stars_repo_head_hexsha": "c690aa6ebd9a32ae885e61478cd29a6aa20e889c", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "app/Main.hs", "max_issues_repo_name": "juliagracedefoor/fourier-visualizer", "max_issues_repo_head_hexsha": "c690aa6ebd9a32ae885e61478cd29a6aa20e889c", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "app/Main.hs", "max_forks_repo_name": "juliagracedefoor/fourier-visualizer", "max_forks_repo_head_hexsha": "c690aa6ebd9a32ae885e61478cd29a6aa20e889c", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 27.1, "max_line_length": 61, "alphanum_fraction": 0.5608856089, "num_tokens": 58, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES\n\n", "lm_q1_score": 0.5544704649604273, "lm_q2_score": 0.5926665999540698, "lm_q1q2_score": 0.3286161252430486}} {"text": "-- |\n-- Module : BattleHack.Piano\n-- Description :\n-- Copyright : (c) Jonatan H Sundqvist, 2015\n-- License : MIT\n-- Maintainer : Jonatan H Sundqvist\n-- Stability : experimental\n-- Portability : POSIX\n\n-- Created September 12 2015\n\n-- TODO | - Split up into several modules\n-- -\n\n-- SPEC | -\n-- -\n\n\n\n--------------------------------------------------------------------------------------------------------------------------------------------\n-- GHC pragmas\n--------------------------------------------------------------------------------------------------------------------------------------------\n\n\n\n--------------------------------------------------------------------------------------------------------------------------------------------\n-- API\n--------------------------------------------------------------------------------------------------------------------------------------------\nmodule BattleHack.Piano where\n\n\n\n--------------------------------------------------------------------------------------------------------------------------------------------\n-- We'll need these\n--------------------------------------------------------------------------------------------------------------------------------------------\nimport Control.Lens hiding (inside)\nimport Data.List (find)\nimport Data.Complex\n\nimport BattleHack.Types\nimport BattleHack.Lenses\nimport BattleHack.Utilities.Vector\nimport BattleHack.Utilities.General\n\n\n\n--------------------------------------------------------------------------------------------------------------------------------------------\n-- Data\n--------------------------------------------------------------------------------------------------------------------------------------------\n-- |\nnaturals :: Integral n => [n]\nnaturals = [0, 2, 4, 5, 7, 9, 11]\n\n\n-- |\naccidentals :: Integral n => [n]\naccidentals = [1, 3, 6, 8, 10]\n\n\n-- | The indeces of every natural key in order, starting at C0 (index 0)\nallnaturals :: [Int]\nallnaturals = zipWith (\\i key -> div i 7 * 12 + key) [0..] $ cycle naturals\n\n\n-- | The indeces of every accidental key in order, starting at C#0 (index 1)\nallaccidentals :: [Int]\nallaccidentals = zipWith (\\i key -> div i 5 * 12 + key) [0..] $ cycle accidentals\n\n\n-- |\nchordlayout :: [KeyLayout]\nchordlayout = [KeyRight, KeyAccidental, KeyBoth, KeyAccidental, KeyLeft, KeyRight, KeyAccidental, KeyBoth, KeyAccidental, KeyBoth, KeyAccidental, KeyLeft]\n\n\n-- | Horizontal offset for each key in the octave, relative to the very first key\nkeysteps :: RealFloat r => [r]\nkeysteps = scanl1 (+) [0, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1]\n\n\n\n--------------------------------------------------------------------------------------------------------------------------------------------\n-- Functions\n--------------------------------------------------------------------------------------------------------------------------------------------\n-- |\nkeyorigin :: PianoSettings -> Int -> Vector\nkeyorigin piano i = piano-->origin + (sx*shiftx :+ 0)\n where\n (sx:+_) = piano-->keysize\n shiftx = 7*octaveFromKeyIndex i + (keysteps !! (i `mod` 12))\n\n\n-- |\nkeylayout :: Int -> KeyLayout\nkeylayout i = chordlayout !! (i `mod` 12)\n\n\n-- | Is the point inside the bounds of the given key?\n-- Note that the function assumes that the key is pinned to the origin.\n-- TODO: Bugs ahead (swat them!)\n-- TODO: Rename (?)\ninside :: PianoSettings -> KeyLayout -> Vector -> Bool\ninside piano KeyLeft p = insideBounds piano p && not (insideLeft piano p)\ninside piano KeyRight p = insideBounds piano p && not (insideRight piano p)\ninside piano KeyBoth p = insideBounds piano p && not (insideLeft piano p || insideRight piano p)\ninside piano KeyAccidental p = insideMiddle piano p -- --insideLeft piano p || insideRight piano p\n\n\n-- | Is the point within the rectangular bounding box of the key?\ninsideBounds :: PianoSettings -> Vector -> Bool\ninsideBounds piano (x:+y) = let (dx:+dy) = piano-->keysize in between 0 dx x && between 0 dy y\n\n\n-- | Is the point within the left indent of the key?\ninsideLeft :: PianoSettings -> Vector -> Bool\ninsideLeft piano (x:+y) = let (dx:+dy) = dotwise (*) (piano-->indent :+ piano-->mid) (piano-->keysize) in between 0 dx x && between 0 dy y\n\n\n-- | Is the point within the right indent of the key?\n-- TODO: Buggy!\ninsideRight :: PianoSettings -> Vector -> Bool\ninsideRight piano p = let shiftx = piano-->keysize.real * (piano-->indent - 1) in insideLeft piano $ p + (shiftx:+0)\n-- insideRight piano p = let shiftx = piano-->keysize.real * (1 - piano-->indent) in insideLeft piano $ p - (piano-->keysize.real:+0) + ((piano-->keysize.real*piano-->indent):+0)\n-- insideRight piano (x:+y) = between ()\n\n\n-- |\ninsideMiddle :: PianoSettings -> Vector -> Bool\ninsideMiddle piano (x:+y) = let (ox:+oy, dx:+dy) = keybounds piano KeyAccidental in between ox (ox+dx) x && between oy (oy+dy) y\n\n\n-- |\n-- TODO: Move to Piano\n-- TODO: Rename (?)\nlayout :: RealFloat r => Complex r -> r -> r -> KeyLayout -> [Complex r]\nlayout (sx:+sy) indent mid which = case which of\n KeyRight -> [nw, nei, rmi, rm, se, sw]\n KeyBoth -> [nwi, nei, rmi, rm, se, sw, lm, lmi]\n KeyLeft -> [nwi, ne, se, sw, lm, lmi]\n KeyAccidental -> [nei, rmi, (sx:+0)+lmi, (sx:+0)+nwi]\n where\n indent' = sx*indent\n mid' = sy*mid\n\n nw = 0:+0 -- North west\n ne = sx:+0 -- North east\n se = sx:+sy -- South east\n sw = 0:+sy -- South west\n\n nwi = indent':+0 -- North west indented\n nei = (sx-indent'):+0 -- North east indented\n\n lmi = indent':+mid' -- Left middle indent\n rmi = (sx-indent'):+mid' -- Right middle indent\n\n lm = 0:+mid' -- Left middle\n rm = sx:+mid' -- Right middle\n\n\n-- | Rectangular bounds of a key (currently as a topleft, size tuple)\n-- TODO: Use Bounding Box type (?)\nkeybounds :: PianoSettings -> KeyLayout -> (Vector, Vector)\nkeybounds piano layout = case layout of\n KeyAccidental -> (piano-->keysize.real' - (indent':+0), (2*indent'):+mid')\n _ -> (0:+0, piano-->keysize)\n where\n (indent':+mid') = dotwise (*) (piano-->keysize) (piano-->indent:+piano-->mid)\n\n\n-- |\n-- TODO: Simplify\n-- TODO: Don't hard-code the range\n-- TODO: This is a pretty dumb algorithm for finding hovered-over keys\nfindKeyAt :: Vector -> PianoSettings -> Maybe Int\nfindKeyAt p piano' = find (insideFromKeyIndex piano' p) (zipWith const [0..] (piano'-->keys))\n\n\n-- | Is the point inside the key at the given index?\n-- TODO: Rename (?)\ninsideFromKeyIndex :: PianoSettings -> Vector -> Int -> Bool\ninsideFromKeyIndex piano' p i = inside piano' (keylayout i) (p-keyorigin piano' i)\n\n-- |\npitchFromKeyIndex :: RealFloat r => Int -> r\npitchFromKeyIndex i = let i' = i+4+49 in 440.0*2.0**((fromIntegral i' - 49)/12.0) -- TODO: Make sure this is correct, elaborate on the meaning of the different index conversions\n-- pitchFromKeyIndex i = 440*2**((fromIntegral $ i+3 + 12*4-49)/12)\n\n\n-- | Which octave does the key belong to (the 0th octave starts with C0, the 1st with C1; no overlap between octaves)\noctaveFromKeyIndex :: RealFloat r => Int -> r\noctaveFromKeyIndex = fromIntegral . (`div` 12)\n\n\n-- |\n-- TODO: Refactor\n-- TODO: Use Unicode (?)\nnotenameFromKeyIndex :: Int -> String\nnotenameFromKeyIndex i = [\"C\", \"C#\", \"D\", \"D#\", \"E\", \"F\", \"F#\", \"G\", \"G#\", \"A\", \"A#\", \"B\"] !! mod i 12\n", "meta": {"hexsha": "aee3a4c79a0801d1f67c8361c59c374a17baaf5f", "size": 7357, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/BattleHack/Piano.hs", "max_stars_repo_name": "SwiftsNamesake/BattleHack-2015", "max_stars_repo_head_hexsha": "14b47f3482dc80ee1469161a0cebb5a0e1b16a05", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/BattleHack/Piano.hs", "max_issues_repo_name": "SwiftsNamesake/BattleHack-2015", "max_issues_repo_head_hexsha": "14b47f3482dc80ee1469161a0cebb5a0e1b16a05", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/BattleHack/Piano.hs", "max_forks_repo_name": "SwiftsNamesake/BattleHack-2015", "max_forks_repo_head_hexsha": "14b47f3482dc80ee1469161a0cebb5a0e1b16a05", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 37.1565656566, "max_line_length": 178, "alphanum_fraction": 0.5174663586, "num_tokens": 1875, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.7371581626286833, "lm_q2_score": 0.4455295350395727, "lm_q1q2_score": 0.328425733446583}} {"text": "{-# LANGUAGE OverloadedStrings #-}\n{-# LANGUAGE DataKinds #-}\n{-# LANGUAGE TypeFamilies #-}\n{-# LANGUAGE RecordWildCards #-}\n{-# LANGUAGE ScopedTypeVariables #-}\n{-# LANGUAGE TypeSynonymInstances #-}\n{-# LANGUAGE FlexibleInstances #-}\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE FlexibleContexts #-}\n\nmodule Main where\n\nimport Lens.Micro.Extras (view)\nimport qualified Data.Text.IO as Text (readFile)\nimport Data.Text (lines)\nimport Data.Maybe (mapMaybe, fromMaybe)\nimport Data.List (zip4) --, foldl')\n\nimport Control.Monad (forM_)\nimport Control.Monad.Random (evalRand)\nimport System.Random (mkStdGen, RandomGen)\nimport qualified System.Random as SR (split)\n\nimport Data.Semigroup ((<>))\nimport Options.Applicative (Parser, option, auto, optional, long, short, value,\n strOption, helper, idm, execParser, info, (<**>), (<|>),\n flag')\nimport qualified Data.ByteString as B\nimport Data.Serialize (Serialize, runPut, put, runGet, get) --, Get\nimport System.Directory (createDirectoryIfMissing)\n\nimport Numeric.LinearAlgebra.Static ((#), (&), R, unwrap, konst) --, zipWithVector)\nimport Numeric.LinearAlgebra (toList)\n\n--import GHC.TypeLits\nimport Data.Singletons (Sing, SomeSing(SomeSing), toSing)\nimport Data.Singletons.TypeLits (KnownNat, Nat, Sing(SNat))\nimport Data.Singletons.Prelude.List (Head, Last)\n\nimport Grenade (Network, FullyConnected, Tanh, Logit, Shape(D1), --Relu,\n LearningParameters(LearningParameters), randomNetwork, S(S1D),\n Gradients)\n--import Grenade (Network((:~>), NNil), FullyConnected(FullyConnected), FullyConnected'(FullyConnected'), Tanh, Logit, Shape(D1), runNet, Relu,\n-- LearningParameters(LearningParameters), randomNetwork, S(S1D))\n\nimport GrenadeExtras (binaryNetError, trainOnBatchesEpochs, normalize, hotvector)\nimport GrenadeExtras.Zip (Zip)\n--import GrenadeExtras.Orphan()\nimport GrenadeExtras.GradNorm (GradNorm)\n\nimport Song (Song, line2song, genre)\nimport Song.Grenade (song2TupleRn) --, SongSD)\nimport Shuffle (shuffle) -- TODO: use the \"standard\" shuffleM http://hackage.haskell.org/package/random-shuffle\n\n--import Debug.Trace (trace)\n\ntype LogisticRegression = Network '[ FullyConnected 75 1, Logit ]\n '[ 'D1 75, 'D1 1, 'D1 1 ]\n\ntype OneHiddenLayer n = Network '[ FullyConnected 75 n, Tanh, FullyConnected n 1, Logit ]\n '[ 'D1 75, 'D1 n, 'D1 n, 'D1 1, 'D1 1 ]\n\ntype DiscreteSepContinuousNet = Network '[ Zip ('D1 21) ('D1 2) (FullyConnected 21 2) ('D1 54) ('D1 2) (FullyConnected 54 2),\n Tanh, FullyConnected 4 1,\n Logit ]\n '[ 'D1 75, 'D1 4, 'D1 4, 'D1 1, 'D1 1 ]\n\ntype HugeNetwork = Network '[ FullyConnected 75 40, Tanh, FullyConnected 40 10, Tanh, FullyConnected 10 3, Tanh, FullyConnected 3 1, Logit ]\n '[ 'D1 75, 'D1 40, 'D1 40, 'D1 10, 'D1 10, 'D1 3, 'D1 3, 'D1 1, 'D1 1 ]\n\n--type FFNet = Network '[ FullyConnected 75 100, Tanh, FullyConnected 100 40, Tanh, FullyConnected 40 20, Relu, FullyConnected 20 1, Logit ]\n-- '[ 'D1 75, 'D1 100, 'D1 100, 'D1 40, 'D1 40, 'D1 20, 'D1 20, 'D1 1, 'D1 1 ]\n\n--netLoad :: KnownNat n => FilePath -> IO (OneHiddenLayer n)\nnetLoad :: Serialize b => FilePath -> IO b\nnetLoad modelPath = do\n modelData <- B.readFile modelPath\n either fail return $ runGet get modelData\n\ncreateKFoldPartitions :: Int -> [a] -> (Int, [([a],[a])])\ncreateKFoldPartitions size ks = (parts, take parts . separateTrainAndValidLists . splitInSizes $ ks)\n where\n len = length ks\n parts = floor $ fromIntegral len / (fromIntegral size :: Double)\n\n splitInSizes :: [a] -> [[a]]\n splitInSizes [] = []\n splitInSizes xs =\n let (start, finish) = splitAt size xs\n in start : splitInSizes finish\n\n separateTrainAndValidLists :: [[a]] -> [([a], [a])]\n separateTrainAndValidLists = fmap (\\(t,v)->(t [], v)) . separate' ([]++)\n\n separate' :: ([a]->[a]) -> [[a]] -> [([a]->[a], [a])]\n separate' acc [x] = [(acc, x)]\n separate' acc (x:xs) = (acc . (concat xs++), x) : separate' (acc . (x++)) xs\n separate' _ [] = error \"this should never happen, the size of the partition is too big to even hold an element\"\n\nsaveScores :: FilePath -> [NetScore] -> IO ()\nsaveScores logsPath scores = writeFile logsPath (headScores<>\"\\n\"<>scoresStr) -- TODO: catch IO Errors!\n where\n scoresStr :: String\n scoresStr = mconcat . fmap netScore2String $ zip [(0::Int)..] scores\n\n netScore2String (i, NetScore{..}) = show i <> \"\\t\"\n <> show trainClassError <> \"\\t\"\n <> show trainingError <> \"\\t\"\n <> show testClassError <> \"\\t\"\n <> show gradientNorm <> \"\\n\"\n\n headScores = \"epoch\\ttrain_classification_error\\ttrain_error\\ttest_classification_error\\tgradient_norm\"\n\n-- Reading data and running code\n\nfilenameDataset :: String\nfilenameDataset = \"./msd_genre_dataset.txt\"\n\ngetSongs :: String -> IO [Song]\ngetSongs filename = do\n --putStrLn \"Reading data file ...\" -- <- this doesn't work by the lazy nature of haskell\n file <- Text.readFile filename\n --let listLines = drop 10 $ Data.Text.lines file\n let listLines = Data.Text.lines file\n all_songs = mapMaybe line2song listLines\n return $ filter inRightGenre all_songs\n\n where inRightGenre song = let g = view genre song\n in g == \"dance and electronica\" || g == \"jazz and blues\"\n\nlabelSong :: String -> Double\nlabelSong \"dance and electronica\" = 1\nlabelSong _ = 0\n\ndata StoppingCondition = StoppingCondition { -- stop training if either:\n maxEpochs :: Int, -- maximum total epochs has been reached\n gradientSmallerthan :: (Double, Int), -- gradient is smaller than `d` for at least `i` consecutive epochs\n stuckInARange :: (Double, Int) -- or, the error hasn't changed more than `d` in the last `i` consecutive epochs\n }\n\ndata TypeOfModelToTrain = LogitRegModel | OneHiddenLayerModel Integer | ArbitraryNNModel Int\n\ndata ModelsParameters =\n ModelsParameters\n Float -- Size of test set\n Int -- Size of batch\n Bool -- Normalize data\n StoppingCondition\n LearningParameters -- Parameters for Gradient Descent\n (Maybe FilePath) -- Load path\n (Maybe FilePath) -- Save path\n (Maybe FilePath) -- Logs path\n (Maybe Double) -- K-fold size of validation set\n TypeOfModelToTrain\n\nmodelsParameters :: Parser ModelsParameters\nmodelsParameters =\n ModelsParameters <$> option auto (long \"test-set\" <> short 't' <> value 0.15)\n <*> option auto (long \"batch-size\" <> short 'b' <> value 40)\n <*> option auto (long \"normalize\" <> value True)\n <*> ( StoppingCondition\n <$> option auto (long \"epochs\" <> short 'e' <> value 300)\n <*> option auto (long \"gradient-smaller\" <> short 'g' <> value (0.085, 3))\n <*> option auto (long \"max-error-change\" <> value (0.004, 15))\n )\n <*> (LearningParameters\n <$> option auto (long \"train_rate\" <> short 'r' <> value 0.01)\n <*> option auto (long \"momentum\" <> value 0.9)\n <*> option auto (long \"l2\" <> value 0) -- 0.0005\n )\n <*> optional (strOption (long \"load\"))\n <*> optional (strOption (long \"save\"))\n <*> optional (strOption (long \"logs\"))\n <*> optional (option auto (long \"k-fold-val-size\"))\n <*> ( flag' LogitRegModel (long \"logit-reg\")\n <|> (OneHiddenLayerModel <$> option auto (long \"one-hidden-layer\" <> short 'h'))\n <|> (ArbitraryNNModel <$> option auto (long \"arbitrary-nn\"))\n )\n\naddLog :: KnownNat n => R n -> R n\naddLog a = signum a * log (abs a+1)\n\ndiscreteToOneHotVector :: R 3 -> R 21\ndiscreteToOneHotVector featDiscre = (fromMaybe (konst 0) $ hotvector (round a)::R 8)\n # (fromMaybe (konst 0) $ hotvector (round b)::R 12)\n & c\n where (a,b,c) = case toList $ unwrap featDiscre of\n [a',b',c'] -> (a',b',c')\n _ -> error $ \"This is weird, there should be only three discrete \"\n <> \"features (R 3), aka. this never happens but the compiler \"\n <> \"asks me to give an exahustive list for pattern matching, doh'\"\n\ntakeWhileCond :: ([a] -> [b]) -> (b -> Bool) -> [a] -> [a]\ntakeWhileCond toCond stopCond xs = fmap snd . takeWhile (stopCond . fst) $ zip (toCond xs) xs\n\ndata NetScore = NetScore {\n trainClassError :: Double, -- Classification training error\n trainingError :: Double, -- (optimization) training error\n testClassError :: Double, -- Classification testing error\n gradientNorm :: Double -- accumulated norm of the gradients on an epoch\n} deriving (Show)\n\nnetScore :: (Last shapes ~ 'D1 1, Foldable t)\n => t (S (Head shapes), S ('D1 1))\n -> t (S (Head shapes), S ('D1 1))\n -> (Double, Network layers shapes)\n -> NetScore\nnetScore trainSet testSet (gradNorm, nn) =\n let (trainCE, trainE) = binaryNetError nn trainSet\n (testCE, _) = binaryNetError nn testSet\n in\n NetScore { trainClassError = trainCE,\n trainingError = trainE,\n testClassError = testCE,\n gradientNorm = gradNorm }\n\ntakeWhileCondFunc :: Show a => StoppingCondition -> [(a, NetScore)] -> [(a, NetScore)]\ntakeWhileCondFunc (StoppingCondition epochs (grad, giters) (stuck, siters)) =\n -- trace (\"hi\" <> show (head (takeWhileCond maxErrorChangeInSIters (stuck)\n where\n consecutiveSmallerThanGrad :: [(a, NetScore)] -> [Int]\n consecutiveSmallerThanGrad = (0:) . countConsecutive (0::Int) . fmap (trainClassError . snd)\n where\n countConsecutive _ [] = []\n countConsecutive cond (x:xs) =\n let condVal = if x [Double]\n maxErrorChangeInSIters = (replicate siters (stuck+1) <>) . fmap findMaxChange . groupOnSIters . fmap (trainClassError . snd)\n where groupOnSIters :: [a] -> [[a]]\n groupOnSIters [] = []\n groupOnSIters xs@(_:xs') = take siters xs : groupOnSIters xs'\n findMaxChange :: [Double] -> Double\n findMaxChange xs = maximum xs - minimum xs\n\nloadModel (Just loadFile) _ = netLoad loadFile\nloadModel Nothing seedNet = return $ evalRand randomNetwork seedNet\n\nmain :: IO ()\nmain = do\n mparams@(ModelsParameters _ _ _ _ _ load _ _ _ modelType) <- execParser (info (modelsParameters <**> helper) idm)\n\n let (seedNet, randSeed) = SR.split (mkStdGen 487239842)\n\n case modelType of\n LogitRegModel ->\n (loadModel load seedNet :: IO LogisticRegression) >>= mainWithRandmNet mparams randSeed\n\n OneHiddenLayerModel sizeHidden ->\n let (singSizeHidden :: SomeSing Nat) = toSing sizeHidden\n in case singSizeHidden of\n SomeSing (SNat :: Sing n) ->\n (loadModel load seedNet :: IO (OneHiddenLayer n)) >>=\n mainWithRandmNet mparams randSeed\n\n ArbitraryNNModel arbModelNum ->\n case arbModelNum of\n 1 -> (loadModel load seedNet :: IO DiscreteSepContinuousNet) >>= mainWithRandmNet mparams randSeed\n 2 -> (loadModel load seedNet :: IO HugeNetwork) >>= mainWithRandmNet mparams randSeed\n _ -> putStrLn $ \"Sorry but there is no arbitrary neural net number \" <> show arbModelNum\n\n\nmainWithRandmNet :: (Head shapes ~ 'D1 75,\n Last shapes ~ 'D1 1,\n Show (Network layers shapes),\n Serialize (Network layers shapes),\n GradNorm (Gradients layers),\n Num (Gradients layers),\n RandomGen g)\n => ModelsParameters -> g -> Network layers shapes -> IO ()\nmainWithRandmNet mparams randSeed net0 = do\n let (seedShuffle, seedTraining) = SR.split randSeed\n ModelsParameters testPerc batchSize norm stopCond rate _ save logs kfoldValPer modelType = mparams\n modelName = case modelType of\n LogitRegModel -> fromMaybe \"logitReg\" logs\n OneHiddenLayerModel sizeHidden -> fromMaybe \"hidden\" logs <> \"-\" <> show sizeHidden\n ArbitraryNNModel arbModelNum ->\n fromMaybe \"arbitrary\" logs <> \"-\" <> case arbModelNum of\n 1 -> \"separated_discrete_continuous\"\n 2 -> \"huge_network\"\n _ -> error $ \"There is no arbitrary Neural Net model #\" <> show arbModelNum\n\n putStrLn $ \"Model name: \" <> modelName\n\n let normFun :: KnownNat m => [R m] -> [R m]\n normFun = if norm then normalize else id\n\n -- Loading songs\n songsRaw <- fmap (song2TupleRn labelSong) <$> getSongs filenameDataset\n let songsDiscrete :: [R 3]\n songsDiscrete = fmap (fst . fst) songsRaw\n songsDisOneHotVector :: [R 21]\n songsDisOneHotVector = fmap discreteToOneHotVector songsDiscrete\n --songsFloat :: [R 27]\n songsFloat = fmap (snd . fst) songsRaw\n --songsLog :: [R 27]\n songsLog = fmap addLog songsFloat\n --songsLabel :: [R 1]\n songsLabel = fmap snd songsRaw\n --songs :: [(S ('D1 57), S ('D1 1))]\n songs = (\\(l1,l2,l3,o)->(S1D (l1#l2#l3), S1D o)) <$> zip4 songsDisOneHotVector (normFun songsFloat) (normFun songsLog) songsLabel\n\n --print . toList . unwrap $ foldl1' (zipWithVector max) songsDiscrete\n --print . toList . unwrap $ foldl1' (zipWithVector min) songsDiscrete\n\n let sizeSongs = length songsRaw\n -- Shuffling songs\n shuffledSongs = evalRand (shuffle songs) seedShuffle\n (testSet, trainSet) = splitAt (round $ fromIntegral sizeSongs * testPerc) shuffledSongs\n\n {-\n -case net0 of\n - x@(FullyConnected (FullyConnected' i o) _) :~> _ -> do\n - let subnet = x :~> NNil :: Network '[FullyConnected 75 n] '[ 'D1 75, 'D1 n ]\n - print $ runNet subnet (S1D 0) -- with this we get the biases\n - --print . sqrt . normSquared $ net0\n - print i -- biases for each output neuron\n - print o -- weights between neurons\n -}\n\n -- Pretraining scores\n --print $ head shuffledSongs\n putStrLn $ \"Total Size: \" <> show sizeSongs\n putStrLn $ \"Test Size: \" <> show (length testSet)\n putStrLn $ \"Batch Size: \" <> show batchSize\n\n case kfoldValPer of\n Nothing -> trainNet net0 trainSet testSet rate batchSize seedTraining stopCond logs save\n Just valPer -> do\n let valSize = floor $ fromIntegral sizeSongs * valPer\n (parts, kfoldSets) = createKFoldPartitions valSize trainSet\n putStrLn $ \"Validation Size: \" <> show valSize\n putStrLn $ \"Total parts for kfold: \" <> show parts\n\n forM_ (zip [(1::Int)..] kfoldSets) $ \\(kfoldNum, (trainSet', valSet)) -> do\n let dirSaveNet = \"kfold-val\" <> show valPer <> \"/\" <> modelName <> \"/\" <> \"kfoldnet\" <> \"-\" <> show kfoldNum\n logsKfoldN = dirSaveNet <> \".txt\"\n saveKfoldN = dirSaveNet <> \"/\" <> fromMaybe \"nnet-hidden\" save\n putStrLn \"\"\n createDirectoryIfMissing True dirSaveNet -- TODO: catch exceptions\n putStrLn $ \"Results to be saved in \" <> logsKfoldN\n putStrLn $ \"Nets to be saved in \" <> saveKfoldN\n trainNet net0 trainSet' valSet rate batchSize seedTraining stopCond (Just logsKfoldN) (Just saveKfoldN)\n\n\ntrainNet :: (Last shapes ~ 'D1 1,\n RandomGen g,\n Num (Gradients layers),\n GradNorm (Gradients layers),\n Show (Network layers shapes),\n Serialize (Network layers shapes))\n => Network layers shapes\n -> [(S (Head shapes), S (Last shapes))]\n -> [(S (Head shapes), S ('D1 1))]\n -> LearningParameters\n -> Int\n -> g\n -> StoppingCondition\n -> Maybe FilePath\n -> Maybe FilePath\n -> IO ()\ntrainNet net0 trainSet testSet rate batchSize seedTraining stopCond logs save = do\n -- Training Net\n let netsInf = (read \"Infinity\", net0) : evalRand (trainOnBatchesEpochs net0 rate trainSet batchSize) seedTraining\n netsScoresInf = fmap (netScore trainSet testSet) netsInf\n\n (nets, netsScores) = unzip . takeWhileCondFunc stopCond $ zip (fmap snd netsInf) netsScoresInf\n --net = last nets\n\n putStrLn $ \"Epoch\"\n <> \"\\tTraining classification error\"\n <> \"\\tTraining error\"\n <> \"\\tTesting error\"\n <> \"\\tGradNorm\"\n\n -- Showing results of training net\n forM_ (zip3 [(0::Integer)..] netsScores nets) $ \\(epoch, NetScore trainCE trainE testE gradNorm, currentNet) -> do\n putStrLn $ show epoch\n <> \"\\t\" <> show trainCE\n <> \"\\t\" <> show trainE\n <> \"\\t\" <> show testE\n <> \"\\t\" <> show gradNorm\n -- saving current trained net\n case save of\n Just saveFile -> let saveFileBin = saveFile <> \"-e_\" <> show epoch\n <> \"-trainCE_\" <> show trainCE\n <> \"-testE_\" <> show testE\n <> \".bin\"\n in B.writeFile saveFileBin $ runPut (put currentNet)\n Nothing -> return ()\n\n case logs of\n Just logsPath -> saveScores logsPath netsScores\n Nothing -> return ()\n\n --case save of\n -- Just saveFile -> B.writeFile saveFile $ runPut (put net)\n -- Nothing -> return ()\n", "meta": {"hexsha": "60484a9da06d85bd1e8da702862d2a9407936338", "size": 18592, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "app/Main.hs", "max_stars_repo_name": "helq/haskell-binary-classification", "max_stars_repo_head_hexsha": "e5c6c9a741532365a335657b8d36775bb8a676e6", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2017-10-02T06:05:23.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-12T11:49:35.000Z", "max_issues_repo_path": "app/Main.hs", "max_issues_repo_name": "helq/haskell-binary-classification", "max_issues_repo_head_hexsha": "e5c6c9a741532365a335657b8d36775bb8a676e6", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "app/Main.hs", "max_forks_repo_name": "helq/haskell-binary-classification", "max_forks_repo_head_hexsha": "e5c6c9a741532365a335657b8d36775bb8a676e6", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-06-12T14:57:00.000Z", "max_forks_repo_forks_event_max_datetime": "2021-06-12T14:57:00.000Z", "avg_line_length": 46.2487562189, "max_line_length": 154, "alphanum_fraction": 0.5818093804, "num_tokens": 4773, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.7371581626286833, "lm_q2_score": 0.4455295350395727, "lm_q1q2_score": 0.328425733446583}} {"text": "module Lib (\n readExpr\n , eval\n , valueToPrint\n) where\n\nimport Control.Monad\nimport Control.Monad.Error\nimport Control.Monad.Error.Class\nimport Data.Array\nimport Data.Complex\nimport Data.Ratio\nimport Numeric\n\nimport Text.ParserCombinators.Parsec hiding (spaces)\n\ndata LispVal = Atom String\n | Vector (Array Int LispVal)\n | List [LispVal]\n | DottedList [LispVal] LispVal\n | Number Integer\n | Real Double\n | Rational Rational\n | Complex (Complex Double)\n | String String\n | Character Char\n | Bool Bool\n\ndata LispError = NumArgs Integer [LispVal]\n | TypeMismatch String LispVal\n | Parser ParseError\n | BadSpecialForm String LispVal\n | NotFunction String String\n | UnboundVar String String\n | Default String\n\ntype ThrowsError = Either LispError\n\nshowVals :: [LispVal] -> String\nshowVals = unwords . map show\n\ninstance Show LispVal where\n show (Atom name) = name\n show (Vector contents) = \"(\" ++ (showVals $ elems contents) ++ \")\"\n show (List contents) = \"(\" ++ showVals contents ++ \")\"\n show (DottedList init last) = \"(\" ++ showVals init ++ \" . \" ++ show last ++ \")\"\n show (Number n) = show n\n show (Real x) = show x\n show (Rational r) = show r\n show (Complex c) = show c\n show (String content) = content\n show (Character c) = charToString c\n show (Bool True) = \"#t\"\n show (Bool False) = \"#f\"\n\ninstance Show LispError where\n show (UnboundVar message varname) = message ++ \": \" ++ varname\n show (BadSpecialForm message form) = message ++ \": \" ++ show form\n show (NotFunction message func) = message ++ \": \" ++ show func\n show (NumArgs expected found) = \"Expected \" ++ show expected ++ \" arguments. Found values \" ++ showVals found\n show (TypeMismatch expected found) = \"Invalid type: expected \" ++ expected ++ \", found \" ++ show found\n show (Parser parseErr) = \"Parse error at \" ++ show parseErr\n\ninstance Error LispError where\n noMsg = Default \"An error has occurred\"\n strMsg = Default\n\nsymbol :: Parser Char\nsymbol = oneOf \"!$%&|*+-/:<=>?@^_~\"\n\nparseAtom :: Parser LispVal\nparseAtom = do\n first <- letter <|> symbol\n rest <- many (letter <|> digit <|> symbol)\n let atom = first:rest\n return $ Atom atom\n\nspaces :: Parser ()\nspaces = skipMany1 space\n\nparseVector' :: Parser LispVal\nparseVector' = do\n vectorValues <- sepBy parseExpr spaces\n return $ Vector (listArray (0, (length vectorValues - 1)) vectorValues)\n\nparseVector :: Parser LispVal\nparseVector = do\n string \"#(\"\n x <- parseVector'\n char ')'\n return x\n\nparseDatum :: Parser LispVal\nparseDatum = do\n char '.'\n spaces\n parseExpr\n\nparseListContent :: Parser LispVal\nparseListContent = do\n list <- sepEndBy parseExpr spaces\n datum <- optionMaybe parseDatum\n return $ case datum of\n Nothing -> List list\n Just datum -> DottedList list datum\n\nparseList :: Parser LispVal\nparseList = do\n char '('\n list <- parseListContent\n char ')'\n return list\n\nparseQuoted :: Parser LispVal\nparseQuoted = do\n char '\\''\n x <- parseExpr\n return $ List [Atom \"quote\", x]\n\nparseQuasiQuoted :: Parser LispVal\nparseQuasiQuoted = do\n char '`'\n x <- parseExpr\n return $ List [Atom \"quasiquote\", x]\n\nparseUnquoted :: Parser LispVal\nparseUnquoted = do\n char ','\n x <- parseExpr\n return $ List [Atom \"unquote\", x]\n\nparseDecimal :: Parser LispVal\nparseDecimal = do\n x <- many1 digit\n (return . Number . read) x\n\nparseDec :: Parser LispVal\nparseDec = do\n try $ string \"#d\"\n x <- many1 digit\n (return . Number . read) x\n\nhex2dig x = fst . head $ readHex x\n\nparseHex :: Parser LispVal\nparseHex = do\n try $ string \"#h\"\n x <- many1 hexDigit\n (return . Number . hex2dig) x\n\noct2dig x = fst . head $ readOct x\n\nparseOct :: Parser LispVal\nparseOct = do\n try $ string \"#o\"\n x <- many1 octDigit\n (return . Number . oct2dig) x\n\nbin2dig = bin2dig' 0\nbin2dig' value \"\" = value\nbin2dig' value (x:xs) = let newValue = 2 * value + (if x == '0' then 0 else 1) in\n bin2dig' newValue xs\n\nparseBin :: Parser LispVal\nparseBin = do\n try $ string \"#b\"\n let binDigit = oneOf \"10\"\n x <- many1 binDigit\n (return . Number . bin2dig) x\n\nparseNumber :: Parser LispVal\nparseNumber = parseDecimal\n <|> parseDec\n <|> parseHex\n <|> parseOct\n <|> parseBin\n\nparseReal :: Parser LispVal\nparseReal = do\n x <- many1 digit\n char '.'\n y <- many1 digit\n (return . Real . fst . head . readFloat) (y ++ \".\" ++ x)\n\nparseRational :: Parser LispVal\nparseRational = do\n x <- many1 digit\n char '/'\n y <- many1 digit\n (return . Rational) ((read x) % (read y))\n\ntoDouble :: LispVal -> Double\ntoDouble (Real r) = realToFrac r\ntoDouble (Number n) = fromIntegral n\n\nparseComplex :: Parser LispVal\nparseComplex = do\n x <- try parseReal <|> parseDecimal\n char '+'\n y <- try parseReal <|> parseDecimal\n char 'i'\n (return . Complex) (toDouble x :+ toDouble y)\n\nescapedChars :: Parser Char\nescapedChars = do\n char '\\\\'\n x <- oneOf \"\\\\\\\"nrt\"\n return $ case x of\n '\\\\' -> x\n '\"' -> x\n 'n' -> '\\n'\n 'r' -> '\\r'\n 't' -> '\\t'\n\nparseString :: Parser LispVal\nparseString = do\n char '\"'\n x <- many $ try escapedChars <|> noneOf \"\\\"\"\n char '\"'\n return $ String x\n\ncharToString :: Char -> String\ncharToString x = [x]\n\nparseCharacter :: Parser LispVal\nparseCharacter = do\n string \"#\\\\\"\n value <- try (string \"newline\" <|> string \"space\")\n <|> do\n x <- anyChar\n notFollowedBy alphaNum\n return $ charToString x\n return $ Character $ case value of\n \"space\" -> ' '\n \"newline\" -> '\\n'\n otherwise -> value !! 0\n\nparseBool :: Parser LispVal\nparseBool = do\n char '#'\n val <- oneOf \"ft\"\n return $ case val of\n 'f' -> Bool False\n 't' -> Bool True\n\nparseExpr :: Parser LispVal\nparseExpr = try parseAtom\n <|> try parseVector\n <|> try parseList\n <|> try parseQuoted\n <|> try parseQuasiQuoted\n <|> try parseUnquoted\n <|> try parseReal\n <|> try parseRational\n <|> try parseComplex\n <|> try parseNumber\n <|> try parseString\n <|> try parseCharacter\n <|> try parseBool\n\n\nprimitives :: [(String, [LispVal] -> ThrowsError LispVal)]\nprimitives = [(\"+\", numberOp (+)),\n (\"-\", numberOp (-)),\n (\"*\", numberOp (*)),\n (\"/\", numberOp div),\n (\"mod\", numberOp mod),\n (\"quotient\", numberOp quot),\n (\"remainder\", numberOp rem),\n (\"=\", numberOpBool (==)),\n (\"<\", numberOpBool (<)),\n (\">\", numberOpBool (>)),\n (\"/=\", numberOpBool (/=)),\n (\"<=\", numberOpBool (<=)),\n (\">=\", numberOpBool (>=)),\n (\"&&\", boolOpBool (&&)),\n (\"||\", boolOpBool (||)),\n (\"string=?\", stringOpBool (==)),\n (\"string?\", stringOpBool (>)),\n (\"string<=?\", stringOpBool (<=)),\n (\"string>=?\", stringOpBool (>=)),\n (\"symbol?\", isAtom),\n (\"vector?\", isVector),\n (\"list?\", isList),\n (\"number?\", isNumber),\n (\"real?\", isReal),\n (\"rational?\", isRational),\n (\"complex?\", isComplex),\n (\"string?\", isString),\n (\"character?\", isCharacter),\n (\"bool?\", isBool),\n (\"string->symbol\", string2symbol),\n (\"symbol->string\", symbol2string)]\n\nunpackNumber :: LispVal -> ThrowsError Integer\nunpackNumber (Number n) = return n\nunpackNumber notNumber = throwError $ TypeMismatch \"number\" notNumber\n\nunpackString :: LispVal -> ThrowsError String\nunpackString (String n) = return n\nunpackString notString = throwError $ TypeMismatch \"string\" notString\n\nunpackBool :: LispVal -> ThrowsError Bool\nunpackBool (Bool n) = return n\nunpackBool notBool = throwError $ TypeMismatch \"bool\" notBool\n\ngetNumberValues :: [LispVal] -> ThrowsError [Integer]\ngetNumberValues lispvals = mapM unpackNumber lispvals\n\nnumberOp :: (Integer -> Integer -> Integer) -> [LispVal] -> ThrowsError LispVal\nnumberOp op [] = throwError $ NumArgs 2 []\nnumberOp op arg@[x] = throwError $ NumArgs 2 arg\nnumberOp op args = getNumberValues args >>= return . Number . foldl1 op\n\nopBool :: (LispVal -> ThrowsError a) -> (a -> a -> Bool) -> [LispVal] -> ThrowsError LispVal\nopBool unpacker op args = if length args /= 2\n then throwError $ NumArgs 2 args\n else do left <- unpacker $ head args\n right <- unpacker $ last args\n return $ Bool $ left `op` right\n\nnumberOpBool = opBool unpackNumber\nstringOpBool = opBool unpackString\nboolOpBool = opBool unpackBool\n\nisAtom :: [LispVal] -> ThrowsError LispVal\nisAtom [Atom _] = return $ Bool True\nisAtom [List (Atom \"quoted\":xs)] = return $ Bool True\nisAtom [_] = return $ Bool False\nisAtom x = throwError $ NumArgs 1 x\n\nisVector :: [LispVal] -> ThrowsError LispVal\nisVector [Vector _] = return $ Bool True\nisVector [_] =return $ Bool False\nisVector x = throwError $ NumArgs 1 x\n\nisList :: [LispVal] -> ThrowsError LispVal\nisList [List _] = return $ Bool True\nisList [DottedList _ _] = return $ Bool True\nisList [_] = return $ Bool False\nisList x = throwError $ NumArgs 1 x\n\nisNumber :: [LispVal] -> ThrowsError LispVal\nisNumber [Number _] = return $ Bool True\nisNumber [_] = return $ Bool False\nisNumber x = throwError $ NumArgs 1 x\n\nisReal :: [LispVal] -> ThrowsError LispVal\nisReal [Number _] = return $ Bool True\nisReal [_] = return $ Bool False\nisReal x = throwError $ NumArgs 1 x\n\nisRational :: [LispVal] -> ThrowsError LispVal\nisRational [Number _] = return $ Bool True\nisRational [_] = return $ Bool False\nisRational x = throwError $ NumArgs 1 x\n\nisComplex :: [LispVal] -> ThrowsError LispVal\nisComplex [Number _] = return $ Bool True\nisComplex [_] = return $ Bool False\nisComplex x = throwError $ NumArgs 1 x\n\nisString :: [LispVal] -> ThrowsError LispVal\nisString [String _] = return $ Bool True\nisString [_] = return $ Bool False\nisString x = throwError $ NumArgs 1 x\n\nisCharacter :: [LispVal] -> ThrowsError LispVal\nisCharacter [Character _] = return $ Bool True\nisCharacter [_] = return $ Bool False\nisCharacter x = throwError $ NumArgs 1 x\n\nisBool :: [LispVal] -> ThrowsError LispVal\nisBool [Bool _] = return $ Bool True\nisBool [_] = return $ Bool False\nisBool x = throwError $ NumArgs 1 x\n\nstring2symbol :: [LispVal] -> ThrowsError LispVal\nstring2symbol [String s] = return $ Atom s\nstring2symbol [x] = throwError $ TypeMismatch \"string\" x\nstring2symbol x = throwError $ NumArgs 1 x\n\nsymbol2string :: [LispVal] -> ThrowsError LispVal\nsymbol2string [Atom s] = return $ String s\nsymbol2string [x] = throwError $ TypeMismatch \"symbol\" x\nsymbol2string x = throwError $ NumArgs 1 x\n\nvalueToPrint = extractValue . trapError\n\ntrapError action = catchError action (return . show)\n\nextractValue :: ThrowsError a -> a\nextractValue (Right val) = val\n\napply :: String -> [LispVal] -> ThrowsError LispVal\napply func args = maybe (throwError $ NotFunction \"Unrecognized primitive function args\" func)\n ($ args)\n (lookup func primitives)\n\neval :: LispVal -> ThrowsError LispVal\neval atom@(Atom _) = return atom\neval vector@(Vector _) = return vector\neval list@(List [Atom \"quote\", value]) = return value\neval list@(List (Atom func : args)) = mapM eval args >>= apply func\neval list@(List _) = return list\neval dotted@(DottedList _ _) = return dotted\neval number@(Number _) = return number\neval real@(Real _) = return real\neval rational@(Rational _) = return rational\neval complex@(Complex _) = return complex\neval string@(String _) = return string\neval char@(Character _) = return char\neval bool@(Bool _) = return bool\n\nreadExpr :: String -> ThrowsError LispVal\nreadExpr input = case parse parseExpr \"lisp\" input of\n Left err -> throwError $ Parser err\n Right value -> return value\n", "meta": {"hexsha": "36db66adf820b2b25ab55fcf89ce1a814a4f9ce6", "size": 12309, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/Lib.hs", "max_stars_repo_name": "prcastro/haskell-scheme", "max_stars_repo_head_hexsha": "fcf03393c3bdac92649c3277c70ed0cf33e9480a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2022-02-06T19:09:21.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-06T19:09:21.000Z", "max_issues_repo_path": "src/Lib.hs", "max_issues_repo_name": "prcastro/haskell-scheme", "max_issues_repo_head_hexsha": "fcf03393c3bdac92649c3277c70ed0cf33e9480a", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/Lib.hs", "max_forks_repo_name": "prcastro/haskell-scheme", "max_forks_repo_head_hexsha": "fcf03393c3bdac92649c3277c70ed0cf33e9480a", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 29.3071428571, "max_line_length": 113, "alphanum_fraction": 0.6105288813, "num_tokens": 3281, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.5964331462646254, "lm_q2_score": 0.5506073655352404, "lm_q1q2_score": 0.3284004833826601}} {"text": "{-# OPTIONS_GHC -fno-warn-unused-binds -fno-warn-unused-matches -fno-warn-name-shadowing -fno-warn-missing-signatures #-}\n{-# LANGUAGE FlexibleInstances, MultiParamTypeClasses, UndecidableInstances, FlexibleContexts, TypeSynonymInstances #-}\n\n\n---------------------------------------------------------------------------------------------------\n---------------------------------------------------------------------------------------------------\n-- | \n-- | Module : Fequency Moments\n-- | Creator: Xiao Ling\n-- | Created: 12/17/2015\n-- |\n---------------------------------------------------------------------------------------------------\n---------------------------------------------------------------------------------------------------\n\nmodule FeqMoments where\n\nimport Prelude hiding (replicate)\nimport Control.Monad.Random.Class\nimport Control.Monad.Random\nimport Control.Monad.State\n\nimport Data.Conduit\nimport Data.Foldable (toList)\nimport qualified Data.Sequence as S\nimport qualified Data.Conduit.List as Cl\nimport Data.Sequence (Seq,(|>),update,empty)\n\nimport Core\nimport Statistics\n\n\n{-----------------------------------------------------------------------------\n Types \n------------------------------------------------------------------------------}\n\n\n\n\n\n\n{-----------------------------------------------------------------------------\n Approximate Median \n------------------------------------------------------------------------------}\n\n\n\n\n\n\n\n\n\n\n", "meta": {"hexsha": "661f87f4cccbd63ac215fa4da428bf98c0654166", "size": 1456, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/FeqMoments.hs", "max_stars_repo_name": "lingxiao/CIS700", "max_stars_repo_head_hexsha": "0aebe925c4b413a37d75b8c782a3dffd53851f8a", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/FeqMoments.hs", "max_issues_repo_name": "lingxiao/CIS700", "max_issues_repo_head_hexsha": "0aebe925c4b413a37d75b8c782a3dffd53851f8a", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/FeqMoments.hs", "max_forks_repo_name": "lingxiao/CIS700", "max_forks_repo_head_hexsha": "0aebe925c4b413a37d75b8c782a3dffd53851f8a", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 26.962962963, "max_line_length": 122, "alphanum_fraction": 0.3818681319, "num_tokens": 205, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.6224593312018546, "lm_q2_score": 0.5273165233795671, "lm_q1q2_score": 0.3282330904745325}} {"text": "{-# LANGUAGE CPP #-}\n{-# OPTIONS_GHC -fno-warn-orphans #-}\n\nmodule Instances where\n\nimport Control.Monad(replicateM)\n\n#if !MIN_VERSION_base(4,8,0)\nimport Control.Applicative((<$>), (<*>), pure)\n#endif\n\nimport Test.Tasty.QuickCheck\nimport Text.Namelist.Types\nimport Data.Complex(Complex((:+)))\nimport Data.CaseInsensitive(mk)\nimport Data.Char(toUpper)\nimport Numeric(showFFloat)\n\narbitrarySafeDouble :: Gen Double\narbitrarySafeDouble = suchThat (arbitrary :: Gen Double) $ \\d ->\n let (n, _:f) = break (== '.') $ showFFloat Nothing d \"\"\n in d == read (n ++ f) / 10 ** fromIntegral (length f)\n\narbitraryIndex :: Gen Index\narbitraryIndex = do\n i <- choose (1, maxBound)\n return $ Index i\n\narbitraryRange :: Gen Index\narbitraryRange = do\n a <- oneof [Just <$> choose (1, maxBound - 1), pure Nothing]\n b <- oneof [Just <$> choose (maybe 1 succ a, maxBound), pure Nothing]\n s <- oneof [Just . unSmall <$> arbitrary, pure Nothing]\n return $ Range a b s\n where\n unSmall (Small a) = a\n\ninstance Arbitrary Index where\n arbitrary = oneof\n [ arbitraryIndex\n , arbitraryRange\n ]\n\narbitraryName :: Gen String\narbitraryName = sized $ \\i -> do\n a <- elements alpha\n as <- replicateM (min i 30) (elements an_)\n return $ a : as\n where\n an_ = '_': ['0' .. '9'] ++ alpha\n alpha = map toUpper lower ++ lower\n lower = ['a'..'z']\n\narbitraryKeyName :: Gen Key\narbitraryKeyName = oneof\n [ Key . mk <$> arbitraryName\n , Indexed <$> (mk <$> arbitraryName) <*> listOf1 arbitrary\n ]\n\narbitrarySub :: Gen Key\narbitrarySub = sized $ \\depth ->\n if depth < 1\n then arbitraryKeyName\n else Sub <$> (mk <$> arbitraryName) <*> arbitrary\n\ninstance Arbitrary Key where\n arbitrary = oneof\n [ arbitraryKeyName\n , arbitrarySub\n ]\n\nnewtype Scalar = Scalar { unScalar :: Value }\n\ninstance Arbitrary Scalar where\n arbitrary = Scalar <$> oneof\n [ Integer <$> arbitrary\n , Real <$> arbitrarySafeDouble\n , Complex <$> ((:+) <$> arbitrarySafeDouble <*> arbitrarySafeDouble)\n , Logical <$> arbitrary\n , String <$> arbitrary\n ]\n\ninstance Arbitrary Value where\n arbitrary = oneof\n [ unScalar <$> arbitrary\n , pure Null\n , sized $ \\i -> do\n as <- map unScalar <$> replicateM (max 1 i) arbitrary\n a <- unScalar <$> arbitrary\n return $ Array (reverse $ a:as)\n , sized $ \\i -> (:*) <$> pure i <*> (unScalar <$> arbitrary)\n ]\n\ninstance Arbitrary Pair where\n arbitrary = (:=) <$> arbitrary <*> arbitrary\n\nscaleDouble :: (Double -> Double) -> Gen a -> Gen a\nscaleDouble f = scale (round . f . fromIntegral)\n\ninstance Arbitrary Group where\n arbitrary = Group <$> (mk <$> arbitraryName) <*> arbitrary\n\nnewtype Namelist = Namelist { getNamelist :: [Group] }\n\ninstance Show Namelist where\n show (Namelist gs) = show gs\n\ninstance Arbitrary Namelist where\n arbitrary = Namelist <$> scaleDouble sqrt arbitrary\n", "meta": {"hexsha": "3c4598e8d47b96acae1ab870abc24ad419fd193e", "size": 3016, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "tests/Instances.hs", "max_stars_repo_name": "philopon/namelist-hs", "max_stars_repo_head_hexsha": "2fcb0909e5e08786c0184b91fc57b659f93ca504", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "tests/Instances.hs", "max_issues_repo_name": "philopon/namelist-hs", "max_issues_repo_head_hexsha": "2fcb0909e5e08786c0184b91fc57b659f93ca504", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "tests/Instances.hs", "max_forks_repo_name": "philopon/namelist-hs", "max_forks_repo_head_hexsha": "2fcb0909e5e08786c0184b91fc57b659f93ca504", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 27.4181818182, "max_line_length": 76, "alphanum_fraction": 0.6167108753, "num_tokens": 776, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.6001883449573376, "lm_q2_score": 0.5467381519846138, "lm_q1q2_score": 0.3281458665646787}} {"text": "{-# LANGUAGE DataKinds #-}\n{-# LANGUAGE DeriveAnyClass #-}\n{-# LANGUAGE DeriveGeneric #-}\n{-# LANGUAGE FlexibleContexts #-}\n{-# LANGUAGE FlexibleInstances #-}\n{-# LANGUAGE MultiParamTypeClasses #-}\n{-# LANGUAGE RankNTypes #-}\n{-# LANGUAGE ScopedTypeVariables #-}\n{-# LANGUAGE Strict #-}\n{-# LANGUAGE TypeFamilies #-}\n{-# LANGUAGE TypeOperators #-}\n{-|\nModule : Grenade.Layers.LeakyTanh\nDescription : Hyperbolic tangent nonlinear layer\nCopyright : (c) Huw Campbell, 2016-2017\nLicense : BSD2\nStability : experimental\n-}\nmodule Grenade.Layers.LeakyTanh\n ( LeakyTanh(..)\n , SpecLeakyTanh (..)\n , specLeakyTanh1D\n , specLeakyTanh2D\n , specLeakyTanh3D\n , specLeakyTanh\n , leakyTanhLayer\n ) where\n\nimport Control.DeepSeq (NFData (..))\nimport Data.Constraint (Dict (..))\nimport Data.Proxy\nimport Data.Reflection (reifyNat)\nimport Data.Serialize\nimport Data.Singletons\nimport GHC.Generics (Generic)\nimport GHC.TypeLits\nimport qualified Numeric.LinearAlgebra.Static as LAS\nimport Unsafe.Coerce (unsafeCoerce)\n\nimport Grenade.Core\nimport Grenade.Dynamic\nimport Grenade.Dynamic.Internal.Build\nimport Grenade.Types\nimport Grenade.Utils.Conversion\nimport Grenade.Utils.Vector\n\n-- | A LeakyTanh layer. A layer which can act between any shape of the same dimension, performing a tanh function. The maximum value is given in Promille, i.e. 995 is 0.995, and is positive and negative. I.e. LeakyTanh(x) = min 0.995 (max (-0.995) x).\ndata LeakyTanh (v :: Nat) = LeakyTanh\n deriving (Generic,NFData,Show)\n\ninstance UpdateLayer (LeakyTanh maxVal) where\n type Gradient (LeakyTanh maxVal) = ()\n runUpdate _ l@LeakyTanh{} _ = l\n\ninstance RandomLayer (LeakyTanh maxVal) where\n createRandomWith _ _ = return LeakyTanh\n\n\ninstance Serialize (LeakyTanh maxVal) where\n put _ = return ()\n get = return LeakyTanh\n\ninstance (a ~ b, SingI a, KnownNat maxVal) => Layer (LeakyTanh maxVal) a b where\n type Tape (LeakyTanh maxVal) a b = S a\n runForwards _ (S1DV v) = (S1DV v, S1DV $ mapVector (tanhMax maxVal) v)\n where\n maxVal = (/ 1000) $ fromIntegral $ max 0 $ min 1000 $ natVal (Proxy :: Proxy maxVal)\n runForwards _ (S2DV v) = (S2DV v, S2DV $ mapVector (tanhMax maxVal) v)\n where\n maxVal = (/ 1000) $ fromIntegral $ max 0 $ min 1000 $ natVal (Proxy :: Proxy maxVal)\n runForwards _ (S1D a) = (S1D a, S1D $ LAS.dvmap (tanhMax maxVal) a)\n where\n maxVal = (/ 1000) $ fromIntegral $ max 0 $ min 1000 $ natVal (Proxy :: Proxy maxVal)\n runForwards _ (S2D a) = (S2D a, S2D $ LAS.dmmap (tanhMax maxVal) a)\n where\n maxVal = (/ 1000) $ fromIntegral $ max 0 $ min 1000 $ natVal (Proxy :: Proxy maxVal)\n runForwards _ (S3D a) = (S3D a, S3D $ LAS.dmmap (tanhMax maxVal) a)\n where\n maxVal = (/ 1000) $ fromIntegral $ max 0 $ min 1000 $ natVal (Proxy :: Proxy maxVal)\n runBackwards _ (S1DV v) (S1DV gs) = ((), S1DV $ zipWithVector (\\t g -> tanhMax' maxVal t * g) v gs)\n where\n maxVal = (/ 1000) $ fromIntegral $ max 0 $ min 1000 $ natVal (Proxy :: Proxy maxVal)\n runBackwards _ (S2DV v) (S2DV gs) = ((), S2DV $ zipWithVector (\\t g -> tanhMax' maxVal t * g) v gs)\n where\n maxVal = (/ 1000) $ fromIntegral $ max 0 $ min 1000 $ natVal (Proxy :: Proxy maxVal)\n runBackwards _ (S1D a) (S1D g) = ((), S1D $ LAS.dvmap (tanhMax' maxVal) a * g)\n where\n maxVal = (/ 1000) $ fromIntegral $ max 0 $ min 1000 $ natVal (Proxy :: Proxy maxVal)\n runBackwards _ (S2D a) (S2D g) = ((), S2D $ LAS.dmmap (tanhMax' maxVal) (tanh' a) * g)\n where\n maxVal = (/ 1000) $ fromIntegral $ max 0 $ min 1000 $ natVal (Proxy :: Proxy maxVal)\n runBackwards _ (S3D a) (S3D g) = ((), S3D $ LAS.dmmap (tanhMax' maxVal) (tanh' a) * g)\n where\n maxVal = (/ 1000) $ fromIntegral $ max 0 $ min 1000 $ natVal (Proxy :: Proxy maxVal)\n runBackwards l x y = runBackwards l x (toLayerShape x y)\n\ntanhMax :: (Ord a, Fractional a) => a -> a -> a\ntanhMax m v\n | v > m = leaky * (v - m) + m\n | v < -m = leaky * (v - m) - m\n | otherwise = v\n where\n leaky = 0.05\n\ntanhMax' :: (Ord a, Fractional a, Floating a) => a -> a -> a\ntanhMax' m v\n | v > m = leaky\n | v < -m = -leaky\n | otherwise = max 0.005 (tanh' v)\n where\n leaky = 0.05\n\n\ntanh' :: (Floating a) => a -> a\ntanh' t = 1 - s ^ (2 :: Int) where s = tanh t\n\n-------------------- DynamicNetwork instance --------------------\n\ninstance (KnownNat maxVal) => FromDynamicLayer (LeakyTanh maxVal) where\n fromDynamicLayer inp _ LeakyTanh = SpecNetLayer $ SpecLeakyTanh maxVal (tripleFromSomeShape inp)\n where maxVal = (/1000) $ fromIntegral $ max 0 $ min 1000 $ natVal (Proxy :: Proxy maxVal)\n\ninstance ToDynamicLayer SpecLeakyTanh where\n toDynamicLayer _ _ (SpecLeakyTanh maxVal (rows, cols, depth)) =\n reifyNat rows $ \\(_ :: (KnownNat rows) => Proxy rows) ->\n reifyNat cols $ \\(_ :: (KnownNat cols) => Proxy cols) ->\n reifyNat depth $ \\(_ :: (KnownNat depth) => Proxy depth) ->\n reifyNat (round $ 1000 * maxVal) $ \\(_ :: (KnownNat maxVal) => Proxy maxVal) ->\n case (rows, cols, depth) of\n (_, 1, 1) -> case (unsafeCoerce (Dict :: Dict()) :: Dict ()) of\n Dict -> return $ SpecLayer (LeakyTanh :: LeakyTanh maxVal) (sing :: Sing ('D1 rows)) (sing :: Sing ('D1 rows))\n (_, _, 1) -> case (unsafeCoerce (Dict :: Dict()) :: Dict ()) of\n Dict -> return $ SpecLayer (LeakyTanh :: LeakyTanh maxVal) (sing :: Sing ('D2 rows cols)) (sing :: Sing ('D2 rows cols))\n _ -> case (unsafeCoerce (Dict :: Dict()) :: Dict (KnownNat (rows GHC.TypeLits.* depth))) of\n Dict -> return $ SpecLayer (LeakyTanh :: LeakyTanh maxVal) (sing :: Sing ('D3 rows cols depth)) (sing :: Sing ('D3 rows cols depth))\n\n\n-- | Create a specification for a LeakyTanh layer.\nspecLeakyTanh1D :: RealNum -> Integer -> SpecNet\nspecLeakyTanh1D maxVal i = specLeakyTanh3D maxVal (i, 1, 1)\n\n-- | Create a specification for a LeakyTanh layer.\nspecLeakyTanh2D :: RealNum -> (Integer, Integer) -> SpecNet\nspecLeakyTanh2D maxVal (i, j) = specLeakyTanh3D maxVal (i, j, 1)\n\n-- | Create a specification for a LeakyTanh layer.\nspecLeakyTanh3D :: RealNum -> (Integer, Integer, Integer) -> SpecNet\nspecLeakyTanh3D maxVal = SpecNetLayer . SpecLeakyTanh maxVal\n\n-- | Create a specification for a LeakyTanh layer.\nspecLeakyTanh :: RealNum -> (Integer, Integer, Integer) -> SpecNet\nspecLeakyTanh maxVal = SpecNetLayer . SpecLeakyTanh maxVal\n\n-- | Add a LeakyTanh layer to your build.\nleakyTanhLayer :: RealNum -> BuildM ()\nleakyTanhLayer maxVal\n | maxVal <= 0 || maxVal > 1 = error \"The maxVal parameter of tanhMaxLayer has to be in (0,1]\"\n | otherwise = buildGetLastLayerOut >>= buildAddSpec . SpecNetLayer . SpecLeakyTanh maxVal\n\n\n-------------------- GNum instances --------------------\n\ninstance GNum (LeakyTanh maxVal) where\n _ |* _ = LeakyTanh\n _ |+ _ = LeakyTanh\n sumG _ = LeakyTanh\n", "meta": {"hexsha": "757173c3963d036359c15504eeaf74d77e7d862a", "size": 7113, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/Grenade/Layers/LeakyTanh.hs", "max_stars_repo_name": "schnecki/grenade", "max_stars_repo_head_hexsha": "027e9c16899e2ca3685e89338a047488ac834249", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-01-11T15:05:38.000Z", "max_stars_repo_stars_event_max_datetime": "2021-01-11T15:05:38.000Z", "max_issues_repo_path": "src/Grenade/Layers/LeakyTanh.hs", "max_issues_repo_name": "schnecki/grenade", "max_issues_repo_head_hexsha": "027e9c16899e2ca3685e89338a047488ac834249", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/Grenade/Layers/LeakyTanh.hs", "max_forks_repo_name": "schnecki/grenade", "max_forks_repo_head_hexsha": "027e9c16899e2ca3685e89338a047488ac834249", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2018-07-02T01:04:29.000Z", "max_forks_repo_forks_event_max_datetime": "2021-01-08T13:08:47.000Z", "avg_line_length": 42.5928143713, "max_line_length": 251, "alphanum_fraction": 0.6243497821, "num_tokens": 2306, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6992544210587585, "lm_q2_score": 0.4687906266262437, "lm_q1q2_score": 0.32780391821930666}} {"text": "--\n-- Copyright (c) 2009-2011, ERICSSON AB\n-- All rights reserved.\n--\n-- Redistribution and use in source and binary forms, with or without\n-- modification, are permitted provided that the following conditions are met:\n--\n-- * Redistributions of source code must retain the above copyright notice,\n-- this list of conditions and the following disclaimer.\n-- * Redistributions in binary form must reproduce the above copyright\n-- notice, this list of conditions and the following disclaimer in the\n-- documentation and/or other materials provided with the distribution.\n-- * Neither the name of the ERICSSON AB nor the names of its contributors\n-- may be used to endorse or promote products derived from this software\n-- without specific prior written permission.\n--\n-- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n-- AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n-- IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\n-- DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE\n-- FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\n-- DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR\n-- SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER\n-- CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,\n-- OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n-- OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n--\n\nmodule Feldspar.Core.Frontend.Complex\nwhere\n\nimport Data.Complex (Complex)\n\nimport Feldspar.Core.Constructs\nimport Feldspar.Core.Constructs.Complex\nimport Feldspar.Core.Frontend.Num\n\ncomplex :: (Numeric a, RealFloat a) => Data a -> Data a -> Data (Complex a)\ncomplex = sugarSymF MkComplex\n\nrealPart :: (Numeric a, RealFloat a) => Data (Complex a) -> Data a\nrealPart = sugarSymF RealPart\n\nimagPart :: (Numeric a, RealFloat a) => Data (Complex a) -> Data a\nimagPart = sugarSymF ImagPart\n\nconjugate :: (Numeric a, RealFloat a) => Data (Complex a) -> Data (Complex a)\nconjugate = sugarSymF Conjugate\n\nmkPolar :: (Numeric a, RealFloat a) => Data a -> Data a -> Data (Complex a)\nmkPolar = sugarSymF MkPolar\n\ncis :: (Numeric a, RealFloat a) => Data a -> Data (Complex a)\ncis = sugarSymF Cis\n\nmagnitude :: (Numeric a, RealFloat a) => Data (Complex a) -> Data a\nmagnitude = sugarSymF Magnitude\n\nphase :: (Numeric a, RealFloat a) => Data (Complex a) -> Data a\nphase = sugarSymF Phase\n\npolar :: (Numeric a, RealFloat a) => Data (Complex a) -> (Data a, Data a)\npolar c = (magnitude c, phase c)\n\ninfixl 6 +.\n\n(+.) :: (Numeric a, RealFloat a) => Data a -> Data a -> Data (Complex a)\n(+.) = complex\n\niunit :: (Numeric a, RealFloat a) => Data (Complex a)\niunit = 0 +. 1\n\n", "meta": {"hexsha": "1148e0bb8851c262a5f31969a079e2f87917f5cc", "size": 2853, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/Feldspar/Core/Frontend/Complex.hs", "max_stars_repo_name": "kffaxen/feldspar-language", "max_stars_repo_head_hexsha": "d407ab1cb7155cd0d184b2deadc2a39ef60acf2c", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/Feldspar/Core/Frontend/Complex.hs", "max_issues_repo_name": "kffaxen/feldspar-language", "max_issues_repo_head_hexsha": "d407ab1cb7155cd0d184b2deadc2a39ef60acf2c", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/Feldspar/Core/Frontend/Complex.hs", "max_forks_repo_name": "kffaxen/feldspar-language", "max_forks_repo_head_hexsha": "d407ab1cb7155cd0d184b2deadc2a39ef60acf2c", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 39.0821917808, "max_line_length": 81, "alphanum_fraction": 0.7230984928, "num_tokens": 708, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES\n\n", "lm_q1_score": 0.6076631698328916, "lm_q2_score": 0.5389832206876841, "lm_q1q2_score": 0.3275202523698191}} {"text": "-- Rummikub.hs\n-- Alex Striff\n\nmodule Rummikub where\n\nimport Prelude hiding\n (Enum, succ, pred, toEnum, fromEnum, enumFrom, enumFromThen, enumFromTo, enumFromThenTo)\nimport Prelude.SafeEnum\nimport Control.Applicative\nimport Control.Arrow\nimport Control.Monad\nimport Data.Function\nimport Data.Functor\nimport Data.Maybe\nimport Data.Function.Pointless\nimport Data.Traversable\nimport Data.Graph\nimport Data.List\nimport Data.List.Split\nimport Text.Read\nimport Numeric.LinearAlgebra hiding ((<#), (<>))\n\nnewtype TileNum = TileNum Int deriving (Eq, Ord)\n\ninstance Show TileNum where\n show (TileNum n) = show n\n\ninstance Bounded TileNum where\n minBound = TileNum 1\n maxBound = TileNum 12\n\ninstance DownwardEnum TileNum where\n pred t@(TileNum n)\n | minBound < t && t <= maxBound = TileNum <$> pred n\n | otherwise = Nothing\n precedes (TileNum n) (TileNum m) = minBound <= n && n < m && m <= maxBound\n\ninstance UpwardEnum TileNum where\n succ t@(TileNum n)\n | minBound <= t && t < maxBound = TileNum <$> succ n\n | otherwise = Nothing\n succeeds (TileNum n) (TileNum m) = maxBound >= n && n > m && m >= minBound\n\ninstance Enum TileNum where\n toEnum n\n | minBound <= tn && tn <= maxBound = Just tn\n | otherwise = Nothing\n where tn = TileNum n\n fromEnum (TileNum n) = Just n\n\ntilenum :: Int -> Maybe TileNum\ntilenum = toEnum\n\ndata Color = Black | Red | Orange | Blue | AnyColor\n\ninstance Show Color where\n show Black = \"B\"\n show Red = \"r\"\n show Orange = \"o\"\n show Blue = \"b\"\n show AnyColor = \"*\"\n\ninstance Eq Color where\n Black /= Black = False\n Red /= Red = False\n Orange /= Orange = False\n Blue /= Blue = False\n _ /= _ = True\n\ninstance Ord Color where\n compare Black Red = LT\n compare Red Orange = LT\n compare Orange Blue = LT\n compare Blue Black = LT\n compare Black Black = EQ\n compare Red Red = EQ\n compare Orange Orange = EQ\n compare Blue Blue = EQ\n compare AnyColor _ = EQ\n compare _ AnyColor = EQ\n compare _ _ = GT\n\ncolor :: Char -> Maybe Color\ncolor s\n | s == 'B' = Just Black\n | s == 'r' = Just Red\n | s == 'o' = Just Orange\n | s == 'b' = Just Blue\n | s == '*' = Just AnyColor\n | otherwise = Nothing\n\ndata Tile = NumTile TileNum Color | Joker deriving (Ord)\n\ninstance Show Tile where\n show (NumTile n c) = show c ++ show n\n show Joker = \"j\"\n\ninstance Eq Tile where\n (NumTile n c) == (NumTile m d) = n == m && c == d\n _ == _ = True -- Comparision with Joker\n\n(<#) :: Tile -> Tile -> Bool\n(NumTile n c) <# (NumTile m d) = succ n == pure m && c == d\nJoker <# (NumTile m _) = minBound < m\n(NumTile n _) <# Joker = n < maxBound\nJoker <# Joker = True\n\n(<#<) :: Tile -> Tile -> Bool\n(NumTile n c) <#< (NumTile m d) = (succ <=< succ) n == pure m && c == d\nJoker <#< (NumTile m _) = pure minBound < pred m\n(NumTile n _) <#< Joker = succ n < pure maxBound\nJoker <#< Joker = True\n\n(<##<) :: Tile -> Tile -> Bool\n(NumTile n c) <##< (NumTile m d) = (succ <=< succ <=< succ) n == pure m && c == d\nJoker <##< (NumTile m _) = pure minBound < (pred <=< pred) m\n(NumTile n _) <##< Joker = (succ <=< succ) n < pure maxBound\nJoker <##< Joker = True\n\n(<@) :: Tile -> Tile -> Bool\n(NumTile n c) <@ (NumTile m d) = c /= d && n == m\n_ <@ _ = True -- Comparison with Joker\n\n(<@<) :: Tile -> Tile -> Bool\n(<@<) = (<@)\n\ntileNum :: Tile -> Maybe TileNum\ntileNum (NumTile n _) = pure n\ntileNum Joker = Nothing\n\ntileColor (NumTile _ c) = c\ntileColor _ = AnyColor\n\ntile :: String -> Maybe Tile\ntile [] = Nothing\ntile s@(c:n)\n | s == \"j\" = Just Joker\n | otherwise = liftA2 NumTile (tilenum =<< readMaybe n) (color c)\n\ntiles :: String -> Maybe [Tile]\ntiles = traverse tile . splitOn \" \"\n\nallRel :: (b -> [(a, a)]) -> (a -> a -> Bool) -> b -> Bool\nallRel p r = all (uncurry r) . p\n\ndpairs :: [a] -> [(a, a)]\ndpairs = sequence <=< ap zip (tail <$> tails)\n\nneighbors :: [a] -> [(a, a)]\nneighbors = ap zip tail\n\nacquaintances :: [a] -> [(a, a)]\nacquaintances [_] = []\nacquaintances xs = ap zip (tail . tail) xs\n\nrandos :: [a] -> [(a, a)]\nrandos xs\n | length xs < 4 = []\n | otherwise = ap zip (tail . tail . tail) xs\n\nvalidNumRun :: [Tile] -> Bool\nvalidNumRun = (. (&)) . flip all $\n [ (3 <=) . length\n , allRel neighbors (<#)\n , allRel acquaintances (<#<)\n , allRel randos (<##<)]\n\nvalidColorRun :: [Tile] -> Bool\nvalidColorRun = (. (&)) . flip all $\n [ liftA2 (||) (3 ==) (4 ==) . length\n , allRel dpairs ((/=) `on` tileColor)\n , allRel neighbors (==) . mapMaybe tileNum]\n\nvalidRun :: [Tile] -> Bool\nvalidRun = liftA2 (||) validNumRun validColorRun\n\ntype Run = [Tile]\ntype Board = [Run]\ntype Frag = Run\ntype PBoard = ([Frag], Board)\n\nshowBoard :: Board -> String\nshowBoard = join . intersperse \"\\n\" . fmap (join . intersperse \" \" . fmap show)\n\nrightFriends :: Tile -> Tile -> Bool\nrightFriends = (liftA2 . liftA2) (||) (<#) (<@)\n\nleftFriends :: Tile -> Tile -> Bool\nleftFriends = flip rightFriends\n\nsplitBin :: (a -> b -> Bool) -> a -> [b] -> [([b], [b])]\nsplitBin = (.) $ liftA2 fmap (flip splitAt) . findIndices\n\nleftFriendSplits :: Tile -> Frag -> [(Frag, Frag)]\nleftFriendSplits = splitBin leftFriends\nrightFriendSplits = splitBin rightFriends\n\nfriendSplits :: Frag -> Run -> ([(Frag, Frag)], [(Frag, Frag)])\nfriendSplits = liftA2 (&&&) (leftFriendSplits . head) (rightFriendSplits . last)\n\nleftSplitRuns :: Frag -> (Frag, Frag) -> [Frag]\nleftSplitRuns fs (xs, (f:ys))\n | null ys = [left]\n | otherwise = [left, ys]\n where left = xs ++ [f] ++ fs\n\nrightSplitRuns :: Frag -> (Frag, Frag) -> [Frag]\nrightSplitRuns fs (xs, xs')\n | null xs = [right]\n | otherwise = [xs, right]\n where right = fs ++ xs'\n\nfragPlays' :: Run -> Frag -> [[Frag]]\nfragPlays' ts fs = (leftSplitRuns fs <$> ls) ++ (rightSplitRuns fs <$> rs)\n where (ls, rs) = friendSplits fs ts\n\nfragPlays :: Run -> Frag -> [PBoard]\nfragPlays = fmap sortRuns .: fragPlays'\n\nfrags :: PBoard -> [Frag]\nfrags = fst\n\nruns :: PBoard -> Board\nruns = snd\n\npboard :: [Frag] -> Board -> PBoard\npboard = (,)\n\nparsePBoard :: [String] -> [String] -> Maybe PBoard\nparsePBoard = liftA2 pboard `on` traverse tiles\n\nuniq :: Eq a => [a] -> [a]\nuniq = nub -- lame O(n^2)\n\naltTopBot :: Int -> [Int] -- altTopBot 4 == [1, 5, 2, 4, 3]\naltTopBot n\n | n > 0 = take n . join . ap (zipWith $ \\a b -> [a, b]) reverse $ [1..n]\n | otherwise = []\n\nsumSet :: Int -> [[Int]]\nsumSet n = sumSet' n [[]] where\n sumSet' n ss\n | n > 0 = [1..n] >>= \\a -> sumSet' (n - a) ((a:) <$> ss)\n | otherwise = ss\n\nfragments :: [a] -> [[[a]]]\nfragments xs = reverse $ flip splitPlaces xs <$> sumSet (length xs)\n\nsortRuns :: [Frag] -> PBoard\nsortRuns = foldl (\\(a, b) r -> if validRun r then (a, r:b) else (r:a, b)) mempty\n\naddSplitRuns :: PBoard -> PBoard -> PBoard\naddSplitRuns = mappend\n\nplayFrags :: PBoard -> PBoard\nplayFrags p = addSplitRuns (pboard mempty . runs $ p) . sortRuns . frags $ p\n\nselect :: Eq b => (a -> [b]) -> a -> [(b, [b])]\nselect = (ap (zipWith $ liftA2 (.) (,) delete) repeat .)\n\ndropUnfinished :: [PBoard] -> [PBoard]\ndropUnfinished = filter $ null . frags\n\nliftFrag :: Functor f => ([Frag] -> f [Frag]) -> PBoard -> f PBoard\nliftFrag f = uncurry (<&>) . (f *** flip pboard)\n\nfragment :: PBoard -> [(Frag, [Frag])]\nfragment p = do\n (frag, fs) <- select frags p -- select a fragment\n ffs <- fragments frag -- smash it\n (frag', fs') <- select id ffs -- select one of the pieces\n return $ (frag', fs' ++ fs)\n\nstepPlay :: ([PBoard] -> [PBoard]) -> PBoard -> [PBoard]\nstepPlay filt p\n | null $ frags p = return p\n | otherwise = do\n (frag, fs) <- fragment p -- select a fragment (by smashing)\n (run, rs) <- select runs p -- select a run\n -- fp <- filt . uniq $ fragPlays run frag -- play the fragment in the run\n fp <- filt $ fragPlays run frag -- play the fragment in the run\n return $ addSplitRuns fp $ pboard fs rs\n\nstepPlay' :: Int -> ([PBoard] -> [PBoard]) -> PBoard -> [PBoard]\nstepPlay' n = foldr1 (<=<) . take n . repeat . stepPlay\n\nfuse :: Eq a => [a] -> [a] -> [[a]]\nfuse x@(a:as) y@(b:bs)\n | last as == b = [x ++ bs]\n | a == last bs = [y ++ as]\n | otherwise = [x, y]\n\n-- TODO: solve problem of turning\n-- [[b1], [b2], [b3]] into [[b1 b2 b3]] without duplicates or using uniq/nub\n\n-- fuseFrags' :: [Frag] -> [[Frag]]\n-- fuseFrags' fl = do\n-- (f, f') <- dpairs fl\n-- return $ fuse f f' ++ (fl \\\\ [f, f'])\n\ngroupFrags' :: [Frag] -> [[Frag]]\ngroupFrags' fl = do\n (f, f') <- dpairs fl\n fg <- fragPlays' f f'\n return $ fg ++ (fl \\\\ [f, f'])\n\ngroupFrags :: PBoard -> [PBoard]\ngroupFrags = liftFrag groupFrags'\n\n-- Graph stuff\n\ntype NGraph node key = (Graph, Vertex -> (node, key, [key]), key -> Maybe Vertex)\n\ngraph :: Ord key => NGraph node key -> Graph\ngraph (g, _, _) = g\n\nnodeFromVertex :: Ord key => NGraph node key -> (Vertex -> (node, key, [key]))\nnodeFromVertex (_, nfv, _) = nfv\n\nvertexFromKey :: Ord key => NGraph node key -> (key -> Maybe Vertex)\nvertexFromKey (_, _, vfk) = vfk\n\nsplit2 :: Int -> Int -> [a] -> ([a], [a])\nsplit2 i j xs = (ys, zs)\n where (ys, ys') = splitAt i xs\n zs = drop j ys'\n\nconstrain1 :: Int -> [Bool] -> (Int, Int) -> [[Bool]]\nconstrain1 m xs (i, h)\n | m' > l = [[]]\n | otherwise = fmap (\\i -> sandwich (split2 i m' xs) ts) [a..b]\n where m' = m - h + 1\n l = length xs\n ts = replicate m' True\n a = max 0 $ i - (m' - 1)\n b = min i $ l - m'\n sandwich (x, y) z = x ++ z ++ y\n\n-- True represents a constrained vertex that will be propagated\n-- m is the minimum number of tiles required to form a run\n-- TODO: Rewrite to always be minimal\nconstrain :: Int -> [Bool] -> [[Bool]]\nconstrain m xs\n | length xs < m = [[]]\n | not (or xs) = [xs]\n | otherwise = nub\n . join -- . fmap (minimumBy howConstrained)\n . groupBy ((==) `on` parts)\n . foldr1 (liftA2 $ zipWith (||))\n . fmap (constrain1 m xs)\n $ boundaryTrues xs\n where trues = length . filter id\n howConstrained = compare `on` trues\n sigbool b = if b then 1 else -1\n parts bs = ((*) . sigbool . head $ bs)\n . length . filter (uncurry (/=)) . ap zip tail $ bs\n\nboundaryTrues :: [Bool] -> [(Int, Int)]\nboundaryTrues bs = reverse . (\\(_, _, ts) -> ts)\n . foldl go (head bs, 0, []) $ groups\n where go (b, i, ts) h = (not b, i+h, if b then (i+h-1,h):(i,h):ts else ts)\n groups = length <$> group bs\n\n-- Needs tests to check all cases\n-- TODO: add more counting stuff to deal with cases like splitting\n-- *oo...oo* (or maybe even *oo..oo*)\ngrowthComponents :: Int -> [Bool] -> [[Bool]]\ngrowthComponents m bs = flip splitPlaces bs . reverse $ maxBound:gs -- maxBound avoids calculating length\n where gc (c, n, i, gs, j) True = (True, 1, i + 1, maybe gs (:gs) j, Nothing)\n gc (c, n, i, gs, j) False = if n == 2 * (m - 1)\n then (False, 1, m, gs, Just $ i - (m - 1))\n else (c, n', i + 1, gs, j)\n where n' = if c then n + 1 else 0\n (_, _, i, gs, _) = foldl gc (False, 1, 1, [], Nothing) bs\n\nshowConstraint :: [Bool] -> String\nshowConstraint = fmap $ \\b -> if b then 'o' else '.'\n\nparseConstraint :: String -> Maybe [Bool]\nparseConstraint = traverse parseConstraint'\n where parseConstraint' c\n | c == '.' = Just False\n | c == 'o' = Just True\n | otherwise = Nothing\n\nparseConstraint' = fromJust . parseConstraint\n\nmpow :: Matrix Z -> Int -> Matrix Z\nmpow = mconcat .: flip replicate\n\nadjacencyMatrix :: (a -> a -> Bool) -> [a] -> Matrix Z\nadjacencyMatrix r = ap (join (><) . length) (fmap edge . join (liftA2 r))\n where edge b = (if b then 1 else 0) :: Z\n\npaths :: Int -> Matrix Z -> Int -> Z\npaths i = liftA2 ((+) `on` sumElements . (!! i)) toColumns toRows .: mpow\n\nminpaths :: Int -> Int -> Matrix Z -> Z\nminpaths m i a = sum $ fmap (paths i a) [m..cols a]\n\ntileGraph :: (Tile -> Tile -> Bool) -> [Tile]\n -> NGraph Tile Int\ntileGraph r ts = graphFromEdges\n $ zipWith (\\t i -> (t, i, fmap snd . filter fst\n $ zipWith (\\t' j -> (r t t', j)) ts [0..])) ts [0..]\n\n-- Here m is the number of tiles\npartitionRuns m = join (***) (concat . fmap (foldMap (:[])))\n . partition ((m <=) . length) . components . graph\n\nconstraints :: Ord key => Int -> [NGraph node key] -> [[[(Vertex, Bool)]]]\nconstraints m gs = fmap ((\\(a, b) -> (fmap . fmap) (id &&& (`elem` b)) a)\n . (fst *** outcasts . fmap snd)) . select id\n . fmap ((id *** concat) . partRuns . comps) $ gs\n where comps = fmap (foldMap (:[])) . components . graph\n partRuns = partition ((m <=) . length)\n outcasts = foldl1 intersect\n\n", "meta": {"hexsha": "5aadb5392878cb905630d1b3e6d2ab0d3a0051c6", "size": 12751, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/Rummikub.hs", "max_stars_repo_name": "jfjhh/rummikub", "max_stars_repo_head_hexsha": "12a728c0af70c5fd46f1554d8957de8fb0c9959e", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/Rummikub.hs", "max_issues_repo_name": "jfjhh/rummikub", "max_issues_repo_head_hexsha": "12a728c0af70c5fd46f1554d8957de8fb0c9959e", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/Rummikub.hs", "max_forks_repo_name": "jfjhh/rummikub", "max_forks_repo_head_hexsha": "12a728c0af70c5fd46f1554d8957de8fb0c9959e", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 30.4319809069, "max_line_length": 105, "alphanum_fraction": 0.5699945102, "num_tokens": 4165, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6926419831347361, "lm_q2_score": 0.4726834766204328, "lm_q1q2_score": 0.32740042064139824}} {"text": "{-# LANGUAGE TypeOperators, FlexibleContexts, DeriveDataTypeable, FlexibleInstances, GADTs, ScopedTypeVariables, UndecidableInstances, OverlappingInstances, MultiParamTypeClasses, NoMonomorphismRestriction, RankNTypes, BangPatterns #-}\n\nmodule Target.Prelude where\n\n{-\n(S.Seed, powInt, sample, primUnit, printC, solveODE,solveODEs, runTests, assertIt, expect, optimise, choose, listToVec, pack, Consolable(..), Askable(..), fillV, Always(..),Never(..),Mostly(..),SamplerDensity(..), runIO, observeSig, (!$!), packL, Plot(..),Radian(..),ObservedSignal(..), csvFile, withNats, packV, vecToList, fillM, mdims)\n-}\n\nimport qualified Math.Probably.Sampler as S\n--import qualified Math.Probably.MALA as MALA\nimport qualified Math.Probably.NelderMead as NM\nimport qualified Math.Probably.PDF as PDF\n--import Math.Probably.BFGS\nimport System.Random.Mersenne.Pure64\nimport Math.Probably.FoldingStats\n--import Math.Probably.GlobalRandoms\nimport qualified Numeric.LinearAlgebra as L\nimport Data.List\nimport Data.Char (toLower)\nimport Data.Maybe (fromJust)\nimport Text.Printf\nimport Data.Record\nimport Data.Record.Combinators ((!!!))\nimport Data.Kind\nimport Data.TypeFun\nimport qualified Data.Vector.Storable as V\nimport qualified Data.Vector.Generic as VG\n\nimport qualified Numeric.SpecFunctions as SM\nimport Statistics.Test.KolmogorovSmirnov\nimport qualified Data.Vector.Unboxed as UV\nimport Control.Monad.Trans (lift)\nimport Data.Array\n\nimport Debug.Trace\nimport Control.Monad\n\nimport Data.List\nimport System.Exit\nimport System.IO.Unsafe\nimport Unsafe.Coerce\nimport Foreign.StablePtr\nimport Foreign.Storable\nimport Foreign.Storable.Tuple\nimport qualified Data.Text as T\nimport qualified Data.Text.IO as TIO\n\nimport Data.STRef\nimport Control.Monad.ST\nimport qualified Data.Vector.Storable.Mutable as VSM\n\n\nrunIO :: IO a -> IO a\nrunIO = id -- silence\n\n --return $ S.Samples [k $ L.fromList init0]\n\nchoose_arr = array ((0,0), (500,500)) [((n,k), SM.choose n k) | n <- [0..500], k<- [0..500]]\nchoose n k | n< 0 || k < 0 = realToFrac $ SM.choose n k\n | n <501 && k<501 = realToFrac $ choose_arr!(n,k)\n | otherwise = realToFrac $ SM.choose n k\n\nprimUnit = \\seed -> let (x, nseed) = randomDouble seed\n in (realToFrac x, nseed)\n\n--sample :: (Seed -> (a, Seed)) -> IO a\nsample s = S.sampleIO s \n\nsolveODE :: (Double -> Double -> Double) -> Double -> Double -> Double -> (Double -> Double)\nsolveODE f tmax dt y0 = y where\n ts = V.enumFromStepN 0 dt (round $ tmax/dt)\n ys = V.scanl intf y0 ts\n intf ylast t = ylast + dt * f ylast t\n y = pack dt 0 ys\n-- y t = let ix = round $ t/dt\n-- in ys L.@> ix\n\n\nnats :: [Int]\nnats = [0..]\n\nwithNats :: [a] -> [(Int,a)] \nwithNats = zip nats\n\nsolveODEs :: ([Double] -> Double -> [Double]) -> Double -> Double -> [Double] -> [Double -> Double]\nsolveODEs f tmax dt y0 = y where\n is = [0..(round $ tmax/dt)]\n yss = transpose $ scanl intf y0 is\n-- yss = L.toRows $ L.trans $ L.fromRows $ map (L.fromList) $ scanl intf y0 is\n intf ylast t = zipWith (+) ylast $ map (dt *) $ f ylast $ (*dt) . realToFrac $ t\n y = flip map yss $ \\ys -> let yv = L.fromList ys in pack dt 0 yv\n\ndecide :: (Real b,Floating b, V.Storable b, RealFrac b) => (b -> (((V.Vector b) -> (((S.Prob a) -> (((((V.Vector b) -> ((a -> b)))) -> (V.Vector b))))))))\ndecide = \\(tol) -> \\((ini::V.Vector b)) -> \\((prob::S.Prob a)) -> \\((util::((V.Vector b) -> ((a -> b))))) -> (optimise tol ini) (\\((vaction::V.Vector b)) -> expect (fmap (util vaction) prob))\n\n\ntraceIt s x = trace (s++\": \"++show x) x \n\n{-pmap :: (a -> b) -> ((c -> ((a,c))) -> (c -> ((b,c))))\npmap = \\((f::a -> b)) -> \\((sam::c -> ((a,c)))) -> bindP sam (\\((x::a)) -> returnP (f x))\n\nbindP :: (s -> ((a,s))) -> ((a -> (s -> ((b,s)))) -> (s -> ((b,s))))\nbindP = \\((f::s -> ((a,s)))) -> \\((g::a -> (s -> ((b,s))))) -> \\((s0::s)) -> let {((x::a),(s1::s)) = f s0} in g x s1\n\nreturnP :: a -> (b -> ((a,b)))\nreturnP = \\((x::a)) -> \\((s::b)) -> (x,s)\n-}\n\n{-for :: Int -> (Int -> ((Int -> (s -> ((a,s)))) -> (s -> ((([a]),s)))))\nfor n m s | n < m = s n `bindP` \\x -> \n for (n+1) m s `bindP` \\xs -> \n returnP (x:xs) \n | otherwise = ((s n) `bindP` (\\v -> returnP (v:[]))) -}\n\n--uniform a b = (\\x->(realToFrac x)*(b-a)+a) `pmap` ran0\n\nexpect :: Fractional c => S.Prob c -> c\nexpect (S.Samples xs) = runStat meanF xs\nexpect s@(S.Sampler _) = unsafePerformIO $ do\n xs <- S.sampleNIO 100 s\n return $ expect $ S.Samples xs\n\n\n\noptimise :: (Real a , Floating a, RealFrac a, V.Storable a) => a -> V.Vector a -> (V.Vector a -> a) -> V.Vector a\noptimise nmtol ini fitfunPos = \n\n let fitfun = negate . realToFrac . fitfunPos . V.map realToFrac\n traceIt x = trace (show x) x\n --liftIO $ print (inivec, nmtol, fitfun inivec)\n inisimplex = NM.genInitial fitfun [] (const 0.1) $ V.map realToFrac ini \n --check here if differences is too small\n --liftIO $ print inisimplex\n nmRes = NM.goNm fitfun [] (realToFrac nmtol) 100 5000 $ inisimplex\n --liftIO $ putStrLn $ \"bye from optimse\" ++ \n -- show (NM.centroid nmRes)\n in V.map realToFrac $ NM.centroid nmRes\n\n--decide :: Double -> ((Vector Double) -> ((S.Prob a) -> (((Vector Double) -> (a -> Double)) -> (Vector Double))))\n--decide = \\((tol::Double)) -> \\((ini::Vector Double)) -> \\((prob::S.Prob a)) -> \\((util::(Vector Double) -> (a -> Double))) -> (optimise tol ini) (\\((vaction::Vector Double)) -> expect (fmap (util vaction) prob))\n\n\nxs !$! ix = if length xs > ix\n then xs !! ix\n else error $ \"!$! out of boiunds: \" ++show (ix, length xs)\n \n\npowInt :: Double -> Int -> Double\npowInt x p = x ^ p\n\n{-binomial n p = \n (for 1 n $ const $ pmap (\n returnP $ length $ [t | t@True <- bools]\n\nunormal = ran0 `bindP` \\u1 ->\n ran0 `bindP` \\u2 -> \n returnP $ sqrt(-2*log(u1))*cos(2*pi*u2) -}\n\n\ncsvFile :: FromCSV a => T.Text -> IO [a]\ncsvFile fnm = do\n lns <- fmap (tail . T.lines) $ TIO.readFile (T.unpack fnm)\n return $ map (fromCSV . T.splitOn (T.pack \",\")) lns\n\nclass FromCSV a where\n fromCSV :: [T.Text] -> a\n\ninstance FromCSV (X (Id KindStar)) where\n fromCSV _ = X\n\ninstance (Name lab, FromCSVCell a, FromCSV (b (Id KindStar))) \n => FromCSV ((b :& lab ::: a) (Id KindStar)) where\n fromCSV (t:ts) = (fromCSV ts) :& (name::lab) := (fromCSVcell t)\n\n\nclass FromCSVCell a where\n fromCSVcell :: T.Text -> a\n\ninstance FromCSVCell Double where\n fromCSVcell = read . T.unpack\n\ninstance FromCSVCell T.Text where\n fromCSVcell = id\n\nprintC :: Consolable a => T.Text -> a -> IO () \nprintC s x = showC x >>= \\s1-> putStrLn (T.unpack s++\" => \"++s1)\n\nclass Consolable a where\n showC :: a -> IO String\n showSamples :: [a] -> IO String\n\ninstance Consolable Double where\n showC x = return $ printf \"%.3g\" x\n showSamples xs = let (mean,sd) = runStat meanSDF xs\n in return $ printf \"%.3g +/- %.3g\" mean sd\n\ninstance Consolable Bool where\n showC x = return $ show x\n showSamples bs = \n let ntrue = length $ filter id bs\n ntotal = length bs\n in return $ show ntrue ++\"/\"++show ntotal\n\ninstance Consolable Int where\n showC x = return $ show x\n showSamples xs = let (mean::Double,sd) = runStat meanSDF $ map realToFrac xs\n in return $ printf \"%.3g +/- %.3g\" mean sd\n\ninstance Consolable [Char] where\n showC x = return x\n showSamples (x:_) = return x\n\ninstance Consolable (Double -> Double) where\n showC _ = return \"\"\n showSamples _ = return \"\"\n\n\ninstance Consolable T.Text where\n showC x = return $ T.unpack x\n showSamples (x:_) = return $ T.unpack x\n\ninstance Consolable a => Consolable [a] where\n showC x = do ss <- mapM showC x \n return $ \"[\"++intercalate \",\" ss++\"]\"\n showSamples xs = do sxs <- mapM showC xs \n return $ \"oneOf \"++show sxs\n\ninstance (Consolable a, V.Storable a) => Consolable (L.Vector a) where\n showC x = do ss <- mapM showC $ L.toList x \n return $ \"<\"++intercalate \",\" ss++\">\"\n showSamples xs = do sxs <- mapM showC xs \n return $ \"oneOf \"++show sxs\n\n\ninstance (Consolable a, Consolable b) => Consolable (a,b) where\n showC (x,y) = do sx <- showC x \n sy <- showC y \n return $ \"(\"++sx++\",\"++sy++\")\"\n showSamples xs = do sxs <- mapM showC xs\n return $ \"oneOf\" ++ show sxs\n\n\ninstance Consolable (X (Id KindStar)) where\n showC x = return \"\"\n showSamples _ = return \"\"\n\ninstance (Consolable a, Show lab, Consolable (b (Id KindStar))) \n => Consolable ((b :& lab ::: a) (Id KindStar)) where\n showC (rest :& lab := val) = do\n vs <- showC val\n rest <- showC rest\n return $ if null rest\n then uncap (show lab) ++ \"=>\"++vs\n else uncap (show lab) ++ \"=>\"++vs ++ \";\"++rest\n showSamples recs = do \n let vs= map (\\(rest :& lab := val) -> val) recs\n ss<- showSamples vs\n more <- showSamples (map getRest recs)\n return (\"\\n\"++\" \"++uncap (getLab (head recs)) ++ \" => \" ++ ss++more)\n \nuncap [] = []\nuncap (c:cs) = toLower c : cs\n\ngetRest (rest :& lab := val) = rest\ngetLab (rest :& lab := val) = show lab\n\nsampleFrom n sam@(S.Sampler _) = do\n sequence $ replicate n $ sam\nsampleFrom n sam@(S.Samples xs) = return xs\n \ninstance Consolable a => Consolable (S.Prob a) where\n showC sam@(S.Sampler _) = do\n xs <- S.sampleIO $ sequence $ replicate 100 $ sam\n showSamples xs\n showC sam@(S.Samples xs) = do\n showSamples xs\n---unormal = S.gaussD 0 1 \ndata Plot = \n Plot ([(T.Text,T.Text)]) (S.Prob ([Radian]))\n |PlotRow ([(T.Text,T.Text)]) ([Plot])\n |PlotColumn ([(T.Text,T.Text)]) ([Plot])\n |PlotGrid ([(T.Text,T.Text)]) Int Int ([(T.Text,Plot)])\n |PlotStack ([(T.Text,T.Text)]) ([(T.Text,Plot)])\ndata Radian = \n Lines ([(Double,Double)])\n |Points ([(Double,Double)])\n |Bars ([(Double,Double)])\n |Histogram ([Double])\n |Timeseries ((Double -> Double))\n |Options ([(T.Text,T.Text)]) ([Radian])\ndata ObservedSignal a = \n ObservedSignal Double Double (V.Vector Double)\n |ObservedXYSignal (V.Vector ((Double,Double)))\n deriving Show\n\nobserveSig :: (Double -> Double) -> ObservedSignal Double\nobserveSig sig = unsafePerformIO $ do\n let ref = sig (0/0)\n deRefStablePtr $ unsafeCoerce ref \n \n\npack :: Double -> Double -> L.Vector Double -> (Double -> Double)\npack dt t0 ys = unsafePerformIO $ do\n putStrLn $ \"packing..\"\n let obs = ObservedSignal dt t0 ys\n ptr <- newStablePtr obs\n return $ \\t -> if isNaN t\n then unsafeCoerce ptr\n else let ix = round $ (t-t0)/dt\n in ys L.@> ix\n\npackL :: Double -> Double -> [Double] -> (Double->Double)\npackL dt t0 ys = pack dt t0 (V.fromList ys)\n\n--packV dt t0 ys t = let ix = round $ (t-t0)/dt\n-- in ys V.! ix\n\n\ndata Always = \n Always (S.Prob Bool)\ndata Never = \n Never (S.Prob Bool)\ndata Mostly = \n Mostly (S.Prob Bool)\ndata SamplerDensity = \n SamplerDensity (S.Prob Double) (Double -> Double)\n | SamplerMass (S.Prob Int) (Int -> Double)\n | SamplesSame (S.Prob Double) (S.Prob Double)\nclass Assertable a where\n assertIt :: a -> S.Prob Bool\n\ninstance Assertable Bool where\n assertIt = return\n\ninstance Assertable Always where\n assertIt (Always s) = do\n bs <- sequence $ replicate 100 $ s\n return $ all id bs\n\ninstance Assertable Never where\n assertIt (Never s) = do\n bs <- sequence $ replicate 100 $ s\n return $ all (id . not) bs\n\ninstance Assertable Mostly where\n assertIt (Mostly s) = do\n bs <- sequence $ replicate 100 $ s\n let yeas = length $ filter id bs\n let nays = length $ filter not bs\n return $ yeas > nays \n\nncdf = 2000\n\ninstance Assertable SamplerDensity where\n assertIt (SamplerDensity sam pdf) = do\n samples@(s0:_) <- sampleFrom 500 sam\n let (lo',hi') = runStat (both (minFrom s0) (maxFrom s0)) samples\n rng' = hi' - lo'\n lo = lo' - 3*rng'\n hi = hi' + 3*rng'\n rng = hi - lo\n dx = rng/ncdf\n xs = map ((+lo) . (*dx)) [0..(ncdf-1)]\n ys = map ((*dx) . exp . pdf) xs\n --prs = zip ys (tail ys)\n cumv = listArray (0,(ncdf-1)) $ scanl (+) 0 ys\n let cdf x = cumv ! (round $ (x-lo)/dx)\n return $ kolmogorovSmirnovTestCdf cdf 0.05 (UV.fromList samples) == NotSignificant\n\n assertIt (SamplesSame sam1 sam2) = do\n samples1 <- sampleFrom 500 sam1\n samples2 <- sampleFrom 500 sam2\n return $ kolmogorovSmirnovTest2 0.05 (UV.fromList samples1) \n (UV.fromList samples2)\n == NotSignificant\n\n\nrunTests :: [(String,S.Prob Bool)] -> IO ()\nrunTests tsts = do\n seed <- S.getSeedIO\n rt 0 0 seed tsts \n where\n rt succ 0 _ [] = do\n putStrLn $ \"All (\"++show succ++\") tests pass\"\n rt succ fail _ [] = do\n putStrLn $ show fail++\"/\"++show (succ+fail)++\" tests fail\"\n exitWith $ ExitFailure 1\n rt s f seed ((nm, sam):rest) = do\n let (b,nseed) = sam1 seed sam\n if b\n then rt (s+1) f nseed rest\n else do putStrLn $ \"FAIL: \"++ nm\n rt s (f+1) nseed rest\n\nsam1 seed (S.Samples xs) = (head xs, seed) \nsam1 seed (S.Sampler f) = f seed\n\n\n--myRound :: Real a => a-> Int\n\n\nlistToVec xs = L.fromList xs\n\nvecToList xs = L.toList xs\n\nfillV = L.buildVector \n\nfillM (n,m) f = L.buildMatrix n m f\n\n\nsvd m = let (m1, v, m2) = L.svd m\n in [m1, L.diag v, m2]\n\nmdims m = (L.rows m, L.cols m)\n\nclass Askable a where\n ask :: Double -> Double -> [String] -> a -> IO [String]\n\ninstance Consolable a => Askable a where\n ask _ _ lns x = do\n ans <- fmap lines $ showC x \n return $ map (('>':) . (' ':)) $ init lns ++ \n [last lns ++ \" => \" ++ head ans] ++ \n tail' ans\n\ntail' [] = []\ntail' xs = tail xs\n\n-- run-time reflection on records\n\n{-class Has a where \n has :: String -> a -> Bool\n\ninstance Has (X (Id KindStar)) where\n has _ _ = False\n\ninstance (Show lab, Name lab, Has (b (Id KindStar))) \n => Has ((b :& lab ::: a) (Id KindStar)) where\n has nm (rest :& lab := val) = nm == show lab || has nm rest -}\n\ninstance L.Element Int \n\nclass (Num a, Ord a, L.Element a) => BayNum a where\n unround :: a -> Double\n\ninstance BayNum Double where \n unround = id\n\ninstance BayNum Int where \n unround = realToFrac\n\nbayError = error . T.unpack \n\naddSTRef ref x = modifySTRef ref (+x)\n\naddSTRef ref !x = modifySTRef ref (+x)\n\nconsSTRef ref !x = modifySTRef ref (x:)\n\nincrSTRef ref size = do\n x <- readSTRef ref\n let y = x+size\n y `seq` writeSTRef ref y\n return x\n\naddMV vref ix x = do\n y <- VSM.read vref ix\n VSM.write vref ix (x+y)\n\n\nshowReal :: Double -> T.Text\nshowReal = T.pack . show\n\n(*%) :: Double -> L.Matrix Double -> L.Matrix Double\n(*%) = L.scale\n\ntransL :: [[a]] -> [[a]]\ntransL = transpose\n\nunsafeFreeze = V.unsafeFreeze\n\nvcons = V.cons \nslice = V.slice -- FIXME: are we sure this uses inicies correctly?\nvmap = V.map\n", "meta": {"hexsha": "5563648a8b0b8d05f2ccc1c819889ae75ff4f82d", "size": 15154, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/Target/Prelude.hs", "max_stars_repo_name": "glutamate/probably-baysig", "max_stars_repo_head_hexsha": "59c99bf29d6948b82243a4d778650d8e503962d9", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 11, "max_stars_repo_stars_event_min_datetime": "2015-02-12T05:53:43.000Z", "max_stars_repo_stars_event_max_datetime": "2019-11-28T03:19:37.000Z", "max_issues_repo_path": "src/Target/Prelude.hs", "max_issues_repo_name": "silky/probably-baysig", "max_issues_repo_head_hexsha": "59c99bf29d6948b82243a4d778650d8e503962d9", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/Target/Prelude.hs", "max_forks_repo_name": "silky/probably-baysig", "max_forks_repo_head_hexsha": "59c99bf29d6948b82243a4d778650d8e503962d9", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2015-08-31T09:18:09.000Z", "max_forks_repo_forks_event_max_datetime": "2019-03-15T11:09:04.000Z", "avg_line_length": 31.2453608247, "max_line_length": 339, "alphanum_fraction": 0.587237693, "num_tokens": 4777, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6757646010190476, "lm_q2_score": 0.48438008427698437, "lm_q1q2_score": 0.327326914393009}} {"text": "{-|\n\n Module : HF\n Copyright : Copyright (c) David Schlegel\n License : BSD\n Maintainer : David Schlegel\n Stability : experimental\n Portability : Haskell\n\n Module \"HF\".\n-}\n\nmodule HF (\n{-| Module \"HF.Data\" provides all important datastructures and corresponding functions as well as dictionary lists.\t-} \nmodule HF.Data, \n{-|In \"ReadWrite\" important functions are provided to\n\n\t* Read input (Geometry information, Basis set information) and convert to internal datastructures, provided in \"Data\"\n\t* Write output (Geometry, structure and basis set information)\n-}\nmodule HF.ReadWrite, \n{-|Gaussian Integral evaluation plays an important role in quantum chemistry. In \"HF.Gauss\", functions will be provided to compute the most important integrals involving gaussian-type orbitals (GTOs). -}\nmodule HF.Gauss)where\n{-\n--Total Packages included\nimport System.Process\nimport System.IO\nimport System.IO.Unsafe\nimport Data.List\nimport Data.List.Split\nimport Numeric.Container hiding (linspace)\nimport Data.Maybe\nimport Numeric.LinearAlgebra\nimport Numeric.LinearAlgebra.Data hiding (linspace)\nimport Text.Printf\n-}\n\n--Some Dictionaries\n--dict1 = [(\"CARBON\", \"C\"), (\"NITROGEN\", \"N\"), (\"OXYGEN\", \"O\"), (\"HYDROGEN\", \"H\")]\n--dict2 = [(\"CARBON\", 6.0), (\"NITROGEN\", 7.0), (\"OXYGEN\", 8.0), (\"HYDROGEN\", 1.0)]\n--dict3 = [(\"S\", 0), (\"P\", 1), (\"D\", 2), (\"F\", 3)]\n\nimport HF.Data\n\nimport HF.ReadWrite\n\n\nimport HF.Gauss\n\n\n--import Matrices\nimport Numeric.Container hiding (linspace)\n\n\n\n", "meta": {"hexsha": "5cc38f87d2617f49cbe55aa0cf9dfb07ca1d1e92", "size": 1485, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "dist/build/autogen/HF.hs", "max_stars_repo_name": "davidschlegel/hartree-fock", "max_stars_repo_head_hexsha": "381fc9c40e8d8f63c540b092ce51fca173149de9", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "dist/build/autogen/HF.hs", "max_issues_repo_name": "davidschlegel/hartree-fock", "max_issues_repo_head_hexsha": "381fc9c40e8d8f63c540b092ce51fca173149de9", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "dist/build/autogen/HF.hs", "max_forks_repo_name": "davidschlegel/hartree-fock", "max_forks_repo_head_hexsha": "381fc9c40e8d8f63c540b092ce51fca173149de9", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 26.5178571429, "max_line_length": 203, "alphanum_fraction": 0.7151515152, "num_tokens": 404, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.6297746074044134, "lm_q2_score": 0.519521321952093, "lm_q1q2_score": 0.3271813365706012}} {"text": "{-# LANGUAGE AllowAmbiguousTypes #-}\n{-# LANGUAGE DataKinds #-}\n{-# LANGUAGE DeriveGeneric #-}\n{-# LANGUAGE PolyKinds #-}\n{-# LANGUAGE FlexibleContexts #-}\n{-# LANGUAGE FlexibleInstances #-}\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE NoMonomorphismRestriction #-}\n{-# LANGUAGE OverloadedStrings #-}\n{-# LANGUAGE ScopedTypeVariables #-}\n{-# LANGUAGE TypeApplications #-}\n{-# LANGUAGE TypeFamilies #-}\n{-# LANGUAGE TypeOperators #-}\n{-# LANGUAGE StandaloneDeriving #-}\n{-# LANGUAGE UndecidableInstances #-}\n\nmodule BlueRipple.Model.MRP where\n\nimport qualified BlueRipple.Data.Keyed as K\nimport qualified BlueRipple.Data.DataFrames as BR\nimport BlueRipple.Data.CountFolds\nimport qualified Control.Foldl as FL\nimport Control.Monad ( join )\nimport qualified Control.Monad.State as State\nimport qualified Data.Array as A\nimport Data.Function ( on )\nimport qualified Data.List as L\nimport qualified Data.Set as S\nimport qualified Data.IntMap as IM\nimport qualified Data.Map as M\nimport Data.Maybe ( isJust\n , fromJust\n )\nimport qualified Data.Text as T\nimport qualified Data.Profunctor as P\nimport qualified Data.Serialize as SE\nimport Data.Serialize.Text ()\nimport qualified Data.Vector as V\nimport qualified Data.Vector.Storable as VS\n\n\nimport qualified Frames as F\nimport qualified Frames.Melt as F\nimport qualified Frames.InCore as FI\nimport qualified Data.Vinyl as V\nimport qualified Data.Vinyl.TypeLevel as V\n\n\nimport qualified Control.MapReduce as MR\nimport qualified Frames.Transform as FT\nimport qualified Frames.Folds as FF\nimport qualified Frames.MapReduce as FMR\nimport qualified Frames.Enumerations as FE\n--import qualified Frames.Misc as FU\nimport qualified Frames.Serialize as FS\n\nimport qualified Knit.Report as K hiding (elements)\nimport qualified Polysemy.Error as P\n ( mapError )\nimport qualified Polysemy as P\n ( raise )\nimport Text.Pandoc.Error as PE\nimport qualified Text.Blaze.Colonnade as BC\nimport qualified Text.Show\n\nimport qualified Numeric.LinearAlgebra as LA\n\nimport qualified Data.IndexedSet as IS\nimport qualified Numeric.GLM.ProblemTypes as GLM\nimport qualified Numeric.GLM.ModelTypes as GLM\nimport qualified Numeric.GLM.FunctionFamily as GLM\nimport Numeric.GLM.MixedModel as GLM\nimport qualified Numeric.GLM.Bootstrap as GLM\nimport qualified Numeric.GLM.Report as GLM\nimport qualified Numeric.GLM.Predict as GLM\nimport qualified Numeric.GLM.Confidence as GLM\nimport qualified Numeric.SparseDenseConversions\n as SD\n\nimport qualified Relude.Extra as Relude\n\nimport qualified Statistics.Types as ST\nimport GHC.Generics ( Generic, Rep )\n\n\n\n{- Moved to BlueRipple.Data.CountFolds\n-- map reduce folds for counting\ntype Count = \"Count\" F.:-> Int\ntype Successes = \"Successes\" F.:-> Int\ntype MeanWeight = \"MeanWeight\" F.:-> Double\ntype VarWeight = \"VarWeight\" F.:-> Double\ntype WeightedSuccesses = \"WeightedSuccesses\" F.:-> Double\ntype UnweightedSuccesses = \"UnweightedSuccesses\" F.:-> Int\n\nbinomialFold\n :: (F.Record r -> Bool) -> FL.Fold (F.Record r) (F.Record '[Count, Successes])\nbinomialFold testRow =\n let successesF = FL.premap (\\r -> if testRow r then 1 else 0) FL.sum\n in (\\n s -> n F.&: s F.&: V.RNil) <$> FL.length <*> successesF\n\ncountFold\n :: forall k r d\n . ( Ord (F.Record k)\n , FI.RecVec (k V.++ '[Count, Successes])\n , k F.\u2286 r\n , d F.\u2286 r\n )\n => (F.Record d -> Bool)\n -> FL.Fold (F.Record r) [F.FrameRec (k V.++ '[Count, Successes])]\ncountFold testData = MR.mapReduceFold\n MR.noUnpack\n (FMR.assignKeysAndData @k)\n (FMR.foldAndAddKey $ binomialFold testData)\n\ntype CountCols = '[Count, UnweightedSuccesses, WeightedSuccesses, MeanWeight, VarWeight]\n\nzeroCount :: F.Record CountCols\nzeroCount = 0 F.&: 0 F.&: 0 F.&: 1 F.&: 0 F.&: V.RNil\n\nweightedBinomialFold\n :: (F.Record r -> Bool)\n -> (F.Record r -> Double)\n -> FL.Fold (F.Record r) (F.Record CountCols)\nweightedBinomialFold testRow weightRow =\n let wSuccessesF =\n FL.premap (\\r -> if testRow r then weightRow r else 0) FL.sum\n successesF = FL.premap (\\r -> if testRow r then 1 else 0) FL.sum\n meanWeightF = FL.premap weightRow FL.mean\n varWeightF = FL.premap weightRow FL.variance\n f s ws mw = if mw < 1e-6 then realToFrac s else ws / mw -- if meanweight is 0 but\n in (\\n s ws mw vw -> n F.&: s F.&: f s ws mw F.&: mw F.&: vw F.&: V.RNil)\n <$> FL.length\n <*> successesF\n <*> wSuccessesF\n <*> meanWeightF\n <*> varWeightF\n\nweightedCountFold\n :: forall k r d\n . (Ord (F.Record k)\n , FI.RecVec (k V.++ CountCols)\n , k F.\u2286 r\n , k F.\u2286 (k V.++ r)\n , d F.\u2286 (k V.++ r)\n )\n => (F.Record r -> Bool) -- ^ count this row?\n -> (F.Record d -> Bool) -- ^ success ?\n -> (F.Record d -> Double) -- ^ weight\n -> FL.Fold (F.Record r) (F.FrameRec (k V.++ CountCols))\nweightedCountFold {- filterData testData weightData-} = weightedCountFoldGeneral (F.rcast @k)\n{- FMR.concatFold $ FMR.mapReduceFold\n (MR.filterUnpack filterData)\n (FMR.assignKeysAndData @k)\n (FMR.foldAndAddKey $ weightedBinomialFold testData weightData)\n-}\n\nweightedCountFoldGeneral\n :: forall k r d\n . (Ord (F.Record k)\n , FI.RecVec (k V.++ CountCols)\n , k F.\u2286 (k V.++ r)\n , d F.\u2286 (k V.++ r)\n )\n => (F.Record r -> F.Record k)\n -> (F.Record r -> Bool) -- ^ include this row?\n -> (F.Record d -> Bool) -- ^ success ?\n -> (F.Record d -> Double) -- ^ weight\n -> FL.Fold (F.Record r) (F.FrameRec (k V.++ CountCols))\nweightedCountFoldGeneral getKey filterData testData weightData =\n FL.prefilter filterData $ FMR.concatFold $ FMR.mapReduceFold\n (MR.Unpack $ \\r -> [getKey r `V.rappend` r])\n (FMR.assignKeysAndData @k @d)\n (FMR.foldAndAddKey $ weightedBinomialFold testData weightData)\n\n-}\n\ngetFraction r =\n let n = F.rgetField @Count r\n in if n == 0\n then 0\n else realToFrac (F.rgetField @Successes r) / realToFrac n\n\ngetFractionWeighted r =\n let n = F.rgetField @Count r\n in if n == 0 then 0 else F.rgetField @WeightedSuccesses r / realToFrac n\n\ndata RecordColsProxy k = RecordColsProxy deriving (Show, Enum, Bounded, A.Ix, Eq, Ord)\ntype instance GLM.GroupKey (RecordColsProxy k) = F.Record k\n\n--type instance GLM.GroupKey (Proxy k) = F.Record k\n\nrecordToGroupKey\n :: forall k r . (k F.\u2286 r) => F.Record r -> RecordColsProxy k -> F.Record k\nrecordToGroupKey r _ = F.rcast @k r\n\nglmErrorToPandocError :: GLM.GLMError -> PE.PandocError\nglmErrorToPandocError x = PE.PandocSomeError $ show x\n\n\ntype GroupCols gs cs = gs V.++ cs\ntype CountedCols gs cs = GroupCols gs cs V.++ CountCols\n\n\n\n---\nnewtype SimplePredictor ps = SimplePredictor { unSimplePredictor :: F.Record ps }\n\ninstance (Show (F.Record ps)) => Show (SimplePredictor ps) where\n show (SimplePredictor x) = \"SimplePredictor \" ++ show @String x\n\ninstance (Eq (F.Record ps)) => Eq (SimplePredictor ps) where\n (SimplePredictor x) == (SimplePredictor y) = x == y\n\ninstance (Ord (F.Record ps)) => Ord (SimplePredictor ps) where\n compare (SimplePredictor x) (SimplePredictor y) = compare x y\n\ninstance (Ord (F.Record ps), K.FiniteSet (F.Record ps)) => Enum (SimplePredictor ps) where\n toEnum n =\n let im = IM.fromList $ zip [0..] $ SimplePredictor <$> S.toAscList K.elements\n in fromMaybe (error \"Bad n given to toEnum :: Int -> SimplePredictor\") $ IM.lookup n im\n fromEnum a =\n let m = M.fromList $ zip (SimplePredictor <$> S.toAscList K.elements) [0..]\n in fromMaybe (error \"Bad SimplePredictor given to fromEnum :: SimplePredictor -> Int. This means something is very bad.\") $ M.lookup a m\n\ninstance (K.FiniteSet (F.Record ps)) => Bounded (SimplePredictor ps) where\n minBound = fromMaybe (error \"Empty Set of Records used as predictor\") $ viaNonEmpty head $ SimplePredictor <$> S.toList K.elements\n maxBound = fromMaybe (error \"Empty Set of Records used as predictor\") $ viaNonEmpty last $ SimplePredictor <$> S.toList K.elements\n\n\nallSimplePredictors :: K.FiniteSet (F.Record ps) => [SimplePredictor ps]\nallSimplePredictors = SimplePredictor <$> S.toList K.elements\n\ntype SimpleEffect ps = GLM.WithIntercept (SimplePredictor ps)\n\nsimplePredictor :: forall ps rs. (ps F.\u2286 rs\n , Eq (F.Record ps)\n )\n => F.Record rs -> SimplePredictor ps -> Double\nsimplePredictor r p = if F.rcast @ps r == unSimplePredictor p then 1 else 0\n\npredMap :: forall cs. (K.FiniteSet (F.Record cs), Ord (F.Record cs), cs F.\u2286 cs)\n => F.Record cs -> M.Map (SimplePredictor cs) Double\npredMap r = M.fromList $ Relude.fmapToSnd (simplePredictor r) allSimplePredictors\n\ncatPredMaps :: forall cs. (K.FiniteSet (F.Record cs), Ord (F.Record cs), cs F.\u2286 cs)\n => M.Map (F.Record cs) (M.Map (SimplePredictor cs) Double)\ncatPredMaps = M.fromList $ fmap (\\k -> (unSimplePredictor k,predMap (unSimplePredictor k))) allSimplePredictors\n\ndata LocationHolder c f a = LocationHolder { locName :: T.Text\n , locKey :: Maybe (F.Rec f LocationCols)\n , catData :: M.Map (F.Rec f c) a\n } deriving (Generic)\n\nderiving instance (V.RMap c\n , V.ReifyConstraint Show F.ElField c\n , V.RecordToList c\n , Show a) => Show (LocationHolder c F.ElField a)\n\ninstance (SE.Serialize a\n , Ord (F.Rec FS.SElField c)\n , SE.GSerializePut\n (Rep (F.Rec FS.SElField c))\n , SE.GSerializeGet (Rep (F.Rec FS.SElField c))\n , (Generic (F.Rec FS.SElField c))\n ) => SE.Serialize (LocationHolder c FS.SElField a)\n\nlhToS :: (Ord (F.Rec FS.SElField c)\n , V.RMap c\n )\n => LocationHolder c F.ElField a -> LocationHolder c FS.SElField a\nlhToS (LocationHolder n lkM cdm) = LocationHolder n (fmap FS.toS lkM) (M.mapKeys FS.toS cdm)\n\nlhFromS :: (Ord (F.Rec F.ElField c)\n , V.RMap c\n ) => LocationHolder c FS.SElField a -> LocationHolder c F.ElField a\nlhFromS (LocationHolder n lkM cdm) = LocationHolder n (fmap FS.fromS lkM) (M.mapKeys FS.fromS cdm)\n\ntype LocationCols = '[BR.StateAbbreviation]\nlocKeyPretty :: F.Record LocationCols -> T.Text\nlocKeyPretty r =\n let stateAbbr = F.rgetField @BR.StateAbbreviation r\n in stateAbbr\n\n--type ASER = '[BR.SimpleAgeC, BR.SexC, BR.CollegeGradC, BR.SimpleRaceC]\npredictionsByLocation ::\n forall ps r rs. ( V.RMap ps\n , V.ReifyConstraint Show V.ElField ps\n , V.RecordToList ps\n , Ord (F.Record ps)\n , Ord (SimplePredictor ps)\n , FI.RecVec (ps V.++ CountCols)\n , F.ElemOf (ps V.++ CountCols) Count\n , F.ElemOf (ps V.++ CountCols) MeanWeight\n , F.ElemOf (ps V.++ CountCols) UnweightedSuccesses\n , F.ElemOf (ps V.++ CountCols) VarWeight\n , F.ElemOf (ps V.++ CountCols) WeightedSuccesses\n , K.FiniteSet (F.Record ps)\n , Show (F.Record (LocationCols V.++ ps V.++ CountCols))\n , Show (F.Record ps)\n , Enum (SimplePredictor ps)\n , Bounded (SimplePredictor ps)\n , (ps V.++ CountCols) F.\u2286 (LocationCols V.++ ps V.++ CountCols)\n , ps F.\u2286 (ps V.++ CountCols)\n , ps F.\u2286 (LocationCols V.++ ps V.++ CountCols)\n , F.ElemOf rs BR.StateAbbreviation\n , K.KnitEffects r\n )\n => GLM.MinimizeDevianceVerbosity\n -> F.FrameRec rs\n -> FL.Fold (F.Record rs) (F.FrameRec (LocationCols V.++ ps V.++ CountCols))\n -> [SimpleEffect ps]\n -> M.Map (F.Record ps) (M.Map (SimplePredictor ps) Double)\n -> K.Sem r [LocationHolder ps V.ElField Double]\npredictionsByLocation verbosity ccesFrame countFold predictors catPredMap =\n P.mapError glmErrorToPandocError $ K.wrapPrefix \"predictionsByLocation\" $ do\n K.logLE K.Diagnostic \"Inferring\"\n (mm, rc, ebg, bu, vb, bs) <- inferMR @LocationCols @ps @ps\n verbosity\n countFold\n predictors\n simplePredictor\n ccesFrame\n\n let states = FL.fold FL.set $ fmap (F.rgetField @BR.StateAbbreviation) ccesFrame\n allStateKeys = (F.&: V.RNil) <$> FL.fold FL.list states\n predictLoc l = LocationHolder (locKeyPretty l) (Just l) catPredMap\n toPredict = [LocationHolder \"National\" Nothing catPredMap] <> fmap predictLoc allStateKeys\n predict (LocationHolder n lkM cpms) = P.mapError glmErrorToPandocError $ do\n let predictFrom catKey predMap =\n let groupKeyM = fmap (`V.rappend` catKey) lkM --lkM >>= \\lk -> return $ lk `V.rappend` catKey\n emptyAsNationalGKM = case groupKeyM of\n Nothing -> Nothing\n Just k -> k <$ GLM.categoryNumberFromKey rc k (RecordColsProxy @(LocationCols V.++ ps))\n in (fmap snd . GLM.runLogOnGLMException Nothing)\n $ GLM.predictFromBetaB mm (`M.lookup` predMap) (const emptyAsNationalGKM) rc ebg bu vb\n cpreds <- M.traverseWithKey predictFrom cpms\n return $ LocationHolder n lkM cpreds\n traverse predict toPredict\n\n---\n\n\n-- TODO: Add bootstraps back in, make optional\n-- Maybe set up way to serialize all this at this level??\n\n-- ls: are keys for locations (groups with no matching fixed-effect)\n-- cs: are keys for fixedEffects, one for each constructor in b\n-- b: Fixed Effect type\n-- g: group type\ninferMR\n :: forall ls cs ks b g f rs effs\n . ( Foldable f\n , Functor f\n , K.KnitEffects effs\n , F.RDeleteAll ls (ls V.++ ks V.++ CountCols) ~ (ks V.++ CountCols)\n , (ls V.++ ks V.++ CountCols) ~ (ls V.++ (ks V.++ CountCols))\n , Ord (F.Record ls)\n , ls F.\u2286 (ls V.++ ks V.++ CountCols)\n , (ks V.++ CountCols) F.\u2286 (ls V.++ ks V.++ CountCols)\n , ks F.\u2286 (ks V.++ CountCols)\n , (ls V.++ cs) F.\u2286 (ls V.++ (ks V.++ CountCols))\n , Show (F.Record (ls V.++ ks V.++ CountCols))\n , FI.RecVec (ls V.++ (ks V.++ CountCols))\n , F.ElemOf (ks V.++ CountCols) Count\n , F.ElemOf (ks V.++ CountCols) MeanWeight\n , F.ElemOf (ks V.++ CountCols) VarWeight\n , F.ElemOf (ks V.++ CountCols) WeightedSuccesses\n , F.ElemOf (ks V.++ CountCols) UnweightedSuccesses\n , F.ElemOf (ls V.++ ks V.++ CountCols) Count\n , F.ElemOf (ls V.++ ks V.++ CountCols) MeanWeight\n , F.ElemOf (ls V.++ ks V.++ CountCols) VarWeight\n , F.ElemOf (ls V.++ ks V.++ CountCols) WeightedSuccesses\n , F.ElemOf (ls V.++ ks V.++ CountCols) UnweightedSuccesses\n , Show (F.Record (ls V.++ cs))\n , K.FiniteSet (F.Record ks)\n , Ord b\n , Show b\n , Enum b\n , Bounded b\n , Ord (F.Record (GroupCols ls cs))\n , g ~ RecordColsProxy (GroupCols ls cs)\n )\n => GLM.MinimizeDevianceVerbosity\n -> FL.Fold (F.Record rs) (F.FrameRec (ls V.++ ks V.++ CountCols))\n -> [GLM.WithIntercept b] -- fixed effects to fit\n -> (F.Record (ls V.++ ks V.++ CountCols) -> b -> Double) -- how to get a fixed effect value from a record\n -> f (F.Record rs)\n -> K.Sem\n effs\n ( GLM.MixedModel b g\n , GLM.RowClassifier g\n , GLM.EffectsByGroup g b\n , GLM.BetaVec\n , LA.Vector Double\n , [(GLM.BetaVec, LA.Vector Double)]\n )\ninferMR verbosity cf fixedEffectList getFixedEffect rows =\n P.mapError glmErrorToPandocError\n $ (fmap snd . GLM.runLogOnGLMException Nothing)\n $ K.wrapPrefix \"inferMR\"\n $ do\n let\n addZeroCountsF = FMR.concatFold $ FMR.mapReduceFold\n FMR.noUnpack\n (FMR.splitOnKeys @ls)\n ( FMR.makeRecsWithKey id\n $ FMR.ReduceFold\n $ const\n $ K.addDefaultRec @ks zeroCount\n )\n counted = FL.fold FL.list $ FL.fold addZeroCountsF $ FL.fold cf rows\n-- K.logLE K.Diagnostic $ T.intercalate \"\\n\" $ fmap (T.pack . show) counted\n let\n vCounts = VS.fromList $ fmap (F.rgetField @Count) counted\n designEffect mw vw = 1 + (vw / (mw * mw))\n vWeights = VS.fromList $ fmap\n (\\r ->\n let mw = F.rgetField @MeanWeight r\n vw = F.rgetField @VarWeight r\n in case (mw < 1e-12, vw < 1e-12) of\n (True, _) -> 0\n (False, True) -> 1\n _ -> 1/sqrt (designEffect mw vw)\n )\n counted -- VS.replicate (VS.length vCounts) 1.0\n\n fixedEffects = GLM.FixedEffects $ IS.fromList fixedEffectList\n groups = IS.fromList [RecordColsProxy]\n (observations, fixedEffectsModelMatrix, rcM) = FL.fold\n (lmePrepFrame getFractionWeighted\n fixedEffects\n groups\n getFixedEffect\n (recordToGroupKey @(GroupCols ls cs))\n )\n counted\n-- K.logLE K.Diagnostic $ \"vCounts=\" <> (T.pack $ show vCounts)\n-- K.logLE K.Diagnostic $ \"vWeights=\" <> (T.pack $ show vWeights)\n-- K.logLE K.Diagnostic $ \"mX=\" <> (T.pack $ show fixedEffectsModelMatrix)\n-- K.logLE K.Diagnostic $ \"vY=\" <> (T.pack $ show observations)\n let regressionModelSpec = GLM.RegressionModelSpec\n fixedEffects\n fixedEffectsModelMatrix\n observations\n rowClassifier <- case rcM of\n Left msg -> K.knitError msg\n Right x -> return x\n-- K.logLE K.Diagnostic $ \"rc=\" <> (T.pack $ show rowClassifier)\n let effectsByGroup =\n M.fromList [(RecordColsProxy, IS.fromList [GLM.Intercept])]\n fitSpecByGroup <- GLM.fitSpecByGroup @b @g fixedEffects\n effectsByGroup\n rowClassifier\n let lmmControls = GLM.LMMControls GLM.LMM_BOBYQA 1e-6 Nothing\n lmmSpec = GLM.LinearMixedModelSpec\n (GLM.MixedModelSpec regressionModelSpec fitSpecByGroup)\n lmmControls\n cc = GLM.PIRLSConvergenceCriterion GLM.PCT_Deviance 1e-6 20\n glmmControls = GLM.GLMMControls GLM.UseCanonical 10 cc\n glmmSpec = GLM.GeneralizedLinearMixedModelSpec\n lmmSpec\n vWeights\n (GLM.Binomial vCounts)\n glmmControls\n mixedModel = GLM.GeneralizedLinearMixedModel glmmSpec\n randomEffectsModelMatrix <- GLM.makeZ fixedEffectsModelMatrix\n fitSpecByGroup\n rowClassifier\n-- K.logLE K.Diagnostic $ \"smZ=\" <> (T.pack $ show randomEffectsModelMatrix)\n let randomEffectCalc = GLM.RandomEffectCalculated\n randomEffectsModelMatrix\n (GLM.makeLambda fitSpecByGroup)\n th0 = GLM.setCovarianceVector fitSpecByGroup 1 0\n -- mdVerbosity = MDVNone\n GLM.checkProblem mixedModel randomEffectCalc\n K.logLE K.Info \"Fitting data...\"\n ((th, pd, sigma2, beta, mzvu, mzvb, cs), vMuSol, cf) <- GLM.minimizeDeviance\n verbosity\n ML\n mixedModel\n randomEffectCalc\n th0\n vb <- K.knitMaybe \"b-vector (random effects coefficients) is zero in MRP.inferMR\" $ GLM.useMaybeZeroVec Nothing Just mzvb\n GLM.report mixedModel\n randomEffectsModelMatrix\n beta\n (SD.toSparseVector vb)\n let fes = GLM.fixedEffectStatistics mixedModel sigma2 cs beta\n K.logLE K.Diagnostic $ \"FixedEffectStatistics: \" <> show fes\n epg <- GLM.effectParametersByGroup @g @b rowClassifier effectsByGroup vb\n-- K.logLE K.Diagnostic\n-- $ \"EffectParametersByGroup: \"\n-- <> (T.pack $ show epg)\n gec <- GLM.effectCovariancesByGroup effectsByGroup mixedModel sigma2 th\n K.logLE K.Diagnostic\n $ \"EffectCovariancesByGroup: \"\n <> show gec\n rebl <- GLM.randomEffectsByLabel epg rowClassifier\n K.logLE K.Diagnostic\n $ \"Random Effects:\\n\"\n <> GLM.printRandomEffectsByLabel rebl\n smCondVar <- GLM.conditionalCovariances mixedModel\n cf\n randomEffectCalc\n th\n beta\n mzvu\n let bootstraps = []\n let GLM.FixedEffectStatistics _ mBetaCov = fes\n let f r = do\n let obs = getFractionWeighted r\n predictCVCI <- GLM.predictWithCI\n mixedModel\n (Just . getFixedEffect r)\n (Just . recordToGroupKey @(GroupCols ls cs) r)\n rowClassifier\n effectsByGroup\n beta\n vb\n (ST.mkCL 0.95)\n (GLM.NaiveCondVarCI mBetaCov smCondVar)\n return (r, obs, predictCVCI)\n fitted <- traverse f (FL.fold FL.list counted)\n K.logLE K.Diagnostic\n $ \"Fitted:\\n\"\n <> (T.intercalate \"\\n\" $ fmap show fitted)\n fixedEffectTable <- GLM.printFixedEffects fes\n K.logLE K.Diagnostic $ \"FixedEffects:\\n\" <> fixedEffectTable\n let GLM.FixedEffectStatistics fep _ = fes\n return\n (mixedModel, rowClassifier, effectsByGroup, beta, vb, bootstraps) -- fes, epg, rowClassifier, bootstraps)\n\nlmePrepFrame\n :: forall p g rs\n . (GLM.PredictorC p, GLM.GroupC g)\n => (F.Record rs -> Double) -- ^ observations\n -> GLM.FixedEffects p\n -> IS.IndexedSet g\n -> (F.Record rs -> p -> Double) -- ^ predictors\n -> (F.Record rs -> g -> GLM.GroupKey g) -- ^ classifiers\n -> FL.Fold\n (F.Record rs)\n ( LA.Vector Double\n , LA.Matrix Double\n , Either T.Text (GLM.RowClassifier g)\n ) -- ^ (X,y,(row-classifier, size of class))\nlmePrepFrame observationF fe groupIndices getPredictorF classifierLabelF\n = let\n makeInfoVector\n :: M.Map g (M.Map (GLM.GroupKey g) Int)\n -> M.Map g (GLM.GroupKey g)\n -> Either T.Text (V.Vector (GLM.ItemInfo g))\n makeInfoVector indexMaps groupKeys =\n let\n g (grp, groupKey) =\n GLM.ItemInfo\n <$> ( maybe\n (Left $ \"Failed on \" <> show (grp, groupKey))\n Right\n $ M.lookup grp indexMaps\n >>= M.lookup groupKey\n )\n <*> pure groupKey\n in fmap V.fromList $ traverse g $ M.toList groupKeys\n makeRowClassifier\n :: Traversable f\n => M.Map g (M.Map (GLM.GroupKey g) Int)\n -> f (M.Map g (GLM.GroupKey g))\n -> Either T.Text (GLM.RowClassifier g)\n makeRowClassifier indexMaps labels = do\n let sizes = fmap M.size indexMaps\n indexed <- traverse (makeInfoVector indexMaps) labels\n return $ GLM.RowClassifier groupIndices\n sizes\n (V.fromList $ FL.fold FL.list indexed)\n indexMaps\n getPredictorF' _ GLM.Intercept = 1\n getPredictorF' row (GLM.Predictor x) = getPredictorF row x\n predictorF row = LA.fromList $ case fe of\n GLM.FixedEffects indexedFixedEffects ->\n getPredictorF' row <$> IS.members indexedFixedEffects\n GLM.InterceptOnly -> [1]\n getClassifierLabels :: F.Record rs -> M.Map g (GLM.GroupKey g)\n getClassifierLabels r =\n M.fromList $ Relude.fmapToSnd (classifierLabelF r) $ IS.members groupIndices\n foldObs = LA.fromList <$> FL.premap observationF FL.list\n foldPred = LA.fromRows <$> FL.premap predictorF FL.list\n foldClass = FL.premap getClassifierLabels FL.list\n g (vY, mX, ls) =\n ( vY\n , mX\n , makeRowClassifier\n (snd $ State.execState (addAll ls) (M.empty, M.empty))\n ls\n )\n in\n g <$> ((,,) <$> foldObs <*> foldPred <*> foldClass)\n\n\n\naddOne\n :: GLM.GroupC g\n => (g, GLM.GroupKey g)\n -> State.State (M.Map g Int, M.Map g (M.Map (GLM.GroupKey g) Int)) ()\naddOne (grp, label) = do\n (nextIndexMap, groupIndexMaps) <- State.get\n let groupIndexMap = fromMaybe M.empty $ M.lookup grp groupIndexMaps\n case M.lookup label groupIndexMap of\n Nothing -> do\n let index = fromMaybe 0 $ M.lookup grp nextIndexMap\n nextIndexMap' = M.insert grp (index + 1) nextIndexMap\n groupIndexMaps' =\n M.insert grp (M.insert label index groupIndexMap) groupIndexMaps\n State.put (nextIndexMap', groupIndexMaps')\n return ()\n _ -> return ()\n\naddMany\n :: (GLM.GroupC g, Traversable h)\n => h (g, GLM.GroupKey g)\n -> State.State (M.Map g Int, M.Map g (M.Map (GLM.GroupKey g) Int)) ()\naddMany = traverse_ addOne\n\naddAll\n :: GLM.GroupC g\n => [M.Map g (GLM.GroupKey g)]\n -> State.State (M.Map g Int, M.Map g (M.Map (GLM.GroupKey g) Int)) ()\naddAll = traverse_ (addMany . M.toList)\n\n-- useful data folds\nweightedSumF :: (Real w, Real v, Fractional y) => FL.Fold (w, v) y\nweightedSumF =\n (/)\n <$> FL.premap (\\(w, v) -> realToFrac w * realToFrac v) FL.sum\n <*> P.dimap fst realToFrac FL.sum\n\nweightedSumRecF\n :: forall w v y rs\n . ( V.KnownField w\n , V.KnownField v\n , Fractional y\n , F.ElemOf rs w\n , F.ElemOf rs v\n , Real (V.Snd w)\n , Real (V.Snd v)\n )\n => FL.Fold (F.Record rs) y\nweightedSumRecF =\n FL.premap (\\r -> (F.rgetField @w r, F.rgetField @v r)) weightedSumF\n\n\nsumProdIfRecF\n :: forall w v t y rs\n . ( V.KnownField w\n , V.KnownField v\n , V.KnownField t\n , Fractional y\n , F.ElemOf rs w\n , F.ElemOf rs v\n , F.ElemOf rs t\n , Real (V.Snd w)\n , Real (V.Snd v)\n )\n => (V.Snd t -> Bool)\n -> FL.Fold (F.Record rs) y\nsumProdIfRecF test = FL.prefilter (test . F.rgetField @t) $ FL.premap\n (\\r -> realToFrac (F.rgetField @w r) * realToFrac (F.rgetField @v r))\n FL.sum\n", "meta": {"hexsha": "7df1257888fa04c763095e6740050ca9da68c3f1", "size": 26964, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "blueripple-glm/src/BlueRipple/Model/MRP.hs", "max_stars_repo_name": "blueripple/preference-model", "max_stars_repo_head_hexsha": "beae97c2d854830bc0e9027609e54166f93d976b", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2019-07-24T11:32:48.000Z", "max_stars_repo_stars_event_max_datetime": "2019-07-24T11:32:48.000Z", "max_issues_repo_path": "blueripple-glm/src/BlueRipple/Model/MRP.hs", "max_issues_repo_name": "blueripple/preference-model", "max_issues_repo_head_hexsha": "beae97c2d854830bc0e9027609e54166f93d976b", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "blueripple-glm/src/BlueRipple/Model/MRP.hs", "max_forks_repo_name": "blueripple/preference-model", "max_forks_repo_head_hexsha": "beae97c2d854830bc0e9027609e54166f93d976b", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 40.2447761194, "max_line_length": 141, "alphanum_fraction": 0.5834445928, "num_tokens": 7348, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO\n\n", "lm_q1_score": 0.7341195269001831, "lm_q2_score": 0.4455295350395727, "lm_q1q2_score": 0.32707193148330965}} {"text": "{-# LANGUAGE GADTs,RebindableSyntax,CPP,FlexibleContexts,FlexibleInstances,ConstraintKinds #-}\n{-# LANGUAGE StandaloneDeriving,DeriveDataTypeable #-}\n{-# OPTIONS_GHC -dcore-lint #-}\n{-\n - This test suite ensures that the rewrites that HerbiePlugin performs\n - give the correct results.\n -}\n\nmodule Main\n where\n\nimport SubHask\n\nimport System.IO\n-- import Data.Complex\n-- import Linear.Quaternion\n-- import Linear.V3\n-- import Linear.Vector\n\n--------------------------------------------------------------------------------\n\ntest1a :: Double -> Double -> Double\ntest1a far near = -(2 * far * near) / (far - near)\n\n{-# ANN test1b \"NoHerbie\" #-}\ntest1b :: Double -> Double -> Double\ntest1b far near = -(2 * far * near) / (far - near)\n\n{-# ANN test1c \"NoHerbie\" #-}\ntest1c :: Double -> Double -> Double\ntest1c far near = if far < -1.7210442634149447e81\n then ((-2 * far) / (far - near)) * near\n else if far < 8.364504563556443e16\n then -2 * far * (near / (far - near))\n else ((-2 * far) / (far - near)) * near\n\n{-\n--------------------\n\ntest2a :: Double -> Double -> Double\ntest2a a b = a + ((b - a) / 2)\n\n{-# ANN test2b \"NoHerbie\" #-}\ntest2b :: Double -> Double -> Double\ntest2b a b = a + ((b - a) / 2)\n\n--------------------\n\n-- test3a :: Quaternion Double -> Quaternion Double -> Quaternion Double\n-- test3a (Quaternion q0 (V3 q1 q2 q3)) (Quaternion r0 (V3 r1 r2 r3)) =\n-- Quaternion (r0*q0+r1*q1+r2*q2+r3*q3)\n-- (V3 (r0*q1-r1*q0-r2*q3+r3*q2)\n-- (r0*q2+r1*q3-r2*q0-r3*q1)\n-- (r0*q3-r1*q2+r2*q1-r3*q0))\n-- ^/ (r0*r0 + r1*r1 + r2*r2 + r3*r3)\n--\n-- {-# ANN test3b \"NoHerbie\" #-}\n-- test3b :: Quaternion Double -> Quaternion Double -> Quaternion Double\n-- test3b (Quaternion q0 (V3 q1 q2 q3)) (Quaternion r0 (V3 r1 r2 r3)) =\n-- Quaternion (r0*q0+r1*q1+r2*q2+r3*q3)\n-- (V3 (r0*q1-r1*q0-r2*q3+r3*q2)\n-- (r0*q2+r1*q3-r2*q0-r3*q1)\n-- (r0*q3-r1*q2+r2*q1-r3*q0))\n-- ^/ (r0*r0 + r1*r1 + r2*r2 + r3*r3)\n\n--------------------\n\ndata Yo a = Yo\n { yo_x2y :: a\n , yo_y2x :: a\n }\n\ntest4 :: Real a => a -> a -> Yo a\ntest4 x y = Yo\n { yo_x2y = x * x * y\n , yo_y2x = y * y * x\n }\n\ntest5 :: Float -> Float -> Float\ntest5 x y = (x * x) + (2 * x * y) + (y * y)\n\n--------------------------------------------------------------------------------\n\n-- asinh_ :: Complex Double -> Complex Double\n-- asinh_ x = log (x + sqrt (1.0+x*x))\n--\n-- acosh_ :: Complex Double -> Complex Double\n-- acosh_ x = log (x + (x+1.0) * sqrt ((x-1.0)/(x+1.0)))\n\natanh_ :: Double -> Double\natanh_ x = 0.5 * log ((1.0+x) / (1.0-x))\n\n--------------------------------------------------------------------------------\n-}\n\n#define mkTest(f1,f2,a,b) \\\n putStrLn $ \"mkTest: \" ++ show (f1 (a) (b)); \\\n putStrLn $ \"mkTest: \" ++ show (f2 (a) (b)); \\\n putStrLn \"\"\n\n#define mkTestB(f1,f2,a) \\\n putStrLn $ \"mkTest: \" ++ show (f1 (a)); \\\n putStrLn $ \"mkTest: \" ++ show (f2 (a)); \\\n putStrLn \"\"\n\nmain = do\n mkTest(test1a,test1b,-2e90,6)\n mkTest(test1a,test1b,3,4)\n mkTest(test1a,test1b,2e90,6)\n\n mkTest(test1a,test1c,-2e90,6)\n mkTest(test1a,test1c,3,4)\n mkTest(test1a,test1c,2e90,6)\n\n{-\n mkTest(test2a,test2b,1,2)\n\n-- mkTest(test3a,test3b,(Quaternion 1 (V3 1 2 3)),(Quaternion 2 (V3 2 3 4)))\n\n-- mkTestB(asinh,asinh_,5e-17::Complex Double)\n-- mkTestB(acosh,acosh_,5e-17::Complex Double)\n mkTestB(atanh,atanh_,5e-17::Double)\n-}\n\n putStrLn \"done\"\n\n\n\n\n\n", "meta": {"hexsha": "66cf8e3dfac128b2156420ce5ef644538e5f5586", "size": 3520, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "test/ValidRewrite.hs", "max_stars_repo_name": "mikeizbicki/herbie-haskell", "max_stars_repo_head_hexsha": "0d495e40961742d578746120cd728c1ec9237cb4", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 212, "max_stars_repo_stars_event_min_datetime": "2015-09-22T15:34:19.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-08T02:10:40.000Z", "max_issues_repo_path": "test/ValidRewrite.hs", "max_issues_repo_name": "mikeizbicki/herbie-haskell", "max_issues_repo_head_hexsha": "0d495e40961742d578746120cd728c1ec9237cb4", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 22, "max_issues_repo_issues_event_min_datetime": "2015-09-22T20:06:08.000Z", "max_issues_repo_issues_event_max_datetime": "2017-03-05T03:56:04.000Z", "max_forks_repo_path": "test/ValidRewrite.hs", "max_forks_repo_name": "mikeizbicki/herbie-haskell", "max_forks_repo_head_hexsha": "0d495e40961742d578746120cd728c1ec9237cb4", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 8, "max_forks_repo_forks_event_min_datetime": "2015-09-22T15:37:46.000Z", "max_forks_repo_forks_event_max_datetime": "2016-05-22T08:51:27.000Z", "avg_line_length": 26.8702290076, "max_line_length": 94, "alphanum_fraction": 0.5142045455, "num_tokens": 1220, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6859494550081925, "lm_q2_score": 0.47657965106367595, "lm_q1q2_score": 0.32690955191512305}} {"text": "module Main where\n\nimport Control.DeepSeq (NFData)\nimport Data.Complex (Complex((:+)))\nimport Data.Function (on)\n\ntest1 :: Int\ntest1 = undefined\n\ntest2 :: a -> a -> Complex a\ntest2 = (:+)\n\ntest25 :: NFData a => a\ntest25 = undefined\n\ntest3 :: (b -> b -> c) -> (a -> b) -> a -> a -> c\ntest3 = on\n\ntest4 :: IO ()\ntest4 = putStrLn \"Bar\"\n\ntest5 :: [t] -> ()\ntest5 (_:_) = ()\ntest5 _ = error \"test5\"\n\n-- hlint\ntest6 :: [Integer] -> [Integer]\ntest6 = map ((+ 1) . (* 2))\n", "meta": {"hexsha": "b18e6eb35876336a3e859b2be90257f93cd87f0b", "size": 464, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "test-elisp/out.hs", "max_stars_repo_name": "betaveros/ghc-mod", "max_stars_repo_head_hexsha": "f5ab347c030e9b191f7a8ed9b6e54760c6d6eeab", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2015-11-08T09:03:04.000Z", "max_stars_repo_stars_event_max_datetime": "2015-11-08T09:03:04.000Z", "max_issues_repo_path": "test-elisp/out.hs", "max_issues_repo_name": "phaazon/ghc-mod", "max_issues_repo_head_hexsha": "af7b910394266a1ce67c54f34f0cb7ff90f29445", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "test-elisp/out.hs", "max_forks_repo_name": "phaazon/ghc-mod", "max_forks_repo_head_hexsha": "af7b910394266a1ce67c54f34f0cb7ff90f29445", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 16.0, "max_line_length": 49, "alphanum_fraction": 0.5646551724, "num_tokens": 159, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.5813030761371502, "lm_q2_score": 0.5621765008857982, "lm_q1q2_score": 0.3267949292969338}} {"text": "module Math.HiddenMarkovModel.Named (\n T(..),\n Discrete,\n Gaussian,\n fromModelAndNames,\n toCSV,\n fromCSV,\n ) where\n\nimport qualified Math.HiddenMarkovModel.Distribution as Distr\nimport qualified Math.HiddenMarkovModel.Private as HMM\nimport qualified Math.HiddenMarkovModel.CSV as HMMCSV\nimport Math.HiddenMarkovModel.Distribution (State(..))\nimport Math.HiddenMarkovModel.Utility (attachOnes)\n\nimport qualified Numeric.LinearAlgebra.Algorithms as Algo\nimport qualified Data.Packed.Vector as Vector\n\nimport qualified Text.CSV.Lazy.String as CSV\nimport Text.Printf (printf)\n\nimport qualified Control.Monad.Exception.Synchronous as ME\nimport qualified Control.Monad.Trans.State as MS\nimport Control.DeepSeq (NFData, rnf)\nimport Foreign.Storable (Storable)\n\nimport qualified Data.Map as Map\nimport qualified Data.List as List\nimport Data.Tuple.HT (swap)\nimport Data.Map (Map)\n\n\n{- |\nA Hidden Markov Model with names for each state.\n\nAlthough 'nameFromStateMap' and 'stateFromNameMap' are exported\nyou must be careful to keep them consistent when you alter them.\n-}\ndata T distr prob =\n Cons {\n model :: HMM.T distr prob,\n nameFromStateMap :: Map State String,\n stateFromNameMap :: Map String State\n }\n deriving (Show, Read)\n\ntype Discrete prob symbol = T (Distr.Discrete prob symbol) prob\ntype Gaussian a = T (Distr.Gaussian a) a\n\n\ninstance\n (NFData distr, NFData prob, Storable prob) =>\n NFData (T distr prob) where\n rnf hmm = rnf (model hmm, nameFromStateMap hmm, stateFromNameMap hmm)\n\n\nfromModelAndNames :: HMM.T distr prob -> [String] -> T distr prob\nfromModelAndNames md names =\n let m = Map.fromList $ zip [State 0 ..] names\n in Cons {\n model = md,\n nameFromStateMap = m,\n stateFromNameMap = inverseMap m\n }\n\ninverseMap :: Map State String -> Map String State\ninverseMap =\n Map.fromListWith (error \"duplicate label\") .\n map swap . Map.toList\n\n\ntoCSV ::\n (Distr.CSV distr, Algo.Field prob, Show prob) =>\n T distr prob -> String\ntoCSV hmm =\n CSV.ppCSVTable $ snd $ CSV.toCSVTable $ HMMCSV.padTable \"\" $\n Map.elems (nameFromStateMap hmm) : HMM.toCells (model hmm)\n\nfromCSV ::\n (Distr.CSV distr, Algo.Field prob, Read prob) =>\n String -> ME.Exceptional String (T distr prob)\nfromCSV =\n MS.evalStateT parseCSV . map HMMCSV.fixShortRow . CSV.parseCSV\n\nparseCSV ::\n (Distr.CSV distr, Algo.Field prob, Read prob) =>\n HMMCSV.CSVParser (T distr prob)\nparseCSV = do\n names <- HMMCSV.parseStringList =<< HMMCSV.getRow\n let duplicateNames =\n Map.keys $ Map.filter (> (1::Int)) $\n Map.fromListWith (+) $ attachOnes names\n in HMMCSV.assert (null duplicateNames) $\n \"duplicate names: \" ++ List.intercalate \", \" duplicateNames\n md <- HMM.parseCSV\n let n = length names\n m = Vector.dim (HMM.initial md)\n in HMMCSV.assert (n == m) $\n printf \"got %d state names for %d state\" n m\n return $ fromModelAndNames md names\n", "meta": {"hexsha": "a79647e2fb3485d2182b87b3e65169d156dc4bfb", "size": 2963, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/Math/HiddenMarkovModel/Named.hs", "max_stars_repo_name": "rybern/hmm-hmatrix", "max_stars_repo_head_hexsha": "3f1c44aa630e0c7a662c1abe100ea8e783e3c44e", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/Math/HiddenMarkovModel/Named.hs", "max_issues_repo_name": "rybern/hmm-hmatrix", "max_issues_repo_head_hexsha": "3f1c44aa630e0c7a662c1abe100ea8e783e3c44e", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/Math/HiddenMarkovModel/Named.hs", "max_forks_repo_name": "rybern/hmm-hmatrix", "max_forks_repo_head_hexsha": "3f1c44aa630e0c7a662c1abe100ea8e783e3c44e", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 29.3366336634, "max_line_length": 72, "alphanum_fraction": 0.7050286871, "num_tokens": 785, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.6150878555160665, "lm_q2_score": 0.5312093733737563, "lm_q1q2_score": 0.3267404342984972}} {"text": "{-# LANGUAGE ViewPatterns #-}\n\nmodule Edge where\n\nimport Codec.Image.DevIL\nimport Data.Array.Unboxed\nimport Math.Probably.MCMC\nimport Math.Probably.Sampler\nimport Math.Probably.FoldingStats\nimport Control.Monad.State.Strict \nimport System.Cmd\nimport System.Environment\nimport Data.Array.IO\nimport System.IO\n\nimport Data.Array.Unboxed\nimport Numeric.LinearAlgebra hiding (find)\nimport qualified Math.Probably.PDF as PDF\nimport Data.List hiding (map)\nimport Data.Maybe\nimport Control.Applicative\nimport Data.Ord\nimport qualified Data.Vector as V\nimport qualified Graphics.Rendering.OpenGL.GLU.Tessellation as GLU\nimport Graphics.Rendering.OpenGL\n\nimport CVUtils\nimport qualified Graphics.UI.GLUT as GLUT\n\nloadPoints :: IO [(R,R)]\nloadPoints = fmap read $ readFile \"edge.dat\"\n\n\ncomplexPolygon :: [(R,R)] -> GLU.ComplexPolygon GLfloat\ncomplexPolygon points\n = let p2v (x,y) = Vertex3 (realToFrac x) (realToFrac y) 0\n in GLU.ComplexPolygon \n [GLU.ComplexContour $map (\\v-> GLU.AnnotatedVertex (p2v v) 0) points]\n\nnoOpCombiner _newVertex _weightedProperties = 0.0 ::GLfloat\n\ntriangulateEdge :: [(R,R)] -> IO [[Vector R]]\ntriangulateEdge pts = do\n fmap getTriangles $ GLU.triangulate\n GLU.TessWindingPositive 0 (Normal3 0 0 0) noOpCombiner\n $ complexPolygon pts\n\ntype Triangles = [[Vector R]]\n \ngetTriangles (GLU.Triangulation tris) = map unTri tris where\n unTri \n (GLU.Triangle (GLU.AnnotatedVertex (Vertex3 x1 y1 _) _) \n (GLU.AnnotatedVertex (Vertex3 x2 y2 _) _) \n (GLU.AnnotatedVertex (Vertex3 x3 y3 _) _)) \n = [fromList [realToFrac x1,realToFrac y1], \n fromList [realToFrac x2,realToFrac y2], \n fromList [realToFrac x3,realToFrac y3]]\n\n--http://frame3dd.svn.sourceforge.net/viewvc/frame3dd/trunk/src/microstran/vec3.c?view=markup\ncross a b = fromList [(a@>1)*(b@>2)-(a@>2)*(b@>1)\n ,(a@>2)*(b@>0)-(a@>0)*(b@>2)\n ,(a@>0)*(b@>1)-(a@>1)*(b@>0)]\n\ncrossZ x y = (x@>0)*(y@>1)-(x@>1)*(y@>0)\n\ncrossZp a b p = ((b@>0)-(a@>0))*((p@>1)-(a@>1))-((b@>1)-(a@>1))*((p@>0)-(a@>0))\n\n--http://www.blackpawn.com/texts/pointinpoly/default.html\n\nsameSide :: (Vector R,Vector R,Vector R,Vector R) -> Bool\nsameSide(p1,p2, a,b) \n = let cp1 = crossZ (b-a) (p1-a)\n cp2 = crossZ (b-a) (p2-a)\n in cp1 * cp2 >= 0 \n\nsameSide' :: (Vector R,Vector R,Vector R,Vector R) -> Bool\nsameSide'(p1,p2, a,b) \n = let cp1 = crossZp a b p1\n cp2 = crossZp a b p2\n in cp1 * cp2 >= 0 \n\n\n\npointInTriangle :: Vector R -> [Vector R] -> Bool\npointInTriangle p [a,b,c]\n = sameSide'(p,a, b,c) && sameSide'(p,b, a,c)\n && sameSide'(p,c, a,b) \n\n\nmarkBg :: Image -> IO Image\nmarkBg im = do\n (progName,args) <- GLUT.getArgsAndInitialize\n pts <- loadPoints\n tris <- triangulateEdge pts\n -- print tris\n print $ head tris\n --print $ cross (head tris!!0) (head tris!!1)\n\n-- print $ pointInTriangle (fromList [100,100]) $ head tris\n mutIm <- thaw im\n ((loy,lox,_),(hiy,hix,_)) <- getBounds (mutIm::MImage)\n forM_ [(y,x,0) | x<- [lox..hix], \n y<- [loy..hiy]] $ \\ix@(y,x,_)-> do\n when (any (pointInTriangle (fromList [realToFrac x, realToFrac y])) tris) $ writeArray mutIm ix 255\n freeze (mutIm::MImage) \n-- return im\n\nloadTriangles :: IO [[Vector R]] \nloadTriangles = do\n (progName,args) <- GLUT.getArgsAndInitialize\n pts <- loadPoints\n triangulateEdge pts\n\nwriteVisMat :: String -> BitImage -> Image -> IO ()\nwriteVisMat nm vm im = do\n mutIm <- thaw im\n ((loy,lox,_),(hiy,hix,_)) <- getBounds (mutIm::MImage)\n forM_ [(y,x,0) | x<- [lox..hix], \n y<- [loy..hiy]] $ \\ix@(y,x,_)-> do\n when (not $ readBitImage vm x y) $ writeArray mutIm ix 255\n \n\n newIm <- freeze (mutIm::MImage)\n writeImage nm newIm\n return ()", "meta": {"hexsha": "c7f8e373bd0e490535acc005809ada276231f6c8", "size": 3820, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "Edge.hs", "max_stars_repo_name": "glutamate/cvutils", "max_stars_repo_head_hexsha": "4211023dade7b755eceb2f16b127fdcd7ad16473", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2019-11-28T03:20:21.000Z", "max_stars_repo_stars_event_max_datetime": "2019-11-28T03:20:21.000Z", "max_issues_repo_path": "Edge.hs", "max_issues_repo_name": "glutamate/cvutils", "max_issues_repo_head_hexsha": "4211023dade7b755eceb2f16b127fdcd7ad16473", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Edge.hs", "max_forks_repo_name": "glutamate/cvutils", "max_forks_repo_head_hexsha": "4211023dade7b755eceb2f16b127fdcd7ad16473", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 30.56, "max_line_length": 105, "alphanum_fraction": 0.6340314136, "num_tokens": 1266, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.7025300449389326, "lm_q2_score": 0.46490157137338844, "lm_q1q2_score": 0.32660732182912694}} {"text": "module Main where\n\nimport Correlation (cacf)\nimport Data.Complex (Complex (..))\nimport Graphics.Rendering.Chart.Backend.Diagrams\nimport Graphics.Rendering.Chart.Easy\nimport Linear.Metric\nimport Linear.V3\nimport Linear.Vector\nimport MLS (mls)\n\nj :: RealFloat a => Complex a\nj = 0 :+ 1\n\nmain :: IO ()\nmain = do\n print \"IDDQD\"\n print code\n toFile def \"example1_big.png\" $ do\n layout_title .= \"Amplitude Modulation\"\n setColors [opaque blue, opaque red]\n plot (line \"am\" [signal' [0, (0.5) .. 400]])\n plot (points \"am points\" (signal' [0, 7 .. 400]))\n\nsignal' :: [Double] -> [(Double, Double)]\nsignal' xs = [(x, (sin (x * 3.14159 / 45) + 1) / 2 * (sin (x * 3.14159 / 5))) | x <- xs]\n\ncode = mls [True, False, True, False, False, True, False, False, True, False, False, True] [True, False, False, False, False, False, False, False, False, False, False]\n\nbase = length code\n\ncarrierFeq :: Double\ncarrierFeq = 1e10\n\ncodeInterval :: Double\ncodeInterval = 1e-6\n\n-- \u0422\u0435\u043e\u0440\u0435\u043c\u0430 \u041a\u043e\u0442\u0435\u043b\u044c\u043d\u0438\u043a\u043e\u0432\u0430\ndf :: Double\ndf = (carrierFeq + fromIntegral base / codeInterval) * 3\n\nsignal :: Double -> Complex Double\nsignal t\n | t >= 0 && t < signalLength = a t * exp (- j * (2 * pi * carrierFeq * t :+ 0))\n | otherwise = 0\n where\n signalLength = codeInterval * fromIntegral base\n i = floor (t / codeInterval) `mod` base\n a t =\n if code !! i\n then 1\n else -1\n\necho :: (Double -> V3 Double) -> Double -> Complex Double\necho obj t = signal (t - d / c)\n where\n d = distance (carrier t) (obj t)\n c = 3e8\n\nscene :: [V3 Double]\nscene = [V3 0 10000 0]\n\nzeroPoint :: V3 Double\nzeroPoint = V3 0 0 0\n\nvel :: V3 Double\nvel = V3 1 0 0\n\ncarrier :: Double -> V3 Double\ncarrier t = zeroPoint + vel ^* t\n", "meta": {"hexsha": "359eb4c467fdfa4adf31060121c8b09def86b70f", "size": 1706, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "app/Main.hs", "max_stars_repo_name": "nihlete/sar-signal", "max_stars_repo_head_hexsha": "08160f3d2dff08dd201b7a05b0194d2ceb83d42b", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "app/Main.hs", "max_issues_repo_name": "nihlete/sar-signal", "max_issues_repo_head_hexsha": "08160f3d2dff08dd201b7a05b0194d2ceb83d42b", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "app/Main.hs", "max_forks_repo_name": "nihlete/sar-signal", "max_forks_repo_head_hexsha": "08160f3d2dff08dd201b7a05b0194d2ceb83d42b", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 24.0281690141, "max_line_length": 167, "alphanum_fraction": 0.6324736225, "num_tokens": 574, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.7799929002541068, "lm_q2_score": 0.41869690935568665, "lm_q1q2_score": 0.3265806166557729}} {"text": "{-# LANGUAGE BangPatterns #-}\n{-# LANGUAGE CPP #-}\n{-# LANGUAGE ScopedTypeVariables #-}\n#if __GLASGOW_HASKELL__ >= 800\n {-# OPTIONS_GHC -Wno-redundant-constraints #-}\n#endif\n-- |\n-- Module : Graphics.ColorSpace.Elevator\n-- Copyright : (c) Alexey Kuleshevich 2018-2019\n-- License : BSD3\n-- Maintainer : Alexey Kuleshevich \n-- Stability : experimental\n-- Portability : non-portable\n--\nmodule Graphics.ColorSpace.Elevator (\n Elevator(..)\n , clamp01\n ) where\n\nimport qualified Data.Complex as C\nimport Data.Int\nimport Data.Typeable\nimport Data.Vector.Storable (Storable)\nimport Data.Vector.Unboxed (Unbox)\nimport Data.Word\nimport GHC.Float\n\n\n-- | A class with a set of convenient functions that allow for changing precision of\n-- channels within pixels, while scaling the values to keep them in an appropriate range.\n--\n-- >>> let rgb = PixelRGB 0.0 0.5 1.0 :: Pixel RGB Double\n-- >>> eToWord8 <$> rgb\n-- \n-- >>> eToWord16 <$> rgb\n-- \n--\nclass (Eq e, Num e, Typeable e, Unbox e, Storable e) => Elevator e where\n\n -- | Values are scaled to @[0, 255]@ range.\n eToWord8 :: e -> Word8\n\n -- | Values are scaled to @[0, 65535]@ range.\n eToWord16 :: e -> Word16\n\n -- | Values are scaled to @[0, 4294967295]@ range.\n eToWord32 :: e -> Word32\n\n -- | Values are scaled to @[0, 18446744073709551615]@ range.\n eToWord64 :: e -> Word64\n\n -- | Values are scaled to @[0.0, 1.0]@ range.\n eToFloat :: e -> Float\n\n -- | Values are scaled to @[0.0, 1.0]@ range.\n eToDouble :: e -> Double\n\n -- | Values are scaled from @[0.0, 1.0]@ range.\n eFromDouble :: Double -> e\n\n\n-- | Lower the precision\ndropDown :: forall a b. (Integral a, Bounded a, Integral b, Bounded b) => a -> b\ndropDown !e = fromIntegral $ fromIntegral e `div` ((maxBound :: a) `div`\n fromIntegral (maxBound :: b))\n{-# INLINE dropDown #-}\n\n-- | Increase the precision\nraiseUp :: forall a b. (Integral a, Bounded a, Integral b, Bounded b) => a -> b\nraiseUp !e = fromIntegral e * ((maxBound :: b) `div` fromIntegral (maxBound :: a))\n{-# INLINE raiseUp #-}\n\n-- | Convert to fractional with value less than or equal to 1.\nsquashTo1 :: forall a b. (Fractional b, Integral a, Bounded a) => a -> b\nsquashTo1 !e = fromIntegral e / fromIntegral (maxBound :: a)\n{-# INLINE squashTo1 #-}\n\n-- | Convert to integral streaching it's value up to a maximum value.\nstretch :: forall a b. (RealFrac a, Floating a, Integral b, Bounded b) => a -> b\nstretch !e = round (fromIntegral (maxBound :: b) * clamp01 e)\n{-# INLINE stretch #-}\n\n\n-- | Clamp a value to @[0, 1]@ range.\nclamp01 :: (Ord a, Floating a) => a -> a\nclamp01 !x = min (max 0 x) 1\n{-# INLINE clamp01 #-}\n\n\n-- | Values between @[0, 255]]@\ninstance Elevator Word8 where\n eToWord8 = id\n {-# INLINE eToWord8 #-}\n eToWord16 = raiseUp\n {-# INLINE eToWord16 #-}\n eToWord32 = raiseUp\n {-# INLINE eToWord32 #-}\n eToWord64 = raiseUp\n {-# INLINE eToWord64 #-}\n eToFloat = squashTo1\n {-# INLINE eToFloat #-}\n eToDouble = squashTo1\n {-# INLINE eToDouble #-}\n eFromDouble = eToWord8\n {-# INLINE eFromDouble #-}\n\n\n-- | Values between @[0, 65535]]@\ninstance Elevator Word16 where\n eToWord8 = dropDown\n {-# INLINE eToWord8 #-}\n eToWord16 = id\n {-# INLINE eToWord16 #-}\n eToWord32 = raiseUp\n {-# INLINE eToWord32 #-}\n eToWord64 = raiseUp\n {-# INLINE eToWord64 #-}\n eToFloat = squashTo1\n {-# INLINE eToFloat #-}\n eToDouble = squashTo1\n {-# INLINE eToDouble #-}\n eFromDouble = eToWord16\n {-# INLINE eFromDouble #-}\n\n\n-- | Values between @[0, 4294967295]@\ninstance Elevator Word32 where\n eToWord8 = dropDown\n {-# INLINE eToWord8 #-}\n eToWord16 = dropDown\n {-# INLINE eToWord16 #-}\n eToWord32 = id\n {-# INLINE eToWord32 #-}\n eToWord64 = raiseUp\n {-# INLINE eToWord64 #-}\n eToFloat = squashTo1\n {-# INLINE eToFloat #-}\n eToDouble = squashTo1\n {-# INLINE eToDouble #-}\n eFromDouble = eToWord32\n {-# INLINE eFromDouble #-}\n\n\n-- | Values between @[0, 18446744073709551615]@\ninstance Elevator Word64 where\n eToWord8 = dropDown\n {-# INLINE eToWord8 #-}\n eToWord16 = dropDown\n {-# INLINE eToWord16 #-}\n eToWord32 = dropDown\n {-# INLINE eToWord32 #-}\n eToWord64 = id\n {-# INLINE eToWord64 #-}\n eToFloat = squashTo1\n {-# INLINE eToFloat #-}\n eToDouble = squashTo1\n {-# INLINE eToDouble #-}\n eFromDouble = eToWord64\n {-# INLINE eFromDouble #-}\n\n-- | Values between @[0, 18446744073709551615]@ on 64bit\ninstance Elevator Word where\n eToWord8 = dropDown\n {-# INLINE eToWord8 #-}\n eToWord16 = dropDown\n {-# INLINE eToWord16 #-}\n eToWord32 = dropDown\n {-# INLINE eToWord32 #-}\n eToWord64 = fromIntegral\n {-# INLINE eToWord64 #-}\n eToFloat = squashTo1\n {-# INLINE eToFloat #-}\n eToDouble = squashTo1\n {-# INLINE eToDouble #-}\n eFromDouble = stretch . clamp01\n {-# INLINE eFromDouble #-}\n\n-- | Values between @[0, 127]@\ninstance Elevator Int8 where\n eToWord8 = fromIntegral . max 0\n {-# INLINE eToWord8 #-}\n eToWord16 = raiseUp . max 0\n {-# INLINE eToWord16 #-}\n eToWord32 = raiseUp . max 0\n {-# INLINE eToWord32 #-}\n eToWord64 = raiseUp . max 0\n {-# INLINE eToWord64 #-}\n eToFloat = squashTo1 . max 0\n {-# INLINE eToFloat #-}\n eToDouble = squashTo1 . max 0\n {-# INLINE eToDouble #-}\n eFromDouble = stretch . clamp01\n {-# INLINE eFromDouble #-}\n\n\n-- | Values between @[0, 32767]@\ninstance Elevator Int16 where\n eToWord8 = dropDown . max 0\n {-# INLINE eToWord8 #-}\n eToWord16 = fromIntegral . max 0\n {-# INLINE eToWord16 #-}\n eToWord32 = raiseUp . max 0\n {-# INLINE eToWord32 #-}\n eToWord64 = raiseUp . max 0\n {-# INLINE eToWord64 #-}\n eToFloat = squashTo1 . max 0\n {-# INLINE eToFloat #-}\n eToDouble = squashTo1 . max 0\n {-# INLINE eToDouble #-}\n eFromDouble = stretch . clamp01\n {-# INLINE eFromDouble #-}\n\n\n-- | Values between @[0, 2147483647]@\ninstance Elevator Int32 where\n eToWord8 = dropDown . max 0\n {-# INLINE eToWord8 #-}\n eToWord16 = dropDown . max 0\n {-# INLINE eToWord16 #-}\n eToWord32 = fromIntegral . max 0\n {-# INLINE eToWord32 #-}\n eToWord64 = raiseUp . max 0\n {-# INLINE eToWord64 #-}\n eToFloat = squashTo1 . max 0\n {-# INLINE eToFloat #-}\n eToDouble = squashTo1 . max 0\n {-# INLINE eToDouble #-}\n eFromDouble = stretch . clamp01\n {-# INLINE eFromDouble #-}\n\n\n-- | Values between @[0, 9223372036854775807]@\ninstance Elevator Int64 where\n eToWord8 = dropDown . max 0\n {-# INLINE eToWord8 #-}\n eToWord16 = dropDown . max 0\n {-# INLINE eToWord16 #-}\n eToWord32 = dropDown . max 0\n {-# INLINE eToWord32 #-}\n eToWord64 = fromIntegral . max 0\n {-# INLINE eToWord64 #-}\n eToFloat = squashTo1 . max 0\n {-# INLINE eToFloat #-}\n eToDouble = squashTo1 . max 0\n {-# INLINE eToDouble #-}\n eFromDouble = stretch . clamp01\n {-# INLINE eFromDouble #-}\n\n\n-- | Values between @[0, 9223372036854775807]@ on 64bit\ninstance Elevator Int where\n eToWord8 = dropDown . max 0\n {-# INLINE eToWord8 #-}\n eToWord16 = dropDown . max 0\n {-# INLINE eToWord16 #-}\n eToWord32 = dropDown . max 0\n {-# INLINE eToWord32 #-}\n eToWord64 = fromIntegral . max 0\n {-# INLINE eToWord64 #-}\n eToFloat = squashTo1 . max 0\n {-# INLINE eToFloat #-}\n eToDouble = squashTo1 . max 0\n {-# INLINE eToDouble #-}\n eFromDouble = stretch . clamp01\n {-# INLINE eFromDouble #-}\n\n\n-- | Values between @[0.0, 1.0]@\ninstance Elevator Float where\n eToWord8 = stretch . clamp01\n {-# INLINE eToWord8 #-}\n eToWord16 = stretch . clamp01\n {-# INLINE eToWord16 #-}\n eToWord32 = stretch . clamp01\n {-# INLINE eToWord32 #-}\n eToWord64 = stretch . clamp01\n {-# INLINE eToWord64 #-}\n eToFloat = id\n {-# INLINE eToFloat #-}\n eToDouble = float2Double\n {-# INLINE eToDouble #-}\n eFromDouble = eToFloat\n {-# INLINE eFromDouble #-}\n\n\n-- | Values between @[0.0, 1.0]@\ninstance Elevator Double where\n eToWord8 = stretch . clamp01\n {-# INLINE eToWord8 #-}\n eToWord16 = stretch . clamp01\n {-# INLINE eToWord16 #-}\n eToWord32 = stretch . clamp01\n {-# INLINE eToWord32 #-}\n eToWord64 = stretch . clamp01\n {-# INLINE eToWord64 #-}\n eToFloat = double2Float\n {-# INLINE eToFloat #-}\n eToDouble = id\n {-# INLINE eToDouble #-}\n eFromDouble = id\n {-# INLINE eFromDouble #-}\n\n\n-- | Discards imaginary part and changes precision of real part.\ninstance (Num e, Elevator e, RealFloat e) => Elevator (C.Complex e) where\n eToWord8 = eToWord8 . C.realPart\n {-# INLINE eToWord8 #-}\n eToWord16 = eToWord16 . C.realPart\n {-# INLINE eToWord16 #-}\n eToWord32 = eToWord32 . C.realPart\n {-# INLINE eToWord32 #-}\n eToWord64 = eToWord64 . C.realPart\n {-# INLINE eToWord64 #-}\n eToFloat = eToFloat . C.realPart\n {-# INLINE eToFloat #-}\n eToDouble = eToDouble . C.realPart\n {-# INLINE eToDouble #-}\n eFromDouble = (C.:+ 0) . eFromDouble\n {-# INLINE eFromDouble #-}\n", "meta": {"hexsha": "72bfeaed8663c2d04ae840e8d04c50b59b8e5538", "size": 8741, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "massiv-io/src/Graphics/ColorSpace/Elevator.hs", "max_stars_repo_name": "masterdezign/massiv", "max_stars_repo_head_hexsha": "6dff1ce56c0eb8bfa5a2c03aac6081cb3c5ffee7", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "massiv-io/src/Graphics/ColorSpace/Elevator.hs", "max_issues_repo_name": "masterdezign/massiv", "max_issues_repo_head_hexsha": "6dff1ce56c0eb8bfa5a2c03aac6081cb3c5ffee7", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "massiv-io/src/Graphics/ColorSpace/Elevator.hs", "max_forks_repo_name": "masterdezign/massiv", "max_forks_repo_head_hexsha": "6dff1ce56c0eb8bfa5a2c03aac6081cb3c5ffee7", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 27.315625, "max_line_length": 89, "alphanum_fraction": 0.6454639057, "num_tokens": 2917, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.6187804196836383, "lm_q2_score": 0.5273165233795672, "lm_q1q2_score": 0.32629313964292567}} {"text": "{-# OPTIONS_GHC -fwarn-unused-imports #-}\n\nmodule Main(main) where\n\nimport Control.Monad\nimport Control.Monad.Par \nimport Control.Monad.Par.Internal (runParAsync)\nimport Control.Monad.Par.Stream as S\nimport Control.Monad.Par.OpenList\nimport Control.DeepSeq\nimport Control.Exception\n\n-- import Data.Array.Unboxed as U\nimport Data.Array.CArray as C\nimport Data.Complex\nimport Data.Int\nimport Data.Word\nimport Data.List (intersperse)\nimport Data.List.Split (chunk)\n\nimport System.CPUTime\nimport System.CPUTime.Rdtsc\nimport GHC.Conc as Conc\nimport GHC.IO (unsafePerformIO, unsafeDupablePerformIO, unsafeInterleaveIO)\nimport Debug.Trace\n\n--------------------------------------------------------------------------------\n-- Main script\n\nmain = do\n\n -- Generate 20 million elements:\n let s = countupWin 1024 (20 * 1000 * 1000) :: Par (WStream Int)\n measureRate $ runParAsync s\n \n putStrLn$ \"Done with 5 million elements.\"\n", "meta": {"hexsha": "16e226faa0ac45115a96bb8348830bbcc8897563", "size": 920, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "examples/stream/simple1_measureSrc.hs", "max_stars_repo_name": "tpetricek/Haskell.ParMonad", "max_stars_repo_head_hexsha": "83a64b9f4bf5f80cb254eb92fb5db61271756e9c", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2015-01-20T05:54:40.000Z", "max_stars_repo_stars_event_max_datetime": "2015-01-20T05:54:40.000Z", "max_issues_repo_path": "examples/stream/simple1_measureSrc.hs", "max_issues_repo_name": "tpetricek/Haskell.ParMonad", "max_issues_repo_head_hexsha": "83a64b9f4bf5f80cb254eb92fb5db61271756e9c", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "examples/stream/simple1_measureSrc.hs", "max_forks_repo_name": "tpetricek/Haskell.ParMonad", "max_forks_repo_head_hexsha": "83a64b9f4bf5f80cb254eb92fb5db61271756e9c", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 24.8648648649, "max_line_length": 80, "alphanum_fraction": 0.7076086957, "num_tokens": 215, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES\n\n", "lm_q1_score": 0.5964331319177487, "lm_q2_score": 0.5467381519846138, "lm_q1q2_score": 0.32609274832710533}} {"text": "#!/usr/bin/env stack\n-- stack runghc --package reanimate\n{-# LANGUAGE OverloadedStrings #-}\nmodule Main where\n\nimport Codec.Picture.Types\nimport Control.Exception\nimport Control.Lens ()\nimport Control.Monad\nimport Data.Function\nimport Data.List\nimport Data.List.NonEmpty (NonEmpty)\nimport qualified Data.List.NonEmpty as NE\nimport Data.Maybe\nimport Data.Ratio\nimport qualified Data.Text as T\nimport Data.Tuple\nimport qualified Data.Vector as V\nimport Debug.Trace\nimport Linear.Matrix hiding (trace)\nimport Linear.Metric\nimport Linear.V2\nimport Linear.V3\nimport Linear.Vector\nimport Numeric.LinearAlgebra hiding (polar, scale, (<>))\nimport qualified Numeric.LinearAlgebra as Matrix\nimport Numeric.LinearAlgebra.HMatrix hiding (polar, scale, (<>))\nimport Reanimate\nimport Reanimate.Builtin.Documentation\nimport Reanimate.Debug\nimport Reanimate.Math.Balloon\nimport Reanimate.Math.Common\nimport Reanimate.Math.Compatible (compatiblyTriangulateP)\nimport qualified Reanimate.Math.DCEL as DCEL\nimport Reanimate.Math.EarClip\nimport Reanimate.Math.Polygon\nimport Reanimate.Math.Render\nimport Reanimate.Math.Smooth\nimport Reanimate.Math.SSSP\nimport Reanimate.Math.Visibility\nimport Reanimate.Morph.Common\nimport Reanimate.Morph.LeastDifference\nimport Reanimate.Morph.LeastWork\nimport Reanimate.Morph.Linear\nimport Reanimate.Morph.Rigid\nimport Reanimate.PolyShape (svgToPolygons)\nimport Text.Printf\n\n-- p1 = centerPolygon $ shape2\n--p1 = pScale 3.5 $ pAtCenter $ pAddPoints (0+2) (pSetOffset shape13 0)\n-- p1 = setOffset (addPoints 2 shape13) 0\n-- p2 = scalePolygon 0.5 $ centerPolygon shape20\n-- p1 = centerPolygon shape2\n--p2 = pScale 3.5 $ pAtCenter $ pAddPoints 0 (pSetOffset shape14 0)\n-- p2 = setOffset shape14 0\np1 = pCopy $ pSetOffset (pCopy p1') 0\np2 = pCopy $ pSetOffset (pCopy p2') 0\n(p1', p2') =\n -- normalizePolygons\n -- closestLinearCorrespondence\n (,)\n -- leastWork zeroStretchCosts defaultBendCosts\n -- leastWork defaultStretchCosts defaultBendCosts\n -- (pAtCenter $ unsafeSVGToPolygon 0.01 $ scale 6 $ latex \"S\")\n -- (pAtCenter $ unsafeSVGToPolygon 0.01 $ scale 6 $ latex \"C\")\n (pAtCenter $ unsafeSVGToPolygon 0.1 $ scale 6 $ latex \"X\")\n (pAtCenter $ unsafeSVGToPolygon 0.1 $ scale 6 $ latex \"I\")\n\np1_ = castPolygon p1\np2_ = castPolygon p2\npolys = triangulate_ p1_ p2_\np1_circ = castPolygon (circumference (map fst polys') p1_)\np2_circ = castPolygon (circumference (map snd polys') p2_)\n\npolys' = alignPolygons polys p1_ p2_\n(p1s, p2s) = unzip $ compatTriagPairs [ (castPolygon a, castPolygon b) | (a,b) <- polys' ]\n\n-- (p1s,p2s) = unzip (compatiblyTriangulateP p1 p2)\n\nm2 = DCEL.buildMesh $ DCEL.polygonsMesh\n (map (fmap realToFrac) $ V.toList $ polygonPoints p2_circ)\n (map (map (fmap realToFrac) . V.toList . polygonPoints) p2s)\n\nm1 = DCEL.buildMesh $ DCEL.polygonsMesh\n (map (fmap realToFrac) $ V.toList $ polygonPoints p1_circ)\n (map (map (fmap realToFrac) . V.toList . polygonPoints) p1s)\n\npipeline1 = last . take 20 . iterate\n ( uncurry DCEL.delaunayFlip .\n uncurry DCEL.splitInternalEdges .\n (\\(a,b) -> (DCEL.meshSmoothPosition a, DCEL.meshSmoothPosition b)))\n(m1final, m2final) = last $ take 30 $ iterate\n (pipeline1 .\n uncurry DCEL.splitLongestEdge .\n pipeline1\n ) (m1,m2)\n\n-- (m1good, m2good) = last $ take 9 $ iterate\n-- (pipeline1 .\n-- -- uncurry DCEL.splitLongestEdge .\n-- pipeline1\n-- ) (m1,m2)\n\nmain :: IO ()\n-- main = do\n-- evaluate (last $ take 900 $ compatiblyTriangulateP p1 p2)\n-- return ()\n-- main = reanimate $ playTraces $ length $ take 29 p1s\n-- main = reanimate $ playThenReverseA $ pauseAround 0.5 0.5 $ scene $ do\n\nmain = reanimate $ scene $ do\n newSpriteSVG_ $ mkBackgroundPixel rtfdBackgroundColor\n -- play\n -- $ playTraces\n -- $ traceA (mapA (withFillOpacity 0 . withStrokeColor \"white\") drawCircle)\n -- $ traceA (mapA (withFillOpacity 0 . withStrokeColor \"white\") drawBox)\n -- $ traceSVG ((withFillOpacity 0 . withStrokeColor \"white\") $ mkCircle 2)\n -- $ traceSVG ((withFillOpacity 0 . withStrokeColor \"white\") $ mkRect 2 2)\n -- $ 20\n -- play $ playTraces $ last $ take 35 $ compatiblyTriangulateP p1 p2\n -- fork $ newSpriteA $ drawCompatible p1 p2\n -- newSpriteSVG_ $ translate 5 0 $ lowerTransformations $ scale 2 $\n -- -- DCEL.renderMesh 0.02 m1final\n -- DCEL.renderMeshColored m1final\n -- renderMeshPair optMesh\n -- newSpriteSVG_ $ translate (-5) 0 $ lowerTransformations $ scale 2 $\n -- DCEL.renderMesh 0.02 m1good\n\n -- newSpriteSVG_ $\n -- translate (-3) 0 $ scale 1 $ mkGroup\n -- [ mkGroup []\n -- , withFillColor \"grey\" $ polygonShape p1\n -- , withFillColor \"grey\" $ polygonNumDots p1\n -- ]\n -- newSpriteSVG_ $\n -- translate 3 0 $ scale 1 $ mkGroup\n -- [ mkGroup []\n -- , withFillColor \"grey\" $ polygonShape p2\n -- , withFillColor \"grey\" $ polygonNumDots p2\n -- ]\n -- wait 1\n -- fork $ forM_ p1s $ \\p1Piece -> do\n -- newSpriteSVG_ $\n -- translate (-3) 0 $ scale 1 $ mkGroup\n -- [ mkGroup []\n -- , withFillColor \"white\" $ polygonShape p1Piece\n -- -- , withFillColor \"grey\" $ polygonNumDots p1Piece\n -- ]\n -- wait (1/60)\n -- -- wait 1\n -- fork $ forM_ p2s $ \\p1Piece -> do\n -- newSpriteSVG_ $\n -- translate 3 0 $ scale 1 $ mkGroup\n -- [ mkGroup []\n -- , withFillColor \"white\" $ polygonShape p1Piece\n -- -- , withFillColor \"grey\" $ polygonNumDots p1Piece\n -- ]\n -- wait (1/60)\n -- -- wait 1\n\n -- fork $ play $ mkAnimation 3 $ \\t ->\n -- let points = interpolate prep t\n -- in translate (-3) 0 $ scale 1 $ mkGroup\n -- [ mkGroup []\n -- , drawTrigs points (meshTriangles myMesh)\n -- -- , DCEL.renderMeshColored m1\n -- ]\n fork $ play $ mkAnimation 3 $ \\t ->\n let points = interpolate optPrep t\n in translate 3 0 $ lowerTransformations $ scale 1 $ mkGroup\n [ mkGroup []\n , drawTrigs points (meshTriangles optMesh)\n -- , DCEL.renderMeshColored m1final\n -- , withGroupOpacity 0.5 $ DCEL.renderMesh 0.02 m1final\n -- , withGroupOpacity 0.5 $ withFillOpacity 0 $ renderMeshPair optMesh\n -- , let V2 x y = V.head points in\n -- translate x y $ withFillColor \"green\" $\n -- mkCircle 0.03\n ]\n -- , scale 2 $ polygonNumDots p1\n -- play $ pauseAtEnd 1 $ mkAnimation 3 $ \\t ->\n -- let points = interpolate bestPrep t\n -- in translate 3 0 $ mkGroup [drawTrigs points (meshTriangles bestMesh)\n -- -- , scale 2 $ polygonNumDots p2\n -- ]\n -- play $ pauseAtEnd 1 $ mkAnimation 3 $ \\t ->\n -- let points = interpolate prepRev t in\n -- mkGroup\n -- [ drawTrigs points (meshTriangles myMeshRev)\n -- -- , polygonNumDots shape2\n -- ]\n -- forM_ (myMesh : smoothMesh myMesh) $ \\newMesh -> do\n -- let (minAngA, minAngB) = meshMinAngle newMesh\n -- txt <- newSpriteSVG $ withFillColor \"white\" $\n -- mkGroup\n -- [translate 5 2 $ center $\n -- latex $ T.pack $ printf \"Min: %.1f\" (minAngA/pi*180)\n -- ,translate 5 1 $ center $\n -- latex $ T.pack $ printf \"Min: %.1f\" (minAngB/pi*180) ]\n -- s <- newSpriteSVG $ renderAMesh newMesh\n -- wait (recip 60)\n -- destroySprite s\n -- destroySprite txt\n -- newSpriteSVG $ translate (-3) 0 $ scale 2 $ renderMesh p1 (map fst trigs)\n -- newSpriteSVG $ translate 3 0 $ scale 2 $ renderMesh p2 (map snd trigs)\n -- wait 1\n where\n prep = prepare myMesh\n optPrep = prepare optMesh\n -- bestPrep = prepare bestMesh\n myMesh = mkMesh p1 p2\n optMesh = toRigidMesh m1final m2final\n -- optMesh = DCEL.toRigidMesh m1good m2good\n -- bestMesh = last $ smoothMesh myMesh\n prepRev = prepare myMeshRev\n myMeshRev = reverseMesh myMesh\n\n\n\nreverseMesh :: Mesh -> Mesh\nreverseMesh mesh =\n mesh { meshPointsA = meshPointsB mesh, meshPointsB = meshPointsA mesh }\n\nmkMesh :: Polygon -> Polygon -> Mesh\nmkMesh a b = Mesh\n { meshPointsA = V.map (fmap realToFrac) pointsA\n , meshPointsB = V.map (fmap realToFrac) pointsB\n , meshOutline = V.map (fromJust . flip V.elemIndex pointsA) (polygonPoints a)\n , meshTriangles = relTrigs\n }\n where\n pointsA =\n V.fromList $ nub $ V.toList $ V.concat [ polygonPoints a | (a, b) <- trigs ]\n pointsB =\n V.fromList $ nub $ V.toList $ V.concat [ polygonPoints b | (a, b) <- trigs ]\n trigs = compatiblyTriangulateP a b\n mkRel arr p =\n ( fromJust $ V.elemIndex (pAccess p 0) arr\n , fromJust $ V.elemIndex (pAccess p 1) arr\n , fromJust $ V.elemIndex (pAccess p 2) arr\n )\n relTrigs = V.fromList [ mkRel pointsA a | (a, b) <- trigs ]\n -- data Mesh = Mesh (Vector P) (Vector (RelTrig, RelTrig))\n\ntestMesh2 :: Mesh\ntestMesh2 = mkMesh (pTranslate (V2 0 0) shape2) shape20\n\ntestPrep = prepare testMesh2\n\ndrawTrigs :: V.Vector (V2 Double) -> V.Vector RelTrig -> SVG\ndrawTrigs points trigs = mkGroup\n [ mkGroup\n [ withFillOpacity 1\n $ withStrokeWidth (defaultStrokeWidth * 0)\n $ withStrokeColor \"grey\"\n $ withFillColor \"black\"\n $ drawPolygon\n $ map (points V.!) [a, b, c]\n | (a, b, c) <- V.toList trigs\n ]\n -- , a == 0\n -- , mkGroup\n -- [ withFillColor \"red\" $ mkGroup\n -- [ drawPoint (points V.! a), drawPoint (points V.! b), drawPoint (points V.! c)]\n -- | (a,b,c) <- V.toList trigs\n -- -- , a == 0\n -- ]\n ]\n\ndrawTrigsLines :: V.Vector (V2 Double) -> V.Vector RelTrig -> SVG\ndrawTrigsLines points trigs = withFillOpacity 0 $ withStrokeColor \"black\" $ mkGroup\n [ mkLinePathClosed\n [ (aPx, aPy)\n , (bPx, bPy)\n , (cPx, cPy)]\n | (a,b,c) <- V.toList trigs\n -- , a==2 || b == 2 || c == 2\n , let V2 aPx aPy = points V.! a\n V2 bPx bPy = points V.! b\n V2 cPx cPy = points V.! c\n ]\n\ndrawPoint :: V2 Double -> SVG\ndrawPoint (V2 x y) = translate x y $ mkCircle 0.1\n\ndrawPolygon :: [V2 Double] -> SVG\ndrawPolygon lst = mkLinePathClosed [ (x, y) | V2 x y <- lst ]\n\ndrawCompatible :: Polygon -> Polygon -> Animation\ndrawCompatible a b = scene $ do\n let left = -6\n right = 4\n newSpriteSVG $ translate left 0 $ mkGroup\n [ withFillColor \"grey\" $ polygonShape a\n , withFillColor \"grey\" $ polygonNumDots a\n ]\n newSpriteSVG $ translate right 0 $ mkGroup\n [ withFillColor \"grey\" $ polygonShape b\n , withFillColor \"grey\" $ polygonNumDots b\n ]\n return ()\n -- let compat = compatiblyTriangulateP a b\n -- forM_ compat $ \\(l, r) -> do\n -- fork $ play $ staticFrame 1 $\n -- translate left 0 $ withStrokeColor \"white\" $ withStrokeWidth (defaultStrokeWidth*0.2) $\n -- withFillOpacity 0 $ polygonShape l\n -- fork $ play $ staticFrame 1 $\n -- translate right 0 $ withStrokeColor \"white\" $ withStrokeWidth (defaultStrokeWidth*0.2) $\n -- withFillOpacity 0 $ polygonShape r\n", "meta": {"hexsha": "7b0e87b749dca634da7ed4908ee347a27dc76e06", "size": 11277, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "videos/morph/rigid.hs", "max_stars_repo_name": "cdodev/reanimate", "max_stars_repo_head_hexsha": "ccc69c0d834b821ec6469c1ecee9cb88c39c1704", "max_stars_repo_licenses": ["Unlicense"], "max_stars_count": 577, "max_stars_repo_stars_event_min_datetime": "2020-07-04T23:45:01.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-30T08:44:36.000Z", "max_issues_repo_path": "videos/morph/rigid.hs", "max_issues_repo_name": "cdodev/reanimate", "max_issues_repo_head_hexsha": "ccc69c0d834b821ec6469c1ecee9cb88c39c1704", "max_issues_repo_licenses": ["Unlicense"], "max_issues_count": 91, "max_issues_repo_issues_event_min_datetime": "2020-06-25T03:32:16.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-30T12:14:42.000Z", "max_forks_repo_path": "videos/morph/rigid.hs", "max_forks_repo_name": "cdodev/reanimate", "max_forks_repo_head_hexsha": "ccc69c0d834b821ec6469c1ecee9cb88c39c1704", "max_forks_repo_licenses": ["Unlicense"], "max_forks_count": 39, "max_forks_repo_forks_event_min_datetime": "2020-07-05T13:30:02.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-17T09:41:00.000Z", "avg_line_length": 36.3774193548, "max_line_length": 97, "alphanum_fraction": 0.6200230558, "num_tokens": 3537, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.7122321842389469, "lm_q2_score": 0.45713671682749474, "lm_q1q2_score": 0.3255874823218675}} {"text": "{-# LANGUAGE FlexibleContexts #-}\n{-# LANGUAGE FlexibleInstances #-}\n{-# LANGUAGE MultiParamTypeClasses #-}\n{-# LANGUAGE ViewPatterns #-}\n{-# LANGUAGE TypeFamilies #-}\n{-# LANGUAGE ScopedTypeVariables #-}\n\n-- |\n-- Module : Main\n-- Description : Test runner\n-- Copyright : (c) Tom Westerhout, 2017\n-- License : BSD3\n-- Maintainer : t.westerhout@student.ru.nl\n-- Stability : experimental\n\nmodule Main where\n\n\nimport Prelude hiding (map, zipWithM)\n\nimport Debug.Trace\nimport qualified System.Random.MWC as MWC\n-- import Control.Lens hiding((<.>))\nimport Control.Monad.Reader hiding (zipWithM)\nimport Control.Monad.Primitive\nimport qualified Data.List as L\nimport Data.Complex\nimport Data.Semigroup\nimport Data.Vector.Storable (Vector, (!))\nimport qualified Data.Vector.Storable as V\nimport System.Exit\nimport System.IO hiding (hGetLine)\nimport System.Environment(getArgs, getProgName)\nimport Foreign.Storable\nimport Data.Text (Text)\nimport Data.Text.IO (hGetLine)\nimport qualified Data.Text.IO as T\n\n\nimport Lens.Micro\nimport Lens.Micro.Extras\n\nimport PSO.Random\nimport PSO.Swarm\n-- import PSO.Heisenberg\n-- import PSO.Energy\n-- import PSO.Neural\nimport PSO.FromPython\nimport NQS.Rbm\n\nmeanVariance :: (RealFloat a, Storable a) => V.Vector a -> (a, a)\nmeanVariance xs\n | n > 1 = (m, sumVar m xs / fromIntegral (n - 1))\n | otherwise = (m, 0)\n where n = V.length xs\n m = V.sum xs / fromIntegral (V.length xs)\n sumVar m' = V.sum . V.map ((^2) . subtract m')\n\ntype R = Float\ntype C = Complex Float\ntype X = Rbm C\n\nfromPyFile :: FilePath -> IO X\nfromPyFile name = withFile name ReadMode toRbm\n where toRight :: Either String (V.Vector (Complex Float)) -> V.Vector (Complex Float)\n toRight (Right x) = x\n toRight (Left x) = error x\n toRbm h = do\n a <- trace (\"a...\") $ toRight <$> readVector <$> hGetLine h\n b <- trace (\"b...\") $ toRight <$> readVector <$> hGetLine h\n s <- hGetLine h\n T.putStrLn s\n let !w = trace (\"w...\") $ toRight $ readMatrix s\n return $ mkRbm (a, b, w)\n\nrandomRbm ::\n ( UniformDist m R\n )\n => Int\n -> Int\n -> (R, R)\n -> (R, R)\n -> (R, R)\n -> m X\nrandomRbm n m (lowV, highV) (lowH, highH) (lowW, highW) =\n do\n visible <- uniformVector n (lowV :+ lowV, highV :+ highV)\n hidden <- uniformVector m (lowH :+ lowH, highH :+ highH)\n weights <- uniformVector (n * m) (lowW :+ lowW, highW :+ highW)\n return $ trace (\"mkRbm...\") (mkRbm (visible, hidden, weights))\n\nrbms :: (UniformDist m R) => m [X]\nrbms = trace (\"Creating rbms...\") $ replicateM 20 (randomRbm 10 20 (-0.1, 0.1) (-0.1, 0.1) (-0.1, 0.1))\n\nrbms' :: IO [X]\nrbms' = Prelude.mapM fromPyFile $\n [ \"test.txt\"\n -- \"/home/tom/src/tcm-swarm/10_spins/Weights_10_spins_2_density_-1.23981661958_energy\"\n -- \"/home/tom/src/tcm-swarm/10_spins/Weights_10_spins_2_density_-1.89541865304_energy\"\n -- , \"/home/tom/src/tcm-swarm/10_spins/Weights_10_spins_2_density_0.0887681979723_energy\"\n -- , \"/home/tom/src/tcm-swarm/10_spins/Weights_10_spins_2_density_1.40938434022_energy\"\n -- , \"/home/tom/src/tcm-swarm/10_spins/Weights_10_spins_2_density_-3.61205064542_energy\"\n -- , \"/home/tom/src/tcm-swarm/10_spins/Weights_10_spins_2_density_-4.1917579599_energy\"\n -- , \"/home/tom/src/tcm-swarm/10_spins/Weights_10_spins_2_density_-5.41817224673_energy\"\n -- , \"/home/tom/src/tcm-swarm/10_spins/Weights_10_spins_2_density_-5.74064288804_energy\"\n -- , \"/home/tom/src/tcm-swarm/10_spins/Weights_10_spins_2_density_-6.33997058402_energy\"\n -- , \"/home/tom/src/tcm-swarm/10_spins/Weights_10_spins_2_density_-6.48266135073_energy\"\n -- , \"/home/tom/src/tcm-swarm/10_spins/Weights_10_spins_2_density_-7.29704001394_energy\"\n -- , \"/home/tom/src/tcm-swarm/10_spins/Weights_10_spins_2_density_-7.4024108663_energy\"\n -- , \"/home/tom/src/tcm-swarm/10_spins/Weights_10_spins_2_density_-7.83407453451_energy\"\n -- , \"/home/tom/src/tcm-swarm/10_spins/Weights_10_spins_2_density_-8.17005224883_energy\"\n -- , \"/home/tom/src/tcm-swarm/10_spins/Weights_10_spins_2_density_-8.18318151693_energy\"\n -- , \"/home/tom/src/tcm-swarm/10_spins/Weights_10_spins_2_density_-8.75410430005_energy\"\n -- , \"/home/tom/src/tcm-swarm/10_spins/Weights_10_spins_2_density_-9.04188789775_energy\"\n -- , \"/home/tom/src/tcm-swarm/10_spins/Weights_10_spins_2_density_-9.34302369964_energy\"\n -- , \"/home/tom/src/tcm-swarm/10_spins/Weights_10_spins_2_density_-9.5917604763_energy\"\n -- , \"/home/tom/src/tcm-swarm/10_spins/Weights_10_spins_2_density_2.01304877555_energy\"\n ]\n\n{-\n [ \"/home/tom/src/tcm-swarm/8_spins/input_singleflip_0.txt\"\n , \"/home/tom/src/tcm-swarm/8_spins/input_singleflip_1.txt\"\n , \"/home/tom/src/tcm-swarm/8_spins/input_singleflip_2.txt\"\n , \"/home/tom/src/tcm-swarm/8_spins/input_singleflip_3.txt\"\n , \"/home/tom/src/tcm-swarm/8_spins/input_singleflip_4.txt\"\n , \"/home/tom/src/tcm-swarm/8_spins/input_singleflip_5.txt\"\n , \"/home/tom/src/tcm-swarm/8_spins/input_singleflip_6.txt\"\n , \"/home/tom/src/tcm-swarm/8_spins/input_singleflip_7.txt\"\n , \"/home/tom/src/tcm-swarm/8_spins/input_singleflip_8.txt\"\n , \"/home/tom/src/tcm-swarm/8_spins/input_singleflip_9.txt\"\n , \"/home/tom/src/tcm-swarm/8_spins/input_singleflip_10.txt\"\n , \"/home/tom/src/tcm-swarm/8_spins/input_singleflip_11.txt\"\n , \"/home/tom/src/tcm-swarm/8_spins/input_singleflip_12.txt\"\n , \"/home/tom/src/tcm-swarm/8_spins/input_singleflip_13.txt\"\n , \"/home/tom/src/tcm-swarm/8_spins/input_singleflip_14.txt\"\n , \"/home/tom/src/tcm-swarm/8_spins/input_singleflip_15.txt\"\n , \"/home/tom/src/tcm-swarm/8_spins/input_singleflip_16.txt\"\n , \"/home/tom/src/tcm-swarm/8_spins/input_singleflip_17.txt\"\n , \"/home/tom/src/tcm-swarm/8_spins/input_singleflip_18.txt\"\n , \"/home/tom/src/tcm-swarm/8_spins/input_singleflip_19.txt\"\n ]\n-}\n\n\nfunction :: QMState X -> ReaderT g IO (Vector C)\nfunction x = lift $\n sampleMoments (x ^. pos) Heisenberg1DPeriodic 4 (1000, 7000 + 1000, 7) (Just 0) 4\n\ninstance {-# OVERLAPS #-} Ord (Vector C) where\n a <= b = let k x = realPart (x ! 3) / (realPart (x ! 1))^2\n in k a <= k b\n\nprocess :: Swarm m (SwarmGuide X (Vector C)) (BeeGuide X (Vector C)) (QMState X) (Vector C)\n -> IO ()\nprocess swarm = do\n putStrLn $ \"At iteration #\" <> show (swarm ^. guide . iteration)\n withFile \"Energies.dat\" AppendMode $ \\h ->\n do\n let xs = view bees swarm\n hPutStrLn h (L.concat $ L.intersperse \"\\t\" $ show . realPart . (! 0) . view val <$> xs)\n withFile \"Variances.dat\" AppendMode $ \\h ->\n do\n let xs = view bees swarm\n hPutStrLn h (L.concat $ L.intersperse \"\\t\" $ show . realPart . (! 1) . view val <$> xs)\n withFile \"Kurtosis.dat\" AppendMode $ \\h ->\n do\n let xs = view bees swarm\n k x = realPart (x ! 3) / (realPart (x ! 1))^2\n hPutStrLn h (L.concat $ L.intersperse \"\\t\" $ show . k . view val <$> xs)\n\ninstance Scalable Float (Rbm C) where\n scale \u03bb x = map (* (\u03bb :+ 0)) x\n\ninstance DeltaWell m R R => DeltaWell m R X where\n upDeltaWell \u03ba p x = zipWithM (upDeltaWell \u03ba) p x\n\nupdate ::\n ( m ~ ReaderT g IO\n , Randomisable m Float\n )\n => PhaseUpdater m (SwarmGuide X r) (BeeGuide X r) (QMState X) r\nupdate = PhaseUpdater $ deltaUpdater (1.9 * log 2 :: R)\n\nrunHeisenbergFromList ::\n ( m ~ ReaderT g IO\n -- , r ~ MeanVar Float\n -- , \u03c7 ~ Rbm (Complex Float)\n -- , DeltaWell m Float \u03c7\n -- , Scalable Float \u03c7\n , UniformDist m Int\n , Randomisable m Float\n , Randomisable m Bool\n )\n => g -> IO ()\nrunHeisenbergFromList gen = runReaderT go gen\n where go =\n do\n -- states <- fmap QMState <$> rbms \n states <- fmap QMState <$> lift rbms'\n optimiseNDFromList\n states\n update\n function\n (\\s -> (s^.guide.iteration == 100))\n (lift . process)\n return ()\n\n{-\nrunHeisenberg ::\n ( m ~ ReaderT g IO\n -- , r ~ MeanVar Float\n -- , \u03c7 ~ Rbm (Complex Float)\n -- , DeltaWell m Float \u03c7\n -- , Scalable Float \u03c7\n , UniformDist m Int\n , Randomisable m Float\n , Randomisable m Bool\n )\n => Int -> Int -> g -> IO ()\nrunHeisenberg spins count gen = do\n let h = heisenberg1DOpen spins\n initBounds = ((-2.0E-1) :+ (-2.0E-1), 2.0E-1 :+ 2.0E-1)\n n = spins\n newState = QMState <$> uniformRbm n (2 * spins) initBounds\n func x = uncurry MV <$> energyHH1DOpenMKLC (x ^. pos) 100 10000\n xs = optimiseND\n newState\n update\n func\n count\n (\\s -> (s^.guide.iteration == 100))\n swarms <- runReaderT xs gen\n writeEnergies2TSV \"Energies.dat\" (view (val . mean)) swarms\n writeEnergies2TSV \"Variances.dat\" (view (val . var)) swarms\n -- writeVariances2TSV \"Variances.dat\" swarms\n let swarm = last swarms\n (m, v) = meanVariance\n . V.fromList\n . map (view (val . mean))\n $ swarm ^. bees\n min = minimum $ view mean <$> view val <$> swarm ^. bees\n max = maximum $ view mean <$> view val <$> swarm ^. bees\n -- mapM_ (print . (!!0) . (view bees)) $ swarms\n putStrLn \"\"\n putStrLn $ \"[+] After \" ++ show (swarm ^. guide . iteration)\n ++ \" iterations: \"\n putStrLn $ \"[+] E[] = \" ++ show m\n putStrLn $ \"[+] Min[] = \" ++ show min\n putStrLn $ \"[+] Max[] = \" ++ show max\n putStrLn $ \"[+] StdDev[] = \" ++ show (sqrt v)\n putStrLn $ \"[+] Best[] = \" ++ show (swarm ^. guide . val . mean)\n putStrLn $ \"[+] Best[Var[]] = \" ++ show (swarm ^. guide . val . var)\n putStrLn $ \"[+] Actual states: \" ++ show (fst . LA.eigSH $ h)\n-}\n\nmain :: IO ()\nmain = do\n args <- getArgs\n case args of\n [ reads -> [(spins :: Int, _)], reads -> [(count :: Int, _)], reads -> [(seed, _)]\n ] -> do g <- mkMWCGen (Just seed)\n runHeisenbergFromList g\n _ -> do name <- getProgName\n hPutStrLn stderr $ \"usage: \" ++ name ++ \" <#spins> <#bees> \"\n exitFailure\n\n", "meta": {"hexsha": "d58cdf03dfddb7be6ea17fff1c36004c6c16e47c", "size": 10139, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "example/hh1d/hh1dopen.hs", "max_stars_repo_name": "twesterhout/tcm-swarm", "max_stars_repo_head_hexsha": "e632d493a9dc0b78c2634c2ac6311abc5f99168a", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "example/hh1d/hh1dopen.hs", "max_issues_repo_name": "twesterhout/tcm-swarm", "max_issues_repo_head_hexsha": "e632d493a9dc0b78c2634c2ac6311abc5f99168a", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "example/hh1d/hh1dopen.hs", "max_forks_repo_name": "twesterhout/tcm-swarm", "max_forks_repo_head_hexsha": "e632d493a9dc0b78c2634c2ac6311abc5f99168a", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 37.9737827715, "max_line_length": 103, "alphanum_fraction": 0.625702732, "num_tokens": 3324, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6548947155710233, "lm_q2_score": 0.49609382947091957, "lm_q1q2_score": 0.3248892273478976}} {"text": "module Strategy.TestOrientation where\n\nimport Prelude hiding (Right, Left)\nimport Numeric.LinearAlgebra ((<>))\nimport qualified Control.Monad.Writer as Writer\nimport qualified Data.DList as DList\n\nimport Cube (Side(..), Color(..))\nimport qualified Cube as Cube\nimport qualified Rotation as Rotation\nimport qualified RotationPath as RotationPath\nimport qualified Strategy.Orientation as Orientation\n\ntestSides :: Bool\ntestSides =\n let expected = [\n (Top, White)\n , (Front, Green)\n , (Right, Red)\n , (Back, Blue)\n , (Left, Orange)\n , (Bottom, Yellow)\n ]\n actual = Orientation.sides Cube.solvedCube\n in expected == actual\n\ntestIsColorOnSide :: Bool\ntestIsColorOnSide =\n let t = Orientation.isColorOnSide White Top Cube.solvedCube\n f = Orientation.isColorOnSide Blue Bottom Cube.solvedCube\n in t == True && f == False\n\ntestForColorOnTop :: Bool\ntestForColorOnTop = and $ do\n color <- [Cube.White ..]\n let (prefix, suffix) = Orientation.forColorOnTop color Cube.solvedCube\n cube = Rotation.rotate prefix Cube.solvedCube\n isOnTop = Orientation.isColorOnSide color Cube.Top cube\n isIdentity = (suffix <> prefix) == Rotation.identity\n return $ isIdentity && isOnTop\n\ntestPutColorOnTop :: Bool\ntestPutColorOnTop =\n let expectedSides = [\n (Top, Yellow)\n , (Front, Blue)\n , (Right, Red)\n , (Back, Green)\n , (Left, Orange)\n , (Bottom, White)\n ]\n expectedRotations = [Rotation.topToFront <> Rotation.topToFront]\n (cube, rotationLog) = Writer.runWriter $\n Orientation.putColorOnTop Yellow Cube.solvedCube\n actualSides = Orientation.sides cube\n in actualSides == expectedSides && expectedRotations == DList.toList rotationLog\n\ntestWithColorOnTop :: Bool\ntestWithColorOnTop =\n let (cube, rotationLog) = Writer.runWriter $\n Orientation.withColorOnTop Green (RotationPath.rotate Rotation.topL) Cube.solvedCube\n [top, frn, rgt, bck, lft, bot] = [Cube.Top ..]\n [w, g, r, b, o, y] = [Cube.White ..]\n expectedCube = [\n (top,0,0,w),(top,0,1,w),(top,0,2,w),(top,1,0,w),(top,1,1,w),(top,1,2,w),(top,2,0,r),(top,2,1,r),(top,2,2,r)\n , (frn,0,0,g),(frn,0,1,g),(frn,0,2,g),(frn,1,0,g),(frn,1,1,g),(frn,1,2,g),(frn,2,0,g),(frn,2,1,g),(frn,2,2,g)\n , (rgt,0,0,y),(rgt,0,1,r),(rgt,0,2,r),(rgt,1,0,y),(rgt,1,1,r),(rgt,1,2,r),(rgt,2,0,y),(rgt,2,1,r),(rgt,2,2,r)\n , (bck,0,0,b),(bck,0,1,b),(bck,0,2,b),(bck,1,0,b),(bck,1,1,b),(bck,1,2,b),(bck,2,0,b),(bck,2,1,b),(bck,2,2,b)\n , (lft,0,0,o),(lft,0,1,o),(lft,0,2,w),(lft,1,0,o),(lft,1,1,o),(lft,1,2,w),(lft,2,0,o),(lft,2,1,o),(lft,2,2,w)\n , (bot,0,0,o),(bot,0,1,o),(bot,0,2,o),(bot,1,0,y),(bot,1,1,y),(bot,1,2,y),(bot,2,0,y),(bot,2,1,y),(bot,2,2,y)]\n expectedRotations = [Rotation.frontL]\n in cube == expectedCube && DList.toList rotationLog == expectedRotations\n\ntests :: [(String, Bool)]\ntests = [\n (\"Strategy.Orientation.sides\", testSides)\n , (\"Strategy.Orientation.isColorOnSide\", testIsColorOnSide)\n , (\"Strategy.Orientation.forColorOnTop\", testForColorOnTop)\n , (\"Strategy.Orientation.putColorOnTop\", testPutColorOnTop)\n , (\"Strategy.Orientation.withColorOnTop\", testWithColorOnTop)\n ]\n", "meta": {"hexsha": "b7a720f7e258e03b2680faf7beccd031e9fa26e2", "size": 3242, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "Strategy/TestOrientation.hs", "max_stars_repo_name": "runjak/hRubiks", "max_stars_repo_head_hexsha": "28798a2a07871c81843490ed95eb5377921c1be5", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Strategy/TestOrientation.hs", "max_issues_repo_name": "runjak/hRubiks", "max_issues_repo_head_hexsha": "28798a2a07871c81843490ed95eb5377921c1be5", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Strategy/TestOrientation.hs", "max_forks_repo_name": "runjak/hRubiks", "max_forks_repo_head_hexsha": "28798a2a07871c81843490ed95eb5377921c1be5", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 39.5365853659, "max_line_length": 118, "alphanum_fraction": 0.6391116595, "num_tokens": 1072, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.6113819732941511, "lm_q2_score": 0.5312093733737563, "lm_q1q2_score": 0.32477183492559664}} {"text": "{-# LANGUAGE BangPatterns #-}\nmodule FokkerPlanck.MonteCarlo\n ( -- runMonteCarloFourierCoefficients\n runMonteCarloFourierCoefficientsGPU\n , solveMonteCarloR2S1\n ) where\n\nimport Array.UnboxedArray as UA\nimport Control.DeepSeq\nimport Control.Monad as M\nimport Control.Concurrent.Async\nimport Control.Monad.Parallel as MP\nimport Data.Array.Accelerate (constant, use)\nimport Data.Array.Accelerate.LLVM.PTX\nimport Data.Array.Repa as R\nimport Data.Binary\nimport Data.ByteString.Lazy as BL\nimport Data.Complex\nimport Data.DList as DL\nimport Data.Ix\nimport Data.List as L\nimport Data.Vector.Unboxed as VU\nimport FokkerPlanck.BrownianMotion\nimport FokkerPlanck.FourierSeries\nimport FokkerPlanck.FourierSeriesGPU\nimport FokkerPlanck.Histogram\nimport Foreign.CUDA.Driver as CUDA\nimport Statistics.Distribution\nimport Statistics.Distribution.Laplace\nimport Statistics.Distribution.Normal\nimport Statistics.Distribution.Poisson\nimport Statistics.Distribution.Uniform\nimport System.Directory\nimport System.IO as IO\nimport System.Random.MWC\nimport Text.Printf\nimport Utils.List\nimport Utils.Parallel\nimport Utils.Time\nimport GHC.Float\n\n{-# INLINE runBatch #-}\nrunBatch :: Int -> Int -> Int -> (Int -> a -> [GenIO] -> IO a) -> a -> IO a\nrunBatch !numGens !numTrails !batchSize monterCarloHistFunc !init = do\n let (!numBatch, !numLeftover) = divMod numTrails batchSize\n printf\n \"%d trails and batch size is %d, %d batch in total.\\n\"\n numTrails\n batchSize\n (numBatch +\n if numLeftover > 0\n then 1\n else 0)\n gensList <- M.replicateM numBatch (M.replicateM numGens createSystemRandom)\n x <-\n M.foldM\n (\\y gens -> do\n printCurrentTime \"\"\n monterCarloHistFunc batchSize y gens)\n init\n gensList\n if numLeftover > 0\n then do\n gens <- M.replicateM numGens createSystemRandom\n monterCarloHistFunc numLeftover x gens\n else return x\n\n{-# INLINE computeHistogramFromMonteCarloParallel #-}\ncomputeHistogramFromMonteCarloParallel ::\n (NFData hist, Binary hist, Show hist)\n => FilePath\n -> (GenIO -> IO particle)\n -> ([particle] -> IO hist)\n -> (hist -> hist -> hist)\n -> Int\n -> hist\n -> [GenIO]\n -> IO hist\ncomputeHistogramFromMonteCarloParallel !filePath pointsGenerator histFunc addHist !n !initHist !gens = do\n xs <- MP.mapM (M.replicateM (div n . L.length $ gens) . pointsGenerator) gens\n let tmpFilePath = (filePath L.++ \"_tmp\")\n hist <- L.foldl' addHist initHist <$> M.mapM histFunc xs\n unless\n (L.null filePath)\n (do encodeFile tmpFilePath hist\n copyFile tmpFilePath filePath)\n return hist\n\n{-# INLINE computeHistogramFromMonteCarloParallelSingleGPU #-}\ncomputeHistogramFromMonteCarloParallelSingleGPU ::\n (NFData hist, Binary hist, Show hist)\n => FilePath\n -> (GenIO -> IO particle)\n -> ([particle] -> hist)\n -> (hist -> hist -> hist)\n -> Int\n -> Int\n -> hist\n -> [GenIO]\n -> IO hist\ncomputeHistogramFromMonteCarloParallelSingleGPU !filePath pointsGenerator histFunc addHist !deviceID !n !initHist !gens = do\n xs <- MP.mapM (M.replicateM (div n . L.length $ gens) . pointsGenerator) gens\n let tmpFilePath = (filePath L.++ \"_tmp\")\n !hist = addHist initHist . histFunc . L.concat $ xs\n unless\n (L.null filePath)\n (do encodeFile tmpFilePath hist\n copyFile tmpFilePath filePath)\n return hist\n\n{-# INLINE computeHistogramFromMonteCarloParallelMultipleGPU #-}\ncomputeHistogramFromMonteCarloParallelMultipleGPU ::\n (NFData hist, Binary hist, Show hist, NFData particle)\n => FilePath\n -> (GenIO -> IO particle)\n -> (PTX -> [particle] -> hist)\n -> (hist -> hist -> hist)\n -> [PTX]\n -> Int\n -> hist\n -> [GenIO]\n -> IO hist\ncomputeHistogramFromMonteCarloParallelMultipleGPU !filePath pointsGenerator histFunc addHist !ptxs !n !initHist !gens = do\n xs <-\n L.concat <$>\n mapConcurrently\n (M.replicateM (div n . L.length $ gens) . pointsGenerator)\n gens\n let tmpFilePath = filePath L.++ \"_tmp\"\n !hist =\n L.foldl' addHist initHist .\n parZipWith rdeepseq histFunc ptxs . divideListN (L.length ptxs) $\n xs\n unless\n (L.null filePath)\n (do encodeFile tmpFilePath hist\n copyFile tmpFilePath filePath)\n return hist\n\n-- {-# INLINE runMonteCarloFourierCoefficients #-}\n-- runMonteCarloFourierCoefficients ::\n-- Int\n-- -> Int\n-- -> Int\n-- -> Double\n-- -> Double\n-- -> Double\n-- -> Double\n-- -> [Double]\n-- -> [Double]\n-- -> [Double]\n-- -> [Double]\n-- -> Double\n-- -> FilePath\n-- -> Histogram (Complex Double)\n-- -> IO (Histogram (Complex Double))\n-- runMonteCarloFourierCoefficients !numGens !numTrails !batchSize !thetaSigma !scaleSigma !maxScale !tao !phiFreqs !rhoFreqs !thetaFreqs !rFreqs !deltaLog !filePath !initHist = do\n-- when\n-- (maxScale <= 1)\n-- (error $\n-- printf \"runMonteCarloFourierCoefficients error: maxScale(%f) <= 1\" maxScale)\n-- let !thetaDist = normalDistrE 0 thetaSigma\n-- !scaleDist = normalDistrE 0 scaleSigma\n-- pointsGenerator = generatePath thetaDist scaleDist maxScale tao 1\n-- histFunc =\n-- computeFourierCoefficients\n-- phiFreqs\n-- rhoFreqs\n-- thetaFreqs\n-- rFreqs\n-- (log maxScale)\n-- deltaLog\n-- monterCarloHistFunc =\n-- computeHistogramFromMonteCarloParallel\n-- filePath\n-- pointsGenerator\n-- histFunc\n-- addHistogramUnsafe\n-- hist <- runBatch numGens numTrails batchSize monterCarloHistFunc initHist\n-- return hist\n\n\n{-# INLINE runMonteCarloFourierCoefficientsSingleGPU #-}\nrunMonteCarloFourierCoefficientsSingleGPU ::\n Int\n -> Int\n -> Int\n -> Int\n -> Double\n -> Double\n -> Double\n -> Double\n -> [Double]\n -> [Double]\n -> [Double]\n -> [Double]\n -> Double -> Double\n -> FilePath\n -> Histogram (Complex Double)\n -> IO (Histogram (Complex Double))\nrunMonteCarloFourierCoefficientsSingleGPU !deviceID !numGens !numTrails !batchSize !thetaSigma !scaleSigma !maxScale !tao !phiFreqs !rhoFreqs !thetaFreqs !rFreqs !deltaLog !initScale !filePath !initHist = do\n when\n (maxScale <= 1)\n (error $\n printf \"runMonteCarloFourierCoefficients error: maxScale(%f) <= 1\" maxScale)\n gen <- createSystemRandom\n initialise []\n dev <- device deviceID\n ctx <- CUDA.create dev []\n ptx <- createTargetFromContext ctx\n let !thetaDist = normalDistrE 0 thetaSigma\n !scaleDist = normalDistrE 0 scaleSigma\n -- !scaleDist = uniformDistrE (- (log maxScale)) (log maxScale)\n !poissonDist = poissonE 0\n !freqArr =\n computeFrequencyArray\n (L.map double2Float phiFreqs)\n (L.map double2Float rhoFreqs)\n (L.map double2Float thetaFreqs)\n (L.map double2Float rFreqs)\n pointsGenerator =\n generatePath\n thetaDist\n scaleDist\n poissonDist\n (maxScale ^ 2)\n maxScale\n tao\n initScale\n 1\n histFuncSingleGPU =\n computeFourierCoefficientsGPU\n phiFreqs\n rhoFreqs\n thetaFreqs\n rFreqs\n (use freqArr)\n (constant . double2Float $ maxScale)\n (constant . double2Float . log $ maxScale)\n ptx\n monterCarloHistFuncSingleGPU =\n computeHistogramFromMonteCarloParallelSingleGPU\n filePath\n pointsGenerator\n histFuncSingleGPU\n addHistogramUnsafe\n deviceID\n hist <-\n runBatch numGens numTrails batchSize monterCarloHistFuncSingleGPU initHist\n -- deepseq hist (destroy ctx)\n return hist\n\n-- {-# INLINE runMonteCarloFourierCoefficientsMultipleGPU #-}\n-- runMonteCarloFourierCoefficientsMultipleGPU ::\n-- [Int]\n-- -> Int\n-- -> Int\n-- -> Int\n-- -> Double\n-- -> Double\n-- -> Double\n-- -> Double\n-- -> [Double]\n-- -> [Double]\n-- -> [Double]\n-- -> [Double]\n-- -> Double\n-- -> Double\n-- -> FilePath\n-- -> Histogram (Complex Double)\n-- -> IO (Histogram (Complex Double))\n-- runMonteCarloFourierCoefficientsMultipleGPU !deviceIDs !numGens !numTrails !batchSize !thetaSigma !scaleSigma !maxScale !tao !phiFreqs !rhoFreqs !thetaFreqs !rFreqs !deltaLog !initScale !filePath !initHist = do\n-- when\n-- (maxScale <= 1)\n-- (error $\n-- printf \"runMonteCarloFourierCoefficients error: maxScale(%f) <= 1\" maxScale)\n-- initialise []\n-- devs <- M.mapM device deviceIDs\n-- ctxs <- M.mapM (\\dev -> CUDA.create dev []) devs\n-- ptxs <- M.mapM createTargetFromContext ctxs\n-- let !thetaDist = normalDistrE 0 thetaSigma\n-- !scaleDist = normalDistrE 0 scaleSigma\n-- !freqArr = computeFrequencyArray phiFreqs rhoFreqs thetaFreqs rFreqs\n-- pointsGenerator = generatePath thetaDist scaleDist maxScale tao initScale\n-- histFuncMultipleGPU =\n-- computeFourierCoefficientsGPU\n-- phiFreqs\n-- rhoFreqs\n-- thetaFreqs\n-- rFreqs\n-- (log maxScale)\n-- deltaLog\n-- (use freqArr)\n-- (constant maxScale)\n-- (constant (log maxScale))\n-- (constant (deltaLog :+ 0))\n-- monterCarloHistFuncMultipleGPU =\n-- computeHistogramFromMonteCarloParallelMultipleGPU\n-- filePath\n-- pointsGenerator\n-- histFuncMultipleGPU\n-- addHistogramUnsafe\n-- ptxs\n-- hist <-\n-- runBatch numGens numTrails batchSize monterCarloHistFuncMultipleGPU initHist\n-- deepseq hist (M.mapM destroy ctxs)\n-- return hist\n\n{-# INLINE runMonteCarloFourierCoefficientsGPU #-}\nrunMonteCarloFourierCoefficientsGPU ::\n [Int]\n -> Int\n -> Int\n -> Int\n -> Double\n -> Double\n -> Double\n -> Double\n -> Double\n -> Double\n -> [Double]\n -> [Double]\n -> [Double]\n -> [Double]\n -> Double\n -> Double\n -> FilePath\n -> IO (Histogram (Complex Double))\nrunMonteCarloFourierCoefficientsGPU !deviceIDs !numGens !numTrails !batchSize !thetaSigma !scaleLambda !poissonLambda !sigma !tao !deltaT !phiFreqs !rhoFreqs !thetaFreqs !rFreqs !periodEnv !stdR2 !filePath = do\n when\n (periodEnv <= 1)\n (error $\n printf\n \"runMonteCarloFourierCoefficients error: periodEnv(%f) <= 1\"\n periodEnv)\n initialise []\n devs <- M.mapM device deviceIDs\n ctxs <- M.mapM (\\dev -> CUDA.create dev []) devs\n ptxs <- M.mapM createTargetFromContext ctxs\n let !initHist =\n emptyHistogram\n [ L.length phiFreqs\n , L.length rhoFreqs\n , L.length thetaFreqs\n , L.length rFreqs\n ]\n 0\n !thetaDist = normalDistrE 0 (thetaSigma * sqrt deltaT)\n !scaleDist = normalDistrE 0 (scaleLambda * sqrt deltaT)\n !poissonDist = poissonE (poissonLambda / deltaT)\n !freqArr =\n computeFrequencyArray\n (L.map double2Float phiFreqs)\n (L.map double2Float rhoFreqs)\n (L.map double2Float thetaFreqs)\n (L.map double2Float rFreqs)\n !maxRho = sqrt periodEnv / 1 / sqrt 2\n !maxR = sqrt periodEnv / 1 / sqrt 2\n pointsGenerator =\n generatePath\n thetaDist\n scaleDist\n poissonDist\n maxRho\n maxR\n (tao / deltaT)\n deltaT\n stdR2\n -- pointsGenerator =\n -- generatePath'\n -- thetaSigma\n -- scaleDist\n -- poissonLambda\n -- maxRho\n -- maxR\n -- tao\n -- deltaT\n -- stdR2\n -- pointsGenerator =\n -- generatePath' thetaSigma scaleDist poissonLambda periodEnv (tao / deltaT) deltaT\n histFuncSingleGPU =\n computeFourierCoefficientsGPU\n phiFreqs\n rhoFreqs\n thetaFreqs\n rFreqs\n (use freqArr)\n (constant . double2Float $ sigma)\n (constant . double2Float $ log periodEnv)\n monterCarloHistFuncGPU =\n computeHistogramFromMonteCarloParallelMultipleGPU\n filePath\n pointsGenerator\n histFuncSingleGPU\n addHistogramUnsafe\n ptxs\n runBatch numGens numTrails batchSize monterCarloHistFuncGPU initHist\n\n{-# INLINE countR2S1 #-}\ncountR2S1 ::\n GenIO\n -> Double\n -> (Int, Int)\n -> (Int, Int)\n -> Int\n -> [DList Particle]\n -> IO (Histogram Double)\ncountR2S1 randomGen thetaSigma xRange@(!xMin, !xMax) yRange@(!yMin, !yMax) !numOrientations !xs = do\n let !deltaTheta = 2 * pi / (fromIntegral numOrientations)\n ys <-\n fmap\n (L.filter\n (\\((_, x, y), _) ->\n (inRange xRange x) && (inRange yRange y) && (x /= 0 || y /= 0)) .\n L.map\n (\\(Particle phi rho theta' _ _) ->\n let !x = rho * cos phi\n !y = rho * sin phi\n !theta =\n if theta' < 0\n then theta' + 2 * pi\n else theta'\n in ((floor $ theta / deltaTheta, round x, round y), 1)) .\n L.concat) .\n M.mapM\n (\\particle@(Particle phi rho theta r _) -> do\n let delta = 1\n n = Prelude.floor $ r / delta\n zs <-\n M.mapM\n (\\i -> do\n let thetaDist =\n normalDistr\n 0\n (thetaSigma * sqrt (delta * fromIntegral i / r))\n (Particle a b c d _) =\n FokkerPlanck.BrownianMotion.moveParticle\n 1\n (Particle\n phi\n rho\n theta\n (Prelude.fromIntegral i * delta)\n 1)\n deltaThetaDiffusion <- genContVar thetaDist randomGen\n return (Particle a b (c `thetaPlus` deltaThetaDiffusion) d 1))\n [1 .. n - 1]\n return .\n L.concatMap\n (\\(Particle phi' rho' theta' r' v) ->\n [ (Particle phi' rho' theta' r' v)\n , (Particle (-phi') rho' (-theta') r' v)\n ]) $\n (FokkerPlanck.BrownianMotion.moveParticle\n 1\n (Particle phi rho theta r 1)) :\n zs) .\n DL.toList . DL.concat $\n xs\n return .\n Histogram\n [(yMax - yMin + 1), (xMax - xMin + 1), numOrientations]\n (L.length ys) .\n toUnboxedVector .\n UA.accum (+) 0 ((0, xMin, yMin), (numOrientations - 1, xMax, yMax)) $\n ys\n\n{-# INLINE solveMonteCarloR2S1 #-}\nsolveMonteCarloR2S1 ::\n Int\n -> Int\n -> Int\n -> Int\n -> Int\n -> Int\n -> Double\n -> Double\n -> Double\n -> Double\n -> FilePath\n -> IO (R.Array U DIM3 Double)\nsolveMonteCarloR2S1 numGens numTrails batchSize xLen yLen numOrientations thetaSigma tao r initSpeed histFilePath = do\n gen <- createSystemRandom\n let !xShift = div xLen 2\n xRange' =\n if odd xLen\n then (-xShift, xShift)\n else (-xShift, xShift - 1)\n !yShift = div yLen 2\n yRange' =\n if odd yLen\n then (-yShift, yShift)\n else (-yShift, yShift - 1)\n thetaDist = normalDistrE 0 thetaSigma\n scaleDist = normalDistrE 0 0\n poissonDist = poissonE 0\n pointsGenerator =\n generatePath\n thetaDist\n scaleDist\n poissonDist\n (r^2)\n r -- (sqrt . fromIntegral $ xLen ^ 2 + yLen ^ 2)\n tao\n initSpeed\n 1\n histFunc = countR2S1 gen thetaSigma xRange' yRange' numOrientations\n monterCarloHistFunc =\n computeHistogramFromMonteCarloParallel\n histFilePath\n pointsGenerator\n histFunc\n addHistogramUnsafe\n hist <-\n runBatch\n numGens\n numTrails\n batchSize\n monterCarloHistFunc\n (emptyHistogram [yLen, xLen, numOrientations] 0)\n return . getNormalizedHistogramArr $ hist\n", "meta": {"hexsha": "b8441bdd686422e85ce7678d740b66d833422f49", "size": 16196, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/FokkerPlanck/MonteCarlo.hs", "max_stars_repo_name": "XinhuaZhang/Stochastic-Completion-Field", "max_stars_repo_head_hexsha": "494a49356e17288ce09864c64ba09d11a3e9e0a8", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/FokkerPlanck/MonteCarlo.hs", "max_issues_repo_name": "XinhuaZhang/Stochastic-Completion-Field", "max_issues_repo_head_hexsha": "494a49356e17288ce09864c64ba09d11a3e9e0a8", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 4, "max_issues_repo_issues_event_min_datetime": "2019-07-25T20:48:32.000Z", "max_issues_repo_issues_event_max_datetime": "2019-09-04T20:46:48.000Z", "max_forks_repo_path": "src/FokkerPlanck/MonteCarlo.hs", "max_forks_repo_name": "XinhuaZhang/Stochastic-Completion-Field", "max_forks_repo_head_hexsha": "494a49356e17288ce09864c64ba09d11a3e9e0a8", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2019-07-29T15:55:46.000Z", "max_forks_repo_forks_event_max_datetime": "2019-07-29T15:55:46.000Z", "avg_line_length": 31.0268199234, "max_line_length": 213, "alphanum_fraction": 0.5921215115, "num_tokens": 4436, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6926419831347361, "lm_q2_score": 0.46879062662624377, "lm_q1q2_score": 0.32470406930137713}} {"text": "module Language.Definition where\n\nimport qualified Data.Complex as C\n\n-- Data Type\n-- @todo: the number tower needs to be implemented\n--\n-- @fixme: It doesn't seem like the DottedList is implemented\n-- correctly. I copied it from the tutorial\ndata LispVal = Atom String\n | List [LispVal]\n | DottedList [LispVal] LispVal\n | Char Char\n | String String\n | Bool Bool\n | Number Integer\n | Float Double\n | Ratio Rational\n | Complex (C.Complex Double)\n deriving Show\n\n", "meta": {"hexsha": "d7923acb483a9289cf80d7dc56f238b5f423d1d8", "size": 581, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "2_Parsing/Language/Definition.hs", "max_stars_repo_name": "ahmadnazir/scheme", "max_stars_repo_head_hexsha": "53ec942e9db093abafba31c857af10e873595f76", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "2_Parsing/Language/Definition.hs", "max_issues_repo_name": "ahmadnazir/scheme", "max_issues_repo_head_hexsha": "53ec942e9db093abafba31c857af10e873595f76", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "2_Parsing/Language/Definition.hs", "max_forks_repo_name": "ahmadnazir/scheme", "max_forks_repo_head_hexsha": "53ec942e9db093abafba31c857af10e873595f76", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 26.4090909091, "max_line_length": 61, "alphanum_fraction": 0.5817555938, "num_tokens": 129, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES\n\n", "lm_q1_score": 0.5621765008857981, "lm_q2_score": 0.5774953651858118, "lm_q1q2_score": 0.3246543236779258}} {"text": "module Sound.Plot where\n\nimport qualified Data.Stream as S\n\nimport Numeric.LinearAlgebra\n\nimport Sound.Types\n\nimport Graphics.Rendering.Plot (Series)\nimport qualified Graphics.Rendering.Plot as P\nimport Graphics.Rendering.Plot.Gtk (PlotHandle)\nimport qualified Graphics.Rendering.Plot.Gtk as P\n\nplot :: Int -> [Audio] -> IO PlotHandle\nplot n audio = P.display $ do\n P.plot (P.Line, map (fromList . S.take n) audio :: [Series])\n P.withTextDefaults $ P.setFontFamily \"Ubuntu\"\n P.xlabel \"samples\"\n P.ylabel \"amplitude\"\n P.yrange P.Linear (-1) 1\n", "meta": {"hexsha": "ea4751fe62f1d7a5461ee230d4aa7c61bcab566e", "size": 587, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/Sound/Plot.hs", "max_stars_repo_name": "svenkeidel/hsynth", "max_stars_repo_head_hexsha": "6c8401a365355d3138b98c0bfca423a180fb94f5", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 4, "max_stars_repo_stars_event_min_datetime": "2015-11-14T12:31:46.000Z", "max_stars_repo_stars_event_max_datetime": "2015-11-15T14:43:34.000Z", "max_issues_repo_path": "src/Sound/Plot.hs", "max_issues_repo_name": "svenkeidel/hsynth", "max_issues_repo_head_hexsha": "6c8401a365355d3138b98c0bfca423a180fb94f5", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/Sound/Plot.hs", "max_forks_repo_name": "svenkeidel/hsynth", "max_forks_repo_head_hexsha": "6c8401a365355d3138b98c0bfca423a180fb94f5", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 27.9523809524, "max_line_length": 62, "alphanum_fraction": 0.6967632027, "num_tokens": 145, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES\n\n", "lm_q1_score": 0.6442251064863697, "lm_q2_score": 0.5039061705290805, "lm_q1q2_score": 0.3246290063682356}} {"text": "import Paraiso\nimport Data.Complex\n\n\nmain = do\n args <- getArgs\n let arch = if \"--cuda\" `elem` args then\n CUDA 128 128\n else\n X86\n putStrLn $ compile arch code\n where\n code = do\n parallel 16384 $ do\n r <- allocate\n x <- allocate\n r =$ Rand (0.0::Double) 4.0\n x =$ Rand 0 1\n cuda $ do\n sequential 65536 $ do\n r =$ r * x * (1-x)\n output [r,x]\n\n\n", "meta": {"hexsha": "48539dbcf2f852623f326e493e8a2618d78dfe39", "size": 488, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "attic/paraiso-2008-ODEsolver/secondlight/MainTest.hs", "max_stars_repo_name": "nushio3/Paraiso", "max_stars_repo_head_hexsha": "e9eaea7a8c7384ceb43f8761e4af2f9206a5bbc7", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 21, "max_stars_repo_stars_event_min_datetime": "2015-02-09T22:41:26.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-20T07:13:43.000Z", "max_issues_repo_path": "attic/paraiso-2008-ODEsolver/secondlight/MainTest.hs", "max_issues_repo_name": "nushio3/Paraiso", "max_issues_repo_head_hexsha": "e9eaea7a8c7384ceb43f8761e4af2f9206a5bbc7", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2016-09-30T07:17:17.000Z", "max_issues_repo_issues_event_max_datetime": "2016-09-30T07:17:17.000Z", "max_forks_repo_path": "attic/paraiso-2008-ODEsolver/secondlight/MainTest.hs", "max_forks_repo_name": "nushio3/Paraiso", "max_forks_repo_head_hexsha": "e9eaea7a8c7384ceb43f8761e4af2f9206a5bbc7", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 8, "max_forks_repo_forks_event_min_datetime": "2015-05-15T01:41:47.000Z", "max_forks_repo_forks_event_max_datetime": "2018-11-18T17:41:56.000Z", "avg_line_length": 19.52, "max_line_length": 41, "alphanum_fraction": 0.4385245902, "num_tokens": 136, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO\n\n", "lm_q1_score": 0.6619228758499942, "lm_q2_score": 0.4882833952958347, "lm_q1q2_score": 0.32320594924401846}} {"text": "{-# LANGUAGE TypeApplications #-}\n{-# LANGUAGE TupleSections #-}\n{-# LANGUAGE FlexibleInstances #-}\n{-# LANGUAGE TypeSynonymInstances #-}\n{-# LANGUAGE FlexibleContexts #-}\n{-# LANGUAGE ConstraintKinds #-}\n{-# LANGUAGE CPP #-}\n{-# LANGUAGE TypeFamilies #-}\n{-# LANGUAGE TypeOperators #-}\n{-# LANGUAGE DefaultSignatures #-}\n{-# LANGUAGE ScopedTypeVariables #-}\n{-# LANGUAGE MultiParamTypeClasses #-}\n{-# LANGUAGE AllowAmbiguousTypes #-}\n{-# LANGUAGE UndecidableInstances #-}\n\n{-# OPTIONS_GHC -Wall #-}\n\n#include \"ConCat/Ops.inc\"\n\n-- | Commutative monoid intended to be used with a multiplicative monoid\n\nmodule ConCat.Additive where\n\nimport Prelude hiding (zipWith)\nimport Data.Monoid (Monoid(..), Sum(..), Product(..))\nimport Data.Semigroup (Semigroup(..))\nimport Data.Complex hiding (magnitude)\nimport Data.Ratio\nimport Foreign.C.Types (CSChar, CInt, CShort, CLong, CLLong, CIntMax, CFloat, CDouble)\nimport GHC.Generics (U1(..),Par1(..),(:*:)(..),(:.:)(..))\nimport GHC.TypeLits (KnownNat)\n\nimport Data.Key(Zip(..))\nimport Data.Pointed\nimport Data.Functor.Rep (Representable(..))\nimport Data.Vector.Sized (Vector)\nimport Data.Finite.Internal\n\nimport ConCat.Misc\nimport ConCat.Rep (HasRep(abst),inAbst,inAbst2)\nimport qualified ConCat.Rep\nimport ConCat.Orphans ()\n\n-- | Commutative monoid intended to be used with a multiplicative monoid\nclass Additive a where\n zero :: a\n infixl 6 ^+^\n (^+^) :: a -> a -> a\n default zero :: (Pointed h, Additive b, a ~ h b) => a\n zero = pointNI zero\n default (^+^) :: (Zip h, Additive b, a ~ h b) => Binop a\n (^+^) = zipWithNI (^+^)\n {-# INLINE zero #-}\n {-# INLINE (^+^) #-}\n\n-- These definitions and the corresponding Catify rewrites in AltCat prevent the point and zipWith methods from getting inlined too soon.\n-- See 2018-04-09 notes.\npointNI :: Pointed h => a -> h a\npointNI = point\n{-# INLINE [0] pointNI #-}\n\nzipWithNI :: Zip h => (a -> b -> c) -> h a -> h b -> h c\nzipWithNI = zipWith\n{-# INLINE [0] zipWithNI #-}\n\ninstance Additive () where\n zero = ()\n () ^+^ () = ()\n\n#define ScalarType(t) \\\n instance Additive (t) where { zero = 0 ; (^+^) = (+) }\n\nScalarType(Int)\nScalarType(Integer)\nScalarType(Float)\nScalarType(Double)\nScalarType(CSChar)\nScalarType(CInt)\nScalarType(CShort)\nScalarType(CLong)\nScalarType(CLLong)\nScalarType(CIntMax)\nScalarType(CDouble)\nScalarType(CFloat)\n\ninstance Integral a => Additive (Ratio a) where\n zero = 0\n (^+^) = (+)\n\ninstance (RealFloat v, Additive v) => Additive (Complex v) where\n zero = zero :+ zero\n (^+^) = (+)\n\n-- The 'RealFloat' constraint is unfortunate here. It's due to a\n-- questionable decision to place 'RealFloat' into the definition of the\n-- 'Complex' /type/, rather than in functions and instances as needed.\n\ninstance (Additive u,Additive v) => Additive (u,v) where\n zero = (zero,zero)\n (u,v) ^+^ (u',v') = (u^+^u',v^+^v')\n\ninstance (Additive u,Additive v,Additive w)\n => Additive (u,v,w) where\n zero = (zero,zero,zero)\n (u,v,w) ^+^ (u',v',w') = (u^+^u',v^+^v',w^+^w')\n\ninstance (Additive u,Additive v,Additive w,Additive x)\n => Additive (u,v,w,x) where\n zero = (zero,zero,zero,zero)\n (u,v,w,x) ^+^ (u',v',w',x') = (u^+^u',v^+^v',w^+^w',x^+^x')\n\ntype AddF f = (Pointed f, Zip f)\n\ninstance KnownNat n => Additive (Finite n) where\n zero = 0\n (^+^) = (+)\n\n#if 1\n\n#define AdditiveFunctor(f) instance (AddF (f), Additive v) => Additive ((f) v)\n\nAdditiveFunctor((->) a)\nAdditiveFunctor(Sum)\nAdditiveFunctor(Product)\nAdditiveFunctor(U1)\nAdditiveFunctor(Par1)\nAdditiveFunctor(f :*: g)\nAdditiveFunctor(g :.: f)\n\n#else\n\ninstance Additive v => Additive (a -> v)\ninstance Additive v => Additive (Sum v)\ninstance Additive v => Additive (Product v)\n\ninstance Additive v => Additive (U1 v)\ninstance Additive v => Additive (Par1 v)\ninstance (Additive v, AddF f, AddF g) => Additive ((f :*: g) v)\ninstance (Additive v, AddF f, AddF g) => Additive ((g :.: f) v)\n\n#endif\n\n\n-- instance (Eq i, Additive v) => Additive (Arr i v) where\n-- zero = point zero\n-- as ^+^ bs = fmap (uncurry (^+^)) (zipC (as,bs))\n\n-- TODO: Define and use zipWithC (^+^) as bs.\n\ninstance (Additive v, KnownNat n) => Additive (Vector n v)\n\n-- Maybe is handled like the Maybe-of-Sum monoid\ninstance Additive a => Additive (Maybe a) where\n zero = Nothing\n Nothing ^+^ b' = b'\n a' ^+^ Nothing = a'\n Just a' ^+^ Just b' = Just (a' ^+^ b')\n\n-- -- Memo tries\n-- instance (HasTrie u, Additive v) => Additive (u :->: v) where\n-- zero = pure zero\n-- (^+^) = liftA2 (^+^)\n\n-- Experiment\ninstance Additive Bool where\n -- zero = undefined\n -- _ ^+^ _ = undefined\n zero = False\n (^+^) = (||)\n {-# INLINE zero #-}\n {-# INLINE (^+^) #-}\n\n{--------------------------------------------------------------------\n Monoid wrapper\n--------------------------------------------------------------------}\n\n-- | Monoid under group addition. Alternative to the @Sum@ in\n-- \"Data.Monoid\", which uses 'Num' instead of 'Additive'.\nnewtype Add a = Add { getAdd :: a }\n deriving (Eq, Ord, Read, Show, Bounded)\n\ninstance HasRep (Add a) where\n type Rep (Add a) = a\n abst = Add\n repr = getAdd\n\ninstance Functor Add where fmap = inAbst\n\ninstance Applicative Add where\n pure = abst\n (<*>) = inAbst2 ($)\n\ninstance Additive a => Semigroup (Add a) where\n (<>) = inAbst2 (^+^)\n\ninstance Additive a => Monoid (Add a) where\n mempty = abst zero\n mappend = (<>)\n\ninstance Additive a => Additive (Add a) where\n zero = mempty\n (^+^) = mappend\n\n-- sumA' :: (Foldable h, Additive a) => h a -> a\n-- sumA' = getAdd . foldMap Add\n\n-- Enables translation of sumA to jamPF in AltCat.\ntype SummableF h = (Representable h, Eq (Rep h), Zip h, Pointed h, Foldable h)\n\nclass SummableF h => Summable h\ninstance SummableF h => Summable h\n\n-- The constraint \u2018Representable h\u2019\n-- is no smaller than the instance head\n-- (Use UndecidableInstances to permit this)\n\nsumA :: (\n -- Summable h, Additive a\n Foldable h, Additive a\n ) => h a -> a\nsumA = getAdd . foldMap Add\n{-# OPINLINE sumA #-}\n", "meta": {"hexsha": "56225b0639dd78f558e012e2e19753d1f3298202", "size": 6031, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "classes/src/ConCat/Additive.hs", "max_stars_repo_name": "kenranunderscore/concat", "max_stars_repo_head_hexsha": "632c3f37a969725053dc55ebec26f5b7aacf8c07", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "classes/src/ConCat/Additive.hs", "max_issues_repo_name": "kenranunderscore/concat", "max_issues_repo_head_hexsha": "632c3f37a969725053dc55ebec26f5b7aacf8c07", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "classes/src/ConCat/Additive.hs", "max_forks_repo_name": "kenranunderscore/concat", "max_forks_repo_head_hexsha": "632c3f37a969725053dc55ebec26f5b7aacf8c07", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 27.0448430493, "max_line_length": 137, "alphanum_fraction": 0.6221190516, "num_tokens": 1866, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.672331699179286, "lm_q2_score": 0.48047867804790706, "lm_q1q2_score": 0.32304104603136646}} {"text": "{-# LANGUAGE TemplateHaskell\n , TupleSections\n , DeriveGeneric\n , DeriveAnyClass\n , OverloadedLists #-}\nmodule Physics.Collision where\n\nimport Numeric.LinearAlgebra (Vector, Matrix, (<>), scale, dot, cross, (#>))\nimport Control.Lens\nimport Numeric.LinearAlgebra.Data\nimport Data.Vector.Storable (init)\nimport GHC.Generics\nimport qualified Data.Vector as V\nimport qualified Data.Vector.Storable as VS\nimport Data.Function (on)\n\nimport Control.DeepSeq\nimport Utils\nimport Prelude hiding (init)\n\ndata Contact = Contact { _contactPoint :: Vector Float\n , _contactNormal :: Vector Float\n , _penetration :: Float\n , _sign :: Float } deriving Show\n\nmakeLenses ''Contact\n\nmakeContactBasis cont =\n let ys = [0,1,0]\n y2 = [0,0,1]\n x = cont^.contactNormal\n zs = normalize $ cross x ys\n z = if VS.any isNaN zs\n then normalize $ cross x y2\n else zs\n y = normalize $ cross z x\n in fromRows [x,y,z]\n\ndata CollisionData = CollisionData { _contacts :: [Contact]\n , _left :: Int }\n\nmakeLenses ''CollisionData\n\ndata Primitive = Sphere { _radius :: Float\n , _primoffset :: Matrix Float }\n | Plane { _normal :: Vector Float\n , _planeoff :: Float }\n | Box { _points :: V.Vector (Vector Float)\n , _faces :: V.Vector Squad }\n deriving Show\n\ndata PrimitiveComputation = CSphere { _r :: Float\n , _poff :: Vector Float }\n | CPlane { _cnormal :: Vector Float\n , _cplaneoff :: Float}\n | CBox { _cpoints :: V.Vector (Vector Float)\n , _quads :: V.Vector Quad } deriving Show\n\ndata Quad = Quad { _qnorm :: Vector Float\n , _qoff :: Float} deriving Show\n\nquadToCPlane (Quad n o) = CPlane n o\n\ndata Squad = Squad { _snorm :: Vector Float\n , _spoint:: Vector Float } deriving Show\n\nsToQ t (Squad n p) = Quad newN o\n where\n newN = init . (t#>) . flip VS.snoc 0 $ n\n o = dot newN . init . (t#>) . flip VS.snoc 1 $ p\n\npreparePrimitive :: Matrix Float -> Primitive -> PrimitiveComputation\npreparePrimitive t (Sphere r p1) = CSphere r ppos\n where ppos = init . (!!3) . toColumns $ t <> p1\npreparePrimitive t (Box p q) = CBox (V.map adjust p) $ V.map (sToQ t) q\n where adjust = init . (t #>) . flip VS.snoc 1\npreparePrimitive _ (Plane n o) = CPlane n o\n\ntolerance = 0.05\n\nquadDepth (Quad n o) p =\n (dot n p - o, n)\n\nboxPtcoll (CBox _ qs) p cdata =\n let dots = V.map (flip quadDepth p) qs\n (d,n) = V.minimumBy (compare `on` fst) dots\n in if V.any ((>=0) . fst) dots\n then cdata\n else over contacts (Contact p n d 1:) cdata\n\nquadPenetration (Quad n o) = planePenetration (CPlane n o)\n\nplanePenetration (CPlane n o) p cdata =\n let vertDist = dot p n\n cPoint = p -- scale (vertDist - o) n + p\n contact = Contact cPoint n (o - vertDist) 1\n in if cdata^.left > 0 && vertDist <= o + tolerance\n then over contacts (contact:) . over left (subtract 1) $ cdata\n else cdata\n\n-- checkAxe :: Vector Float -> Vector Float -> V.Vector\ncheckAxe pos r ps ix =\n let vals = V.map (VS.!ix) ps\n in (pos VS.! ix + r) >= minimum vals &&\n (pos VS.! ix - r) <= maximum vals\n\ncheckConvexAxe ps1 ps2 ix =\n let vals1 = V.map (VS.! ix) ps1\n vals2 = V.map (VS.! ix) ps2\n in maximum vals1 >= minimum vals2 &&\n minimum vals1 <= maximum vals2\n\naxeList :: [Int]\naxeList = [0,1,2]\n\nseparatingAxes :: PrimitiveComputation -> PrimitiveComputation -> Bool\nseparatingAxes (CSphere r pos) (CBox ps _) = all (checkAxe pos r ps) axeList\nseparatingAxes (CBox ps _) (CSphere r pos) = all (checkAxe pos r ps) axeList\nseparatingAxes (CBox ps _) (CBox ps2 _) = all (checkConvexAxe ps ps2) axeList\n\ndetectCollision prim1 prim2 =\n collisionDetector prim1 prim2 (CollisionData [] 8)\n\nquadSphereCollision (CSphere r p) q@(Quad n o) =\n (dot n p - r - o, n)\n\nquadContact (CSphere r p) (dist, n) =\n let contactPos = p - scale (dist + r) n\n in Contact contactPos n (-dist) 1\n\ncollisionDetector (CSphere r1 pos1) (CSphere r2 pos2) cdata =\n let mid = pos1 - pos2\n midnorm = norm mid\n in if cdata^.left <= 0 || midnorm <= 0.0 || midnorm >= r1 + r2\n then cdata\n else let normal = scale (1/midnorm) mid\n contactPos = pos1 + scale 0.5 mid\n contactPen = r1 + r2 - midnorm\n contact = Contact contactPos normal contactPen 1\n in over contacts (contact:) . over left (subtract 1) $ cdata\ncollisionDetector p@(CPlane _ _) s@(CSphere _ _) cdata =\n set (contacts.traverse.sign) (-1) $\n collisionDetector s p cdata\ncollisionDetector (CSphere r pos1) (CPlane n p2) cdata =\n if cdata^.left <= 0 then cdata\n else let dist = dot n pos1 - r - p2\n in if dist >= 0\n then cdata\n else let contactPos = pos1 - scale (dist + r) n\n contact = Contact contactPos n (-dist) 1\n in over contacts (contact:) cdata\ncollisionDetector (CBox ps _) p@(CPlane _ _) cdata =\n V.foldr (planePenetration p) cdata ps\ncollisionDetector s@(CSphere _ _) b@(CBox _ _) cdata =\n set (contacts.traverse.sign) (-1) $\n collisionDetector b s cdata\ncollisionDetector (CBox _ q) s@(CSphere _ _) cdata =\n let cols = V.map (quadSphereCollision s) q\n best = V.maximumBy (compare `on` fst) cols\n in if V.any ((>=0) . fst) cols\n then cdata\n else over contacts (quadContact s best:) cdata\ncollisionDetector p@(CPlane _ _) b@(CBox _ _) cdata =\n set (contacts.traverse.sign) (-1) $\n collisionDetector b p cdata\ncollisionDetector b1@(CBox ps qs) b2@(CBox ps2 qs2) cdata =\n V.foldr (boxPtcoll b2) (V.foldr (boxPtcoll b1) cdata ps2) ps\ncollisionDetector _ _ cdata = cdata\n", "meta": {"hexsha": "a7c94388c13e2b3e6c4d0e5ada09155b3fa1b09b", "size": 5977, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/Physics/Collision.hs", "max_stars_repo_name": "Antystenes/CPG", "max_stars_repo_head_hexsha": "9a9e669f30d6816735b5d004cd2ca32bcf2c32bc", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/Physics/Collision.hs", "max_issues_repo_name": "Antystenes/CPG", "max_issues_repo_head_hexsha": "9a9e669f30d6816735b5d004cd2ca32bcf2c32bc", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/Physics/Collision.hs", "max_forks_repo_name": "Antystenes/CPG", "max_forks_repo_head_hexsha": "9a9e669f30d6816735b5d004cd2ca32bcf2c32bc", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 35.3668639053, "max_line_length": 80, "alphanum_fraction": 0.6011376945, "num_tokens": 1745, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.7431680086124812, "lm_q2_score": 0.43398146480389854, "lm_q1q2_score": 0.3225211409730409}} {"text": "{-# language Rank2Types #-}\n{-# language ScopedTypeVariables #-}\n{-# language DataKinds #-}\n{-# language TypeOperators #-}\n{-# language TypeFamilies #-}\n{-# language FlexibleInstances #-}\n{-# language FlexibleContexts #-}\n{-# language MultiParamTypeClasses #-}\n{-# language PolyKinds #-}\n{-# language GADTs #-}\n{-# language ConstraintKinds #-}\n{-# language GeneralizedNewtypeDeriving #-}\n\nmodule Feldspar.Software.Verify.Primitive where\n\nimport Feldspar.Sugar\nimport Feldspar.Representation\nimport Feldspar.Software.Primitive\nimport Feldspar.Software.Expression\nimport Feldspar.Software.Representation hiding (Nil)\nimport Feldspar.Software.Verify.Command\nimport Feldspar.Verify.Arithmetic\n\nimport Feldspar.Verify.Monad (Verify)\nimport qualified Feldspar.Verify.FirstOrder as FO\nimport qualified Feldspar.Verify.Monad as V\nimport qualified Feldspar.Verify.SMT as SMT\nimport qualified Feldspar.Verify.Abstract as A\n\nimport Data.Struct\nimport qualified Data.Map.Strict as Map\n\nimport qualified Control.Monad.RWS.Strict as S\n\nimport qualified SimpleSMT as SMT hiding (not, declareFun)\n\nimport qualified Language.Embedded.Expression as Imp\nimport qualified Language.Embedded.Imperative.CMD as Imp\n\nimport qualified Data.Bits as Bits\nimport qualified Data.Complex as Complex\nimport Data.Constraint hiding (Sub)\nimport Data.Int\nimport Data.Word\nimport Data.Typeable\n\nimport Language.Syntactic\n\nimport GHC.Stack\n\n--------------------------------------------------------------------------------\n-- *\n--------------------------------------------------------------------------------\n\nnewtype Symbolic a = Symbolic { unSymbolic :: Rat }\n deriving (Eq, Ord, Show, V.TypedSExpr, V.SMTOrd)\n\ninstance V.Fresh (Symbolic a)\n where\n fresh = V.freshSExpr\n\nsymbCast :: Symbolic a -> Symbolic b\nsymbCast = Symbolic . unSymbolic\n\nsymbFun :: SymbParam a => String -> [Symbolic a] -> Symbolic a\nsymbFun name (args :: [Symbolic a]) = V.fromSMT $\n SMT.fun (symbType (undefined :: a) ++ \"-\" ++ name) (map V.toSMT args)\n\nfromComplexConstant :: (RealFrac a, SymbParam b) => Complex.Complex a -> Symbolic b\nfromComplexConstant c = symbFun \"complex\" [real, imag]\n where\n real = Symbolic $ fromRational $ toRational $ Complex.realPart c\n imag = Symbolic $ fromRational $ toRational $ Complex.imagPart c\n\n--------------------------------------------------------------------------------\n\ndata SymbFloat\ndata SymbDouble\ndata SymbComplexFloat\ndata SymbComplexDouble\n\nclass SymbParam a\n where\n symbType :: a -> String\n\ninstance SymbParam SymbFloat where symbType _ = \"float\"\ninstance SymbParam SymbDouble where symbType _ = \"double\"\ninstance SymbParam SymbComplexFloat where symbType _ = \"cfloat\"\ninstance SymbParam SymbComplexDouble where symbType _ = \"cdouble\"\n\ninstance SymbParam a => Num (Symbolic a)\n where\n fromInteger = Symbolic . fromInteger\n x + y = symbFun \"+\" [x, y]\n x - y = symbFun \"-\" [x, y]\n x * y = symbFun \"*\" [x, y]\n abs = smtAbs\n signum = smtSignum\n\ninstance SymbParam a => Fractional (Symbolic a) where\n fromRational = Symbolic . fromRational\n x / y = symbFun \"/\" [x, y]\n\ninstance SymbParam a => Floating (Symbolic a) where\n pi = fromRational (toRational pi)\n exp x = symbFun \"exp\" [x]\n log x = symbFun \"log\" [x]\n sqrt x = symbFun \"sqrt\" [x]\n x ** y = symbFun \"pow\" [x, y]\n sin x = symbFun \"sin\" [x]\n cos x = symbFun \"cos\" [x]\n tan x = symbFun \"tan\" [x]\n asin x = symbFun \"asin\" [x]\n acos x = symbFun \"acos\" [x]\n atan x = symbFun \"atan\" [x]\n sinh x = symbFun \"sinh\" [x]\n cosh x = symbFun \"cosh\" [x]\n tanh x = symbFun \"tanh\" [x]\n asinh x = symbFun \"asinh\" [x]\n acosh x = symbFun \"acosh\" [x]\n atanh x = symbFun \"atanh\" [x]\n\n--------------------------------------------------------------------------------\n\nclass Floating a => Complex a\n where\n type RealPart a\n complex :: RealPart a -> RealPart a -> a\n polar :: RealPart a -> RealPart a -> a\n real :: a -> RealPart a\n imag :: a -> RealPart a\n magnitude :: a -> RealPart a\n phase :: a -> RealPart a\n conjugate :: a -> a\n\ninstance Complex (V.SMTExpr Prim (Complex.Complex Float))\n where\n type RealPart (V.SMTExpr Prim (Complex.Complex Float)) = V.SMTExpr Prim Float\n complex (Float x) (Float y) = ComplexFloat (complex x y)\n polar (Float x) (Float y) = ComplexFloat (polar x y)\n real (ComplexFloat x) = Float (real x)\n imag (ComplexFloat x) = Float (imag x)\n magnitude (ComplexFloat x) = Float (magnitude x)\n phase (ComplexFloat x) = Float (phase x)\n conjugate (ComplexFloat x) = ComplexFloat (conjugate x)\n\ninstance Complex (V.SMTExpr Prim (Complex.Complex Double))\n where\n type RealPart (V.SMTExpr Prim (Complex.Complex Double)) = V.SMTExpr Prim Double\n complex (Double x) (Double y) = ComplexDouble (complex x y)\n polar (Double x) (Double y) = ComplexDouble (polar x y)\n real (ComplexDouble x) = Double (real x)\n imag (ComplexDouble x) = Double (imag x)\n magnitude (ComplexDouble x) = Double (magnitude x)\n phase (ComplexDouble x) = Double (phase x)\n conjugate (ComplexDouble x) = ComplexDouble (conjugate x)\n\nwitnessComplex :: (SoftwarePrimType a, SoftwarePrimType (Complex.Complex a)) =>\n Prim (Complex.Complex a) ->\n Dict ( Floating (V.SMTExpr Prim a)\n , Complex (V.SMTExpr Prim (Complex.Complex a))\n , RealPart (V.SMTExpr Prim (Complex.Complex a)) ~ V.SMTExpr Prim a)\nwitnessComplex (_ :: Prim (Complex.Complex a)) =\n case softwareRep :: SoftwarePrimTypeRep (Complex.Complex a) of\n ComplexFloatST -> Dict\n ComplexDoubleST -> Dict\n\nwitnessFractional :: (SoftwarePrimType a, Fractional a) =>\n Prim a ->\n Dict (Floating (V.SMTExpr Prim a))\nwitnessFractional (_ :: Prim a) = case softwareRep :: SoftwarePrimTypeRep a of\n FloatST -> Dict\n DoubleST -> Dict\n ComplexFloatST -> Dict\n ComplexDoubleST -> Dict\n\nwitnessIntegral :: (SoftwarePrimType a, Integral a) =>\n Prim a ->\n Dict (Integral (V.SMTExpr Prim a), Bits (V.SMTExpr Prim a))\nwitnessIntegral (_ :: Prim a) = case softwareRep :: SoftwarePrimTypeRep a of\n Int8ST -> Dict\n Int16ST -> Dict\n Int32ST -> Dict\n Int64ST -> Dict\n Word8ST -> Dict\n Word16ST -> Dict\n Word32ST -> Dict\n Word64ST -> Dict\n\nwitnessBits :: (SoftwarePrimType a, Bits.Bits a) =>\n Prim a ->\n Dict ( Num a\n , Integral (V.SMTExpr Prim a)\n , Bits (V.SMTExpr Prim a))\nwitnessBits (_ :: Prim a) = case softwareRep :: SoftwarePrimTypeRep a of\n Int8ST -> Dict\n Int16ST -> Dict\n Int32ST -> Dict\n Int64ST -> Dict\n Word8ST -> Dict\n Word16ST -> Dict\n Word32ST -> Dict\n Word64ST -> Dict\n\n--------------------------------------------------------------------------------\n\ntoRat :: (SoftwarePrimType a, Fractional a) => V.SMTExpr Prim a -> Rat\ntoRat (x :: V.SMTExpr Prim a) = case softwareRep :: SoftwarePrimTypeRep a of\n FloatST -> let Float (Symbolic y) = x in y\n DoubleST -> let Double (Symbolic y) = x in y\n ComplexFloatST -> let ComplexFloat (Symbolic y) = x in y\n ComplexDoubleST -> let ComplexDouble (Symbolic y) = x in y\n\nfromRat :: forall a. (SoftwarePrimType a, Num a) => Rat -> V.SMTExpr Prim a\nfromRat x = case softwareRep :: SoftwarePrimTypeRep a of Int8ST -> Int8 (f2i x)\n where\n f2i :: forall s w. (Sign s, Width w) => Rat -> BV s w\n f2i (Rat x) = BV $ SMT.List [SMT.fam \"int2bv\" [width (undefined :: w)], SMT.fun \"to_int\" [x]]\n\ni2n :: forall a b.\n ( V.SMTEval Prim a, SoftwarePrimType a, Integral a\n , V.SMTEval Prim b, SoftwarePrimType b, Num b) =>\n V.SMTExpr Prim a ->\n V.SMTExpr Prim b\ni2n x = toBV x $ case softwareRep :: SoftwarePrimTypeRep b of\n Int8ST -> Int8 . i2i\n Int16ST -> Int16 . i2i\n Int32ST -> Int32 . i2i\n Int64ST -> Int64 . i2i\n Word8ST -> Word8 . i2i\n Word16ST -> Word16 . i2i\n Word32ST -> Word32 . i2i\n Word64ST -> Word64 . i2i\n FloatST -> Float . Symbolic . i2f\n DoubleST -> Double . Symbolic . i2f\n ComplexFloatST -> ComplexFloat . Symbolic . i2f\n ComplexDoubleST -> ComplexDouble . Symbolic . i2f\n where\n toBV :: forall a b. (V.SMTEval Prim a, SoftwarePrimType a, Integral a) =>\n V.SMTExpr Prim a -> (forall s w. (Sign s, Width w) => BV s w -> b) -> b\n toBV (x :: V.SMTExpr Prim a) k = case softwareRep :: SoftwarePrimTypeRep a of\n Int8ST -> let Int8 y = x in k y\n Int16ST -> let Int16 y = x in k y\n Int32ST -> let Int32 y = x in k y\n Int64ST -> let Int64 y = x in k y\n Word8ST -> let Word8 y = x in k y\n Word16ST -> let Word16 y = x in k y\n Word32ST -> let Word32 y = x in k y\n Word64ST -> let Word64 y = x in k y\n\n i2f :: (Sign s, Width w) => BV s w -> Rat\n i2f (BV x) = Rat (SMT.fun \"to_real\" [SMT.fun \"bv2int\" [x]])\n\n i2i :: forall s1 w1 s2 w2. (Sign s1, Width w1, Sign s2, Width w2) => BV s1 w1 -> BV s2 w2\n i2i x = case compare m n of\n LT | isSigned x -> V.fromSMT (SMT.signExtend (n-m) (V.toSMT x))\n | otherwise -> V.fromSMT (SMT.zeroExtend (n-m) (V.toSMT x))\n EQ -> V.fromSMT (V.toSMT x)\n GT -> V.fromSMT (SMT.extract (V.toSMT x) (n-1) 0)\n where\n m = width (undefined :: w1)\n n = width (undefined :: w2)\n\n--------------------------------------------------------------------------------\n\nclass SymbParam a => SymbComplex a\n where\n type SymbRealPart a\n\ninstance SymbComplex SymbComplexFloat\n where\n type SymbRealPart SymbComplexFloat = SymbFloat\n\ninstance SymbComplex SymbComplexDouble\n where\n type SymbRealPart SymbComplexDouble = SymbDouble\n\ninstance SymbComplex a => Complex (Symbolic a)\n where\n type RealPart (Symbolic a) = Symbolic (SymbRealPart a)\n complex x y = symbFun \"complex\" [symbCast x, symbCast y]\n polar x y = symbFun \"polar\" [symbCast x, symbCast y]\n real x = symbCast (symbFun \"real\" [x])\n imag x = symbCast (symbFun \"imag\" [x])\n magnitude x = symbCast (symbFun \"magnitude\" [x])\n phase x = symbCast (symbFun \"phase\" [x])\n conjugate x = symbFun \"conjugate\" [x]\n\n--------------------------------------------------------------------------------\n\ndeclareSymbFun :: SymbParam a => String -> a ->\n [SMT.SExpr] -> SMT.SExpr -> SMT.SMT ()\ndeclareSymbFun name (_ :: a) args res =\n S.void $ SMT.declareFun (symbType (undefined :: a) ++ \"-\" ++ name) args res\n\ndeclareSymbArith :: SymbParam a => a -> SMT.SMT ()\ndeclareSymbArith x = do\n declareSymbFun \"+\" x [SMT.tReal, SMT.tReal] SMT.tReal\n declareSymbFun \"-\" x [SMT.tReal, SMT.tReal] SMT.tReal\n declareSymbFun \"*\" x [SMT.tReal, SMT.tReal] SMT.tReal\n declareSymbFun \"/\" x [SMT.tReal, SMT.tReal] SMT.tReal\n declareSymbFun \"exp\" x [SMT.tReal] SMT.tReal\n declareSymbFun \"log\" x [SMT.tReal] SMT.tReal\n declareSymbFun \"sqrt\" x [SMT.tReal] SMT.tReal\n declareSymbFun \"pow\" x [SMT.tReal, SMT.tReal] SMT.tReal\n declareSymbFun \"sin\" x [SMT.tReal] SMT.tReal\n declareSymbFun \"cos\" x [SMT.tReal] SMT.tReal\n declareSymbFun \"tan\" x [SMT.tReal] SMT.tReal\n declareSymbFun \"asin\" x [SMT.tReal] SMT.tReal\n declareSymbFun \"acos\" x [SMT.tReal] SMT.tReal\n declareSymbFun \"atan\" x [SMT.tReal] SMT.tReal\n declareSymbFun \"sinh\" x [SMT.tReal] SMT.tReal\n declareSymbFun \"cosh\" x [SMT.tReal] SMT.tReal\n declareSymbFun \"tanh\" x [SMT.tReal] SMT.tReal\n declareSymbFun \"asinh\" x [SMT.tReal] SMT.tReal\n declareSymbFun \"acosh\" x [SMT.tReal] SMT.tReal\n declareSymbFun \"atanh\" x [SMT.tReal] SMT.tReal\n\ndeclareSymbComplex :: SymbParam a => a -> SMT.SMT ()\ndeclareSymbComplex x = do\n declareSymbArith x\n declareSymbFun \"complex\" x [SMT.tReal, SMT.tReal] SMT.tReal\n declareSymbFun \"polar\" x [SMT.tReal, SMT.tReal] SMT.tReal\n declareSymbFun \"real\" x [SMT.tReal] SMT.tReal\n declareSymbFun \"imag\" x [SMT.tReal] SMT.tReal\n declareSymbFun \"magnitude\" x [SMT.tReal] SMT.tReal\n declareSymbFun \"phase\" x [SMT.tReal] SMT.tReal\n declareSymbFun \"conjugate\" x [SMT.tReal] SMT.tReal\n\ndeclareFeldsparGlobals :: SMT.SMT ()\ndeclareFeldsparGlobals = do\n declareSymbArith (undefined :: SymbFloat)\n declareSymbArith (undefined :: SymbDouble)\n declareSymbComplex (undefined :: SymbComplexFloat)\n declareSymbComplex (undefined :: SymbComplexDouble)\n SMT.declareFun \"skolem-int8\" [] (SMT.tBits 8)\n SMT.declareFun \"skolem-int16\" [] (SMT.tBits 16)\n SMT.declareFun \"skolem-int32\" [] (SMT.tBits 32)\n SMT.declareFun \"skolem-int64\" [] (SMT.tBits 64)\n SMT.declareFun \"skolem-word8\" [] (SMT.tBits 8)\n SMT.declareFun \"skolem-word16\" [] (SMT.tBits 16)\n SMT.declareFun \"skolem-word32\" [] (SMT.tBits 32)\n SMT.declareFun \"skolem-word64\" [] (SMT.tBits 64)\n return ()\n\ninstance FO.Substitute Prim\n where\n type SubstPred Prim = SoftwarePrimType\n subst sub (Prim exp) = Prim (everywhereUp f exp)\n where\n f :: ASTF SoftwarePrimDomain a -> ASTF SoftwarePrimDomain a\n f (Sym (FreeVar x :&: ty)) = case FO.lookupSubst sub (Imp.ValComp x) of\n Imp.ValComp y -> Sym (FreeVar y :&: ty)\n Imp.ValRun z -> Sym (Lit z :&: ty)\n f (Sym (ArrIx iarr :&: ty) :$ i) = Sym (ArrIx iarr' :&: ty) :$ i\n where iarr' = FO.lookupSubst sub iarr\n f x = x\n\ninstance FO.TypeablePred SoftwarePrimType\n where\n witnessTypeable Dict = Dict\n\n--------------------------------------------------------------------------------\n\ninstance V.SMTEval Prim Bool where\n fromConstant = Bool . SMT.bool\n witnessOrd _ = Dict\n\ninstance V.SMTEval Prim Int8 where\n fromConstant = Int8 . fromIntegral\n witnessNum _ = Dict\n witnessOrd _ = Dict\n skolemIndex = V.fromSMT (SMT.fun \"skolem-int8\" [])\n\ninstance V.SMTEval Prim Int16 where\n fromConstant = Int16 . fromIntegral\n witnessNum _ = Dict\n witnessOrd _ = Dict\n skolemIndex = V.fromSMT (SMT.fun \"skolem-int16\" [])\n\ninstance V.SMTEval Prim Int32 where\n fromConstant = Int32 . fromIntegral\n witnessNum _ = Dict\n witnessOrd _ = Dict\n skolemIndex = V.fromSMT (SMT.fun \"skolem-int32\" [])\n\ninstance V.SMTEval Prim Int64 where\n fromConstant = Int64 . fromIntegral\n witnessNum _ = Dict\n witnessOrd _ = Dict\n skolemIndex = V.fromSMT (SMT.fun \"skolem-int64\" [])\n\ninstance V.SMTEval Prim Word8 where\n fromConstant = Word8 . fromIntegral\n witnessNum _ = Dict\n witnessOrd _ = Dict\n skolemIndex = V.fromSMT (SMT.fun \"skolem-word8\" [])\n\ninstance V.SMTEval Prim Word16 where\n fromConstant = Word16 . fromIntegral\n witnessNum _ = Dict\n witnessOrd _ = Dict\n skolemIndex = V.fromSMT (SMT.fun \"skolem-word16\" [])\n\ninstance V.SMTEval Prim Word32 where\n fromConstant = Word32 . fromIntegral\n witnessNum _ = Dict\n witnessOrd _ = Dict\n skolemIndex = V.fromSMT (SMT.fun \"skolem-word32\" [])\n\ninstance V.SMTEval Prim Word64 where\n fromConstant = Word64 . fromIntegral\n witnessNum _ = Dict\n witnessOrd _ = Dict\n skolemIndex = V.fromSMT (SMT.fun \"skolem-word64\" [])\n\ninstance V.SMTEval Prim Float where\n fromConstant = Float . fromRational . toRational\n witnessOrd _ = Dict\n witnessNum _ = Dict\n\ninstance V.SMTEval Prim Double where\n fromConstant = Double . fromRational . toRational\n witnessOrd _ = Dict\n witnessNum _ = Dict\n\ninstance V.SMTEval Prim (Complex.Complex Float) where\n fromConstant = ComplexFloat . fromComplexConstant\n witnessNum _ = Dict\n\ninstance V.SMTEval Prim (Complex.Complex Double) where\n fromConstant = ComplexDouble . fromComplexConstant\n witnessNum _ = Dict\n\n--------------------------------------------------------------------------------\n\ninstance V.SMTEval1 Prim where\n type Pred Prim = SoftwarePrimType\n newtype SMTExpr Prim Bool = Bool SMT.SExpr\n deriving (Typeable)\n newtype SMTExpr Prim Float = Float (Symbolic SymbFloat)\n deriving (Typeable, Num, Fractional, Floating, V.SMTOrd, V.TypedSExpr)\n newtype SMTExpr Prim Double = Double (Symbolic SymbDouble)\n deriving (Typeable, Num, Fractional, Floating, V.SMTOrd, V.TypedSExpr)\n newtype SMTExpr Prim (Complex.Complex Float) =\n ComplexFloat (Symbolic SymbComplexFloat)\n deriving (Typeable, Num, Fractional, Floating, V.TypedSExpr)\n newtype SMTExpr Prim (Complex.Complex Double) =\n ComplexDouble (Symbolic SymbComplexDouble)\n deriving (Typeable, Num, Fractional, Floating, V.TypedSExpr)\n newtype SMTExpr Prim Int8 = Int8 (BV Signed W8)\n deriving (Typeable, Num, Real, Enum, Integral, Bits, V.SMTOrd, V.TypedSExpr)\n newtype SMTExpr Prim Int16 = Int16 (BV Signed W16)\n deriving (Typeable, Num, Real, Enum, Integral, Bits, V.SMTOrd, V.TypedSExpr)\n newtype SMTExpr Prim Int32 = Int32 (BV Signed W32)\n deriving (Typeable, Num, Real, Enum, Integral, Bits, V.SMTOrd, V.TypedSExpr)\n newtype SMTExpr Prim Int64 = Int64 (BV Signed W64)\n deriving (Typeable, Num, Real, Enum, Integral, Bits, V.SMTOrd, V.TypedSExpr)\n newtype SMTExpr Prim Word8 = Word8 (BV Unsigned W8)\n deriving (Typeable, Num, Real, Enum, Integral, Bits, V.SMTOrd, V.TypedSExpr)\n newtype SMTExpr Prim Word16 = Word16 (BV Unsigned W16)\n deriving (Typeable, Num, Real, Enum, Integral, Bits, V.SMTOrd, V.TypedSExpr)\n newtype SMTExpr Prim Word32 = Word32 (BV Unsigned W32)\n deriving (Typeable, Num, Real, Enum, Integral, Bits, V.SMTOrd, V.TypedSExpr)\n newtype SMTExpr Prim Word64 = Word64 (BV Unsigned W64)\n deriving (Typeable, Num, Real, Enum, Integral, Bits, V.SMTOrd, V.TypedSExpr)\n\n eval (Prim exp :: Prim a) =\n simpleMatch (\\(exp :&: ty) -> case softwarePrimWitType ty of\n Dict -> case V.witnessPred (undefined :: Prim a) of\n Dict -> verifyPrim exp) exp\n\n witnessPred (_ :: Prim a) = case softwareRep :: SoftwarePrimTypeRep a of\n BoolST -> Dict\n Int8ST -> Dict\n Int16ST -> Dict\n Int32ST -> Dict\n Int64ST -> Dict\n Word8ST -> Dict\n Word16ST -> Dict\n Word32ST -> Dict\n Word64ST -> Dict\n FloatST -> Dict\n DoubleST -> Dict\n ComplexFloatST -> Dict\n ComplexDoubleST -> Dict\n\ninstance V.SMTOrd (V.SMTExpr Prim Bool) where\n Bool x .<. Bool y = SMT.not x SMT..&&. y\n Bool x .>. Bool y = x SMT..&&. SMT.not y\n Bool x .<=. Bool y = SMT.not x SMT..||. y\n Bool x .>=. Bool y = x SMT..||. SMT.not y\n\ninstance V.TypedSExpr (V.SMTExpr Prim Bool) where\n smtType _ = SMT.tBool\n toSMT (Bool x) = x\n fromSMT x = Bool x\n\n--------------------------------------------------------------------------------\n\nverifyPrim :: forall a .\n (SoftwarePrimType (DenResult a), V.SMTEval Prim (DenResult a), HasCallStack) =>\n SoftwarePrim a ->\n Args (AST SoftwarePrimDomain) a ->\n V.Verify (V.SMTExpr Prim (DenResult a))\nverifyPrim (FreeVar x) _ = peekValue x\nverifyPrim (Lit x) _ = return (V.fromConstant x)\nverifyPrim Add (x :* y :* Nil)\n | Dict <- V.witnessNum (undefined :: Prim (DenResult a)) =\n S.liftM2 (+) (V.eval (Prim x)) (V.eval (Prim y))\nverifyPrim Sub (x :* y :* Nil)\n | Dict <- V.witnessNum (undefined :: Prim (DenResult a)) =\n S.liftM2 (-) (V.eval (Prim x)) (V.eval (Prim y))\nverifyPrim Mul (x :* y :* Nil)\n | Dict <- V.witnessNum (undefined :: Prim (DenResult a)) =\n S.liftM2 (*) (V.eval (Prim x)) (V.eval (Prim y))\nverifyPrim Neg (x :* Nil)\n | Dict <- V.witnessNum (undefined :: Prim (DenResult a)) =\n fmap negate (V.eval (Prim x))\nverifyPrim Abs (x :* Nil)\n | Dict <- V.witnessNum (undefined :: Prim (DenResult a)) =\n fmap abs (V.eval (Prim x))\nverifyPrim Sign (x :* Nil)\n | Dict <- V.witnessNum (undefined :: Prim (DenResult a)) =\n fmap signum (V.eval (Prim x))\nverifyPrim Div (x :* y :* Nil)\n | Dict <- witnessIntegral (undefined :: Prim (DenResult a)) =\n S.liftM2 div (V.eval (Prim x)) (V.eval (Prim y))\nverifyPrim Mod (x :* y :* Nil)\n | Dict <- witnessIntegral (undefined :: Prim (DenResult a)) =\n S.liftM2 mod (V.eval (Prim x)) (V.eval (Prim y))\nverifyPrim Quot (x :* y :* Nil)\n | Dict <- witnessIntegral (undefined :: Prim (DenResult a)) =\n S.liftM2 quot (V.eval (Prim x)) (V.eval (Prim y))\nverifyPrim Rem (x :* y :* Nil)\n | Dict <- witnessIntegral (undefined :: Prim (DenResult a)) =\n S.liftM2 rem (V.eval (Prim x)) (V.eval (Prim y))\nverifyPrim FDiv (x :* y :* Nil)\n | Dict <- witnessFractional (undefined :: Prim (DenResult a)) =\n S.liftM2 (/) (V.eval (Prim x)) (V.eval (Prim y))\nverifyPrim Pi Nil\n | Dict <- witnessFractional (undefined :: Prim (DenResult a)) =\n return pi\nverifyPrim Exp (x :* Nil)\n | Dict <- witnessFractional (undefined :: Prim (DenResult a)) =\n fmap exp (V.eval (Prim x))\nverifyPrim Log (x :* Nil)\n | Dict <- witnessFractional (undefined :: Prim (DenResult a)) =\n fmap log (V.eval (Prim x))\nverifyPrim Sqrt (x :* Nil)\n | Dict <- witnessFractional (undefined :: Prim (DenResult a)) =\n fmap sqrt (V.eval (Prim x))\nverifyPrim Pow (x :* y :* Nil)\n | Dict <- witnessFractional (undefined :: Prim (DenResult a)) =\n S.liftM2 (**) (V.eval (Prim x)) (V.eval (Prim y))\nverifyPrim Sin (x :* Nil)\n | Dict <- witnessFractional (undefined :: Prim (DenResult a)) =\n fmap sin (V.eval (Prim x))\nverifyPrim Cos (x :* Nil)\n | Dict <- witnessFractional (undefined :: Prim (DenResult a)) =\n fmap cos (V.eval (Prim x))\nverifyPrim Tan (x :* Nil)\n | Dict <- witnessFractional (undefined :: Prim (DenResult a)) =\n fmap tan (V.eval (Prim x))\nverifyPrim Asin (x :* Nil)\n | Dict <- witnessFractional (undefined :: Prim (DenResult a)) =\n fmap asin (V.eval (Prim x))\nverifyPrim Acos (x :* Nil)\n | Dict <- witnessFractional (undefined :: Prim (DenResult a)) =\n fmap acos (V.eval (Prim x))\nverifyPrim Atan (x :* Nil)\n | Dict <- witnessFractional (undefined :: Prim (DenResult a)) =\n fmap atan (V.eval (Prim x))\nverifyPrim Sinh (x :* Nil)\n | Dict <- witnessFractional (undefined :: Prim (DenResult a)) =\n fmap sinh (V.eval (Prim x))\nverifyPrim Cosh (x :* Nil)\n | Dict <- witnessFractional (undefined :: Prim (DenResult a)) =\n fmap cosh (V.eval (Prim x))\nverifyPrim Tanh (x :* Nil)\n | Dict <- witnessFractional (undefined :: Prim (DenResult a)) =\n fmap tanh (V.eval (Prim x))\nverifyPrim Asinh (x :* Nil)\n | Dict <- witnessFractional (undefined :: Prim (DenResult a)) =\n fmap asinh (V.eval (Prim x))\nverifyPrim Acosh (x :* Nil)\n | Dict <- witnessFractional (undefined :: Prim (DenResult a)) =\n fmap acosh (V.eval (Prim x))\nverifyPrim Atanh (x :* Nil)\n | Dict <- witnessFractional (undefined :: Prim (DenResult a)) =\n fmap atanh (V.eval (Prim x))\nverifyPrim Complex (x :* y :* Nil)\n | Dict <- witnessComplex (undefined :: Prim (DenResult a)) =\n S.liftM2 complex (V.eval (Prim x)) (V.eval (Prim y))\nverifyPrim Polar (x :* y :* Nil)\n | Dict <- witnessComplex (undefined :: Prim (DenResult a)) =\n S.liftM2 polar (V.eval (Prim x)) (V.eval (Prim y))\nverifyPrim Real ((x :: ASTF SoftwarePrimDomain b) :* Nil)\n | Dict <- witnessComplex (undefined :: Prim b) =\n fmap real (V.eval (Prim x))\nverifyPrim Imag ((x :: ASTF SoftwarePrimDomain b) :* Nil)\n | Dict <- witnessComplex (undefined :: Prim b) =\n fmap imag (V.eval (Prim x))\nverifyPrim Magnitude ((x :: ASTF SoftwarePrimDomain b) :* Nil)\n | Dict <- witnessComplex (undefined :: Prim b) =\n fmap magnitude (V.eval (Prim x))\nverifyPrim Phase ((x :: ASTF SoftwarePrimDomain b) :* Nil)\n | Dict <- witnessComplex (undefined :: Prim b) =\n fmap phase (V.eval (Prim x))\nverifyPrim Conjugate ((x :: ASTF SoftwarePrimDomain b) :* Nil)\n | Dict <- witnessComplex (undefined :: Prim b) =\n fmap conjugate (V.eval (Prim x))\nverifyPrim I2N ((x :: ASTF SoftwarePrimDomain b) :* Nil)\n | Dict <- V.witnessPred (undefined :: Prim b),\n Dict <- V.witnessNum (undefined :: Prim b) = do\n fmap i2n (V.eval (Prim x))\nverifyPrim I2B ((x :: ASTF SoftwarePrimDomain b) :* Nil)\n | Dict <- V.witnessPred (undefined :: Prim b),\n Dict <- V.witnessNum (undefined :: Prim b) = do\n x <- V.eval (Prim x)\n return (V.fromSMT (SMT.not (x V..==. 0)))\nverifyPrim B2I (x :* Nil)\n | Dict <- V.witnessNum (undefined :: Prim (DenResult a)) = do\n x <- V.eval (Prim x)\n return (V.smtIte (V.toSMT x) 1 0)\nverifyPrim Round ((x :: ASTF SoftwarePrimDomain b) :* Nil) = do\n x <- V.eval (Prim x)\n return (fromRat (toRat x))\nverifyPrim Not (x :* Nil) =\n fmap (V.fromSMT . SMT.not . V.toSMT) (V.eval (Prim x))\nverifyPrim And (x :* y :* Nil) = do\n x <- V.eval (Prim x)\n y <- V.eval (Prim y)\n return (V.fromSMT (V.toSMT x SMT..&&. V.toSMT y))\nverifyPrim Or (x :* y :* Nil) = do\n x <- V.eval (Prim x)\n y <- V.eval (Prim y)\n return (V.fromSMT (V.toSMT x SMT..||. V.toSMT y))\nverifyPrim Eq ((x :: ASTF SoftwarePrimDomain b) :* y :* Nil)\n | Dict <- V.witnessPred (undefined :: Prim b) =\n fmap V.fromSMT (S.liftM2 (V..==.) (V.eval (Prim x)) (V.eval (Prim y)))\nverifyPrim Neq ((x :: ASTF SoftwarePrimDomain b) :* y :* Nil)\n | Dict <- V.witnessPred (undefined :: Prim b) =\n fmap V.fromSMT (S.liftM2 (./=.) (V.eval (Prim x)) (V.eval (Prim y)))\n where\n x ./=. y = SMT.not (x V..==. y)\nverifyPrim Lt ((x :: ASTF SoftwarePrimDomain b) :* y :* Nil)\n | Dict <- V.witnessPred (undefined :: Prim b),\n Dict <- V.witnessOrd (undefined :: Prim b) =\n fmap V.fromSMT (S.liftM2 (V..<.) (V.eval (Prim x)) (V.eval (Prim y)))\nverifyPrim Gt ((x :: ASTF SoftwarePrimDomain b) :* y :* Nil)\n | Dict <- V.witnessPred (undefined :: Prim b),\n Dict <- V.witnessOrd (undefined :: Prim b) =\n fmap V.fromSMT (S.liftM2 (V..>.) (V.eval (Prim x)) (V.eval (Prim y)))\nverifyPrim Lte ((x :: ASTF SoftwarePrimDomain b) :* y :* Nil)\n | Dict <- V.witnessPred (undefined :: Prim b),\n Dict <- V.witnessOrd (undefined :: Prim b) =\n fmap V.fromSMT (S.liftM2 (V..<=.) (V.eval (Prim x)) (V.eval (Prim y)))\nverifyPrim Gte ((x :: ASTF SoftwarePrimDomain b) :* y :* Nil)\n | Dict <- V.witnessPred (undefined :: Prim b),\n Dict <- V.witnessOrd (undefined :: Prim b) =\n fmap V.fromSMT (S.liftM2 (V..>=.) (V.eval (Prim x)) (V.eval (Prim y)))\nverifyPrim BitAnd (x :* y :* Nil)\n | Dict <- witnessBits (undefined :: Prim (DenResult a)) =\n S.liftM2 (.&.) (V.eval (Prim x)) (V.eval (Prim y))\nverifyPrim BitOr (x :* y :* Nil)\n | Dict <- witnessBits (undefined :: Prim (DenResult a)) =\n S.liftM2 (.|.) (V.eval (Prim x)) (V.eval (Prim y))\nverifyPrim BitXor (x :* y :* Nil)\n | Dict <- witnessBits (undefined :: Prim (DenResult a)) =\n S.liftM2 xor (V.eval (Prim x)) (V.eval (Prim y))\nverifyPrim BitCompl (x :* Nil)\n | Dict <- witnessBits (undefined :: Prim (DenResult a)) =\n fmap complement (V.eval (Prim x))\nverifyPrim ShiftL (x :* (y :: ASTF SoftwarePrimDomain b) :* Nil)\n | Dict <- witnessBits (undefined :: Prim (DenResult a)),\n Dict <- V.witnessPred (undefined :: Prim b),\n Dict <- witnessIntegral (undefined :: Prim b) = do\n -- todo: should check for undefined behaviour\n x <- V.eval (Prim x)\n y <- V.eval (Prim y)\n return (shiftL x (i2n y))\nverifyPrim ShiftR (x :* (y :: ASTF SoftwarePrimDomain b) :* Nil)\n | Dict <- witnessBits (undefined :: Prim (DenResult a)),\n Dict <- V.witnessPred (undefined :: Prim b),\n Dict <- witnessIntegral (undefined :: Prim b) = do\n -- todo: should check for undefined behaviour\n x <- V.eval (Prim x)\n y <- V.eval (Prim y)\n return (shiftR x (i2n y))\nverifyPrim (ArrIx (Imp.IArrComp name :: Imp.IArr Index b)) (i :* Nil) = do\n i <- V.eval (Prim i)\n readArray name i\nverifyPrim Cond (cond :* x :* y :* Nil) =\n S.liftM3 V.smtIte\n (fmap V.toSMT (V.eval (Prim cond)))\n (V.eval (Prim x))\n (V.eval (Prim y))\nverifyPrim exp _ = error (\"Unimplemented: \" ++ show exp)\n\n--------------------------------------------------------------------------------\n", "meta": {"hexsha": "fecf2284ba30b8b1475ff476adc9bc7e0e07780e", "size": 27307, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/Feldspar/Software/Verify/Primitive.hs", "max_stars_repo_name": "markus-git/co-feldspar", "max_stars_repo_head_hexsha": "580c693f0c80505ad879e4363c715464c5e04aab", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 8, "max_stars_repo_stars_event_min_datetime": "2016-08-17T13:31:32.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-30T14:16:09.000Z", "max_issues_repo_path": "src/Feldspar/Software/Verify/Primitive.hs", "max_issues_repo_name": "markus-git/co-feldspar", "max_issues_repo_head_hexsha": "580c693f0c80505ad879e4363c715464c5e04aab", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2021-06-05T23:49:58.000Z", "max_issues_repo_issues_event_max_datetime": "2021-07-12T17:10:33.000Z", "max_forks_repo_path": "src/Feldspar/Software/Verify/Primitive.hs", "max_forks_repo_name": "markus-git/co-feldspar", "max_forks_repo_head_hexsha": "580c693f0c80505ad879e4363c715464c5e04aab", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2017-09-12T13:36:02.000Z", "max_forks_repo_forks_event_max_datetime": "2021-06-30T14:16:26.000Z", "avg_line_length": 38.8988603989, "max_line_length": 97, "alphanum_fraction": 0.6327681547, "num_tokens": 8589, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6992544335934766, "lm_q2_score": 0.46101677931231594, "lm_q1q2_score": 0.3223680268951223}} {"text": "{-#OPTIONS_GHC -w#-}\nmodule Plots (plotAndSave2D') where\n\n-- import Data.Colour\n-- import Data.Colour.Names\nimport Graphics.Rendering.Chart.Backend.Cairo\nimport Graphics.Rendering.Chart.Easy\nimport Numeric.LinearAlgebra as L (Vector (..), size,\n toList)\nimport System.FilePath (takeBaseName)\n\nplotAndSave2D' :: FilePath\n -> Int\n -> Int\n -> (Int, Int)\n -> [L.Vector Double]\n -> IO ()\nplotAndSave2D' file len basePoint (gn, pn) results =\n if (L.size . head $ results) /= 2\n then error \"This function only works for 2D points!\"\n else do\n putStrLn \"Plotting...\"\n toFile def plotFileName $ chartPlot2D results'\n putStrLn $ \"Writing data points to file: \" ++ dataFileName\n pp2DResults' dataFileName results'\n where\n actualFileName = takeBaseName file\n baseOutputName = actualFileName ++ \"-\"\n ++ \"base\" ++ show basePoint ++\n \"-\" ++ show gn ++ \"-\" ++ show pn\n plotFileName = baseOutputName ++ \".png\"\n dataFileName = baseOutputName ++ \".txt\"\n results' = map ((\\[a, b] -> (a, b)) . L.toList) results\n\nchartPlot2D results = do\n layout_title .= \"Normal Coordinates\"\n setColors [opaque red]\n plot (points \"points\" results)\n\npp2DResults' :: FilePath -> [(Double,Double)] -> IO ()\npp2DResults' file xs = writeFile file . transPairLine $ xs\n where\n transPairLine = concatMap (\\x -> show (fst x) ++ \" \" ++ show (snd x) ++ \"\\n\")\n", "meta": {"hexsha": "355402581ff7b1c7f259805d3fbcbdda22e299b3", "size": 1661, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/Plots.hs", "max_stars_repo_name": "emmanueldenloye/manifoldRNC", "max_stars_repo_head_hexsha": "60af1dfe62cac2b6ceb8b33ceaa8d1e572d8c619", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 12, "max_stars_repo_stars_event_min_datetime": "2015-10-29T19:01:57.000Z", "max_stars_repo_stars_event_max_datetime": "2021-08-24T18:04:55.000Z", "max_issues_repo_path": "src/Plots.hs", "max_issues_repo_name": "emmanueldenloye/manifoldRNC", "max_issues_repo_head_hexsha": "60af1dfe62cac2b6ceb8b33ceaa8d1e572d8c619", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/Plots.hs", "max_forks_repo_name": "emmanueldenloye/manifoldRNC", "max_forks_repo_head_hexsha": "60af1dfe62cac2b6ceb8b33ceaa8d1e572d8c619", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2015-10-29T19:24:25.000Z", "max_forks_repo_forks_event_max_datetime": "2016-01-21T18:30:26.000Z", "avg_line_length": 37.75, "max_line_length": 84, "alphanum_fraction": 0.5418422637, "num_tokens": 394, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.5467381519846138, "lm_q2_score": 0.588889130767832, "lm_q1q2_score": 0.32196815507983007}} {"text": "{-# LANGUAGE ConstraintKinds #-}\n{-# LANGUAGE DataKinds #-}\n{-# LANGUAGE DeriveGeneric #-}\n{-# LANGUAGE FlexibleContexts #-}\n{-# LANGUAGE FlexibleInstances #-}\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE OverloadedStrings #-}\n{-# LANGUAGE PolyKinds #-}\n{-# LANGUAGE QuasiQuotes #-}\n{-# LANGUAGE RankNTypes #-}\n{-# LANGUAGE ScopedTypeVariables #-}\n{-# LANGUAGE TemplateHaskell #-}\n{-# LANGUAGE TypeApplications #-}\n{-# LANGUAGE TypeFamilies #-}\n{-# LANGUAGE TypeOperators #-}\n{-# LANGUAGE UndecidableInstances #-}\n{-# LANGUAGE AllowAmbiguousTypes #-}\n{-# LANGUAGE NoMonomorphismRestriction #-}\n{-# LANGUAGE PartialTypeSignatures #-}\n--{-# LANGUAGE MonomorphismRestriction #-}\nmodule Main where\n\nimport DataSources\nimport qualified Frames.Utils as FU\nimport qualified Frames.Folds as FF\nimport qualified Frames.KMeans as KM\nimport qualified Frames.Regression as FR\nimport qualified Frames.MaybeUtils as FM\nimport qualified Frames.VegaLite as FV\nimport qualified Frames.Transform as FT\nimport qualified Frames.Table as Table\nimport qualified Math.Rescale as MR\nimport qualified Frames.MapReduce as MR\n\nimport qualified Knit.Report as K\nimport qualified Knit.Effect.RandomFu as KR\nimport qualified Knit.Effect.Pandoc as K (newPandoc, NamedDoc (..))\nimport qualified Knit.Report.Other.Lucid as KL\n{-\nimport qualified Polysemy as PS\nimport qualified Knit.Effects.Logger as Log\nimport qualified Knit.Effects.PandocMonad as PM\nimport qualified Knit.Effects.Pandoc as PE\nimport Knit.Effects.RandomFu (Random, runRandomIOPureMT)\nimport Knit.Effects.Docs (toNamedDocListWithM)\n--import qualified Knit.Report.Blaze as RB\nimport qualified Knit.Report.Pandoc as RP\nimport qualified Knit.Report.Lucid as RL\n-}\n\nimport qualified Control.Foldl as FL\nimport Control.Monad.IO.Class (MonadIO, liftIO)\nimport Control.Monad (sequence)\nimport Control.Lens ((%~),(^.))\nimport Data.Bool (bool)\nimport qualified Data.Map as M\nimport Data.Maybe (catMaybes, fromJust, fromMaybe)\nimport Data.Monoid ((<>))\nimport qualified Data.Monoid as MO\nimport Data.Proxy (Proxy (..))\nimport qualified Data.Text as T\nimport qualified Data.Text.IO as T\nimport qualified Data.Text.Lazy as TL\nimport qualified Data.Vector as V\nimport qualified Data.Vinyl as V\nimport qualified Data.Vinyl.Functor as V\nimport qualified Data.Vinyl.Class.Method as V\nimport qualified Data.Vinyl.TypeLevel as V\nimport Data.Vinyl.Lens (type (\u2208))\nimport Frames ((:.), (&:))\nimport qualified Frames as F\nimport qualified Frames.CSV as F\nimport qualified Frames.Melt as F\nimport qualified Frames.InCore as FI\nimport qualified Frames.TH as F\nimport qualified Graphics.Vega.VegaLite as GV\nimport qualified Pipes as P\nimport qualified Pipes.Prelude as P\nimport qualified Lucid as HL\nimport qualified Text.Blaze.Html.Renderer.Text as BH\nimport Data.Random.Source.PureMT as R\nimport Data.Random as R\nimport qualified System.Clock as C\nimport qualified Statistics.Types as ST\n-- stage restriction means this all has to be up top\nF.tableTypes' (F.rowGen fipsByCountyFP) { F.rowTypeName = \"FIPSByCountyRenamed\", F.columnNames = [\"fips\",\"County\",\"State\"]}\n\ntype CO_AnalysisVERA_Cols = [Year, State, TotalPop, TotalJailAdm, TotalJailPop, TotalPrisonAdm, TotalPrisonPop]\n \njustsFromRec :: V.RMap fs => F.Record fs -> F.Rec (Maybe :. F.ElField) fs\njustsFromRec = V.rmap (V.Compose . Just)\n\nrDiv :: (Real a, Real b, Fractional c) => a -> b -> c\nrDiv a b = realToFrac a/realToFrac b\n\ntype instance FI.VectorFor (Maybe a) = V.Vector\n\ntype DblX = \"X\" F.:-> Double\ntype DblY = \"Y\" F.:-> Double\n\ntemplateVars = M.fromList\n [\n (\"lang\", \"English\")\n , (\"author\", \"Adam Conner-Sax\")\n , (\"pagetitle\", \"Colorado Incarceration Data Analysis\")\n , (\"tufte\",\"True\")\n ]\n\nmain :: IO ()\nmain = do\n -- create streams which are filtered to CO\n let writeNamedHtml (K.NamedDoc n lt) = T.writeFile (T.unpack $ \"analysis/\" <> n <> \".html\") $ TL.toStrict lt\n writeAllHtml = fmap (const ()) . traverse writeNamedHtml\n pandocWriterConfig = K.PandocWriterConfig (Just \"pandoc-templates/minWithVega-pandoc.html\") templateVars K.mindocOptionsF\n startReal <- C.getTime C.Monotonic\n eitherDocs <- K.knitHtmls (Just \"colorado-analysis.Main\") K.logAll pandocWriterConfig $ KR.runRandomIOPureMT (pureMT 1) $ do\n K.logLE K.Info \"Creating data producers from CSV files\"\n let parserOptions = F.defaultParser { F.quotingMode = F.RFC4180Quoting ' ' }\n veraData :: F.MonadSafe m => P.Producer (FM.MaybeRow IncarcerationTrends) m ()\n veraData = F.readTableMaybeOpt F.defaultParser veraTrendsFP P.>-> P.filter (FU.filterOnMaybeField @State (==\"CO\"))\n povertyData :: F.MonadSafe m => P.Producer SAIPE m ()\n povertyData = F.readTableOpt parserOptions censusSAIPE_FP P.>-> P.filter (FU.filterOnField @Abbreviation (== \"CO\"))\n fipsByCountyData :: F.MonadSafe m => P.Producer FIPSByCountyRenamed m ()\n fipsByCountyData = F.readTableOpt parserOptions fipsByCountyFP P.>-> P.filter (FU.filterOnField @State (== \"CO\"))\n -- NB: This data has 2 rows per county, one for misdemeanors, one for felonies\n countyBondCO_Data :: F.MonadSafe m => P.Producer (FM.MaybeRow CountyBondCO) m ()\n countyBondCO_Data = F.readTableMaybeOpt parserOptions countyBondCO_FP\n countyDistrictCO_Data :: F.MonadSafe m => P.Producer CountyDistrictCO m ()\n countyDistrictCO_Data = F.readTableOpt parserOptions countyDistrictCrosswalkCO_FP\n -- This data has 3 rows per county and year, one for each type of crime (against persons, against property, against society)\n crimeStatsCO_Data :: F.MonadSafe m => P.Producer (FM.MaybeRow CrimeStatsCO) m ()\n crimeStatsCO_Data = F.readTableMaybeOpt parserOptions crimeStatsCO_FP\n -- load streams into memory for joins, subsetting as we go\n K.logLE K.Info \"loading producers into memory for joining\"\n fipsByCountyFrame <- liftIO $ F.inCoreAoS $ fipsByCountyData P.>-> P.map (F.rcast @[Fips,County]) -- get rid of state col\n povertyFrame <- liftIO $ F.inCoreAoS $ povertyData P.>-> P.map (F.rcast @[Fips, Year, MedianHI,MedianHIMOE,PovertyR])\n countyBondFrameM <- liftIO $ fmap F.boxedFrame $ F.runSafeEffect $ P.toListM countyBondCO_Data\n veraFrameM <- liftIO $ fmap F.boxedFrame $ F.runSafeEffect $ P.toListM $ veraData P.>-> P.map (F.rcast @[Fips,Year,TotalPop,Urbanicity,IndexCrime])\n countyDistrictFrame <- liftIO $F.inCoreAoS countyDistrictCO_Data\n K.logLE K.Diagnostic $ (T.pack $ show $ FL.fold FL.length fipsByCountyFrame) <> \" rows in fipsByCountyFrame.\"\n K.logLE K.Diagnostic $ (T.pack $ show $ FL.fold FL.length povertyFrame) <> \" rows in povertyFrame.\"\n K.logLE K.Diagnostic $ (T.pack $ show $ FL.fold FL.length countyBondFrameM) <> \" rows in countyBondFrameM.\"\n K.logLE K.Diagnostic $ (T.pack $ show $ FL.fold FL.length veraFrameM) <> \" rows in veraFrameM.\"\n K.logLE K.Diagnostic $ (T.pack $ show $ FL.fold FL.length countyDistrictFrame) <> \" rows in countyDistrictFrame.\"\n -- do joins\n K.logLE K.Info $ \"Doing initial the joins...\"\n let countyBondPlusFIPS = FM.leftJoinMaybe (Proxy @'[County]) countyBondFrameM (justsFromRec <$> fipsByCountyFrame)\n countyBondPlusFIPSAndDistrict = FM.leftJoinMaybe (Proxy @'[County]) (F.boxedFrame countyBondPlusFIPS) (justsFromRec <$> countyDistrictFrame)\n countyBondPlusFIPSAndSAIPE = FM.leftJoinMaybe (Proxy @[Fips, Year]) (F.boxedFrame countyBondPlusFIPSAndDistrict) (justsFromRec <$> povertyFrame)\n countyBondPlusFIPSAndSAIPEAndVera = FM.leftJoinMaybe (Proxy @[Fips, Year]) (F.boxedFrame countyBondPlusFIPSAndSAIPE) veraFrameM \n K.newPandoc \"moneyBondRateAndPovertyRate\" $ kmMoneyBondPctAnalysis countyBondPlusFIPSAndSAIPEAndVera\n K.newPandoc \"moneyBondRateAndCrimeRate\" $ bondVsCrimeAnalysis countyBondCO_Data crimeStatsCO_Data\n endReal <- liftIO $ C.getTime C.Monotonic\n let realTime = C.diffTimeSpec endReal startReal\n printTime (C.TimeSpec s ns) = (T.pack $ show $ realToFrac s + realToFrac ns/(10^9)) \n K.logLE K.Info $ \"Time (real): \" <> printTime realTime <> \"s\" \n return ()\n case eitherDocs of\n Right namedDocs -> writeAllHtml namedDocs\n Left err -> putStrLn $ \"pandoc error: \" ++ show err\n\n-- extra columns we will need\n-- CrimeRate is defined in DataSources since we use it in more places\ntype MoneyBondRate = \"money_bond_rate\" F.:-> Double\ntype PostedBondRate = \"posted_bond_rate\" F.:-> Double\ntype PostedBondPerCapita = \"posted_bond_per_capita\" F.:-> Double\ntype ReoffenseRate = \"reoffense_rate\" F.:-> Double\ntype PostedBondFreq = \"posted_bond_freq\" F.:-> Int\ntype CrimeRateError = \"crime_rate_error\" F.:-> Double\ntype CrimeRateFitted = \"crime_rate_fitted\" F.:-> Double\ntype CrimeRateFittedErr = \"crime_rate_fitted_err\" F.:-> Double\n\n\n-- functions to populate some of those columns from other columns\nmoneyBondRate r = let t = r ^. totalBondFreq in FT.recordSingleton @MoneyBondRate $ bool ((r ^. moneyBondFreq) `rDiv` t) 0 (t == 0) \npostedBondRate r = let t = r ^. totalBondFreq in FT.recordSingleton @PostedBondRate $ bool ((r ^. moneyPosted + r ^. prPosted) `rDiv` t) 0 (t == 0)\npostedBondPerCapita r = FT.recordSingleton @PostedBondPerCapita $ (r ^. moneyPosted + r ^. prPosted) `rDiv` (r ^. estPopulation)\ncRate r = FT.recordSingleton @CrimeRate $ (r ^. crimes) `rDiv` (r ^. estPopulation)\nreoffenseRate r = FT.recordSingleton @ReoffenseRate $ (r ^. moneyNewYes + r ^. prNewYes) `rDiv` (r ^. moneyPosted + r ^. prPosted) \npostedBondFreq r = FT.recordSingleton @PostedBondFreq $ (r ^. moneyPosted + r ^. prPosted)\n\n\nbondVsCrimeAnalysis :: forall effs. ( MonadIO (K.Semantic effs)\n , K.PandocEffects effs\n , K.Member K.ToPandoc effs\n , K.Member KR.Random effs)\n => P.Producer (FM.MaybeRow CountyBondCO) (F.SafeT IO) ()\n -> P.Producer (FM.MaybeRow CrimeStatsCO) (F.SafeT IO) ()\n -> K.Semantic effs ()\nbondVsCrimeAnalysis bondDataMaybeProducer crimeDataMaybeProducer = K.wrapPrefix \"BondRateVsCrimeRate\" $ do\n K.logLE K.Info \"Doing bond rate vs crime rate analysis...\"\n countyBondFrameM <- liftIO $ fmap F.boxedFrame $ F.runSafeT $ P.toListM bondDataMaybeProducer\n let blanksToZeroes :: F.Rec (Maybe :. F.ElField) '[Crimes,Offenses] -> F.Rec (Maybe :. F.ElField) '[Crimes,Offenses]\n blanksToZeroes = FM.fromMaybeMono 0\n -- turn Nothing into 0, sequence the Maybes out, use concat to \"fold\" over those maybes, removing any nothings\n crimeStatsList <- liftIO $ F.runSafeT $ P.toListM $ crimeDataMaybeProducer P.>-> P.map (F.recMaybe . (F.rsubset %~ blanksToZeroes)) P.>-> P.concat\n let sumCrimesFold = FF.sequenceEndoFolds $ FF.FoldEndo FL.sum V.:& FF.FoldEndo FL.sum V.:& FF.FoldEndo (fmap (fromMaybe 0) FL.last) V.:& V.RNil\n foldAllCrimes = MR.concatFold $ MR.hashableMapReduceFold MR.noUnpack (MR.assignKeysAndData @[County, Year] @[Crimes, Offenses, EstPopulation]) (MR.foldAndAddKey sumCrimesFold)\n mergedCrimeStatsFrame = FL.fold foldAllCrimes crimeStatsList\n unmergedCrimeStatsFrame = F.boxedFrame crimeStatsList\n foldAllBonds = MR.concatFold $ MR.hashableMapReduceFold\n (MR.unpackGoodRows @[County,Year,MoneyBondFreq,PrBondFreq,TotalBondFreq,MoneyPosted,PrPosted,MoneyNewYes,PrNewYes])\n (MR.splitOnKeys @[County,Year])\n (MR.foldAndAddKey $ FF.foldAllMonoid @MO.Sum)\n mergedBondDataFrame = FL.fold foldAllBonds countyBondFrameM\n countyBondAndCrimeMerged = F.leftJoin @[County,Year] mergedBondDataFrame mergedCrimeStatsFrame\n countyBondAndCrimeUnmerged = F.leftJoin @[County,Year] mergedBondDataFrame unmergedCrimeStatsFrame\n K.logLE K.Info \"Joined crime data and bond data\" \n K.logLE K.Diagnostic $ (T.pack $ show $ FL.fold FL.length crimeStatsList) <> \" rows in crimeStatsList (unmerged).\"\n K.logLE K.Diagnostic $ (T.pack $ show $ FL.fold FL.length mergedCrimeStatsFrame) <> \" rows in crimeStatsFrame(merged).\"\n let initialCentroidsF n = MR.functionToFoldM (KM.kMeansPPCentroids @DblX @DblY @EstPopulation KM.euclidSq n) \n kmReduce f k rows = sequence $ M.singleton k $ f 10 10 initialCentroidsF (KM.weighted2DRecord @DblX @DblY @EstPopulation) KM.euclidSq rows\n sunCrimeRateF = FL.premap (F.rgetField @CrimeRate) $ MR.scaleAndUnscale (MR.RescaleNormalize 1) (MR.RescaleNone) id\n sunMoneyBondRateF = FL.premap (F.rgetField @MoneyBondRate) $ MR.scaleAndUnscale (MR.RescaleNormalize 1) (MR.RescaleNone) id\n sunPostedBondRateF = FL.premap (F.rgetField @PostedBondRate) $ MR.scaleAndUnscale (MR.RescaleNormalize 1) MR.RescaleNone id \n sunReoffenseRateF = FL.premap (F.rgetField @ReoffenseRate) $ MR.scaleAndUnscale (MR.RescaleNormalize 1) MR.RescaleNone id\n mbrAndCr r = moneyBondRate r F.<+> cRate r \n pbrAndCr r = postedBondRate r F.<+> cRate r\n rorAndMbr r = reoffenseRate r F.<+> moneyBondRate r\n kmMergedCrimeRateVsMoneyBondRateByYear <- do\n K.logLE K.Info \"Doing weighted-KMeans on crime rate vs. money-bond rate (merged crime types).\"\n let unpack = fmap (FT.mutate mbrAndCr) (MR.unpackGoodRows @[Year,County,MoneyBondFreq,TotalBondFreq,Crimes,Offenses,EstPopulation])\n reduce :: _\n reduce = MR.ReduceM $ kmReduce (KM.kMeansOneWithClusters @MoneyBondRate @CrimeRate @EstPopulation sunMoneyBondRateF sunCrimeRateF)\n kmFoldM = MR.concatFoldM $ MR.hashableMapReduceFoldM (MR.generalizeUnpack unpack) (MR.generalizeAssign $ MR.assignKeys @'[Year]) reduce\n flip FL.foldM countyBondAndCrimeMerged $\n fmap (KM.clusteredRows @MoneyBondRate @CrimeRate @EstPopulation (F.rgetField @County)) $ kmFoldM\n kmCrimeRateVsMoneyBondRateByYearAndType <- do\n K.logLE K.Info \"Doing weighted-KMeans on crime rate vs. money-bond rate (separate crime types).\"\n let unpack = fmap (FT.mutate mbrAndCr) (MR.unpackGoodRows @[Year,County,CrimeAgainst,MoneyBondFreq,TotalBondFreq,Crimes,Offenses,EstPopulation])\n reduce :: _\n reduce = MR.ReduceM $ kmReduce (KM.kMeansOneWithClusters @MoneyBondRate @CrimeRate @EstPopulation sunMoneyBondRateF sunCrimeRateF)\n kmFoldM = MR.concatFoldM $ MR.hashableMapReduceFoldM (MR.generalizeUnpack unpack) (MR.generalizeAssign $ MR.assignKeys @'[Year, CrimeAgainst]) reduce \n flip FL.foldM countyBondAndCrimeUnmerged $\n fmap (KM.clusteredRows @MoneyBondRate @CrimeRate @EstPopulation (F.rgetField @County)) $ kmFoldM\n kmMergedCrimeRateVsPostedBondRateByYear <- do\n K.logLE K.Info \"Doing weighted-KMeans on crime rate vs. posted-bond rate (merged).\"\n let unpack = fmap (FT.mutate pbrAndCr) (MR.unpackGoodRows @[Year,County,TotalBondFreq,MoneyPosted,PrPosted,Crimes,Offenses,EstPopulation])\n reduce :: _ \n reduce = MR.ReduceM $ kmReduce (KM.kMeansOneWithClusters @PostedBondRate @CrimeRate @EstPopulation sunPostedBondRateF sunCrimeRateF)\n kmFoldM = MR.concatFoldM $ MR.hashableMapReduceFoldM (MR.generalizeUnpack unpack) (MR.generalizeAssign $ MR.assignKeys @'[Year]) reduce \n flip FL.foldM countyBondAndCrimeMerged $\n fmap (KM.clusteredRows @PostedBondRate @CrimeRate @EstPopulation (F.rgetField @County)) $ kmFoldM\n kmCrimeRateVsPostedBondRateByYearAndType <- do \n K.logLE K.Info \"Doing weighted-KMeans on crime rate vs. posted-bond rate (unmerged).\" \n let unpack = fmap (FT.mutate pbrAndCr) (MR.unpackGoodRows @[Year,County,CrimeAgainst,TotalBondFreq,MoneyPosted,PrPosted,Crimes,Offenses,EstPopulation])\n reduce :: _\n reduce = MR.ReduceM $ kmReduce (KM.kMeansOneWithClusters @PostedBondRate @CrimeRate @EstPopulation sunPostedBondRateF sunCrimeRateF)\n kmFoldM = MR.concatFoldM $ MR.hashableMapReduceFoldM (MR.generalizeUnpack unpack) (MR.generalizeAssign $ MR.assignKeys @'[Year,CrimeAgainst]) reduce \n flip FL.foldM countyBondAndCrimeUnmerged $\n fmap (KM.clusteredRows @PostedBondRate @CrimeRate @EstPopulation (F.rgetField @County)) $ kmFoldM\n kmReoffenseRateVsMergedMoneyBondRateByYear <- do\n K.logLE K.Info \"Doing weighted-KMeans on re-offense rate vs. money-bond rate (merged).\" \n let unpack = fmap (FT.mutate rorAndMbr) (MR.unpackGoodRows @[Year, County, MoneyNewYes, PrNewYes, MoneyPosted, PrPosted, TotalBondFreq, MoneyBondFreq, EstPopulation])\n reduce :: _\n reduce = MR.ReduceM $ kmReduce (KM.kMeansOneWithClusters @MoneyBondRate @ReoffenseRate @EstPopulation sunMoneyBondRateF sunReoffenseRateF)\n kmFoldM = MR.concatFoldM $ MR.hashableMapReduceFoldM (MR.generalizeUnpack unpack) (MR.generalizeAssign $ MR.assignKeys @'[Year]) reduce \n flip FL.foldM countyBondAndCrimeMerged $\n fmap (KM.clusteredRows @MoneyBondRate @ReoffenseRate @EstPopulation (F.rgetField @County)) $ kmFoldM\n -- regressions\n let rMut r = mbrAndCr r F.<+> postedBondFreq r F.<+> postedBondRate r F.<+> postedBondPerCapita r\n (rData, regressionRes, regressionResMany) <- do\n let regUnpack = fmap (FT.mutate rMut) $ (MR.unpackGoodRows @[Year,MoneyBondFreq,PrBondFreq,PrPosted,MoneyPosted,TotalBondFreq,Crimes,EstPopulation])\n-- regReduce :: Foldable f => (forall g. Foldable g => g (F.Record rs) -> PS.Semantic effs b) -> k -> f (F.Record rs) -> PS.Semantic effs (M.Map k b)\n\n regMR r = MR.concatFoldM $ MR.hashableMapReduceFoldM (MR.generalizeUnpack regUnpack) (MR.generalizeAssign $ MR.assignKeys @'[Year]) r --(MR.ReduceM $ regReduce r)\n dataMR = MR.unpackOnlyFoldM (MR.generalizeUnpack regUnpack)\n guess = [0,0] -- guess has one extra dimension for constant\n regressOneBM = MR.functionToFoldM $ return . FR.leastSquaresByMinimization @Crimes @'[EstPopulation, MoneyBondFreq] False guess\n regressOneOLS = MR.functionToFoldM $ FR.ordinaryLeastSquares @effs @Crimes @False @'[EstPopulation]\n regressOneWLS = MR.functionToFoldM $ FR.popWeightedLeastSquares @effs @CrimeRate @True @'[] @EstPopulation \n regressOneWLS2 = MR.functionToFoldM $ FR.varWeightedLeastSquares @effs @Crimes @False @'[EstPopulation, PostedBondFreq] @EstPopulation \n regressOneWTLS = MR.functionToFoldM $ FR.varWeightedTLS @effs @Crimes @False @'[EstPopulation, PostedBondFreq] @EstPopulation\n regReduceF r k = fmap (M.singleton k) r\n allMR = (,,,,,) <$> dataMR\n <*> (regMR $ MR.ReduceFoldM $ regReduceF regressOneBM)\n <*> (regMR $ MR.ReduceFoldM $ regReduceF regressOneOLS)\n <*> (regMR $ MR.ReduceFoldM $ regReduceF regressOneWLS)\n <*> (regMR $ MR.ReduceFoldM $ regReduceF regressOneWLS2)\n <*> (regMR $ MR.ReduceFoldM $ regReduceF regressOneWTLS) \n K.logLE K.Info \"Regressing Crime Rate on Money Bond Rate\"\n (rData, r1, r2,r3,r4,r5) <- FL.foldM allMR countyBondAndCrimeMerged\n-- K.logLE K.Info $ \"regression (by minimization) results: \" <> (T.pack $ show $ fmap (flip FR.prettyPrintRegressionResult 0.95) r1)\n K.logLE K.Info $ \"regression (by OLS) results: \" <> FR.prettyPrintRegressionResults FR.keyRecordText (M.toList r2) ST.cl95 FR.prettyPrintRegressionResult \"\\n\"\n K.logLE K.Info $ \"regression (rates by pop weighted LS) results: \" <> FR.prettyPrintRegressionResults FR.keyRecordText (M.toList r3) ST.cl95 FR.prettyPrintRegressionResult \"\\n\"\n K.logLE K.Info $ \"regression (counts by inv sqrt pop weighted LS) results: \" <> FR.prettyPrintRegressionResults FR.keyRecordText (M.toList r4) ST.cl95 FR.prettyPrintRegressionResult \"\\n\"\n K.logLE K.Info $ \"regression (counts by TLS) results: \" <> FR.prettyPrintRegressionResults FR.keyRecordText (M.toList r5) ST.cl95 FR.prettyPrintRegressionResult \"\\n\"\n let rData2016 = F.filterFrame ((== 2016) . F.rgetField @Year) $ F.toFrame rData\n regressionR = fromJust $ M.lookup (FT.recordSingleton @Year 2016) r4\n return $ (rData2016, regressionR, r4) \n-- K.log K.Info $ \"data=\\n\" <> Table.textTable rData\n \n K.logLE K.Info \"Creating Doc\"\n K.addLucid $ do\n HL.h1_ \"Colorado Money Bond Rate vs Crime rate\" \n KL.placeTextSection $ do\n HL.h2_ \"Colorado Bond Rates and Crime Rates (preliminary)\"\n HL.p_ [HL.class_ \"subtitle\"] \"Adam Conner-Sax\"\n HL.p_ \"Each county in Colorado issues money bonds and personal recognizance bonds. For each county I look at the % of money bonds out of all bonds issued and the crime rate. We have 3 years of data and there are 64 counties in Colorado (each with vastly different populations). So I've used a population-weighted k-means clustering technique (see notes below) to reduce the number of points to at most 10 per year. Each circle in the plot below represents one cluster of counties with similar money bond and poverty rates. The size of the circle represents the total population in the cluster.\"\n KL.placeVisualization \"crimeRateVsMoneyBondRateMerged\" $ cRVsMBRVL True kmMergedCrimeRateVsMoneyBondRateByYear \n HL.p_ \"Broken down by Colorado's crime categories:\"\n KL.placeVisualization \"crimeRateVsMoneyBondRateUnMerged\" $ cRVsMBRVL False kmCrimeRateVsMoneyBondRateByYearAndType\n KL.placeTextSection $ do\n HL.p_ \"Notes:\"\n HL.ul_ $ do\n HL.li_ $ do\n HL.span_ \"Money Bond Rate is (number of money bonds/total number of bonds). That data comes from \"\n HL.a_ [HL.href_ \"https://github.com/Data4Democracy/incarceration-trends/blob/master/Colorado_ACLU/4-money-bail-analysis/complete-county-bond.csv\"] \"complete-county-bond.csv\"\n HL.span_ \". NB: Bond rates are not broken down by crime type because they are not broken down in the data we have.\"\n HL.li_ $ do\n HL.span_ \"Crime Rate is crimes/estimated_population. Those numbers come from the Colorado crime statistics \"\n HL.a_ [HL.href_ \"https://coloradocrimestats.state.co.us/\"] \"web-site\"\n HL.span_ \". We also have some of that data in the \"\n HL.a_ [HL.href_ \"https://github.com/Data4Democracy/incarceration-trends/blob/master/Colorado_ACLU/4-money-bail-analysis/crime-rate-bycounty.csv\"] \"repo\"\n HL.span_ \", but only for 2016, so I re-downloaded it for this. Also, there are some crimes in that data that don't roll up to a particular county but instead are attributed to the Colorado Bureau of Investigation or the Colorado State Patrol. I've ignored those.\"\n KL.placeTextSection $ do\n HL.p_ \"Below I look at the percentage of all bonds which are \\\"posted\\\" (posting bond means paying the money bond or agreeing to the terms of the personal recognizance bond ?) rather than the % of money bonds. I use the same clustering technique.\"\n KL.placeVisualization \"crimeRateVsPostedBondRate\" $ cRVsPBRVL True kmMergedCrimeRateVsPostedBondRateByYear\n HL.p_ \"Broken down by Colorado's crime categories:\"\n KL.placeVisualization \"crimeRateVsPostedBondRateUnMerged\" $ cRVsPBRVL False kmCrimeRateVsPostedBondRateByYearAndType\n KL.placeTextSection $ do\n HL.p_ \"Notes:\"\n HL.ul_ $ do\n HL.li_ $ do\n HL.span_ \"Posted Bond Rate is [(number of posted money bonds + number of posted PR bonds)/total number of bonds] where that data comes from \"\n HL.a_ [HL.href_ \"https://github.com/Data4Democracy/incarceration-trends/blob/master/Colorado_ACLU/4-money-bail-analysis/complete-county-bond.csv\"] \"complete-county-bond.csv.\"\n HL.li_ $ do\n HL.span_ \"Crime Rate, as above, is crimes/estimated_population where those numbers come from the Colorado crime statistics \"\n HL.a_ [HL.href_ \"https://coloradocrimestats.state.co.us/\"] \"web-site.\"\n HL.p_ \"Below I look at the rate of re-offending among people out on bond, here considered in each county along with money-bond rate and clustered as above.\" \n KL.placeVisualization \"reoffenseRateVsMoneyBondRate\" $ rRVsMBRVL True kmReoffenseRateVsMergedMoneyBondRateByYear\n KL.placeTextSection $ do\n HL.p_ \"Notes:\"\n HL.ul_ $ do\n HL.li_ $ do\n HL.span_ \"Reoffense Rate is (number of new offenses for all bonds/total number of posted bonds) where that data comes from \"\n HL.a_ [HL.href_ \"https://github.com/Data4Democracy/incarceration-trends/blob/master/Colorado_ACLU/4-money-bail-analysis/complete-county-bond.csv\"] \"complete-county-bond.csv.\"\n\n KL.placeTextSection $ do\n HL.h2_ \"Regressions\"\n HL.p_ \"We can use linear regression to investigate the relationship between Crime Rate and the use of money and personal recognizance bonds. We begin by finding a best fit (using population-weighted least squares) to the model \"\n KL.latex_ \"$c_i = cr (p_{i}) + A (pb_{i}) + e_{i}$\" \n HL.p_ \"where, for each county (denoted by the subscipt i), c is the number of crimes, p is the population and pb is the number of posted bonds and e is an error term we seek to minimize. We look at the result for each of the years in the data:\"\n KL.placeVisualization \"regresssionCoeffs\" $ FV.regressionCoefficientPlotMany (T.pack . show . F.rgetField @Year) \"Regression Results (by year)\" [\" cr\",\"A\"] (M.toList (fmap FR.regressionResult regressionResMany)) ST.cl95\n HL.p_ \"We look at these regressions directly by overlaying this model on the data itself:\"\n-- H.placeVisualization \"regresssionScatter\" $ FV.scatterWithFit @PostedBondPerCapita @CrimeRate errF (FV.FitToPlot \"WLS regression\" fitF) \"test scatter with fit\" rData\n-- H.placeVisualization \"regresssionScatter\" $ FV.scatterWithFit @PostedBondPerCapita @CrimeRate errF (FV.FitToPlot \"WLS regression\" fitF) \"test scatter with fit\" rData\n KL.placeVisualization \"regresssionScatter\" $ FV.frameScatterWithFit \"test scatter with fit\" (Just \"WLS\") regressionRes ST.cl95 rData\n kMeansNotes\n-- liftIO $ T.writeFile \"analysis/moneyBondRateAndCrimeRate.html\" $ TL.toStrict $ htmlAsText\n\ncRVsMBRVL mergedOffenseAgainst dataRecords =\n let dat = FV.recordsToVLData (transformF @MoneyBondRate (*100) . transformF @CrimeRate (*100)) dataRecords\n ptEnc = GV.color [FV.mName @Year, GV.MmType GV.Nominal]\n . GV.size [FV.mName @EstPopulation, GV.MmType GV.Quantitative, GV.MLegend [GV.LTitle \"population\"]]\n in case mergedOffenseAgainst of\n True ->\n let vlF = FV.clustersWithClickIntoVL @MoneyBondRate @CrimeRate @KM.IsCentroid @KM.ClusterId @KM.MarkLabel @'[Year] \n in vlF \"Money Bond Rate (%, All Crimes)\" \"Crime Rate (%, All Crimes)\" \"Crime Rate vs Money Bond Rate\" ptEnc id id id dat\n False ->\n let ptEncFaceted = ptEnc\n . GV.row [FV.fName @CrimeAgainst, GV.FmType GV.Nominal,GV.FHeader [GV.HTitle \"Crime Against\"]]\n vlF = FV.clustersWithClickIntoVL @MoneyBondRate @CrimeRate @KM.IsCentroid @KM.ClusterId @KM.MarkLabel @[Year,CrimeAgainst]\n in vlF \"Money Bond Rate (%, All Crimes)\" \"Crime Rate (%)\" \"Crime Rate vs Money Bond Rate\" ptEncFaceted id id id dat\n\ncRVsPBRVL mergedOffenseAgainst dataRecords =\n let dat = FV.recordsToVLData (transformF @PostedBondRate (*100) . transformF @CrimeRate (*100)) dataRecords\n ptEnc = GV.color [FV.mName @Year, GV.MmType GV.Nominal]\n . GV.size [FV.mName @EstPopulation, GV.MmType GV.Quantitative, GV.MLegend [GV.LTitle \"population\"]]\n in case mergedOffenseAgainst of\n True ->\n let vlF = FV.clustersWithClickIntoVL @PostedBondRate @CrimeRate @KM.IsCentroid @KM.ClusterId @KM.MarkLabel @'[Year] \n in vlF \"Posted Bond Rate (%, All Crimes)\" \"Crime Rate (%, All Crimes)\" \"Crime Rate vs Posted Bond Rate\" ptEnc id id id dat\n False ->\n let ptEncFaceted = ptEnc\n . GV.row [FV.fName @CrimeAgainst, GV.FmType GV.Nominal,GV.FHeader [GV.HTitle \"Crime Against\"]]\n vlF = FV.clustersWithClickIntoVL @PostedBondRate @CrimeRate @KM.IsCentroid @KM.ClusterId @KM.MarkLabel @[Year,CrimeAgainst]\n in vlF \"Posted Bond Rate (%, All Crimes)\" \"Crime Rate (%)\" \"Crime Rate vs Posted Bond Rate\" ptEncFaceted id id id dat\n\nrRVsMBRVL mergedOffenseAgainst dataRecords =\n let dat = FV.recordsToVLData (transformF @MoneyBondRate (*100) . transformF @ReoffenseRate (*100)) dataRecords\n ptEnc = GV.color [FV.mName @Year, GV.MmType GV.Nominal]\n . GV.size [FV.mName @EstPopulation, GV.MmType GV.Quantitative, GV.MLegend [GV.LTitle \"population\"]]\n in case mergedOffenseAgainst of\n True ->\n let vlF = FV.clustersWithClickIntoVL @MoneyBondRate @ReoffenseRate @KM.IsCentroid @KM.ClusterId @KM.MarkLabel @'[Year] \n in vlF \"Money Bond Rate (%, All Crimes)\" \"Reoffense Rate (%, All Crimes)\" \"Reoffense Rate vs Money Bond Rate\" ptEnc id id id dat\n False ->\n let ptEncFaceted = ptEnc\n . GV.row [FV.fName @CrimeAgainst, GV.FmType GV.Nominal,GV.FHeader [GV.HTitle \"Crime Against\"]]\n vlF = FV.clustersWithClickIntoVL @MoneyBondRate @CrimeRate @KM.IsCentroid @KM.ClusterId @KM.MarkLabel @[Year,CrimeAgainst]\n in vlF \"Money Bond Rate (%, All Crimes)\" \"Reoffense Rate (%)\" \"Reoffense Rate vs Money Bond Rate\" ptEncFaceted id id id dat\n\n \n-- NB: The data has two rows for each county and year, one for misdemeanors and one for felonies.\n--type MoneyPct = \"moneyPct\" F.:-> Double --F.declareColumn \"moneyPct\" ''Double\nkmMoneyBondPctAnalysis :: _\nkmMoneyBondPctAnalysis joinedData = K.wrapPrefix \"MoneyBondVsPoverty\" $ do\n K.logLE K.Info \"Doing money bond % vs poverty rate analysis...\"\n let sunPovertyRF = FL.premap (F.rgetField @PovertyR) $ MR.scaleAndUnscale (MR.RescaleNormalize 1) MR.RescaleNone id\n sunMoneyBondRateF = FL.premap (F.rgetField @MoneyBondRate) $ MR.scaleAndUnscale (MR.RescaleNormalize 1) MR.RescaleNone id\n initialCentroids = KM.kMeansPPCentroids @DblX @DblY @TotalPop KM.euclidSq\n unpack = fmap (FT.mutate moneyBondRate) $ MR.unpackGoodRows @[Year,County,OffType,Urbanicity,PovertyR, MoneyBondFreq,TotalBondFreq,TotalPop]\n reduce :: _\n reduce = MR.ReduceM $ \\_ -> KM.kMeansOne @PovertyR @MoneyBondRate @TotalPop sunPovertyRF sunMoneyBondRateF 5 initialCentroids (KM.weighted2DRecord @DblX @DblY @TotalPop) KM.euclidSq\n toRec (x, y, z) = (x F.&: y F.&: z F.&: V.RNil) :: F.Record [PovertyR, MoneyBondRate, TotalPop]\n kmByYearF = MR.concatFoldM $ MR.hashableMapReduceFoldM\n (MR.generalizeUnpack unpack)\n (MR.generalizeAssign $ MR.assignKeysAndData @[Year, OffType] @[PovertyR, MoneyBondRate, TotalPop])\n (MR.makeRecsWithKeyM toRec reduce)\n kmByYearUrbF = MR.concatFoldM $ MR.hashableMapReduceFoldM\n (MR.generalizeUnpack unpack)\n (MR.generalizeAssign $ MR.assignKeysAndData @'[Year, OffType, Urbanicity] @[PovertyR, MoneyBondRate, TotalPop])\n (MR.makeRecsWithKeyM toRec reduce)\n (kmByYear, kmByYearUrb) <- FL.foldM ((,) <$> kmByYearF <*> kmByYearUrbF) joinedData\n{- (kmByYear, kmByYearUrb) <- FL.foldM ((,)\n <$> KM.kMeans @[Year, OffType] @PovertyR @MoneyBondRate @TotalPop sunPovertyRF sunMoneyBondRateF 5 (KM.kMeansPPCentroids KM.euclidSq) KM.euclidSq\n <*> KM.kMeans @[Year, OffType, Urbanicity] @PovertyR @MoneyBondRate @TotalPop sunPovertyRF sunMoneyBondRateF 5 (KM.kMeansPPCentroids KM.euclidSq) KM.euclidSq) kmData -}\n K.logLE K.Info \"Creating Doc\"\n K.addLucid $ do\n HL.h1_ \"Colorado Money Bonds and Poverty\" \n KL.placeTextSection $ do\n HL.h2_ \"Colorado Money Bond Rate and Poverty (preliminary)\"\n HL.p_ [HL.class_ \"subtitle\"] \"Adam Conner-Sax\"\n HL.p_ \"Colorado issues two types of bonds when releasing people from jail before trial. Sometimes people are released on a \\\"money bond\\\" and sometimes on a personal recognizance bond. We have county-level data of all bonds (?) issued in 2014, 2015 and 2016. Plotting it all is very noisy (since there are 64 counties in CO) so we use a population-weighted k-means clustering technique to combine similar counties into clusters. In the plots below, each circle represents one cluster of counties and the circle's size represents the total population of all the counties included in the cluster. We consider felonies and misdemeanors separately.\"\n KL.placeVisualization \"mBondsVspRateByYrFelonies\" $ moneyBondPctVsPovertyRateVL False kmByYear\n KL.placeTextSection $ HL.h3_ \"Broken down by \\\"urbanicity\\\":\"\n KL.placeVisualization \"mBondsVspRateByYrUrbFelonies\" $ moneyBondPctVsPovertyRateVL True kmByYearUrb\n KL.placeTextSection $ do\n HL.p_ \"Notes:\"\n HL.ul_ $ do\n HL.li_ \"Denver, the only urban county in CO, didn't report misdemeanors in this data, so the last plot is blank.\"\n HL.li_ $ do\n HL.span_ \"Money Bond Rate is (number of money bonds/total number of bonds). That data comes from \"\n HL.a_ [HL.href_ \"https://github.com/Data4Democracy/incarceration-trends/blob/master/Colorado_ACLU/4-money-bail-analysis/complete-county-bond.csv\"] \"complete-county-bond.csv.\"\n HL.li_ $ do\n HL.span_ \"Poverty Rate comes from the census and we have that data in \"\n HL.a_ [HL.href_ \"https://github.com/Data4Democracy/incarceration-trends/blob/master/Colorado_ACLU/4-money-bail-analysis/complete-county-bond-SAIPE.csv\"] \"complete-county-bond-SAIPE.csv\"\n HL.span_ \". That data originates from the \"\n HL.a_ [HL.href_ \"https://www.census.gov/programs-surveys/saipe.html\"] \"SAIPE website\"\n HL.span_ \" at the census bureau.\"\n HL.li_ $ do\n HL.span_ \"Urbanicity classification comes from the \"\n HL.a_ [HL.href_ \"https://www.vera.org/projects/incarceration-trends\"] \"VERA\"\n HL.span_ \" data. In the repo \"\n HL.a_ [HL.href_ \"https://github.com/Data4Democracy/incarceration-trends/blob/master/Colorado_ACLU/4-money-bail-analysis/county_bond_saipe_vera_data.csv\"] \"here.\"\n kMeansNotes\n-- liftIO $ T.writeFile \"analysis/moneyBondRateAndPovertyRate.html\" $ TL.toStrict $ htmlAsText\n\nmoneyBondPctVsPovertyRateVL facetByUrb dataRecords =\n let dat = FV.recordsToVLData (transformF @MoneyBondRate (*100)) dataRecords\n enc = GV.encoding\n . GV.position GV.X [FV.pName @PovertyR, GV.PmType GV.Quantitative, GV.PAxis [GV.AxTitle \"Poverty Rate (%)\"]]\n . GV.position GV.Y [FV.pName @MoneyBondRate, GV.PmType GV.Quantitative, GV.PAxis [GV.AxTitle \"% Money Bonds\"]]\n . GV.color [FV.mName @Year, GV.MmType GV.Nominal]\n . GV.size [FV.mName @TotalPop, GV.MmType GV.Quantitative, GV.MLegend [GV.LTitle \"population\"]]\n . GV.row [FV.fName @OffType, GV.FmType GV.Nominal, GV.FHeader [GV.HTitle \"Type of Offense\"]]\n . if facetByUrb then GV.column [FV.fName @Urbanicity, GV.FmType GV.Nominal] else id\n sizing = if facetByUrb\n then [GV.autosize [GV.AFit, GV.AResize]]\n else [GV.autosize [GV.AFit], GV.height 300, GV.width 700]\n vl = GV.toVegaLite $\n [ GV.description \"Vega-Lite Attempt\"\n , GV.title (\"% of money bonds (out of money and personal recognizance bonds) vs poverty rate in CO\")\n , GV.background \"white\"\n , GV.mark GV.Point []\n , enc []\n , dat] <> sizing\n in vl\n\nkMeansNotes = KL.placeTextSection $ do\n HL.h3_ \"Some notes on weighted k-means\"\n HL.ul_ $ do\n HL.li_ $ do\n HL.a_ [HL.href_ \"https://en.wikipedia.org/wiki/K-means_clustering\"] \"k-means\"\n HL.span_ \" works by choosing random starting locations for cluster centers, assigning each data-point to the nearest cluster center, moving the center of each cluster to the weighted average of the data-points assigned to the same cluster and then repeating until no data-points move to a new cluster.\"\n HL.li_ \"How do you define distance between points? Each axis has a different sort of data and it's not clear how to combine differences in each into a meanignful overall distance. Here, before we hand the data off to the k-means algorithm, we shift and rescale the data so that the set of points has mean 0 and std-deviation 1 in each variable. Then we use ordinary Euclidean distance, that is the sum of the squares of the differences in each coordinate. Before plotting, we reverse that scaling so that we can visualize the data in the original. This attempts to give the two variables equal weight in determining what \\\"nearby\\\" means for these data points.\"\n HL.li_ \"This clustering happens for each combination plotted.\"\n HL.li_ $ do\n HL.span_ \"k-means is sensitive to the choice of starting points. Here we use the \\\"k-means++\\\" method. This chooses one of the data points as a starting point. Then chooses among the remaining points in a way designed to make it likely that the initial centers are widely dispersed. See \"\n HL.a_ [HL.href_ \"https://en.wikipedia.org/wiki/K-means%2B%2B\"] \"here\"\n HL.span_ \" for more information. We repeat the k-means clustering with a few different starting centers chosen this way and choose the best clustering, in the sense of minimizing total weighted distance of all points from their cluster centers.\"\n\n\ntransformF :: forall x rs. (V.KnownField x, x \u2208 rs) => (V.Snd x -> V.Snd x) -> F.Record rs -> F.Record rs\ntransformF f r = F.rputField @x (f $ F.rgetField @x r) r\n\n\n-- kmBondRatevsCrimeRateAnalysis countyBondPlusFIPSAndSAIPEAndVera\ntype IndexCrimeRate = \"index_crime_rate\" F.:-> Double\ntype TotalBondRate = \"total_bond_rate\" F.:-> Double\nindexCrimeRate r = FT.recordSingleton @IndexCrimeRate $ (r ^. indexCrime) `rDiv` (r ^. totalPop)\ntotalBondRate r = FT.recordSingleton @TotalBondRate $ (r ^. totalBondFreq) `rDiv` (r ^. totalPop) \nkmBondRatevsCrimeRateAnalysis joinedData = do\n let select = F.rcast @[Year,County,Urbanicity,TotalBondFreq,IndexCrime,TotalPop]\n mutation r = totalBondRate r F.<+> indexCrimeRate r\n mData = fmap (FT.mutate mutation) . catMaybes $ fmap (F.recMaybe . select) joinedData\n F.writeCSV \"data/raw_COCrimeRatevsBondRate.csv\" mData\n{- let dataCols = Proxy @[TotalBondRate, IndexCrimeRate, TotalPop]\n xScaling = FL.premap (F.rgetField @TotalBondRate &&& F.rgetField @TotalPop) $ MR.weightedScaleAndUnscale (MR.RescaleNormalize 1) MR.RescaleNone id\n yScaling = FL.premap (F.rgetField @IndexCrimeRate &&& F.rgetField @TotalPop) $ MR.weightedScaleAndUnscale (MR.RescaleNormalize 1) MR.RescaleNone id\n-}\n\n\n-- FM.writeCSV_Maybe \"data/countyBondPlusFIPS.csv\" countyBondPlusFIPS\n-- FM.writeCSV_Maybe \"data/countyBondPlusSAIPE.csv\" countyBondPlusFIPSAndSAIPE\n-- FM.writeCSV_Maybe \"data/countyBondPlus.csv\" countyBondPlusFIPSAndSAIPEAndVera\n-- coloradoRowCheck <- F.runSafeEffect $ FL.purely P.fold (goodDataByKey [F.pr1|Year|]) coloradoTrendsData\n-- putStrLn $ \"(CO rows, CO rows with all fields) = \" ++ show coloradoRowCheck\n\n\n\n", "meta": {"hexsha": "94c3550c7acfe8cf857b38407b0de6f9ff481d5b", "size": 39322, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "explore-data/colorado-analysis.hs", "max_stars_repo_name": "adamConnerSax/incarceration", "max_stars_repo_head_hexsha": "3bcd9826c6eb62fa3e9ea06136531ea6fa624e18", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "explore-data/colorado-analysis.hs", "max_issues_repo_name": "adamConnerSax/incarceration", "max_issues_repo_head_hexsha": "3bcd9826c6eb62fa3e9ea06136531ea6fa624e18", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "explore-data/colorado-analysis.hs", "max_forks_repo_name": "adamConnerSax/incarceration", "max_forks_repo_head_hexsha": "3bcd9826c6eb62fa3e9ea06136531ea6fa624e18", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 76.6510721248, "max_line_length": 669, "alphanum_fraction": 0.7071105234, "num_tokens": 10803, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.6334102636778401, "lm_q2_score": 0.5078118642792044, "lm_q1q2_score": 0.32165324685182645}} {"text": "{-# LANGUAGE GADTs #-}\nmodule Format.Percentile\n ( Percentile()\n , percentile\n , ignoreHigh\n ) where\n\nimport Data.Time.Clock\nimport Statistics.Distribution\nimport Statistics.Distribution.Normal\nimport Text.Printf\n\ndata Percentile where\n Percentile :: Distribution d => d -> Double -> Percentile\n\ninstance Show Percentile where\n showsPrec _ = showPercentile\n\n\npercentile :: Distribution d => d -> NominalDiffTime -> Percentile\npercentile d a = Percentile d $ realToFrac a\n\n\nshowPercentile :: Percentile -> ShowS\nshowPercentile = showString . go . calc\n where go p | p < 0.1 = replicate 4 '\\8595'\n | p > 99.9 = replicate 4 '\\8593'\n | otherwise = printf \"%4.1f\" p\n\nignoreHigh :: Percentile -> String\nignoreHigh a = go $ calc a\n where go p | p > 99.9 = \" \"\n | otherwise = show a\n\n\ncalc :: Percentile -> Double\ncalc (Percentile d t) =\n let b = complCumulative d t\n in (/10) $ fromIntegral $ (round :: Double -> Integer) $ b * 1000\n", "meta": {"hexsha": "be6706a67ec431dc117d45b77df86cd13a0c4e23", "size": 978, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/Format/Percentile.hs", "max_stars_repo_name": "argiopetech/timer", "max_stars_repo_head_hexsha": "1962af91004cddb0e2409a5089164eb343e7eb2e", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/Format/Percentile.hs", "max_issues_repo_name": "argiopetech/timer", "max_issues_repo_head_hexsha": "1962af91004cddb0e2409a5089164eb343e7eb2e", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2018-01-29T16:51:06.000Z", "max_issues_repo_issues_event_max_datetime": "2018-01-29T16:51:58.000Z", "max_forks_repo_path": "src/Format/Percentile.hs", "max_forks_repo_name": "argiopetech/timer", "max_forks_repo_head_hexsha": "1962af91004cddb0e2409a5089164eb343e7eb2e", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 24.45, "max_line_length": 67, "alphanum_fraction": 0.6615541922, "num_tokens": 273, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6584175139669997, "lm_q2_score": 0.4882833952958347, "lm_q1q2_score": 0.32149433924204923}} {"text": "{-# LANGUAGE RankNTypes #-}\n{-# LANGUAGE TypeApplications #-}\n\n-- | Flexible numeric parsers for real-world programming languages.\n-- These parsers aim to be a superset of the numeric syntaxes across\n-- the most popular programming languages.\n--\n-- All parsers assume any trailing whitespace has already been\n-- consumed, and places no requirement for an @endOfInput@ at the end\n-- of a literal. Be sure to handle these in a calling context. These\n-- parsers do not use 'Text.Parser.Token.TokenParsing', and therefore\n-- may fail while consuming input, depending on if you use a parser\n-- that automatically backtracks or not. Apply 'try' if needed.\nmodule Numeric.Parse.Flexible\n ( integer,\n natural,\n decimal,\n hexadecimal,\n octal,\n binary,\n floating,\n signed,\n imaginary,\n )\nwhere\n\nimport Control.Applicative\nimport Control.Monad hiding (fail)\nimport Data.Scientific hiding (scientific)\nimport Numeric\nimport Text.Parser.Char\nimport Text.Parser.Combinators\nimport Text.Read (readMaybe)\nimport Prelude hiding (exponent, fail, takeWhile)\nimport Data.Complex\nimport Numeric.Natural (Natural)\n\n-- | Parse an integer in 'decimal', 'hexadecimal', 'octal', or 'binary', with optional leading sign.\n--\n-- Note that because the 'octal' parser takes primacy over 'decimal', numbers with a leading\n-- @0@ will be parsed as octal. This is unfortunate, but matches the behavior\n-- of C, Python, and Ruby.\ninteger :: (CharParsing m, Monad m) => m Integer\ninteger = signed (choice [try hexadecimal, try octal, try binary, decimal])\n\n-- | Parse a natural number in 'decimal', 'hexadecimal', 'octal', or 'binary'. As with 'integer',\n-- a leading @0@ is interpreted as octal. Leading signs are not accepted.\nnatural :: (CharParsing m, Monad m) => m Natural\nnatural = fromIntegral <$> choice [try hexadecimal, try octal, try binary, decimal]\n\n-- | Parse an integer in base 10.\n--\n-- Accepts @0..9@ and underscore separators. No leading signs are accepted.\ndecimal :: (CharParsing m, Monad m) => m Integer\ndecimal = do\n contents <- withUnder digit\n attempt contents\n\n-- | Parse a number in hexadecimal.\n--\n-- Requires a @0x@ or @0X@ prefix. No leading signs are accepted.\n-- Accepts @A..F@, @a..f@, @0..9@ and underscore separators.\nhexadecimal :: forall a m. (Eq a, Num a, CharParsing m, Monad m) => m a\nhexadecimal = do\n void (string \"0x\" <|> string \"0X\")\n contents <- withUnder hexDigit\n let res = readHex contents\n case res of\n [] -> unexpected (\"unparsable hex literal \" <> contents)\n [(x, \"\")] -> pure x\n _ -> unexpected (\"ambiguous hex literal \" <> contents)\n\n-- | Parse a number in octal.\n--\n-- Requires a @0@, @0o@ or @0O@ prefix. No leading signs are accepted.\n-- Accepts @0..7@ and underscore separators.\noctal :: forall a m. (Num a, CharParsing m, Monad m) => m a\noctal = do\n void (char '0' *> optional (oneOf \"oO\"))\n digs <- withUnder octDigit\n fromIntegral <$> attempt @Integer (\"0o\" <> digs)\n\n-- | Parse a number in binary.\n--\n-- Requires a @0b@ or @0B@ prefix. No leading signs are accepted.\n-- Accepts @0@, @1@, and underscore separators.\nbinary :: forall a m. (Show a, Num a, CharParsing m, Monad m) => m a\nbinary = do\n void (char '0')\n void (optional (oneOf \"bB\"))\n digs <- withUnder (oneOf \"01\")\n let c2b c = case c of\n '0' -> 0\n '1' -> 1\n x -> error (\"Invariant violated: both Attoparsec and readInt let a bad digit through: \" <> [x])\n let res = readInt 2 (`elem` \"01\") c2b digs\n case res of\n [] -> unexpected (\"No parse of binary literal: \" <> digs)\n [(x, \"\")] -> pure x\n others -> unexpected (\"Too many parses of binary literal: \" <> show others)\n\n-- | Parse an arbitrary-precision number with an optional decimal part.\n--\n-- Unlike 'scientificP' or Scientific's 'Read' instance, this handles:\n--\n-- * omitted whole parts, e.g. @.5@\n-- * omitted decimal parts, e.g. @5.@\n-- * exponential notation, e.g. @3.14e+1@\n-- * numeric parts, in whole or decimal or exponent parts, with @_@ characters\n-- * hexadecimal, octal, and binary integer literals, without a decimal part.\n--\n-- You may either omit the whole or the leading part, not both; this parser also rejects the empty string.\n-- It does /not/ handle hexadecimal floating-point numbers.\nfloating :: (CharParsing m, Monad m) => m Scientific\nfloating = signed (choice [hexadecimal, octal, binary, dec])\n where\n -- Compared to the binary parser, this is positively breezy.\n dec = do\n -- Try getting the whole part of a floating literal.\n leadings <- stripUnder <$> many (digit <|> char '_')\n -- Try reading a dot.\n void (optional (char '.'))\n -- The trailing part...\n trailings <- stripUnder <$> many (digit <|> char '_')\n -- ...and the exponent.\n exponent <- stripUnder <$> many (oneOf \"eE_0123456789+-\")\n -- Ensure we don't read an empty string, or one consisting only of a dot and/or an exponent.\n when (null trailings && null leadings) (unexpected \"Does not accept a single dot\")\n -- Replace empty parts with a zero.\n let leads = if null leadings then \"0\" else leadings\n let trail = if null trailings then \"0\" else trailings\n attempt (leads <> \".\" <> trail <> exponent)\n\n-- | Converts a numeric parser to one that accepts an optional leading sign.\nsigned :: forall a m . (CharParsing m, Num a) => m a -> m a\nsigned p =\n (negate <$> (char '-' *> p))\n <|> (char '+' *> p)\n <|> p\n\n-- | Converts a numeric parser to one that accepts a trailing imaginary specifier\n-- @i@ or @j@. This does not add facilities for two-valued literals, i.e. @1+4j@,\n-- as those are generally best left to high-level expression facilities.\nimaginary :: forall a m . (CharParsing m, Monad m, Num a) => m a -> m (Complex a)\nimaginary num = do\n real <- num\n void (oneOf \"ij\")\n pure (0 :+ real)\n\nstripUnder :: String -> String\nstripUnder = Prelude.filter (/= '_')\n\nattempt :: (Read a, CharParsing m) => String -> m a\nattempt str = maybe (unexpected (\"No parse: \" <> str)) pure (readMaybe str)\n\nwithUnder :: CharParsing m => m Char -> m String\nwithUnder p = stripUnder <$> ((:) <$> p <*> many (p <|> char '_'))\n", "meta": {"hexsha": "f0b24b0148307678a69479fe51344f5daeabcf55", "size": 6118, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/Numeric/Parse/Flexible.hs", "max_stars_repo_name": "patrickt/flexible-numeric-parsers", "max_stars_repo_head_hexsha": "6e631b56ff8e72caa05c04257efc914a7c3688a1", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 10, "max_stars_repo_stars_event_min_datetime": "2020-06-29T01:25:35.000Z", "max_stars_repo_stars_event_max_datetime": "2021-09-15T14:07:19.000Z", "max_issues_repo_path": "src/Numeric/Parse/Flexible.hs", "max_issues_repo_name": "patrickt/flexible-numeric-parsers", "max_issues_repo_head_hexsha": "6e631b56ff8e72caa05c04257efc914a7c3688a1", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/Numeric/Parse/Flexible.hs", "max_forks_repo_name": "patrickt/flexible-numeric-parsers", "max_forks_repo_head_hexsha": "6e631b56ff8e72caa05c04257efc914a7c3688a1", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 38.7215189873, "max_line_length": 106, "alphanum_fraction": 0.6675384112, "num_tokens": 1627, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.6187804337438501, "lm_q2_score": 0.519521321952093, "lm_q1q2_score": 0.32146962893669445}} {"text": "{-# LANGUAGE CPP #-}\n#ifndef MIN_VERSION_base\n#include \"../dist/build/autogen/cabal_macros.h\"\n#endif\nmodule Calico.Base (\n\n -- * Basic types\n\n -- ** Maybe\n Data.Maybe.Maybe(..)\n , Data.Maybe.maybe\n , Data.Maybe.isJust\n , Data.Maybe.isNothing\n , Data.Maybe.fromMaybe\n , Data.Maybe.listToMaybe\n , Data.Maybe.maybeToList\n , Data.Maybe.catMaybes\n , Data.Maybe.mapMaybe\n\n -- ** Either\n , Data.Either.Either(..)\n , Data.Either.either\n\n -- ** Bool\n , Data.Bool.Bool(..)\n , (Data.Bool.&&)\n , (Data.Bool.||)\n , Data.Bool.not\n , Data.Bool.otherwise\n\n -- ** Numeric types\n#if MIN_VERSION_base(4, 8, 0)\n , Numeric.Natural.Natural\n#endif\n , Prelude.Integer\n , Prelude.Int\n , Prelude.Rational\n , Prelude.Float\n , Prelude.Double\n\n -- ** Char\n , Data.Char.Char\n , Data.Char.toUpper\n , Data.Char.toLower\n , Data.Char.ord\n , Data.Char.chr\n\n -- ** Word\n , Data.Word.Word\n , Data.Word.Word8\n , Data.Word.Word16\n , Data.Word.Word32\n , Data.Word.Word64\n\n -- ** Ratio\n , Data.Ratio.Ratio\n , (Data.Ratio.%)\n , Data.Ratio.numerator\n , Data.Ratio.denominator\n , Data.Ratio.approxRational\n\n -- ** Complex\n , Data.Complex.Complex(..)\n , Data.Complex.cis\n , Data.Complex.conjugate\n , Data.Complex.imagPart\n , Data.Complex.magnitude\n , Data.Complex.mkPolar\n , Data.Complex.polar\n , Data.Complex.phase\n , Data.Complex.realPart\n\n -- ** List\n , (Data.List.!!)\n , Data.List.intercalate\n , Data.List.permutations\n , Data.List.zip\n , Data.List.zipWith\n#if MIN_VERSION_base(4, 8, 0)\n , Data.List.uncons\n#else\n , uncons\n#endif\n , Data.List.unzip\n\n -- ** String\n , Data.String.String\n , Data.String.IsString\n , Text.Printf.printf\n , Text.Printf.PrintfType\n\n -- * Basic type classes\n\n -- ** Ordering\n , Data.Eq.Eq(..)\n , Data.Ord.Ordering(..)\n , Data.Ord.Ord(..)\n\n -- ** Numerics\n , Prelude.Enum(..)\n , Prelude.Bounded(..)\n , Prelude.Num(..)\n , Prelude.Real(..)\n , Prelude.Integral(..)\n , Prelude.Fractional(..)\n , Prelude.Floating(..)\n , Prelude.RealFrac(..)\n , Prelude.RealFloat(..)\n , Prelude.subtract\n , Prelude.even\n , Prelude.odd\n , Prelude.gcd\n , Prelude.lcm\n , (Prelude.^)\n , (Prelude.^^)\n , Prelude.fromIntegral\n , Prelude.realToFrac\n\n -- ** Bits\n , Data.Bits.Bits\n , (Data.Bits..&.)\n , (Data.Bits..|.)\n , Data.Bits.xor\n , Data.Bits.complement\n , Data.Bits.shift\n , Data.Bits.rotate\n , Data.Bits.bit\n , Data.Bits.setBit\n , Data.Bits.clearBit\n , Data.Bits.complementBit\n , Data.Bits.testBit\n , Data.Bits.isSigned\n , Data.Bits.shiftL\n , Data.Bits.shiftR\n , Data.Bits.rotateL\n , Data.Bits.rotateR\n\n -- ** Read\n , Text.Read.ReadS\n , Text.Read.Read\n , Text.Read.readsPrec\n , Text.Read.readList\n , Text.Read.reads\n , Text.Read.readParen\n , Text.Read.read\n , maybeRead\n , Text.Read.lex\n\n -- ** Show\n , Text.Show.ShowS\n , Text.Show.Show(..)\n , Text.Show.shows\n , Text.Show.showChar\n , Text.Show.showString\n , Text.Show.showParen\n , Text.Show.showListWith\n\n -- ** Monoid\n , Data.Monoid.Monoid(..)\n , (Data.Monoid.<>)\n\n -- ** Foldable\n , Data.Foldable.Foldable(..)\n#if !MIN_VERSION_base(4, 8, 0)\n , Data.Foldable.toList\n , null\n , length\n , Data.Foldable.elem\n , Data.Foldable.maximum\n , Data.Foldable.minimum\n , Data.Foldable.sum\n , Data.Foldable.product\n#endif\n , Data.Foldable.foldlM\n , Data.Foldable.foldrM\n , Data.Foldable.traverse_\n , Data.Foldable.for_\n , Data.Foldable.sequenceA_\n , Data.Foldable.asum\n , Data.Foldable.concatMap\n , Data.Foldable.and\n , Data.Foldable.or\n , Data.Foldable.any\n , Data.Foldable.all\n , sum'\n , prod'\n , Data.Foldable.maximumBy\n , Data.Foldable.minimumBy\n , Data.Foldable.notElem\n , Data.Foldable.find\n\n -- ** Traversable\n , Data.Traversable.Traversable(..)\n , Data.Traversable.for\n , Data.Traversable.forM\n , Data.Traversable.mapAccumL\n , Data.Traversable.mapAccumR\n , Data.Traversable.fmapDefault\n , Data.Traversable.foldMapDefault\n\n -- ** Category\n , Control.Category.Category\n , Control.Category.id\n , (Control.Category..)\n , (Control.Category.<<<)\n , (Control.Category.>>>)\n\n -- ** Arrow\n , Control.Arrow.Arrow\n , Control.Arrow.arr\n , Control.Arrow.first\n , Control.Arrow.second\n , (Control.Arrow.***)\n , (Control.Arrow.&&&)\n , Control.Arrow.returnA\n , (Control.Arrow.^>>)\n , (Control.Arrow.>>^)\n , Control.Arrow.ArrowChoice\n , Control.Arrow.left\n , Control.Arrow.right\n , (Control.Arrow.+++)\n , (Control.Arrow.|||)\n\n -- ** Functor\n , Data.Functor.Functor(..)\n , (Data.Functor.<$>)\n#if MIN_VERSION_base(4, 7, 0)\n , (Data.Functor.$>)\n#else\n , ($>)\n#endif\n , Data.Functor.void\n\n -- ** Applicative\n , Control.Applicative.Applicative(..)\n , Control.Applicative.Alternative(..)\n , Control.Applicative.Const(..)\n , (Control.Applicative.<**>)\n , Control.Applicative.optional\n\n -- ** Monad\n , Control.Monad.Monad(..)\n , Control.Monad.MonadPlus(..)\n , (Control.Monad.=<<)\n , (Control.Monad.<=<)\n , (Control.Monad.>=>)\n , Control.Monad.join\n , Control.Monad.forever\n , Control.Monad.guard\n , Control.Monad.when\n , Control.Monad.unless\n\n -- ** Generic\n , GHC.Generics.Generic\n\n -- ** Typeable\n , Data.Typeable.Typeable\n\n -- ** Type-level programming\n#if MIN_VERSION_base(4, 7, 0)\n , Data.Proxy.Proxy(Proxy)\n , Data.Proxy.asProxyTypeOf\n , Data.Proxy.KProxy(KProxy)\n#endif\n\n -- * Functions\n\n -- ** Tuples\n , Data.Tuple.fst\n , Data.Tuple.snd\n , Data.Tuple.curry\n , Data.Tuple.uncurry\n , Data.Tuple.swap\n\n -- ** Utility\n , (Data.Function.$)\n , Data.Function.flip\n , Data.Function.fix\n , Prelude.seq\n , (Prelude.$!)\n , Prelude.asTypeOf\n , Data.Function.on\n , Prelude.until\n , Prelude.error\n\n -- ** Debugging\n , Prelude.undefined\n , Debug.Trace.trace\n , Debug.Trace.traceShow\n , Debug.Trace.traceStack\n#if MIN_VERSION_base(4, 7, 0)\n , Debug.Trace.traceId\n , Debug.Trace.traceShowId\n#else\n , traceId\n , traceShowId\n#endif\n\n ) where\nimport qualified Prelude\nimport qualified Control.Applicative\nimport qualified Control.Arrow\nimport qualified Control.Category\nimport qualified Control.Monad\nimport qualified Data.Bits\nimport qualified Data.Bool\nimport qualified Data.Char\nimport qualified Data.Complex\nimport qualified Data.Either\nimport qualified Data.Eq\nimport qualified Data.Foldable\nimport qualified Data.Functor\nimport qualified Data.Function\nimport qualified Data.List\nimport qualified Data.Maybe\nimport qualified Data.Monoid\nimport qualified Data.Ord\n#if MIN_VERSION_base(4, 7, 0)\nimport qualified Data.Proxy\n#endif\nimport qualified Data.Ratio\nimport qualified Data.String\nimport qualified Data.Traversable\nimport qualified Data.Typeable\nimport qualified Data.Word\nimport qualified Data.Tuple\nimport qualified Debug.Trace\nimport qualified GHC.Generics\n#if MIN_VERSION_base(4, 8, 0)\nimport qualified Numeric.Natural (Natural)\n#endif\nimport qualified Text.Read\nimport qualified Text.Show\nimport qualified Text.Printf\nimport Data.Maybe (Maybe(..))\nimport Data.String (String)\nimport Text.Read (Read, reads)\n\n#if !MIN_VERSION_base(4, 7, 0)\ninfixl 4 $>\n($>) :: Functor f => f a -> b -> f b\n($>) = Data.Functor.flip (Data.<$)\n#endif\n\n#if !MIN_VERSION_base(4, 8, 0)\n-- | Note: if base is older than 4.8, this may not be very efficient.\nnull :: Data.Foldable.Foldable t => t a -> Data.Bool.Bool\nnull = Data.Foldable.foldr (\\_ _ -> Data.Bool.False) Data.Bool.True\n\n-- | Note: if base is older than 4.8, this will always be /O(n)/. If\n-- performance is critical, consider explicitly importing from\n-- @Data.Foldable@ or use the specialized versions.\nlength :: Data.Foldable.Foldable t => t a -> Prelude.Int\nlength = Data.Foldable.foldr (\\_ x -> Prelude.succ x) 0\n#endif\n\n-- | Strict version of 'sum'.\nsum' :: (Data.Foldable.Foldable t, Prelude.Num a) => t a -> a\nsum' = Data.Foldable.foldl' (Prelude.+) 0\n\n-- | Strict version of 'prod'.\nprod' :: (Data.Foldable.Foldable t, Prelude.Num a) => t a -> a\nprod' = Data.Foldable.foldl' (Prelude.*) 1\n\n#if !MIN_VERSION_base(4, 7, 0)\ntraceId :: Show a => a -> a\ntraceId a = Debug.Trace.trace a a\n\ntraceShowId :: Show a => a -> a\ntraceShowId a = Debug.Trace.traceShow a a\n#endif\n\n#if !MIN_VERSION_base(4, 8, 0)\nuncons :: [a] -> Maybe (a, [a])\nuncons [] = Nothing\nuncons (x : xs) = Just (x, xs)\n#endif\n\nmaybeRead :: Read a => String -> Maybe a\nmaybeRead s = do\n case reads s of\n [(x, \"\")] -> Just x\n _ -> Nothing\n", "meta": {"hexsha": "cc35a345937ba3643af90f5ecd30a130769b9ada", "size": 8368, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "Calico/Base.hs", "max_stars_repo_name": "Rufflewind/calico-hs", "max_stars_repo_head_hexsha": "c1dbdc2ceb7b5ef691247e668fa2500b8ecd4b2e", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Calico/Base.hs", "max_issues_repo_name": "Rufflewind/calico-hs", "max_issues_repo_head_hexsha": "c1dbdc2ceb7b5ef691247e668fa2500b8ecd4b2e", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Calico/Base.hs", "max_forks_repo_name": "Rufflewind/calico-hs", "max_forks_repo_head_hexsha": "c1dbdc2ceb7b5ef691247e668fa2500b8ecd4b2e", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 21.7916666667, "max_line_length": 69, "alphanum_fraction": 0.6592973231, "num_tokens": 2577, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.519521321952093, "lm_q2_score": 0.6187804337438501, "lm_q1q2_score": 0.32146962893669445}} {"text": "{-# LANGUAGE DataKinds #-}\n{-# LANGUAGE ScopedTypeVariables #-}\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE TypeOperators #-}\n{-# LANGUAGE TypeFamilies #-}\n{-# LANGUAGE FlexibleContexts #-}\n{-# LANGUAGE MultiParamTypeClasses #-}\n{-|\nModule : Grenade.Layers.Crop\nDescription : Cropping layer\nCopyright : (c) Huw Campbell, 2016-2017\nLicense : BSD2\nStability : experimental\n-}\nmodule Grenade.Layers.Crop (\n Crop (..)\n ) where\n\nimport Data.Maybe\nimport Data.Proxy\nimport Data.Singletons.TypeLits\nimport GHC.TypeLits\n\nimport Grenade.Core\nimport Grenade.Layers.Internal.Pad\n\nimport Numeric.LinearAlgebra (konst, subMatrix, diagBlock)\nimport Numeric.LinearAlgebra.Static (extract, create)\n\n-- | A cropping layer for a neural network.\ndata Crop :: Nat\n -> Nat\n -> Nat\n -> Nat -> * where\n Crop :: Crop cropLeft cropTop cropRight cropBottom\n\ninstance Show (Crop cropLeft cropTop cropRight cropBottom) where\n show Crop = \"Crop\"\n\ninstance UpdateLayer (Crop l t r b) where\n type Gradient (Crop l t r b) = ()\n runUpdate _ x _ = x\n createRandom = return Crop\n\n-- | A two dimentional image can be cropped.\ninstance ( KnownNat cropLeft\n , KnownNat cropTop\n , KnownNat cropRight\n , KnownNat cropBottom\n , KnownNat inputRows\n , KnownNat inputColumns\n , KnownNat outputRows\n , KnownNat outputColumns\n , (outputRows + cropTop + cropBottom) ~ inputRows\n , (outputColumns + cropLeft + cropRight) ~ inputColumns\n ) => Layer (Crop cropLeft cropTop cropRight cropBottom) ('D2 inputRows inputColumns) ('D2 outputRows outputColumns) where\n type Tape (Crop cropLeft cropTop cropRight cropBottom) ('D2 inputRows inputColumns) ('D2 outputRows outputColumns) = ()\n runForwards Crop (S2D input) =\n let cropl = fromIntegral $ natVal (Proxy :: Proxy cropLeft)\n cropt = fromIntegral $ natVal (Proxy :: Proxy cropTop)\n nrows = fromIntegral $ natVal (Proxy :: Proxy outputRows)\n ncols = fromIntegral $ natVal (Proxy :: Proxy outputColumns)\n m = extract input\n r = subMatrix (cropt, cropl) (nrows, ncols) m\n in ((), S2D . fromJust . create $ r)\n runBackwards _ _ (S2D dEdy) =\n let cropl = fromIntegral $ natVal (Proxy :: Proxy cropLeft)\n cropt = fromIntegral $ natVal (Proxy :: Proxy cropTop)\n cropr = fromIntegral $ natVal (Proxy :: Proxy cropRight)\n cropb = fromIntegral $ natVal (Proxy :: Proxy cropBottom)\n eo = extract dEdy\n vs = diagBlock [konst 0 (cropt,cropl), eo, konst 0 (cropb,cropr)]\n in ((), S2D . fromJust . create $ vs)\n\n\n-- | A two dimentional image can be cropped.\ninstance ( KnownNat cropLeft\n , KnownNat cropTop\n , KnownNat cropRight\n , KnownNat cropBottom\n , KnownNat inputRows\n , KnownNat inputColumns\n , KnownNat outputRows\n , KnownNat outputColumns\n , KnownNat channels\n , KnownNat (inputRows * channels)\n , KnownNat (outputRows * channels)\n , (outputRows + cropTop + cropBottom) ~ inputRows\n , (outputColumns + cropLeft + cropRight) ~ inputColumns\n ) => Layer (Crop cropLeft cropTop cropRight cropBottom) ('D3 inputRows inputColumns channels) ('D3 outputRows outputColumns channels) where\n type Tape (Crop cropLeft cropTop cropRight cropBottom) ('D3 inputRows inputColumns channels) ('D3 outputRows outputColumns channels) = ()\n runForwards Crop (S3D input) =\n let padl = fromIntegral $ natVal (Proxy :: Proxy cropLeft)\n padt = fromIntegral $ natVal (Proxy :: Proxy cropTop)\n padr = fromIntegral $ natVal (Proxy :: Proxy cropRight)\n padb = fromIntegral $ natVal (Proxy :: Proxy cropBottom)\n inr = fromIntegral $ natVal (Proxy :: Proxy inputRows)\n inc = fromIntegral $ natVal (Proxy :: Proxy inputColumns)\n outr = fromIntegral $ natVal (Proxy :: Proxy outputRows)\n outc = fromIntegral $ natVal (Proxy :: Proxy outputColumns)\n ch = fromIntegral $ natVal (Proxy :: Proxy channels)\n m = extract input\n cropped = crop ch padl padt padr padb outr outc inr inc m\n in ((), S3D . fromJust . create $ cropped)\n\n runBackwards Crop () (S3D gradient) =\n let padl = fromIntegral $ natVal (Proxy :: Proxy cropLeft)\n padt = fromIntegral $ natVal (Proxy :: Proxy cropTop)\n padr = fromIntegral $ natVal (Proxy :: Proxy cropRight)\n padb = fromIntegral $ natVal (Proxy :: Proxy cropBottom)\n inr = fromIntegral $ natVal (Proxy :: Proxy inputRows)\n inc = fromIntegral $ natVal (Proxy :: Proxy inputColumns)\n outr = fromIntegral $ natVal (Proxy :: Proxy outputRows)\n outc = fromIntegral $ natVal (Proxy :: Proxy outputColumns)\n ch = fromIntegral $ natVal (Proxy :: Proxy channels)\n m = extract gradient\n padded = pad ch padl padt padr padb outr outc inr inc m\n in ((), S3D . fromJust . create $ padded)\n", "meta": {"hexsha": "4b8b7597764a4176bfe09eaad9ca11961fe71db8", "size": 5109, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/Grenade/Layers/Crop.hs", "max_stars_repo_name": "sholland1/grenade", "max_stars_repo_head_hexsha": "b613502971fe43f4066d492912d45b57083dacd8", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/Grenade/Layers/Crop.hs", "max_issues_repo_name": "sholland1/grenade", "max_issues_repo_head_hexsha": "b613502971fe43f4066d492912d45b57083dacd8", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/Grenade/Layers/Crop.hs", "max_forks_repo_name": "sholland1/grenade", "max_forks_repo_head_hexsha": "b613502971fe43f4066d492912d45b57083dacd8", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 42.9327731092, "max_line_length": 148, "alphanum_fraction": 0.6359365825, "num_tokens": 1314, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.7341195269001831, "lm_q2_score": 0.4378234991142019, "lm_q1q2_score": 0.3214147800355006}} {"text": "{-# LANGUAGE FlexibleContexts #-}\n\nmodule Primitives where\n\nimport Types\nimport Environment\nimport Parsing\nimport Evaluation\n\nimport qualified Data.Text as T\n\nimport System.IO\nimport Control.Monad.Except\nimport Data.Bifunctor\n\nimport Data.Complex\nimport Data.Ratio\nimport Data.Fixed\n\n\nprimitiveBindings :: IO Env\nprimitiveBindings = nullEnv >>= flip bindVars (map (second IOFunc) ioPrimitives\n ++ map (second PrimitiveFunc) primitives\n ++ primitiveVariables )\n\n-------------------------\n-- Default variables\n-------------------------\n\nprimitiveVariables :: [(T.Text, LispVal)]\nprimitiveVariables = [(\"stdlib\", String \"lib/stdlib.scm\")]\n\n-------------------------\n-- IO Primitive functions\n-------------------------\n\nioPrimitives :: [(T.Text, [LispVal] -> IOThrowsError LispVal)]\nioPrimitives = [(\"apply\", applyProc),\n (\"open-input-file\", makePort ReadMode),\n (\"open-output-file\", makePort WriteMode),\n (\"close-input-port\", closePort),\n (\"close-output-port\", closePort),\n (\"read\", readProc),\n (\"write\", writeProc),\n (\"display\", writeProc),\n (\"newline\", newline),\n (\"read-contents\", readContents),\n (\"read-all\", readAll)]\n\napplyProc :: [LispVal] -> IOThrowsError LispVal\napplyProc [func, List args] = apply func args\napplyProc (func : args) = apply func args\napplyProc params = throwError $ NumArgs 2 params -- TODO This is actually a min\n\nmakePort :: IOMode -> [LispVal] -> IOThrowsError LispVal\nmakePort mode [String filename] = Port <$> liftIO (openFile (T.unpack filename) mode)\nmakePort _ [a] = throwError $ TypeMismatch \"port\" a\nmakePort _ params = throwError $ NumArgs 1 params\n\nclosePort :: [LispVal] -> IOThrowsError LispVal\nclosePort [Port port] = liftIO $ hClose port >> return (Bool True)\nclosePort [a] = throwError $ TypeMismatch \"port\" a\nclosePort params = throwError $ NumArgs 1 params\n\nreadProc :: [LispVal] -> IOThrowsError LispVal\nreadProc [] = readProc [Port stdin]\nreadProc [Port port] = liftIO (hGetLine port) >>= liftThrows . readExpr\nreadProc [a] = throwError $ TypeMismatch \"port\" a\nreadProc params = throwError $ VariableNumArgs [0, 1] params\n\nwriteProc :: [LispVal] -> IOThrowsError LispVal\nwriteProc [obj] = writeProc [obj, Port stdout]\nwriteProc [obj, Port port] = liftIO $ hPrint port obj >> return (Bool True)\nwriteProc [_, a] = throwError $ TypeMismatch \"port\" a\nwriteProc params = throwError $ VariableNumArgs [1, 2] params\n\nnewline :: [LispVal] -> IOThrowsError LispVal\nnewline [] = writeProc [Char '\\n', Port stdout]\nnewline [Port port] = writeProc [Char '\\n', Port port]\nnewline [a] = throwError $ TypeMismatch \"port\" a\nnewline params = throwError $ VariableNumArgs [0, 1] params\n\nreadContents :: [LispVal] -> IOThrowsError LispVal\nreadContents [String filename] = String . T.pack <$> liftIO (readFile $ T.unpack filename)\nreadContents [a] = throwError $ TypeMismatch \"string\" a\nreadContents params = throwError $ NumArgs 1 params\n\nreadAll :: [LispVal] -> IOThrowsError LispVal\nreadAll [String filename] = List <$> load filename\nreadAll [a] = throwError $ TypeMismatch \"string\" a\nreadAll params = throwError $ NumArgs 1 params\n\n-------------------------\n-- Primitive functions\n-------------------------\n\nprimitives :: [(T.Text, [LispVal] -> ThrowsError LispVal)]\nprimitives =\n [ (\"+\", numAdd)\n , (\"-\", numSub)\n , (\"*\", numMul)\n , (\"/\", numDiv)\n , (\"mod\", numMod)\n\n , (\"quotient\", numericBinop quot)\n , (\"remainder\", numericBinop rem)\n\n , (\"null?\", unaryOp null')\n , (\"not\", unaryOp not')\n , (\"symbol?\", unaryOp symbolp)\n , (\"string?\", unaryOp stringp)\n , (\"number?\", unaryOp numberp)\n , (\"bool?\", unaryOp boolp)\n , (\"pair?\", unaryOp pair')\n , (\"list?\", unaryOp listp)\n , (\"symbol->string\", unaryOp symbol2string)\n , (\"string->symbol\", unaryOp string2symbol)\n\n , (\"=\", numBoolBinopEq)\n , (\">\", numBoolBinopGt)\n , (\">=\", numBoolBinopGte)\n , (\"<\", numBoolBinopLt)\n , (\"<=\", numBoolBinopLte)\n\n , (\"&&\", boolBoolBinop (&&))\n , (\"||\", boolBoolBinop (||))\n , (\"string=?\", strBoolBinop (==))\n , (\"string?\", strBoolBinop (>))\n , (\"string<=?\", strBoolBinop (<=))\n , (\"string>=?\", strBoolBinop (>=))\n , (\"string-length\", stringLen)\n , (\"string-ref\", stringRef)\n , (\"car\", car)\n , (\"cdr\", cdr)\n , (\"cons\", cons)\n , (\"eq?\", eqv)\n , (\"eqv?\", eqv)\n , (\"equal?\", eqv)\n ]\n\n-- - Begin GenUtil - http://repetae.net/computer/haskell/GenUtil.hs\nfoldlM :: Monad m => (a -> b -> m a) -> a -> [b] -> m a\nfoldlM f v (x : xs) = (f v x) >>= \\ a -> foldlM f a xs\nfoldlM _ v [] = return v\n\nfoldl1M :: Monad m => (a -> a -> m a) -> [a] -> m a\nfoldl1M f (x : xs) = foldlM f x xs\nfoldl1M _ _ = error \"Unexpected error in foldl1M\"\n-- end GenUtil\n\n-- |Accept two numbers and cast one of them to the appropriate type, if necessary\nnumCast' :: (LispVal, LispVal) -> ThrowsError (LispVal, LispVal)\nnumCast' (a@(Number _), b@(Number _)) = return $ (a, b)\nnumCast' (a@(Float _), b@(Float _)) = return $ (a, b)\nnumCast' (a@(Ratio _), b@(Ratio _)) = return $ (a, b)\nnumCast' (a@(Complex _), b@(Complex _)) = return $ (a, b)\nnumCast' ((Number a), b@(Float _)) = return $ (Float $ fromInteger a, b)\nnumCast' ((Number a), b@(Ratio _)) = return $ (Ratio $ fromInteger a, b)\nnumCast' ((Number a), b@(Complex _)) = return $ (Complex $ fromInteger a, b)\nnumCast' (a@(Float _), (Number b)) = return $ (a, Float $ fromInteger b)\nnumCast' (a@(Float _), (Ratio b)) = return $ (a, Float $ fromRational b)\nnumCast' ((Float a), b@(Complex _)) = return $ (Complex $ a :+ 0, b)\nnumCast' (a@(Ratio _), (Number b)) = return $ (a, Ratio $ fromInteger b)\nnumCast' ((Ratio a), b@(Float _)) = return $ (Float $ fromRational a, b)\nnumCast' ((Ratio a), b@(Complex _)) = return $ (Complex $ (fromInteger $ numerator a) / (fromInteger $ denominator a), b)\nnumCast' (a@(Complex _), (Number b)) = return $ (a, Complex $ fromInteger b)\nnumCast' (a@(Complex _), (Float b)) = return $ (a, Complex $ b :+ 0)\nnumCast' (a@(Complex _), (Ratio b)) = return $ (a, Complex $ (fromInteger $ numerator b) / (fromInteger $ denominator b))\nnumCast' (a, b) = case a of\n Number _ -> doThrowError b\n Float _ -> doThrowError b\n Ratio _ -> doThrowError b\n Complex _ -> doThrowError b\n _ -> doThrowError a\n where doThrowError num = throwError $ TypeMismatch \"number\" num\n\n-- |Accept two numbers and cast one of them to the appropriate type, if necessary\nnumCast :: [LispVal] -> ThrowsError LispVal\nnumCast [a, b] = do\n (a', b') <- numCast' (a, b)\n pure $ List [a', b']\nnumCast _ = throwError $ Default \"Unexpected error in numCast\"\n\n-- |Add the given numbers\nnumAdd :: [LispVal] -> ThrowsError LispVal\nnumAdd [] = return $ Number 0\nnumAdd aparams = do\n foldl1M (\\ a b -> doAdd =<< (numCast [a, b])) aparams\n where doAdd (List [(Number a), (Number b)]) = return $ Number $ a + b\n doAdd (List [(Float a), (Float b)]) = return $ Float $ a + b\n doAdd (List [(Ratio a), (Ratio b)]) = return $ Ratio $ a + b\n doAdd (List [(Complex a), (Complex b)]) = return $ Complex $ a + b\n doAdd _ = throwError $ Default \"Unexpected error in +\"\n\n-- |Subtract the given numbers\nnumSub :: [LispVal] -> ThrowsError LispVal\nnumSub [] = throwError $ NumArgs 1 []\nnumSub [Number n] = return $ Number $ -1 * n\nnumSub [Float n] = return $ Float $ -1 * n\nnumSub [Ratio n] = return $ Ratio $ -1 * n\nnumSub [Complex n] = return $ Complex $ -1 * n\nnumSub aparams = do\n foldl1M (\\ a b -> doSub =<< (numCast [a, b])) aparams\n where doSub (List [(Number a), (Number b)]) = return $ Number $ a - b\n doSub (List [(Float a), (Float b)]) = return $ Float $ a - b\n doSub (List [(Ratio a), (Ratio b)]) = return $ Ratio $ a - b\n doSub (List [(Complex a), (Complex b)]) = return $ Complex $ a - b\n doSub _ = throwError $ Default \"Unexpected error in -\"\n\n-- |Multiply the given numbers\nnumMul :: [LispVal] -> ThrowsError LispVal\nnumMul [] = return $ Number 1\nnumMul aparams = do\n foldl1M (\\ a b -> doMul =<< (numCast [a, b])) aparams\n where doMul (List [(Number a), (Number b)]) = return $ Number $ a * b\n doMul (List [(Float a), (Float b)]) = return $ Float $ a * b\n doMul (List [(Ratio a), (Ratio b)]) = return $ Ratio $ a * b\n doMul (List [(Complex a), (Complex b)]) = return $ Complex $ a * b\n doMul _ = throwError $ Default \"Unexpected error in *\"\n\n-- |Divide the given numbers\nnumDiv :: [LispVal] -> ThrowsError LispVal\nnumDiv [] = throwError $ NumArgs 1 []\nnumDiv [Number 0] = throwError $ DivideByZero\nnumDiv [Ratio 0] = throwError $ DivideByZero\nnumDiv [Number n] = return $ Ratio $ 1 / (fromInteger n)\nnumDiv [Float n] = return $ Float $ 1.0 / n\nnumDiv [Ratio n] = return $ Ratio $ 1 / n\nnumDiv [Complex n] = return $ Complex $ 1 / n\nnumDiv aparams = do\n foldl1M (\\ a b -> doDiv =<< (numCast [a, b])) aparams\n where doDiv (List [(Number a), (Number b)])\n | b == 0 = throwError $ DivideByZero\n | (mod a b) == 0 = return $ Number $ div a b\n | otherwise = -- Not an integer\n return $ Ratio $ (fromInteger a) / (fromInteger b)\n doDiv (List [(Float a), (Float b)])\n | b == 0.0 = throwError $ DivideByZero\n | otherwise = return $ Float $ a / b\n doDiv (List [(Ratio a), (Ratio b)])\n | b == 0 = throwError $ DivideByZero\n | otherwise = return $ Ratio $ a / b\n doDiv (List [(Complex a), (Complex b)])\n | b == 0 = throwError $ DivideByZero\n | otherwise = return $ Complex $ a / b\n doDiv _ = throwError $ Default \"Unexpected error in /\"\n\n-- |Take the modulus of the given numbers\nnumMod :: [LispVal] -> ThrowsError LispVal\nnumMod [] = return $ Number 1\nnumMod aparams = do\n foldl1M (\\ a b -> doMod =<< (numCast [a, b])) aparams\n where doMod (List [(Number a), (Number b)]) = return $ Number $ mod' a b\n doMod (List [(Float a), (Float b)]) = return $ Float $ mod' a b\n doMod (List [(Ratio a), (Ratio b)]) = return $ Ratio $ mod' a b\n doMod (List [(Complex _), (Complex _)]) = throwError $ Default \"modulo not implemented for complex numbers\"\n doMod _ = throwError $ Default \"Unexpected error in modulo\"\n\nnumericBinop :: (Integer -> Integer -> Integer) -> [LispVal] -> ThrowsError LispVal\nnumericBinop _ [] = throwError $ NumArgs 2 []\nnumericBinop _ singleVal@[_] = throwError $ NumArgs 2 singleVal\nnumericBinop op params = Number . foldl1 op <$> mapM unpackNum params\n\nunaryOp :: (LispVal -> LispVal) -> [LispVal] -> ThrowsError LispVal\nunaryOp f [v] = return $ f v\nunaryOp _ params = throwError $ NumArgs 1 params\n\nnot', null', pair', symbolp, numberp, stringp, boolp, listp, symbol2string, string2symbol :: LispVal -> LispVal\n\nnot' (Bool x) = (Bool . not) x\nnot' _ = Bool False\n\nnull' (List []) = Bool True\nnull' _ = Bool False\n\npair' (DottedList _ _) = Bool True\npair' _ = Bool False\n\nsymbolp (Atom _) = Bool True\nsymbolp _ = Bool False\n\nnumberp (Number _) = Bool True\nnumberp _ = Bool False\n\nstringp (String _) = Bool True\nstringp _ = Bool False\n\nboolp (Bool _) = Bool True\nboolp _ = Bool False\n\nlistp (List _) = Bool True\nlistp (DottedList _ _) = Bool True\nlistp _ = Bool False\n\nsymbol2string (Atom s) = String s\nsymbol2string _ = String \"\"\n\nstring2symbol (String s) = Atom s\nstring2symbol _ = Atom \"\"\n\nstringLen :: [LispVal] -> ThrowsError LispVal\nstringLen [(String s)] = Right $ Number $ fromIntegral $ T.length s\nstringLen [notString] = throwError $ TypeMismatch \"string\" notString\nstringLen badArgList = throwError $ NumArgs 1 badArgList\n\nstringRef :: [LispVal] -> ThrowsError LispVal\nstringRef [(String s), (Number k)]\n | T.length s < k' + 1 = throwError $ Default \"Out of bound error\"\n | otherwise = Right $ Char $ T.index s $ fromIntegral k\n where k' = fromIntegral k\nstringRef [(String _), notNum] = throwError $ TypeMismatch \"number\" notNum\nstringRef [notString, _] = throwError $ TypeMismatch \"string\" notString\nstringRef badArgList = throwError $ NumArgs 2 badArgList\n\n\nboolBinop :: (LispVal -> ThrowsError a) -> (a -> a -> Bool) -> [LispVal] -> ThrowsError LispVal\nboolBinop unpacker op args =\n if length args /= 2\n then throwError $ NumArgs 2 args\n else do\n left <- unpacker $ head args\n right <- unpacker $ args !! 1\n return $ Bool $ left `op` right\n\nnumBoolBinop :: (Integer -> Integer -> Bool) -> [LispVal] -> ThrowsError LispVal\nnumBoolBinop = boolBinop unpackNum\nstrBoolBinop :: (T.Text -> T.Text -> Bool) -> [LispVal] -> ThrowsError LispVal\nstrBoolBinop = boolBinop unpackStr\nboolBoolBinop :: (Bool -> Bool -> Bool) -> [LispVal] -> ThrowsError LispVal\nboolBoolBinop = boolBinop unpackBool\n\n-- |Compare a series of numbers using a given numeric comparison\n-- function and an array of lisp values\nnumBoolBinopCompare :: (LispVal\n -> LispVal -> Either LispError LispVal)\n -> LispVal -> [LispVal] -> Either LispError LispVal\nnumBoolBinopCompare cmp n1 (n2 : ns) = do\n (n1', n2') <- numCast' (n1, n2)\n result <- cmp n1' n2'\n case result of\n Bool True -> numBoolBinopCompare cmp n2' ns\n _ -> return $ Bool False\nnumBoolBinopCompare _ _ _ = return $ Bool True\n\n-- |Numeric equals\nnumBoolBinopEq :: [LispVal] -> ThrowsError LispVal\nnumBoolBinopEq [] = throwError $ NumArgs 0 []\nnumBoolBinopEq (n : ns) = numBoolBinopCompare cmp n ns\n where\n f a b = a == b\n cmp (Number a) (Number b) = return $ Bool $ f a b\n cmp (Float a) (Float b) = return $ Bool $ f a b\n cmp (Ratio a) (Ratio b) = return $ Bool $ f a b\n cmp (Complex a) (Complex b) = return $ Bool $ f a b\n cmp _ _ = throwError $ Default \"Unexpected error in =\"\n\n-- |Numeric greater than\nnumBoolBinopGt :: [LispVal] -> ThrowsError LispVal\nnumBoolBinopGt [] = throwError $ NumArgs 0 []\nnumBoolBinopGt (n : ns) = numBoolBinopCompare cmp n ns\n where\n f a b = a > b\n cmp (Number a) (Number b) = return $ Bool $ f a b\n cmp (Float a) (Float b) = return $ Bool $ f a b\n cmp (Ratio a) (Ratio b) = return $ Bool $ f a b\n cmp _ _ = throwError $ Default \"Unexpected error in >\"\n\n-- |Numeric greater than equal\nnumBoolBinopGte :: [LispVal] -> ThrowsError LispVal\nnumBoolBinopGte [] = throwError $ NumArgs 0 []\nnumBoolBinopGte (n : ns) = numBoolBinopCompare cmp n ns\n where\n f a b = a >= b\n cmp (Number a) (Number b) = return $ Bool $ f a b\n cmp (Float a) (Float b) = return $ Bool $ f a b\n cmp (Ratio a) (Ratio b) = return $ Bool $ f a b\n cmp _ _ = throwError $ Default \"Unexpected error in >=\"\n\n-- |Numeric less than\nnumBoolBinopLt :: [LispVal] -> ThrowsError LispVal\nnumBoolBinopLt [] = throwError $ NumArgs 0 []\nnumBoolBinopLt (n : ns) = numBoolBinopCompare cmp n ns\n where\n f a b = a < b\n cmp (Number a) (Number b) = return $ Bool $ f a b\n cmp (Float a) (Float b) = return $ Bool $ f a b\n cmp (Ratio a) (Ratio b) = return $ Bool $ f a b\n cmp _ _ = throwError $ Default \"Unexpected error in <\"\n\n-- |Numeric less than equal\nnumBoolBinopLte :: [LispVal] -> ThrowsError LispVal\nnumBoolBinopLte [] = throwError $ NumArgs 0 []\nnumBoolBinopLte (n : ns) = numBoolBinopCompare cmp n ns\n where\n f a b = a <= b\n cmp (Number a) (Number b) = return $ Bool $ f a b\n cmp (Float a) (Float b) = return $ Bool $ f a b\n cmp (Ratio a) (Ratio b) = return $ Bool $ f a b\n cmp _ _ = throwError $ Default \"Unexpected error in <=\"\n\ncar :: [LispVal] -> ThrowsError LispVal\ncar [List (x : _)] = return x\ncar [DottedList (x : _) _] = return x\ncar [badArg] = throwError $ TypeMismatch \"pair\" badArg\ncar badArgList = throwError $ NumArgs 1 badArgList\n\ncdr :: [LispVal] -> ThrowsError LispVal\ncdr [List (_ : xs)] = return $ List xs\ncdr [DottedList [_] x] = return x\ncdr [DottedList (_ : xs) x] = return $ DottedList xs x\ncdr [badArg] = throwError $ TypeMismatch \"pair\" badArg\ncdr badArgList = throwError $ NumArgs 1 badArgList\n\ncons :: [LispVal] -> ThrowsError LispVal\ncons [x1, List []] = return $ List [x1]\ncons [x, List xs] = return $ List $ x : xs\ncons [x, DottedList xs xlast] = return $ DottedList (x : xs) xlast\ncons [x1, x2] = return $ DottedList [x1] x2\ncons badArgList = throwError $ NumArgs 2 badArgList\n", "meta": {"hexsha": "59bc860601790e1fd9e145075ae87581709b3499", "size": 16658, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/Primitives.hs", "max_stars_repo_name": "guimcaballero/scheme-hs", "max_stars_repo_head_hexsha": "7b4de3130cd614d654cf4837a22dcfe8c9c67416", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/Primitives.hs", "max_issues_repo_name": "guimcaballero/scheme-hs", "max_issues_repo_head_hexsha": "7b4de3130cd614d654cf4837a22dcfe8c9c67416", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/Primitives.hs", "max_forks_repo_name": "guimcaballero/scheme-hs", "max_forks_repo_head_hexsha": "7b4de3130cd614d654cf4837a22dcfe8c9c67416", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 39.567695962, "max_line_length": 121, "alphanum_fraction": 0.6099171569, "num_tokens": 4984, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.600188359260205, "lm_q2_score": 0.5350984286266115, "lm_q1q2_score": 0.32115984792011987}} {"text": "-- This file is auto-generated. Do not edit directly.\n-- |\n-- Stability: Experimental\n--\n-- Generic interface to Blas using safe foreign calls. Refer to the GHC documentation\n-- for more information regarding appropriate use of safe and unsafe foreign calls.\n--\n-- The functions here are named in a similar fashion to the original Blas interface, with\n-- the type-dependent letter(s) removed. Some functions have been merged with\n-- others to allow the interface to work on both real and complex numbers. If you can't a\n-- particular function, try looking for its corresponding complex equivalent (e.g.\n-- @symv@ is a special case of 'hemv' applied to real numbers).\n--\n-- Note: although complex versions of @rot@ and @rotg@ exist in many implementations,\n-- they are not part of the official Blas standard and therefore not included here. If\n-- you /really/ need them, submit a ticket so we can try to come up with a solution.\n--\n-- The documentation here is still incomplete. Consult the\n-- for more\n-- information.\n--\n-- Notation:\n--\n-- * @\u22c5@ denotes dot product (without any conjugation).\n-- * @*@ denotes complex conjugation.\n-- * @\u22a4@ denotes transpose.\n-- * @\u2020@ denotes conjugate transpose (Hermitian conjugate).\n--\n-- Conventions:\n--\n-- * All scalars are denoted with lowercase Greek letters\n-- * All vectors are denoted with lowercase Latin letters and are\n-- assumed to be column vectors (unless transposed).\n-- * All matrices are denoted with uppercase Latin letters.\n{-# LANGUAGE FlexibleInstances, TypeFamilies #-}\nmodule Blas.Generic.Safe (\n Numeric(..)\n , RealNumeric(..)\n , D.dsdot\n , S.sdsdot\n ) where\nimport Prelude (Floating, Double, Float, Int, IO)\nimport Data.Complex (Complex)\nimport Foreign (Ptr, Storable)\nimport Blas.Primitive.Types (Order, Transpose, Uplo, Diag, Side)\nimport qualified Blas.Specialized.Float.Safe as S\nimport qualified Blas.Specialized.Double.Safe as D\nimport qualified Blas.Specialized.ComplexFloat.Safe as C\nimport qualified Blas.Specialized.ComplexDouble.Safe as Z\n\n-- | Blas operations that are applicable to real and complex numbers.\n--\n-- Instances are defined for the 4 types supported by Blas: the single- and\n-- double-precision floating point types and their complex versions.\nclass (Floating a, Storable a) => Numeric a where\n\n -- | The corresponding real type of @a@.\n --\n -- In other words, @'RealType' ('Complex' a)@ is an alias for @a@. For everything\n -- else, @'RealType' a@ is simply @a@.\n type RealType a :: *\n -- | Swap two vectors:\n --\n -- > (x, y) \u2190 (y, x)\n swap :: Int\n -> Ptr a\n -> Int\n -> Ptr a\n -> Int\n -> IO ()\n\n -- | Multiply a vector by a scalar.\n --\n -- > x \u2190 \u03b1 x\n scal :: Int\n -> a\n -> Ptr a\n -> Int\n -> IO ()\n\n -- | Copy a vector into another vector:\n --\n -- > y \u2190 x\n copy :: Int\n -> Ptr a\n -> Int\n -> Ptr a\n -> Int\n -> IO ()\n\n -- | Add a scalar-vector product to a vector.\n --\n -- > y \u2190 \u03b1 x + y\n axpy :: Int\n -> a\n -> Ptr a\n -> Int\n -> Ptr a\n -> Int\n -> IO ()\n\n -- | Calculate the bilinear dot product of two vectors:\n --\n -- > x \u22c5 y \u2261 \u2211[i] x[i] y[i]\n dotu :: Int\n -> Ptr a\n -> Int\n -> Ptr a\n -> Int\n -> IO a\n\n -- | Calculate the sesquilinear dot product of two vectors.\n --\n -- > x* \u22c5 y \u2261 \u2211[i] x[i]* y[i]\n dotc :: Int\n -> Ptr a\n -> Int\n -> Ptr a\n -> Int\n -> IO a\n\n -- | Calculate the Euclidean (L\u00b2) norm of a vector:\n --\n -- > \u2016x\u2016\u2082 \u2261 \u221a(\u2211[i] x[i]\u00b2)\n nrm2 :: Int\n -> Ptr a\n -> Int\n -> IO (RealType a)\n\n -- | Calculate the Manhattan (L\u00b9) norm, equal to the sum of the magnitudes of the elements:\n --\n -- > \u2016x\u2016\u2081 = \u2211[i] |x[i]|\n asum :: Int\n -> Ptr a\n -> Int\n -> IO (RealType a)\n\n -- | Calculate the index of the element with the maximum magnitude (absolute value).\n iamax :: Int\n -> Ptr a\n -> Int\n -> IO Int\n\n -- | Perform a general matrix-vector update.\n --\n -- > y \u2190 \u03b1 T(A) x + \u03b2 y\n gemv :: Order\n -> Transpose\n -> Int\n -> Int\n -> a\n -> Ptr a\n -> Int\n -> Ptr a\n -> Int\n -> a\n -> Ptr a\n -> Int\n -> IO ()\n\n -- | Perform a general banded matrix-vector update.\n --\n -- > y \u2190 \u03b1 T(A) x + \u03b2 y\n gbmv :: Order\n -> Transpose\n -> Int\n -> Int\n -> Int\n -> Int\n -> a\n -> Ptr a\n -> Int\n -> Ptr a\n -> Int\n -> a\n -> Ptr a\n -> Int\n -> IO ()\n\n -- | Perform a hermitian matrix-vector update.\n --\n -- > y \u2190 \u03b1 A x + \u03b2 y\n hemv :: Order\n -> Uplo\n -> Int\n -> a\n -> Ptr a\n -> Int\n -> Ptr a\n -> Int\n -> a\n -> Ptr a\n -> Int\n -> IO ()\n\n -- | Perform a hermitian banded matrix-vector update.\n --\n -- > y \u2190 \u03b1 A x + \u03b2 y\n hbmv :: Order\n -> Uplo\n -> Int\n -> Int\n -> a\n -> Ptr a\n -> Int\n -> Ptr a\n -> Int\n -> a\n -> Ptr a\n -> Int\n -> IO ()\n\n -- | Perform a hermitian packed matrix-vector update.\n --\n -- > y \u2190 \u03b1 A x + \u03b2 y\n hpmv :: Order\n -> Uplo\n -> Int\n -> a\n -> Ptr a\n -> Ptr a\n -> Int\n -> a\n -> Ptr a\n -> Int\n -> IO ()\n\n -- | Multiply a triangular matrix by a vector.\n --\n -- > x \u2190 T(A) x\n trmv :: Order\n -> Uplo\n -> Transpose\n -> Diag\n -> Int\n -> Ptr a\n -> Int\n -> Ptr a\n -> Int\n -> IO ()\n\n -- | Multiply a triangular banded matrix by a vector.\n --\n -- > x \u2190 T(A) x\n tbmv :: Order\n -> Uplo\n -> Transpose\n -> Diag\n -> Int\n -> Int\n -> Ptr a\n -> Int\n -> Ptr a\n -> Int\n -> IO ()\n\n -- | Multiply a triangular packed matrix by a vector.\n --\n -- > x \u2190 T(A) x\n tpmv :: Order\n -> Uplo\n -> Transpose\n -> Diag\n -> Int\n -> Ptr a\n -> Ptr a\n -> Int\n -> IO ()\n\n -- | Multiply an inverse triangular matrix by a vector.\n --\n -- > x \u2190 T(A\u207b\u00b9) x\n trsv :: Order\n -> Uplo\n -> Transpose\n -> Diag\n -> Int\n -> Ptr a\n -> Int\n -> Ptr a\n -> Int\n -> IO ()\n\n -- | Multiply an inverse triangular banded matrix by a vector.\n --\n -- > x \u2190 T(A\u207b\u00b9) x\n tbsv :: Order\n -> Uplo\n -> Transpose\n -> Diag\n -> Int\n -> Int\n -> Ptr a\n -> Int\n -> Ptr a\n -> Int\n -> IO ()\n\n -- | Multiply an inverse triangular packed matrix by a vector.\n --\n -- > x \u2190 T(A\u207b\u00b9) x\n tpsv :: Order\n -> Uplo\n -> Transpose\n -> Diag\n -> Int\n -> Ptr a\n -> Ptr a\n -> Int\n -> IO ()\n\n -- | Perform an unconjugated rank-1 update of a general matrix.\n --\n -- > A \u2190 \u03b1 x y\u22a4 + A\n geru :: Order\n -> Int\n -> Int\n -> a\n -> Ptr a\n -> Int\n -> Ptr a\n -> Int\n -> Ptr a\n -> Int\n -> IO ()\n\n -- | Perform a conjugated rank-1 update of a general matrix.\n --\n -- > A \u2190 \u03b1 x y\u2020 + A\n gerc :: Order\n -> Int\n -> Int\n -> a\n -> Ptr a\n -> Int\n -> Ptr a\n -> Int\n -> Ptr a\n -> Int\n -> IO ()\n\n -- | Perform a rank-1 update of a Hermitian matrix.\n --\n -- > A \u2190 \u03b1 x y\u2020 + A\n her :: Order\n -> Uplo\n -> Int\n -> RealType a\n -> Ptr a\n -> Int\n -> Ptr a\n -> Int\n -> IO ()\n\n -- | Perform a rank-1 update of a Hermitian packed matrix.\n --\n -- > A \u2190 \u03b1 x y\u2020 + A\n hpr :: Order\n -> Uplo\n -> Int\n -> RealType a\n -> Ptr a\n -> Int\n -> Ptr a\n -> IO ()\n\n -- | Perform a rank-2 update of a Hermitian matrix.\n --\n -- > A \u2190 \u03b1 x y\u2020 + y (\u03b1 x)\u2020 + A\n her2 :: Order\n -> Uplo\n -> Int\n -> a\n -> Ptr a\n -> Int\n -> Ptr a\n -> Int\n -> Ptr a\n -> Int\n -> IO ()\n\n -- | Perform a rank-2 update of a Hermitian packed matrix.\n --\n -- > A \u2190 \u03b1 x y\u2020 + y (\u03b1 x)\u2020 + A\n hpr2 :: Order\n -> Uplo\n -> Int\n -> a\n -> Ptr a\n -> Int\n -> Ptr a\n -> Int\n -> Ptr a\n -> IO ()\n\n -- | Perform a general matrix-matrix update.\n --\n -- > C \u2190 \u03b1 T(A) U(B) + \u03b2 C\n gemm :: Order -- ^ Layout of all the matrices.\n -> Transpose -- ^ The operation @T@ to be applied to @A@.\n -> Transpose -- ^ The operation @U@ to be applied to @B@.\n -> Int -- ^ Number of rows of @T(A)@ and @C@.\n -> Int -- ^ Number of columns of @U(B)@ and @C@.\n -> Int -- ^ Number of columns of @T(A)@ and number of rows of @U(B)@.\n -> a -- ^ Scaling factor @\u03b1@ of the product.\n -> Ptr a -- ^ Pointer to a matrix @A@.\n -> Int -- ^ Stride of the major dimension of @A@.\n -> Ptr a -- ^ Pointer to a matrix @B@.\n -> Int -- ^ Stride of the major dimension of @B@.\n -> a -- ^ Scaling factor @\u03b2@ of the original @C@.\n -> Ptr a -- ^ Pointer to a mutable matrix @C@.\n -> Int -- ^ Stride of the major dimension of @C@.\n -> IO ()\n\n -- | Perform a symmetric matrix-matrix update.\n --\n -- > C \u2190 \u03b1 A B + \u03b2 C or C \u2190 \u03b1 B A + \u03b2 C\n --\n -- where @A@ is symmetric. The matrix @A@ must be in an unpacked format, although the\n -- routine will only access half of it as specified by the @'Uplo'@ argument.\n symm :: Order -- ^ Layout of all the matrices.\n -> Side -- ^ Side that @A@ appears in the product.\n -> Uplo -- ^ The part of @A@ that is used.\n -> Int -- ^ Number of rows of @C@.\n -> Int -- ^ Number of columns of @C@.\n -> a -- ^ Scaling factor @\u03b1@ of the product.\n -> Ptr a -- ^ Pointer to a symmetric matrix @A@.\n -> Int -- ^ Stride of the major dimension of @A@.\n -> Ptr a -- ^ Pointer to a matrix @B@.\n -> Int -- ^ Stride of the major dimension of @B@.\n -> a -- ^ Scaling factor @\u03b1@ of the original @C@.\n -> Ptr a -- ^ Pointer to a mutable matrix @C@.\n -> Int -- ^ Stride of the major dimension of @C@.\n -> IO ()\n\n -- | Perform a Hermitian matrix-matrix update.\n --\n -- > C \u2190 \u03b1 A B + \u03b2 C or C \u2190 \u03b1 B A + \u03b2 C\n --\n -- where @A@ is Hermitian. The matrix @A@ must be in an unpacked format, although the\n -- routine will only access half of it as specified by the @'Uplo'@ argument.\n hemm :: Order -- ^ Layout of all the matrices.\n -> Side -- ^ Side that @A@ appears in the product.\n -> Uplo -- ^ The part of @A@ that is used.\n -> Int -- ^ Number of rows of @C@.\n -> Int -- ^ Number of columns of @C@.\n -> a -- ^ Scaling factor @\u03b1@ of the product.\n -> Ptr a -- ^ Pointer to a Hermitian matrix @A@.\n -> Int -- ^ Stride of the major dimension of @A@.\n -> Ptr a -- ^ Pointer to a matrix @B@.\n -> Int -- ^ Stride of the major dimension of @B@.\n -> a -- ^ Scaling factor @\u03b1@ of the original @C@.\n -> Ptr a -- ^ Pointer to a mutable matrix @C@.\n -> Int -- ^ Stride of the major dimension of @C@.\n -> IO ()\n\n -- | Perform a symmetric rank-k update.\n --\n -- > C \u2190 \u03b1 A A\u22a4 + \u03b2 C or C \u2190 \u03b1 A\u22a4 A + \u03b2 C\n syrk :: Order\n -> Uplo\n -> Transpose\n -> Int\n -> Int\n -> a\n -> Ptr a\n -> Int\n -> a\n -> Ptr a\n -> Int\n -> IO ()\n\n -- | Perform a Hermitian rank-k update.\n --\n -- > C \u2190 \u03b1 A A\u2020 + \u03b2 C or C \u2190 \u03b1 A\u2020 A + \u03b2 C\n herk :: Order\n -> Uplo\n -> Transpose\n -> Int\n -> Int\n -> RealType a\n -> Ptr a\n -> Int\n -> RealType a\n -> Ptr a\n -> Int\n -> IO ()\n\n -- | Perform a symmetric rank-2k update.\n --\n -- > C \u2190 \u03b1 A B\u22a4 + \u03b1* B A\u22a4 + \u03b2 C or C \u2190 \u03b1 A\u22a4 B + \u03b1* B\u22a4 A + \u03b2 C\n syr2k :: Order\n -> Uplo\n -> Transpose\n -> Int\n -> Int\n -> a\n -> Ptr a\n -> Int\n -> Ptr a\n -> Int\n -> a\n -> Ptr a\n -> Int\n -> IO ()\n\n -- | Perform a Hermitian rank-2k update.\n --\n -- > C \u2190 \u03b1 A B\u2020 + \u03b1* B A\u2020 + \u03b2 C or C \u2190 \u03b1 A\u2020 B + \u03b1* B\u2020 A + \u03b2 C\n her2k :: Order\n -> Uplo\n -> Transpose\n -> Int\n -> Int\n -> a\n -> Ptr a\n -> Int\n -> Ptr a\n -> Int\n -> RealType a\n -> Ptr a\n -> Int\n -> IO ()\n\n -- | Perform a triangular matrix-matrix multiplication.\n --\n -- > B \u2190 \u03b1 T(A) B or B \u2190 \u03b1 B T(A)\n --\n -- where @A@ is triangular.\n trmm :: Order\n -> Side\n -> Uplo\n -> Transpose\n -> Diag\n -> Int\n -> Int\n -> a\n -> Ptr a\n -> Int\n -> Ptr a\n -> Int\n -> IO ()\n\n -- | Perform an inverse triangular matrix-matrix multiplication.\n --\n -- > B \u2190 \u03b1 T(A\u207b\u00b9) B or B \u2190 \u03b1 B T(A\u207b\u00b9)\n --\n -- where @A@ is triangular.\n trsm :: Order\n -> Side\n -> Uplo\n -> Transpose\n -> Diag\n -> Int\n -> Int\n -> a\n -> Ptr a\n -> Int\n -> Ptr a\n -> Int\n -> IO ()\n\n-- | Blas operations that are only applicable to real numbers.\nclass Numeric a => RealNumeric a where\n\n -- | Generate a Givens rotation. (Only available for real floating-point types.)\n rotg :: Ptr a\n -> Ptr a\n -> Ptr a\n -> Ptr a\n -> IO ()\n\n -- | Generate a modified Givens rotation. (Only available for real floating-point\n -- types.)\n rotmg :: Ptr a\n -> Ptr a\n -> Ptr a\n -> a\n -> Ptr a\n -> IO ()\n\n -- | Apply a Givens rotation. (Only available for real floating-point types.)\n rot :: Int\n -> Ptr a\n -> Int\n -> Ptr a\n -> Int\n -> a\n -> a\n -> IO ()\n\n -- | Apply a modified Givens rotation. (Only available for real floating-point types.)\n rotm :: Int\n -> Ptr a\n -> Int\n -> Ptr a\n -> Int\n -> Ptr a\n -> IO ()\n\ninstance Numeric Float where\n type RealType Float = Float\n swap = S.swap\n scal = S.scal\n copy = S.copy\n axpy = S.axpy\n dotu = S.dotu\n dotc = S.dotc\n nrm2 = S.nrm2\n asum = S.asum\n iamax = S.iamax\n gemv = S.gemv\n gbmv = S.gbmv\n hemv = S.hemv\n hbmv = S.hbmv\n hpmv = S.hpmv\n trmv = S.trmv\n tbmv = S.tbmv\n tpmv = S.tpmv\n trsv = S.trsv\n tbsv = S.tbsv\n tpsv = S.tpsv\n geru = S.geru\n gerc = S.gerc\n her = S.her\n hpr = S.hpr\n her2 = S.her2\n hpr2 = S.hpr2\n gemm = S.gemm\n symm = S.symm\n hemm = S.hemm\n syrk = S.syrk\n herk = S.herk\n syr2k = S.syr2k\n her2k = S.her2k\n trmm = S.trmm\n trsm = S.trsm\n\n\ninstance Numeric Double where\n type RealType Double = Double\n swap = D.swap\n scal = D.scal\n copy = D.copy\n axpy = D.axpy\n dotu = D.dotu\n dotc = D.dotc\n nrm2 = D.nrm2\n asum = D.asum\n iamax = D.iamax\n gemv = D.gemv\n gbmv = D.gbmv\n hemv = D.hemv\n hbmv = D.hbmv\n hpmv = D.hpmv\n trmv = D.trmv\n tbmv = D.tbmv\n tpmv = D.tpmv\n trsv = D.trsv\n tbsv = D.tbsv\n tpsv = D.tpsv\n geru = D.geru\n gerc = D.gerc\n her = D.her\n hpr = D.hpr\n her2 = D.her2\n hpr2 = D.hpr2\n gemm = D.gemm\n symm = D.symm\n hemm = D.hemm\n syrk = D.syrk\n herk = D.herk\n syr2k = D.syr2k\n her2k = D.her2k\n trmm = D.trmm\n trsm = D.trsm\n\n\ninstance Numeric (Complex Float) where\n type RealType (Complex Float) = Float\n swap = C.swap\n scal = C.scal\n copy = C.copy\n axpy = C.axpy\n dotu = C.dotu\n dotc = C.dotc\n nrm2 = C.nrm2\n asum = C.asum\n iamax = C.iamax\n gemv = C.gemv\n gbmv = C.gbmv\n hemv = C.hemv\n hbmv = C.hbmv\n hpmv = C.hpmv\n trmv = C.trmv\n tbmv = C.tbmv\n tpmv = C.tpmv\n trsv = C.trsv\n tbsv = C.tbsv\n tpsv = C.tpsv\n geru = C.geru\n gerc = C.gerc\n her = C.her\n hpr = C.hpr\n her2 = C.her2\n hpr2 = C.hpr2\n gemm = C.gemm\n symm = C.symm\n hemm = C.hemm\n syrk = C.syrk\n herk = C.herk\n syr2k = C.syr2k\n her2k = C.her2k\n trmm = C.trmm\n trsm = C.trsm\n\n\ninstance Numeric (Complex Double) where\n type RealType (Complex Double) = Double\n swap = Z.swap\n scal = Z.scal\n copy = Z.copy\n axpy = Z.axpy\n dotu = Z.dotu\n dotc = Z.dotc\n nrm2 = Z.nrm2\n asum = Z.asum\n iamax = Z.iamax\n gemv = Z.gemv\n gbmv = Z.gbmv\n hemv = Z.hemv\n hbmv = Z.hbmv\n hpmv = Z.hpmv\n trmv = Z.trmv\n tbmv = Z.tbmv\n tpmv = Z.tpmv\n trsv = Z.trsv\n tbsv = Z.tbsv\n tpsv = Z.tpsv\n geru = Z.geru\n gerc = Z.gerc\n her = Z.her\n hpr = Z.hpr\n her2 = Z.her2\n hpr2 = Z.hpr2\n gemm = Z.gemm\n symm = Z.symm\n hemm = Z.hemm\n syrk = Z.syrk\n herk = Z.herk\n syr2k = Z.syr2k\n her2k = Z.her2k\n trmm = Z.trmm\n trsm = Z.trsm\ninstance RealNumeric Float where\n rotg = S.rotg\n rotmg = S.rotmg\n rot = S.rot\n rotm = S.rotm\n\n\ninstance RealNumeric Double where\n rotg = D.rotg\n rotmg = D.rotmg\n rot = D.rot\n rotm = D.rotm\n", "meta": {"hexsha": "5b358652f4fdad66fb55475310dfa8368099ebdc", "size": 16785, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/Blas/Generic/Safe.hs", "max_stars_repo_name": "Rufflewind/blas-hs", "max_stars_repo_head_hexsha": "59fdc1c48b19024f9bb6283b4ddc90fe45383937", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2016-01-20T04:34:54.000Z", "max_stars_repo_stars_event_max_datetime": "2018-06-09T12:09:06.000Z", "max_issues_repo_path": "src/Blas/Generic/Safe.hs", "max_issues_repo_name": "Rufflewind/blas-hs", "max_issues_repo_head_hexsha": "59fdc1c48b19024f9bb6283b4ddc90fe45383937", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 3, "max_issues_repo_issues_event_min_datetime": "2016-04-25T05:53:19.000Z", "max_issues_repo_issues_event_max_datetime": "2020-11-28T22:27:04.000Z", "max_forks_repo_path": "src/Blas/Generic/Safe.hs", "max_forks_repo_name": "Rufflewind/blas-hs", "max_forks_repo_head_hexsha": "59fdc1c48b19024f9bb6283b4ddc90fe45383937", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 21.8839634941, "max_line_length": 93, "alphanum_fraction": 0.4893655049, "num_tokens": 5563, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.6224593312018546, "lm_q2_score": 0.5156199157230157, "lm_q1q2_score": 0.320952427895305}} {"text": "{-# LANGUAGE OverloadedStrings #-}\n{-# LANGUAGE Strict #-}\n{-# LANGUAGE FlexibleContexts #-}\n\nmodule CPVO.IO.Reader.Ecalj.DOS (\n readPDOS\n )\n where\n\nimport CPVO.Numeric\nimport CPVO.IO\n--\nimport Text.Printf as TP\nimport Numeric.LinearAlgebra\nimport qualified System.Process as SP\nimport System.IO (openTempFile,hClose)\n-- ===============================================\n\ngetPDOS' :: Matrix Double -> String -> [Int] -> [String] -> IO (Matrix Double)\ngetPDOS' res _ _ [] = return res\ngetPDOS' res tmpf intAOs (nf:nfiles) = do\n _ <- SP.system $ \"mkdir -p temp; more +2 \" ++ nf ++ \" > \" ++ tmpf\n aPDOS' <- fmap (\\x -> sumRow $ (\u00bf) x intAOs) $ loadMatrix tmpf\n getPDOS' (fromBlocks [[res,asColumn aPDOS']]) tmpf intAOs nfiles\n\n-------------------------------------------------------------\n-- Input Processing: read PDOS data\n--\nreadPDOS :: Double -> String -> String -> [(Int, ([Char], (String, [Int])))]\n -> IO [(Matrix Double, (Int, (String, (Int, String))))]\nreadPDOS invStat tailer dir ctrlAtAOs = do\n putStrLn \"========readPDOS\"\n putStrLn $ show ctrlAtAOs\n sequence\n $ (\\x -> [f a | f <- (readPDOS' invStat dir tailer), a <- x]) ctrlAtAOs\n\nreadPDOS' :: Double -> String -> String -> [(Int, (String, (String, [Int])))\n -> IO (Matrix Double, (Int, (String, (Int, String))))]\nreadPDOS' invStat foldernya tailer = fmap (readOnePDOS foldernya tailer) $ flipBy invStat [1,2] -- spin 1 up n spin 2 down\n\n--readPDOS :: String -> String -> Int -> ((String, String, [Int]), [(Int, String)]) -> IO (Int,String, Matrix Double)\n--readPDOS ::(spin, (noAt, (symAt, (labelAt, PDOS :: Matrix Double))))\nreadOnePDOS :: String\n -> String -> Int -> (Int, (String, (String, [Int])))\n -> IO (Matrix Double, (Int, (String, (Int, String))))\nreadOnePDOS theFolder tailing spin (noAt,(symAt,(labelAt,intAOs))) = do\n let namaFao = theFolder ++ \"/dos.isp\" ++ show spin ++ \".site\" ++ (TP.printf \"%03d\" noAt) ++ \".\" ++ tailing\n (tmpfile,h) <- openTempFile \"temp\" \"aEDOS.suffix\"\n hClose h\n _ <- SP.system $ \"mkdir -p temp; sed '{1d}' \" ++ namaFao ++ \" > \" ++ tmpfile\n aoE <- fmap (\\x -> (\u00bf) x [0]) $ loadMatrix $ tmpfile -- 0th column, Energy column\n let zeroE = asColumn $ konst 0 (rows aoE) -- zero valued column instead of real column\n aPDOS <- fmap (dropColumns 1) $ getPDOS' zeroE tmpfile intAOs [namaFao] -- create sum of per atomic AOs (PDOS/atom)\n return $ (fromBlocks [[aoE, aPDOS]] , (spin, (hashSpaceText labelAt, (noAt, symAt))))\n------------------------------------------------------------------\n\n-- getPDOS :: String -> String -> Int -> ((String, String, [Int]), [(Int, String)]) -> IO (Int,String, Matrix Double)\n-- getPDOS theFolder tailing spin (a@(namaAtom,jdAtom,intAOs),lsAtoms) = do\n-- let namaFaos = map (\\(x,_) -> theFolder ++ \"/dos.isp\" ++ show spin ++ \".site\" ++ (TP.printf \"%03d\" x) ++ \".\" ++ tailing) lsAtoms\n-- (tmpfile,h) <- openTempFile \"temp\" \"aEDOS.suffix\"\n-- hClose h\n-- _ <- inshell2text $ \"mkdir -p temp; more +2 \" ++ (head namaFaos) ++ \" > \" ++ tmpfile -- this is needed only to generate aoE, the real processing is in getPDOS'\n-- aoE <- fmap (\\x -> (\u00bf) x [0]) $ loadMatrix tmpfile -- 0th column, Energy column\n-- let zeroE = asColumn $ konst 0 (rows aoE) -- zero valued column instead of real column\n-- aPDOS <- fmap (dropColumns 1) $ getPDOS' zeroE tmpfile intAOs namaFaos -- create sum of per atomic AOs (PDOS/atom)\n-- return $ (spin, hashSpaceText jdAtom, fromBlocks [[aoE, aPDOS]])\n-- ------------------------------------------------------------------\n--\n", "meta": {"hexsha": "f70a14f07be7b8d6a80d2806ff2aa506b29e0a11", "size": 3706, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/CPVO/IO/Reader/Ecalj/DOS.hs", "max_stars_repo_name": "hasanalrasyid/cpvoh", "max_stars_repo_head_hexsha": "d4e40c681a512b9ffb3f79ec46a4f4e5831e4165", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/CPVO/IO/Reader/Ecalj/DOS.hs", "max_issues_repo_name": "hasanalrasyid/cpvoh", "max_issues_repo_head_hexsha": "d4e40c681a512b9ffb3f79ec46a4f4e5831e4165", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/CPVO/IO/Reader/Ecalj/DOS.hs", "max_forks_repo_name": "hasanalrasyid/cpvoh", "max_forks_repo_head_hexsha": "d4e40c681a512b9ffb3f79ec46a4f4e5831e4165", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 53.7101449275, "max_line_length": 164, "alphanum_fraction": 0.5574743659, "num_tokens": 1095, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.7799929002541067, "lm_q2_score": 0.411110869232168, "lm_q1q2_score": 0.3206635592183855}} {"text": "module Duck.Analysis where\n\nimport Duck.Types\nimport Duck.Plot\nimport Duck.Utils\nimport Duck.Statistics\nimport Duck.Hypothesis\n\nimport qualified Statistics.Resampling.Bootstrap as B\n\nimport Criterion\nimport Criterion.Main.Options (defaultConfig)\nimport Criterion.Internal (runAndAnalyseOne)\nimport Criterion.Monad (withConfig)\nimport Control.DeepSeq (NFData)\nimport qualified Criterion.Types as CT\n\n-- |The worker function. Takes a set of parameters and\n-- a function to evaluate and produces a full report of\n-- results. It is required that the function to be evaluated\n-- is of type (a -> b), where 'a' is sizable and willing to\n-- have test cases generated, and 'b' needs to have a normal\n-- form.\nrunSingleTest :: (Cased a, Sized a, NFData b) => Parameters -> (a -> b) -> IO FullReport\nrunSingleTest pr src = do\n putStrIf ((verbosity pr) >= Moderate) \"Starting benchmarks...\"\n testInstances <- genInstances $ genSizeList (range pr) (iterations pr)\n let sizes = [fromIntegral $ dimSize vl | vl <- testInstances]\n (expTimes, expStds, otlr) <- runSource pr (src) testInstances sizes\n putStrIf ((verbosity pr) >= Moderate) \"Crunching results...\"\n return (FullReport {experiment = expTimes,\n expStd = expStds,\n sizes = sizes,\n outlierEffect = otlr / (fromIntegral $ length sizes)\n })\n\n-- |Takes an hypothesis complexity function and a full\n-- report and fits the experimental data to the analytical\n-- data to obtain a confidence value and a proportionality\n-- constant (in seconds).\ntestHypothesis :: Hypothesis -> FullReport -> Report\ntestHypothesis hp fr = generateReport ana fr\n where ana = [hp (fromIntegral vl) | vl <- (sizes fr)]\n\n-- |Performs a grouped hypothesis test, takes a full report\n-- and a set of named hypothesis, as well as a grouping function\n-- (some examples defined in Duck.Statistics) and produces a list\n-- of reports.\ntestGroup :: FullReport -> [(String, Hypothesis)] ->\n ([(Double, (String, Report))] -> [(Double, (String, Report))])\n -> GroupReport\ntestGroup fr xs flt = map snd fltrd\n where ls = map (\\(name, f) -> (name, testHypothesis f fr)) xs\n ind = zip (map (confidence . snd) ls) ls\n fltrd = flt ind\n\n-- |Takes experimental data and an hypothesis and plots both.\nplotHypothesis :: FullReport -> Hypothesis -> Report -> String -> IO ()\nplotHypothesis fr hp r ttype = plotReportHypothesis sz exp ana ttype\n where sz = (sizes fr)\n exp = (experiment fr)\n ana = [(propConstant r) * hp (fromIntegral vl) | vl <- (sizes fr)]\n\n-- |Runs a source function in a set of inputs with a given size\n-- and produces a tuple of: ([Mean], [Standard deviation], Outlier effect),\n-- wrapped in the IO monad.\n-- A quiet verbosity produces no output, a moderate one produces a summary\n-- and a full one details every step.\nrunSource :: (NFData b) => Parameters -> (a -> b) -> [a] -> [Int] -> IO ([Double], [Double], Double)\nrunSource _ _ [] [] = return ([], [], 0)\nrunSource pr src (inst:is) (sz:ss) = do\n let res = runAndAnalyseOne 1 \"\" (nf src inst)\n CT.Analysed rep <- withConfig (defaultConfig { CT.verbosity = CT.Quiet,\n CT.timeLimit = (timePerTest pr) }) res\n let sampPoint = CT.anMean $ CT.reportAnalysis rep\n sampVar = CT.anStdDev $ CT.reportAnalysis rep\n sampOutlier = CT.anOutlierVar $ CT.reportAnalysis rep\n \n putStrIf ((verbosity pr) == Full) $ show sampPoint\n putStrIf ((verbosity pr) == Full) $ show sz\n putStrIf ((verbosity pr) == Full) $ show sampOutlier\n putStrIf ((verbosity pr) == Full) $ show sampVar\n putStrIf ((verbosity pr) == Full) \"\"\n putStrIf ((verbosity pr) == Moderate && (1 + length ss) `mod` 5 == 0) $\n (show $ 1 + length ss) ++ \" iterations left (about \" ++\n (show $ (round $ timePerTest pr) * 4 * (1 + length ss) `div` 3) ++ \" seconds left)\"\n \n (avgs, stds, otlr) <- runSource pr src is ss\n return ((B.estPoint sampPoint):avgs,\n (B.estPoint sampVar):stds,\n otlr + CT.ovFraction sampOutlier)\n\n-- |Generates a report from a full report and a list\n-- of analytical results.\ngenerateReport :: [Double] -> FullReport -> Report\ngenerateReport ana fr = Report {confidence = conf,\n propConstant = const}\n where (const, conf) = regress ana (experiment fr)\n", "meta": {"hexsha": "e3be07b77b3a3fb1d0a0df8554f181ad940019c7", "size": 4365, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "Duck/Analysis.hs", "max_stars_repo_name": "gangsterveggies/duck-analyzer", "max_stars_repo_head_hexsha": "848bdeadd63c9d6f287ddf9aaf1a6ff3d2df4dd4", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Duck/Analysis.hs", "max_issues_repo_name": "gangsterveggies/duck-analyzer", "max_issues_repo_head_hexsha": "848bdeadd63c9d6f287ddf9aaf1a6ff3d2df4dd4", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Duck/Analysis.hs", "max_forks_repo_name": "gangsterveggies/duck-analyzer", "max_forks_repo_head_hexsha": "848bdeadd63c9d6f287ddf9aaf1a6ff3d2df4dd4", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 44.0909090909, "max_line_length": 100, "alphanum_fraction": 0.6627720504, "num_tokens": 1150, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6513548511303336, "lm_q2_score": 0.4921881357207956, "lm_q1q2_score": 0.3205891298705353}} {"text": "{- |\nModule : $Header$\nDescription : This is the abstract file for the Scheme compiler.\nCopyright : (c) Michael Buchel\nLicense : BSD3\n\nMaintainer : abuchel2@uwo.ca\nStability : experimental\nPortability : portable\n\nThis is the abstract module, where all the abstract concepts are kept.\n| -}\nmodule Abstract where\n\nimport Data.Array\nimport Data.Complex\nimport Data.Ratio\n\n-- | Data structure for holding Lisp values.\ndata LispVal = Atom String\n\t | List [LispVal]\n\t | DottedList [LispVal] LispVal\n\t | Number Integer\n\t | String String\n\t | Bool Bool\n\t | Character Char\n\t | Float Double\n\t | Ratio Rational\n\t | Complex (Complex Double)\n\t | Vector (Array Int LispVal)\n\n-- | Instance of show for LispVal.\ninstance Show LispVal where\n\tshow = showVal\n\n-- | Seperates the list into words.\nunwordsList :: [LispVal] -- ^ List to unword.\n\t-> String\nunwordsList = unwords . map showVal\n\n-- | Lisp value to string.\nshowVal :: LispVal -- ^ Expression we got.\n\t-> String\nshowVal (Atom name) = name\nshowVal (List x) = \"(\" ++ unwordsList x ++ \")\"\nshowVal (DottedList x y) = \"(\" ++ unwordsList x ++ \" . \" ++ showVal y ++ \")\"\nshowVal (String contents) = \"\\\"\" ++ contents ++ \"\\\"\"\nshowVal (Bool True) = \"#t\"\nshowVal (Bool False) = \"#f\"\nshowVal (Number x) = show x\nshowVal (Character x) = show x\nshowVal (Float x) = show x\nshowVal (Ratio x) = show x\nshowVal (Complex x) = show x\nshowVal (Vector x) = show x\n", "meta": {"hexsha": "6bc14b59f16e9f0eec95033ad397a22cafacffd9", "size": 1462, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/Abstract.hs", "max_stars_repo_name": "mbuchel/compiler", "max_stars_repo_head_hexsha": "4a021bae14b851cedfec5e86f0afb627a987cd94", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/Abstract.hs", "max_issues_repo_name": "mbuchel/compiler", "max_issues_repo_head_hexsha": "4a021bae14b851cedfec5e86f0afb627a987cd94", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/Abstract.hs", "max_forks_repo_name": "mbuchel/compiler", "max_forks_repo_head_hexsha": "4a021bae14b851cedfec5e86f0afb627a987cd94", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 26.1071428571, "max_line_length": 76, "alphanum_fraction": 0.6456908345, "num_tokens": 406, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.5660185351961015, "lm_q2_score": 0.5660185351961016, "lm_q1q2_score": 0.3203769821855404}} {"text": "{-# language LambdaCase #-}\n{-# language FlexibleInstances #-}\n{-# language OverloadedStrings #-}\n{-# language GeneralizedNewtypeDeriving #-}\n{-# language TypeFamilies #-}\n{-# language DerivingVia #-}\n{-# language DeriveTraversable #-}\n{-# language UndecidableInstances #-}\n{-# language FlexibleContexts #-}\n\nmodule Geometry.Decorations\n ( WithOptions (..)\n , Options, Option(..)\n , mkOptions, getOptions\n , Decorated(..), fromDecorated\n , Decorator(..)\n , (#:), (#::)\n , visible, invisible\n , stroke, white, fill\n , thickness, thin\n , dashed, dotted\n , arcs\n , label, loffs, lpos, lparam\n )\nwhere\n\nimport Data.Monoid\nimport Data.Complex\nimport Data.Maybe\nimport Data.String( IsString(..) )\nimport Control.Monad\nimport Data.Functor.Identity\n\nimport Geometry.Base\nimport Geometry.Point\nimport Geometry.Line\nimport Geometry.Circle\nimport Geometry.Angle\nimport Geometry.Polygon\nimport Geometry.Plot\n\n\n-- | Possible SVG options for a figure.\ndata Option = Invisible Bool\n | Stroke String\n | Fill String\n | Thickness String\n | Dashing String\n | MultiStroke Int\n | LabelText String\n | LabelCorner (Int, Int)\n | LabelPosition Cmp\n | LabelOffset Cmp\n | LabelAngle Direction\n | SegmentMark Int\n deriving (Show)\n\n-- | Monoidal options list wrapper. Concatenates dually to a usual list.\nnewtype Options = Options (Dual [Option])\n deriving (Semigroup, Monoid, Show)\n\n-- | Puts a list of options to a wrapper.g\nmkOptions = Options . Dual\n-- | Extracts an option list from the `Options` wrapper.\ngetOptions (Options (Dual os)) = os\n\n-- | The class of objects which could have decorations.\nclass WithOptions a where\n -- | Get the decoration data\n options :: a -> Options\n options = defaultOptions\n\n -- | Set the decoration data\n setOptions :: Options -> a -> a\n setOptions _ = id\n\n -- | Default labeling settings\n defaultOptions :: a -> Options\n defaultOptions _ = mempty\n\ninstance\n {-# OVERLAPPABLE #-}\n (Functor t, Foldable t, WithOptions a) => WithOptions (t a) where\n options = foldMap options\n setOptions o a = setOptions o <$> a\n\n------------------------------------------------------------\n\n-- | The transparent decoration wrapper for geometric objects.\n-- Inherits all properties of embedded object.\nnewtype Decorated a = Decorated (Options, a)\n deriving (Functor, Foldable, Traversable)\n\n-- | The selector for the embedded object.\nfromDecorated (Decorated (_, x)) = x\n\ninstance Applicative Decorated where\n pure p = Decorated (mempty, p)\n (<*>) = ap\n\ninstance Monad Decorated where\n Decorated (d, x) >>= f =\n let Decorated (d', y) = f x\n in Decorated (d <> d', y)\n \n\ninstance {-# OVERLAPPING #-} WithOptions (Decorated a) where\n options (Decorated (o, _)) = o\n setOptions o' f = Decorated (o', id) <*> f\n\ninstance Show a => Show (Decorated a) where\n show f = l <> show (fromDecorated f)\n where l = maybe mempty (<> \":\") lab\n lab = find optLabelText f\n find p d = extractOption p $ defaultOptions d <> options d\n extractOption p = getFirst . foldMap (First . p) . getOptions\n optLabelText = \\case {LabelText x -> Just x; _ -> Nothing }\n\ninstance Eq a => Eq (Decorated a) where\n d1 == d2 = fromDecorated d1 == fromDecorated d2\n\ninstance Metric a => Metric (Decorated a) where\n dist a b = dist (fromDecorated a) (fromDecorated b)\n dist2 a b = dist2 (fromDecorated a) (fromDecorated b)\n\ninstance Affine a => Affine (Decorated a) where\n cmp = cmp . fromDecorated\n asCmp = pure . asCmp\n\ninstance {-# OVERLAPPING #-} Trans a => Trans (Decorated a) where\n transform t = fmap (transform t)\n\ninstance Manifold m => Manifold (Decorated m) where\n type Domain (Decorated m) = Domain m\n param = param . fromDecorated\n project = project . fromDecorated\n paramMaybe = paramMaybe . fromDecorated\n projectMaybe = projectMaybe . fromDecorated\n isContaining = isContaining . fromDecorated\n unit = unit . fromDecorated\n\ninstance Curve c => Curve (Decorated c) where\n tangent = tangent . fromDecorated\n normal = normal . fromDecorated\n\ninstance ClosedCurve c => ClosedCurve (Decorated c) where\n isEnclosing = isEnclosing . fromDecorated\n location = location . fromDecorated\n\ninstance {-# OVERLAPPING #-} Figure a => Figure (Decorated a) where\n isTrivial = isTrivial . fromDecorated\n refPoint = refPoint . fromDecorated\n box = box . fromDecorated\n\ninstance APoint p => APoint (Decorated p) where\n toPoint = toPoint . fromDecorated\n asPoint = pure . asPoint\n\ninstance Linear l => Linear (Decorated l) where\n refPoints = refPoints . fromDecorated\n\ninstance Circular a => Circular (Decorated a) where\n toCircle = toCircle . fromDecorated\n asCircle = pure . asCircle\n\ninstance PiecewiseLinear a => PiecewiseLinear (Decorated a) where\n vertices = vertices . fromDecorated\n asPolyline = asPolyline . fromDecorated\n\ninstance Polygonal p => Polygonal (Decorated p) where\n\ninstance Angular a => Angular (Decorated a) where\n asAngle = pure . asAngle\n toAngle = toAngle . fromDecorated\n setValue v = fmap (setValue v)\n\ninstance APlot p => APlot (Decorated p) where\n rmap = fmap . rmap\n \n------------------------------------------------------------\n-- | A wrapped decoration function with monoidal properties,\n-- corresponding to decoration options.\nnewtype Decorator a = Decorator (a -> Decorated a)\n\nmkDecorator opt val = Decorator $\n \\d -> setOptions (mkOptions [ opt val ]) (pure d)\n\ninstance Semigroup (Decorator a) where\n Decorator a <> Decorator b = Decorator (a >=> b)\n \ninstance Monoid (Decorator a) where\n mempty = Decorator $ \\a -> Decorated (mempty, a)\n\ninstance WithOptions a => IsString (Decorator a) where\n fromString = label\n\ninfixl 5 #:\n{- | The infix operator for decorator application.\n\n>>> aPoint # at (4, 5) #: label \"A\"\nA:\n\n>>> segment (4,5) (6,9) #: \"s\" <> dotted <> white\ns:\n-}\n(#:) :: WithOptions a => a -> Decorator a -> Decorated a\na #: (Decorator d) = d a\n\n(#::) :: Decorated a -> Decorator (Decorated a) -> Decorated a\na #:: (Decorator d) = join (d a)\n\n-- | The stroke color decorator.\nstroke :: WithOptions a => String -> Decorator a\nstroke = mkDecorator Stroke\n\n-- | The decorator for white lines.\nwhite :: WithOptions a => Decorator a\nwhite = stroke \"white\"\n\n-- | The fill color decorator.\nfill :: WithOptions a => String -> Decorator a\nfill = mkDecorator Fill\n\n-- | The stroke-thickness decorator.\nthickness :: WithOptions a => String -> Decorator a\nthickness = mkDecorator Thickness\n\n-- | The decorator for thin lines.\nthin :: WithOptions a => Decorator a\nthin = thickness \"1\"\n\n-- | The decorator for dashed lines.\ndashed :: WithOptions a => Decorator a\ndashed = mkDecorator Dashing \"5,5\"\n\n-- | The decorator for dotted lines.\ndotted :: WithOptions a => Decorator a\ndotted = mkDecorator Dashing \"2,3\"\n\n-- | The decorator for dotted lines.\narcs :: Int -> Decorator Angle\narcs = mkDecorator MultiStroke\n\n-- | The decorator which makes invisible object visible.\nvisible :: WithOptions a => Decorator a\nvisible = mkDecorator Invisible False\n\n-- | The decorator which makes visible object invisible.\ninvisible :: WithOptions a => Decorator a\ninvisible = mkDecorator Invisible True\n\n-- | The decorator for labeling objects. Could be used as overloaded string.\n--\n-- >>> aPoint # at (4, 5) #: \"A\"\n-- A:\n--\nlabel :: WithOptions a => String -> Decorator a\nlabel = mkDecorator LabelText\n\n-- | The decorator for label offset.\nloffs :: (Affine p, WithOptions a) => p -> Decorator a\nloffs = mkDecorator LabelOffset . conjugate . cmp\n\n-- | The decorator for label position.\nlpos :: (Affine p, WithOptions a) => p -> Decorator a\nlpos = mkDecorator LabelPosition . cmp\n\n-- | The decorator for setting label on a curve at a given parameter value.\nlparam :: (WithOptions m, Manifold m) => Double -> Decorator m\nlparam x = Decorator $ \\f -> f #: lpos (f @-> x)\n\n------------------------------------------------------------\n", "meta": {"hexsha": "414cf0db9b995c1723aebfa37aab717fdcdb69d1", "size": 8009, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "Geometry/Decorations.hs", "max_stars_repo_name": "MethaHardworker/geometry", "max_stars_repo_head_hexsha": "77c987e0704722636d7d00afa54e22295df3e428", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Geometry/Decorations.hs", "max_issues_repo_name": "MethaHardworker/geometry", "max_issues_repo_head_hexsha": "77c987e0704722636d7d00afa54e22295df3e428", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Geometry/Decorations.hs", "max_forks_repo_name": "MethaHardworker/geometry", "max_forks_repo_head_hexsha": "77c987e0704722636d7d00afa54e22295df3e428", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 29.336996337, "max_line_length": 76, "alphanum_fraction": 0.6706205519, "num_tokens": 2107, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.5888891163376235, "lm_q2_score": 0.5428632831725052, "lm_q1q2_score": 0.3196862791195977}} {"text": "{-# LANGUAGE OverloadedStrings #-}\n{-# LANGUAGE RecordWildCards #-}\n\nmodule Main where\nimport qualified Data.Foldable as Foldable\n\n-- vector\nimport Data.Vector (Vector)\nimport qualified Data.Vector as Vector\n\n-- Matrix\nimport Data.Matrix (Matrix)\nimport qualified Data.Matrix as Matrix\n\n-- HMatrix\nimport qualified Numeric.LinearAlgebra.Data as HMatrix\nimport qualified Numeric.LinearAlgebra.HMatrix as HMatrix\n\n-- bytestring\nimport Data.ByteString.Lazy (ByteString)\nimport qualified Data.ByteString.Lazy as ByteString\n\n-- cassava\nimport Data.Csv\n ( DefaultOrdered(headerOrder)\n , FromField(parseField)\n , FromNamedRecord(parseNamedRecord)\n , Header\n , ToField(toField)\n , ToNamedRecord(toNamedRecord)\n , (.:)\n , (.=)\n )\nimport qualified Data.Csv as Cassava\n\n-- text\nimport Data.Text (Text)\nimport qualified Data.Text.Encoding as Text\n\n-- Exception\nimport Control.Exception\n\n-- base\nimport qualified Control.Monad as Monad\nimport qualified System.Exit as Exit\nimport qualified Debug.Trace as Trace\n\n\n\ndata ComponentData = \n ComponentData { \n componentType :: ComponentType,\n nodeK :: Int,\n nodeM :: Int,\n magnitude :: Double,\n param1 :: Double,\n param2 :: Double,\n plot :: Int\n }\n deriving (Eq, Show)\n\n\ndata SimulationData = \n SimulationData { \n nodes :: Int,\n voltageSources :: Int,\n stepSize :: Double,\n tmax :: Double\n }\n deriving (Eq, Show)\n\ndata ComponentType = Resistor | Capacitor | Inductor | EAC | EDC | Other Text deriving (Eq, Show)\ntype SimulationResults = (Vector Double, Matrix Double)\n\ninstance FromNamedRecord SimulationData where\n parseNamedRecord m =\n SimulationData\n <$> m .: \"Number of Nodes\"\n <*> m .: \"Number of Voltages Sources\"\n <*> m .: \"Step Size\"\n <*> m .: \"Maximum time for simulation\"\n\n\ninstance FromNamedRecord ComponentData where\n parseNamedRecord m =\n ComponentData\n <$> m .: \"Element Type\"\n <*> m .: \"Node K\"\n <*> m .: \"Node M\"\n <*> m .: \"Value\"\n <*> m .: \"Source param 1\"\n <*> m .: \"Source param 2\"\n <*> m .: \"Plot\"\n\ninstance FromField ComponentType where\n parseField \"R\" =\n pure Resistor\n\n parseField \"L\" =\n pure Inductor\n\n parseField \"C\" =\n pure Capacitor\n\n parseField \"EDC\" =\n pure EDC\n\n parseField \"EAC\" =\n pure EAC\n\n parseField otherType =\n Other <$> parseField otherType\n\n\ndecodeItems :: ByteString -> Either String (Vector ComponentData)\ndecodeItems =\n fmap snd . Cassava.decodeByName\n\ndecodeItemsFromFile :: FilePath -> IO (Either String (Vector ComponentData))\ndecodeItemsFromFile filePath =\n catchShowIO (ByteString.readFile filePath)\n >>= return . either Left decodeItems\n\ndecodeSimulation :: ByteString -> Either String (Vector SimulationData)\ndecodeSimulation =\n fmap snd . Cassava.decodeByName\n\ndecodeSimulationFromFile :: FilePath -> IO (Either String (Vector SimulationData))\ndecodeSimulationFromFile filePath =\n catchShowIO (ByteString.readFile filePath)\n >>= return . either Left decodeSimulation\n\ngetSingleSimulationLine :: Vector SimulationData -> SimulationData\ngetSingleSimulationLine = \n Vector.head \n\n\nnhComponents :: [ComponentData] -> [ComponentData]\nnhComponents =\n filter (\\r -> (componentType r == Capacitor) || (componentType r == Inductor))\n\nfilterEnergyStorageComponent :: Vector ComponentData -> Vector ComponentData\nfilterEnergyStorageComponent =\n Vector.filter (\\r -> (componentType r == Capacitor) || (componentType r == Inductor))\n\nnh :: Vector ComponentData -> Int\nnh components =\n length $ filterEnergyStorageComponent components\n \n-- filter ((== Zaal) . reviewLocation) reviews \n\nfilterSources :: Vector ComponentData -> Vector ComponentData\nfilterSources =\n Vector.filter (\\r -> (componentType r == EDC) || (componentType r == EAC))\n\ncondutance :: ComponentData -> Double -> Double\ncondutance component dt =\n case componentType component of\n Resistor -> 1.0 / (magnitude component)\n Capacitor -> (magnitude component) * 0.000001 * 2 / dt\n Inductor -> dt / (2 * 0.001 * (magnitude component))\n _ -> 0.0\n\ngkm :: Vector ComponentData -> Double -> Vector Double\ngkm components dt =\n Vector.map (\\c -> condutance c dt) components\n -- Matrix.colVector (Vector.map (\\c -> condutance c dt) components)\n -- Matrix.fromList (length components) 1 (Vector.toList (Vector.map (\\c -> condutance c dt) components))\n\nbuildCompactGMatrix :: Double -> [ComponentData] -> Matrix Double -> Matrix Double\nbuildCompactGMatrix dt [] buffer = buffer\nbuildCompactGMatrix dt (component:cs) buffer =\n case (nodeK component, nodeM component) of (0, m) -> buildCompactGMatrix dt cs (Matrix.setElem (Matrix.getElem m m buffer + condutance component dt) (m, m) buffer)\n (k, 0) -> buildCompactGMatrix dt cs (Matrix.setElem (Matrix.getElem k k buffer + condutance component dt) (k, k) buffer)\n (k, m) -> buildCompactGMatrix dt cs (Matrix.setElem (Matrix.getElem k k buffer + condutance component dt) (k, k) (Matrix.setElem (Matrix.getElem m m buffer + condutance component dt) (m, m) (Matrix.setElem (Matrix.getElem k m buffer - condutance component dt) (k, m) (Matrix.setElem (Matrix.getElem m k buffer - condutance component dt) (m, k) buffer))))\n (_, _) -> buildCompactGMatrix dt cs buffer\n\n\nbuildGMatrixFromVector :: SimulationData -> Vector ComponentData -> Matrix Double\nbuildGMatrixFromVector simulation components =\n buildCompactGMatrix (stepSize simulation) (Vector.toList components) (Matrix.zero (nodes simulation) (nodes simulation))\n\n\nbuildIhVector :: [ComponentData] -> Double -> Int -> [Double] -> [Double] -> Matrix Double -> Vector Double\nbuildIhVector [] _ _ _ ihnew _ = Vector.fromList ihnew\nbuildIhVector (component:cs) dt n (hold:ihold) ihnew vMatrix =\n case (componentType component, nodeK component, nodeM component) of (Inductor, 0, m) -> buildIhVector cs dt n ihold (ihnew ++ [(2*(condutance component dt)*(Matrix.getElem m n vMatrix) + hold)]) vMatrix\n (Inductor, k, 0) -> buildIhVector cs dt n ihold (ihnew ++ [(-2*(condutance component dt)*(Matrix.getElem k n vMatrix) + hold)]) vMatrix\n (Inductor, k, m) -> buildIhVector cs dt n ihold (ihnew ++ [(-2*(condutance component dt)*((Matrix.getElem k n vMatrix) - (Matrix.getElem m n vMatrix)) + hold)]) vMatrix\n (Capacitor, 0, m) -> buildIhVector cs dt n ihold (ihnew ++ [(-2*(condutance component dt)*(Matrix.getElem m n vMatrix) - hold)]) vMatrix\n (Capacitor, k, 0) -> buildIhVector cs dt n ihold (ihnew ++ [(2*(condutance component dt)*(Matrix.getElem k n vMatrix) - hold)]) vMatrix\n (Capacitor, k, m) -> buildIhVector cs dt n ihold (ihnew ++ [(2*(condutance component dt)*((Matrix.getElem k n vMatrix) - (Matrix.getElem m n vMatrix)) - hold)]) vMatrix\n (_, _, _) -> buildIhVector cs dt n ihold ihnew vMatrix\n\n\n\nbuildVBVector :: [ComponentData] -> Double -> [Double] -> Vector Double\nbuildVBVector [] _ buffer = Vector.fromList buffer\nbuildVBVector (c:components) time buffer =\n case (componentType c) of EDC -> buildVBVector components time ((magnitude c) : buffer)\n EAC -> buildVBVector components time (((magnitude c * cos (2 * pi * param2 c * time + (param1 c * (pi/180))))) : buffer)\n _ -> buildVBVector components time buffer\n\n\nbuildIVector :: [ComponentData] -> [Double] -> Vector Double -> Vector Double\nbuildIVector [] _ iVector = iVector\nbuildIVector (component:cs) (ihEl:ih) iVector =\n case (componentType component, nodeK component, nodeM component) of (Inductor, k, 0) -> buildIVector cs ih (iVector Vector.// [((k - 1), ((iVector Vector.! (k-1)) + ihEl))])\n (Inductor, 0, m) -> buildIVector cs ih (iVector Vector.// [((m - 1), ((iVector Vector.! (m-1)) - ihEl))])\n (Inductor, k, m) -> buildIVector cs ih (iVector Vector.// [((m - 1), ((iVector Vector.! (m-1)) - ihEl)), ((k-1), ((iVector Vector.! (k-1)) + ihEl))])\n (Capacitor, k, 0) -> buildIVector cs ih (iVector Vector.// [((k - 1), ((iVector Vector.! (k-1)) + ihEl))])\n (Capacitor, 0, m) -> buildIVector cs ih (iVector Vector.// [((m - 1), ((iVector Vector.! (m-1)) - ihEl))])\n (Capacitor, k, m) -> buildIVector cs ih (iVector Vector.// [((m - 1), ((iVector Vector.! (m-1)) - ihEl)), ((k-1), ((iVector Vector.! (k-1)) + ihEl))])\n (_, _, _) -> buildIVector cs ih iVector\n\n\nthtaControl :: Int -> Double -> Vector Double -> Vector Double -> SimulationData -> (Int, Vector Double, Double)\nthtaControl thtactl time ihnew ih simulation\n | thtactl <= 0 = (thtactl, ihnew, (stepSize simulation + time))\n | thtactl < 3 = (thtactl + 1, (Vector.map (\\i -> i/2) $ Vector.zipWith (+) ih ihnew), (time + (stepSize simulation/2)))\n | otherwise = (0, ihnew, (stepSize simulation + time))\n\nfromHMatrixTransformer :: HMatrix.Matrix Double -> Matrix Double\nfromHMatrixTransformer matrix =\n Matrix.fromLists $ HMatrix.toLists matrix\n\ntoHMatrixTransformer :: Matrix Double -> HMatrix.Matrix Double\ntoHMatrixTransformer matrix =\n HMatrix.fromLists $ Matrix.toLists matrix\n\nfromHMatrixVectorTransformer :: HMatrix.Vector Double -> Vector Double\nfromHMatrixVectorTransformer vec =\n Vector.fromList $ HMatrix.toList vec\n\ntoHMatrixVectorTransformer :: Vector Double -> HMatrix.Vector Double\ntoHMatrixVectorTransformer vec =\n HMatrix.fromList $ Vector.toList vec\n\nsolver :: HMatrix.Vector Double -> HMatrix.Matrix Double -> HMatrix.Matrix Double -> HMatrix.Matrix Double -> HMatrix.Matrix Double -> HMatrix.Vector Double -> SimulationData -> (Vector Double, Vector Double)\nsolver iVector gaa gab gba gbb vb simulation =\n let ia = HMatrix.subVector 0 ((nodes simulation) - (voltageSources simulation)) iVector\n rhsa = ia - (gab HMatrix.#> vb)\n va = gaa HMatrix.<\\> rhsa\n ib = (gba HMatrix.#> va) + (gbb HMatrix.#> vb)\n iVec = HMatrix.vjoin [ia, ib] \n vVec = HMatrix.vjoin [va, vb]\n in\n ((fromHMatrixVectorTransformer iVec), (fromHMatrixVectorTransformer vVec))\n \n\nthtaSimulationStep :: [ComponentData] -> Matrix Double -> SimulationData -> Int -> Int -> Double -> Vector Double -> Matrix Double -> Vector Double -> Vector Double -> SimulationResults\nthtaSimulationStep _ _ _ _ 1 _ _ vMatrix _ iVector = (iVector, vMatrix)\nthtaSimulationStep components condutances simulation thtactl n time ih vMatrix vbVector iVector =\n let (gaa, gab, gba, gbb) = Matrix.splitBlocks (nodes simulation - voltageSources simulation) (nodes simulation - voltageSources simulation) condutances\n ihBuffer = buildIhVector (nhComponents components) (stepSize simulation) n (Vector.toList ih) [] vMatrix\n (thta, ihThta, timeThta) = thtaControl thtactl time ihBuffer ih simulation\n vbVec = buildVBVector components timeThta []\n iVec = buildIVector (nhComponents components) (Vector.toList ihThta) (Vector.replicate (nodes simulation) 0)\n -- (iVecCalc, vVec) = Trace.trace (\"Solver = \\n\" ++ show (solver (toHMatrixVectorTransformer iVec) (toHMatrixTransformer gaa) (toHMatrixTransformer gab) (toHMatrixTransformer gba) (toHMatrixTransformer gbb) (toHMatrixVectorTransformer vbVec) simulation)) solver (toHMatrixVectorTransformer iVec) (toHMatrixTransformer gaa) (toHMatrixTransformer gab) (toHMatrixTransformer gba) (toHMatrixTransformer gbb) (toHMatrixVectorTransformer vbVec) simulation\n (iVecCalc, vVec) = solver (toHMatrixVectorTransformer iVec) (toHMatrixTransformer gaa) (toHMatrixTransformer gab) (toHMatrixTransformer gba) (toHMatrixTransformer gbb) (toHMatrixVectorTransformer vbVec) simulation\n vMatr = Matrix.mapCol (\\r _ -> vVec Vector.! (r - 1)) (n-1) vMatrix\n in\n thtaSimulationStep components condutances simulation thta (n-1) timeThta ihThta vMatr vbVec iVecCalc\n\n\nthtaSimulation :: Vector ComponentData -> SimulationData -> SimulationResults\nthtaSimulation components simulation = \n thtaSimulationStep (Vector.toList components) (buildGMatrixFromVector simulation components) simulation 1 (npoints simulation) 0.0 (Vector.replicate (nh components) 0) (Matrix.zero (nodes simulation) (npoints simulation)) (Vector.replicate (voltageSources simulation) 0) (Vector.replicate (nodes simulation) 0)\n\n\nnpoints :: SimulationData -> Int\nnpoints sim = \n round ((tmax sim)/(stepSize sim)) + 1\n\ncatchShowIO :: IO a -> IO (Either String a)\ncatchShowIO action =\n fmap Right action\n `catch` handleIOException\n where\n handleIOException :: IOException -> IO (Either String a)\n handleIOException =\n return . Left . show\n\nmain :: IO ()\nmain = do\n\n eitherSimulation <-\n fmap getSingleSimulationLine\n <$> decodeSimulationFromFile \"data/simulation.csv\"\n\n case eitherSimulation of\n Left reason ->\n Exit.die reason\n\n Right simulation -> do\n components_list <- decodeItemsFromFile \"data/components.csv\"\n case components_list of\n Left reason -> Exit.die reason\n Right components -> do\n let gmt = buildGMatrixFromVector simulation components\n putStr \"GMatrix: \\n\"\n print (gmt)\n let results = thtaSimulation components simulation\n putStr \"Simulation: \\n\"\n print (results)\n\n\n\n", "meta": {"hexsha": "599c427f5888917df994766a3d27814ddf095cb9", "size": 13907, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/Main.hs", "max_stars_repo_name": "hannelita/thtahs", "max_stars_repo_head_hexsha": "895339b836f1ed43b66c99b6208edf2be9ec858e", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2019-10-27T02:04:04.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-15T20:54:11.000Z", "max_issues_repo_path": "src/Main.hs", "max_issues_repo_name": "hannelita/thtahs", "max_issues_repo_head_hexsha": "895339b836f1ed43b66c99b6208edf2be9ec858e", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 15, "max_issues_repo_issues_event_min_datetime": "2019-10-13T22:53:05.000Z", "max_issues_repo_issues_event_max_datetime": "2019-12-03T01:05:05.000Z", "max_forks_repo_path": "src/Main.hs", "max_forks_repo_name": "hannelita/thtahs", "max_forks_repo_head_hexsha": "895339b836f1ed43b66c99b6208edf2be9ec858e", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-11-15T20:54:14.000Z", "max_forks_repo_forks_event_max_datetime": "2021-11-15T20:54:14.000Z", "avg_line_length": 45.0064724919, "max_line_length": 455, "alphanum_fraction": 0.6577982311, "num_tokens": 3475, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.6187804196836383, "lm_q2_score": 0.5156199157230156, "lm_q1q2_score": 0.31905550784832976}} {"text": "-- |\n-- Module : BenchShow.Report\n-- Copyright : (c) 2018 Composewell Technologies\n--\n-- License : BSD3\n-- Maintainer : harendra.kumar@gmail.com\n-- Stability : experimental\n-- Portability : GHC\n--\n\n{-# LANGUAGE FlexibleContexts #-}\n{-# LANGUAGE RecordWildCards #-}\n{-# LANGUAGE TupleSections #-}\n\nmodule BenchShow.Report\n (\n report\n ) where\n\nimport Control.Applicative (ZipList(..))\nimport Control.Monad (forM_)\nimport Data.Maybe (fromMaybe)\nimport Statistics.Types (Estimate(..))\nimport Text.PrettyPrint.ANSI.Leijen hiding ((<$>))\nimport Text.Printf (printf)\n\nimport BenchShow.Common\nimport BenchShow.Analysis\n\nmultiplesToPercentDiff :: Double -> Double\nmultiplesToPercentDiff x = (if x > 0 then x - 1 else x + 1) * 100\n\ncolorCode :: Word -> Double -> Doc -> Doc\ncolorCode thresh x =\n if x > fromIntegral thresh\n then dullred\n else if x < (-1) * fromIntegral thresh\n then dullgreen\n else id\n\n-- XXX in comparative reports render lower than baseline in green and higher\n-- than baseline in red\ngenGroupReport :: RawReport -> Config -> IO ()\ngenGroupReport RawReport{..} cfg@Config{..} = do\n let diffStr =\n if length reportColumns > 1\n then diffString presentation diffStrategy\n else Nothing\n case mkTitle of\n Just _ -> putStrLn $ maybe \"\" (\\f -> f reportIdentifier) mkTitle\n Nothing -> putStrLn $ makeTitle reportIdentifier diffStr cfg\n\n let benchcol = \"Benchmark\" : reportRowIds\n groupcols =\n let firstCol : tailCols = reportColumns\n colorCol ReportColumn{..} =\n let f x = case presentation of\n Groups Diff ->\n if x > 0 then dullred else dullgreen\n Groups PercentDiff -> colorCode threshold x\n Groups Multiples ->\n let y = multiplesToPercentDiff x\n in colorCode threshold y\n _ -> id\n in map f colValues\n renderTailCols estimators col analyzed =\n let regular = renderGroupCol $ showCol col Nothing analyzed\n colored = zipWith ($) (id : id : colorCol col)\n $ renderGroupCol\n $ showCol col estimators analyzed\n in case presentation of\n Groups Diff -> colored\n Groups PercentDiff -> colored\n Groups Multiples -> colored\n _ -> regular\n in renderGroupCol (showFirstCol firstCol)\n : case reportEstimators of\n Just ests -> getZipList $\n renderTailCols\n <$> ZipList (map Just $ tail ests)\n <*> ZipList tailCols\n <*> ZipList (tail reportAnalyzed)\n Nothing -> getZipList $\n renderTailCols\n <$> pure Nothing\n <*> ZipList tailCols\n <*> ZipList (tail reportAnalyzed)\n rows = foldl (zipWith (<+>)) (renderCol benchcol) groupcols\n putDoc $ vcat rows\n putStrLn \"\\n\"\n\n where\n\n renderCol [] = error \"Bug: header row missing\"\n renderCol col@(h : rows) =\n let maxlen = maximum (map length col)\n in map (fill maxlen . text) (h : replicate maxlen '-' : rows)\n\n renderGroupCol [] = error\n \"Bug: There has to be at least one column in raw report\"\n renderGroupCol col@(h : rows) =\n let maxlen = maximum (map length col)\n in map (\\x -> indent (maxlen - length x) $ text x)\n (h : replicate maxlen '-' : rows)\n\n showEstimator est =\n case est of\n Mean -> \"(mean)\"\n Median -> \"(medi)\"\n Regression -> \"(regr)\"\n\n showEstVal estvals est =\n case est of\n Mean ->\n let sd = analyzedStdDev estvals\n val = analyzedMean estvals\n in\n if val /= 0\n then printf \"(%.2f)\" $ sd / abs val\n else \"\"\n Median ->\n let x = ovFraction $ analyzedOutlierVar estvals\n in printf \"(%.2f)\" x\n Regression ->\n case analyzedRegRSq estvals of\n Just rsq -> printf \"(%.2f)\" (estPoint rsq)\n Nothing -> \"\"\n\n showFirstCol ReportColumn{..} =\n let showVal = printf \"%.2f\"\n withEstimator val estvals =\n showVal val ++\n if verbose\n then showEstVal estvals estimator\n else \"\"\n withEstVal =\n zipWith withEstimator colValues (head reportAnalyzed)\n in colName : withEstVal\n\n showCol ReportColumn{..} estimators analyzed = colName :\n let showVal val =\n let showDiff =\n if val > 0\n then printf \"+%.2f\" val\n else printf \"%.2f\" val\n in case presentation of\n Groups Diff -> showDiff\n Groups PercentDiff -> showDiff\n Groups Multiples ->\n if val > 0\n then printf \"%.2f\" val\n else printf \"1/%.2f\" (negate val)\n _ -> printf \"%.2f\" val\n\n showEstAnnot est =\n case presentation of\n Groups Diff -> showEstimator est\n Groups PercentDiff -> showEstimator est\n Groups Multiples -> showEstimator est\n _ -> \"\"\n\n in case estimators of\n Just ests ->\n let withAnnot val estvals est =\n showVal val\n ++ if verbose\n then showEstVal estvals est\n ++ showEstAnnot est\n else \"\"\n in getZipList $\n withAnnot\n <$> ZipList colValues\n <*> ZipList analyzed\n <*> ZipList ests\n\n Nothing ->\n let withEstVal val estvals est =\n showVal val\n ++ if verbose then showEstVal estvals est else \"\"\n in getZipList $\n withEstVal\n <$> ZipList colValues\n <*> ZipList analyzed\n <*> pure estimator\n\n-- | Presents the benchmark results in a CSV input file as text reports\n-- according to the provided configuration. The first parameter is the input\n-- file name. The second parameter, when specified using 'Just', is the name\n-- prefix for the output SVG image file(s). One or more output files may be\n-- generated with the given prefix depending on the 'Presentation' setting.\n-- When the second parameter is 'Nothing' the reports are printed on the\n-- console. The last parameter is the configuration to customize the report,\n-- you can start with 'defaultConfig' as the base and override any of the\n-- fields that you may want to change.\n--\n-- For example:\n--\n-- @\n-- report \"bench-results.csv\" Nothing 'defaultConfig'\n-- @\n--\n-- @since 0.2.0\nreport :: FilePath -> Maybe FilePath -> Config -> IO ()\nreport inputFile outputFile cfg@Config{..} = do\n let dir = fromMaybe \".\" outputDir\n (csvlines, fields) <- prepareToReport inputFile cfg\n (runs, matrices) <- prepareGroupMatrices cfg inputFile csvlines fields\n case presentation of\n Groups style ->\n forM_ fields $\n reportComparingGroups style dir outputFile TextReport runs\n cfg genGroupReport matrices\n Fields -> do\n forM_ matrices $\n reportPerGroup dir outputFile TextReport cfg genGroupReport\n Solo ->\n let funcs = map\n (\\mx -> reportComparingGroups Absolute dir\n (fmap (++ \"-\" ++ groupName mx) outputFile)\n TextReport runs cfg genGroupReport [mx])\n matrices\n in sequence_ $ funcs <*> fields\n", "meta": {"hexsha": "acf4bddde7db3127d1a3914578729b1563300b30", "size": 8456, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "lib/BenchShow/Report.hs", "max_stars_repo_name": "pranaysashank/bench-show", "max_stars_repo_head_hexsha": "96fdb71a2c0c683b01580ee63281df7b0d693dcf", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 8, "max_stars_repo_stars_event_min_datetime": "2018-11-12T15:08:55.000Z", "max_stars_repo_stars_event_max_datetime": "2020-12-08T15:29:31.000Z", "max_issues_repo_path": "lib/BenchShow/Report.hs", "max_issues_repo_name": "pranaysashank/bench-show", "max_issues_repo_head_hexsha": "96fdb71a2c0c683b01580ee63281df7b0d693dcf", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 27, "max_issues_repo_issues_event_min_datetime": "2018-11-18T00:41:32.000Z", "max_issues_repo_issues_event_max_datetime": "2022-02-02T00:00:57.000Z", "max_forks_repo_path": "lib/BenchShow/Report.hs", "max_forks_repo_name": "pranaysashank/bench-show", "max_forks_repo_head_hexsha": "96fdb71a2c0c683b01580ee63281df7b0d693dcf", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 4, "max_forks_repo_forks_event_min_datetime": "2019-01-16T15:45:28.000Z", "max_forks_repo_forks_event_max_datetime": "2020-08-15T10:48:39.000Z", "avg_line_length": 37.9192825112, "max_line_length": 79, "alphanum_fraction": 0.5104068117, "num_tokens": 1696, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6477982179521103, "lm_q2_score": 0.4921881357207956, "lm_q1q2_score": 0.31883859721710284}} {"text": "{-# LANGUAGE ScopedTypeVariables #-}\n{-# LANGUAGE MultiWayIf #-}\n{-# LANGUAGE ForeignFunctionInterface #-}\n{-# LANGUAGE LambdaCase #-}\n{-# LANGUAGE RecordWildCards #-}\n{-# LANGUAGE TemplateHaskell #-}\n{-# LANGUAGE OverloadedStrings #-}\nmodule Main where\n\nimport qualified Sound.Pulse.Simple as Pulse\nimport Control.Exception (bracket, finally)\nimport qualified Math.FFT as FFT\nimport Data.Array.IArray (amap, listArray)\nimport qualified Data.Array.IArray as IArray\nimport Data.Complex (Complex(..))\nimport Pipes\nimport qualified Pipes.Prelude as Pipes\nimport Graphics.Rendering.OpenGL (GLfloat)\nimport Graphics.DynamicGraph.FillLine\nimport Graphics.DynamicGraph.Line\nimport Graphics.DynamicGraph.Window\nimport Control.Monad (unless, guard, forever, when)\nimport Control.Error.Util (exceptT)\nimport Foreign.C.Types (CInt (..))\nimport Data.Foldable (for_)\nimport Data.Maybe (isJust)\nimport qualified Data.Aeson as Aeson\nimport qualified Data.Aeson.TH as Aeson.TH\nimport qualified Data.Yaml as Yaml\nimport qualified Data.Yaml.Pretty as Yaml.Pretty\nimport System.Environment (getArgs)\nimport Data.IORef\nimport qualified Data.ByteString.Char8 as BSC8\n\n-- key presses\n-- --------------------------------------------------------------------\n\nforeign import ccall \"fakekey_init\" fakeKeyInit :: IO ()\nforeign import ccall \"fakekey_press\" fakeKeyPress :: CInt -> IO ()\nforeign import ccall \"fakekey_release\" fakeKeyRelease :: CInt -> IO ()\n\nkeyCodeToX11KeySym :: String -> Maybe CInt\nkeyCodeToX11KeySym code = case code of\n \"KeyA\" -> Just 0x0061\n \"KeyB\" -> Just 0x0062\n \"KeyC\" -> Just 0x0063\n \"KeyD\" -> Just 0x0064\n \"KeyE\" -> Just 0x0065\n \"KeyF\" -> Just 0x0066\n \"KeyG\" -> Just 0x0067\n \"KeyH\" -> Just 0x0068\n \"KeyI\" -> Just 0x0069\n \"KeyJ\" -> Just 0x006a\n \"KeyK\" -> Just 0x006b\n \"KeyL\" -> Just 0x006c\n \"KeyM\" -> Just 0x006d\n \"KeyN\" -> Just 0x006e\n \"KeyO\" -> Just 0x006f\n \"KeyP\" -> Just 0x0070\n \"KeyQ\" -> Just 0x0071\n \"KeyR\" -> Just 0x0072\n \"KeyS\" -> Just 0x0073\n \"KeyT\" -> Just 0x0074\n \"KeyU\" -> Just 0x0075\n \"KeyV\" -> Just 0x0076\n \"KeyW\" -> Just 0x0077\n \"KeyX\" -> Just 0x0078\n \"KeyY\" -> Just 0x0079\n \"KeyZ\" -> Just 0x007a\n \"ArrowLeft\" -> Just 0xff51\n \"ArrowUp\" -> Just 0xff52\n \"ArrowRight\" -> Just 0xff53\n \"ArrowDown\" -> Just 0xff54\n \"Space\" -> Just 0x0020\n _ -> Nothing\n\n-- fft\n-- --------------------------------------------------------------------\n\nsampleRate :: Int\nsampleRate = 16000\n\nnumSamples :: Int\nnumSamples = 512\n\nfftFreqs :: [Float]\nfftFreqs = 0 : (do\n let binWidth :: Float = fromIntegral sampleRate / fromIntegral numSamples\n ix <- fromIntegral <$> [1..numSamples]\n let freq = binWidth * ix\n -- filter frequencies above 2000, they're not very useful for what\n -- we're doing\n guard (freq < 2000)\n return freq)\n\nfft :: [Float] -> [Float]\nfft signal = IArray.elems $ amap\n (\\(real :+ imag) -> sqrt (real ** 2 + imag ** 2))\n (FFT.dftRC (listArray (0, numSamples-1) signal))\n\n-- reading audio\n-- --------------------------------------------------------------------\n\ndata Graph = Audio | Frequency\n deriving (Show, Eq)\ninstance Aeson.FromJSON Graph where\n parseJSON = Aeson.withText \"Graph\" $ \\case\n \"Audio\" -> return Audio\n \"Frequency\" -> return Frequency\n txt -> fail (\"Invalid graph \" ++ show txt)\n\ndata Params = Params\n { paramsAmplitudeCoefficient :: GLfloat\n , paramsAmplitudeLowTreshold :: GLfloat\n , paramsAmplitudeHighTreshold :: GLfloat\n -- ^ what the minimum scaled peak frequency should be to trigger high / low\n , paramsFrequncyTreshold :: GLfloat\n } deriving (Eq, Show)\nAeson.TH.deriveJSON\n Aeson.defaultOptions{ Aeson.fieldLabelModifier = drop (length (\"params\" :: String))}\n ''Params\n\ndata Options = Options\n { optionsPrintBestFreq :: Bool -- ^ wether to print what the chosen frequency\n , optionsControls :: Maybe (String, String) -- ^ what to press when low and high\n , optionsGraph :: Graph\n } deriving (Eq, Show)\nAeson.TH.deriveFromJSON\n Aeson.defaultOptions{ Aeson.fieldLabelModifier = drop (length (\"options\" :: String))}\n ''Options\n\ndata Frame = Frame\n { frameAudio :: [GLfloat]\n , frameFrequencies :: [GLfloat]\n -- ^ the frequencies amplitudes are scaled by paramsAmplitudeCoefficient\n }\n\n-- returns the unscaled frame\nreadFrame :: Pulse.Simple -> IO Frame\nreadFrame spl = do\n frameAudio <- Pulse.simpleRead spl numSamples\n let frameFrequencies = take (length fftFreqs) (fft frameAudio)\n return Frame{..}\n\naudioFreqs :: Pulse.Simple -> Params -> Producer Frame IO void\naudioFreqs spl Params{..} = forever $ do\n frame <- lift (readFrame spl)\n yield frame{ frameFrequencies = map (* paramsAmplitudeCoefficient) (frameFrequencies frame) }\n\ndata LowHigh = Low | High\n deriving (Eq, Show)\n\ncomputeLowHigh :: Options -> Params -> [GLfloat] -> IO (Maybe LowHigh)\ncomputeLowHigh Options{..} Params{..} freqs = do\n let weightedAvg = sum (zipWith (*) fftFreqs freqs) / sum freqs\n let mbLowHigh = do\n let lowHigh = if weightedAvg < paramsFrequncyTreshold then Low else High\n guard $ case lowHigh of\n Low -> maximum freqs > paramsAmplitudeLowTreshold\n High -> maximum freqs > paramsAmplitudeHighTreshold\n return lowHigh\n when (optionsPrintBestFreq && isJust mbLowHigh) $ do\n putStrLn (\"best freq: \" ++ show weightedAvg)\n return mbLowHigh\n\ncontrol :: Options -> Params -> Pipe Frame Frame IO ()\ncontrol options@Options{..} params@Params{..} = go Nothing\n where\n go mbLowHigh = do\n frame@(Frame _ freqs) <- await\n newMbLowHigh <- lift (computeLowHigh options params freqs)\n lift $ case (mbLowHigh, newMbLowHigh) of\n (Nothing, Nothing) -> return ()\n (Nothing, Just newLowHigh) -> do\n putStrLn (\"Going from idle to \" ++ show newLowHigh)\n keyPress newLowHigh\n (Just lowHigh, Nothing) -> do\n putStrLn (\"Going from \" ++ show lowHigh ++ \" to idle\")\n keyRelease lowHigh\n (Just lowHigh, Just newLowHigh) | lowHigh == newLowHigh -> return ()\n (Just lowHigh, Just newLowHigh) -> do\n putStrLn (\"Going from \" ++ show lowHigh ++ \" to \" ++ show lowHigh)\n keyRelease lowHigh\n keyPress newLowHigh\n yield frame\n go newMbLowHigh\n\n keyPress lowHigh = for_ optionsControls $ \\(lowKey, highKey) -> case lowHigh of\n Low -> do\n Just keyCode <- return (keyCodeToX11KeySym lowKey)\n fakeKeyPress keyCode\n High -> do\n Just keyCode <- return (keyCodeToX11KeySym highKey)\n fakeKeyPress keyCode\n\n keyRelease lowHigh = for_ optionsControls $ \\(lowKey, highKey) -> case lowHigh of\n Low -> do\n Just keyCode <- return (keyCodeToX11KeySym lowKey)\n fakeKeyRelease keyCode\n High -> do\n Just keyCode <- return (keyCodeToX11KeySym highKey)\n fakeKeyRelease keyCode\n\ncalibrate :: Pulse.Simple -> IORef GLfloat -> Producer Frame IO void\ncalibrate spl maxFreqRef = forever $ do\n maxFreq <- lift (readIORef maxFreqRef)\n frame <- lift (readFrame spl)\n lift (writeIORef maxFreqRef (max maxFreq (maximum (frameFrequencies frame))))\n yield frame\n\nmain :: IO ()\nmain = do\n bracket\n (Pulse.simpleNew\n Nothing \"pitch-control\" Pulse.Record Nothing \"Pitch controls for your keyboard\"\n (Pulse.SampleSpec (Pulse.F32 Pulse.LittleEndian) sampleRate 1) Nothing Nothing)\n Pulse.simpleFree\n (\\spl -> exceptT error return $ do\n res <- lift setupGLFW\n unless res (error \"Unable to initilize GLFW\")\n args <- lift getArgs\n case args of\n [\"calibrate\"] -> do\n maxFreqRef <- lift (newIORef 0)\n render <- window 1024 480 (fmap pipeify (renderFilledLine (length fftFreqs) jet_mod))\n let tranformFreqs = forever $ do\n frame <- await\n maxFreq <- lift (readIORef maxFreqRef)\n yield (map (/ maxFreq) (frameFrequencies frame))\n lift $ finally (runEffect (calibrate spl maxFreqRef >-> tranformFreqs >-> render)) $ do\n maxFreq <- readIORef maxFreqRef\n BSC8.putStrLn $ Yaml.Pretty.encodePretty Yaml.Pretty.defConfig Params\n { paramsAmplitudeCoefficient = 1 / maxFreq\n , paramsAmplitudeLowTreshold = 0.1\n , paramsAmplitudeHighTreshold = 0.2\n , paramsFrequncyTreshold = 700\n }\n [\"run\", paramsFile, optionsFile] -> do\n params <- lift (either (error . Yaml.prettyPrintParseException) id <$> Yaml.decodeFileEither paramsFile)\n options <- lift (either (error . Yaml.prettyPrintParseException) id <$> Yaml.decodeFileEither optionsFile)\n lift fakeKeyInit\n render <- window 1024 480 $ fmap pipeify $ case optionsGraph options of\n Frequency -> renderFilledLine (length fftFreqs) jet_mod\n Audio -> renderLine numSamples 1024\n let data_ = Pipes.map $ case optionsGraph options of\n Frequency -> frameFrequencies\n Audio -> map ((+ 0.5) . (/ 2)) . frameAudio\n lift (runEffect (audioFreqs spl params >-> control options params >-> data_ >-> render)))\n\n", "meta": {"hexsha": "f979c2daaae016fdaac3ec232a522b894b5075c3", "size": 9041, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "app/Main.hs", "max_stars_repo_name": "bitonic/pitch-control", "max_stars_repo_head_hexsha": "4be256d24b015799a88fca804e6a87ac6c6c19de", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 6, "max_stars_repo_stars_event_min_datetime": "2018-06-10T13:46:59.000Z", "max_stars_repo_stars_event_max_datetime": "2018-08-17T12:09:38.000Z", "max_issues_repo_path": "app/Main.hs", "max_issues_repo_name": "bitonic/pitch-control", "max_issues_repo_head_hexsha": "4be256d24b015799a88fca804e6a87ac6c6c19de", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "app/Main.hs", "max_forks_repo_name": "bitonic/pitch-control", "max_forks_repo_head_hexsha": "4be256d24b015799a88fca804e6a87ac6c6c19de", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 36.164, "max_line_length": 116, "alphanum_fraction": 0.6571175755, "num_tokens": 2465, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6477982179521103, "lm_q2_score": 0.49218813572079556, "lm_q1q2_score": 0.3188385972171028}} {"text": "{-# LANGUAGE CPP #-}\n{-# LANGUAGE FunctionalDependencies #-}\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE MultiParamTypeClasses #-}\n{-# LANGUAGE Rank2Types #-}\n{-# LANGUAGE RecordWildCards #-}\n{-# LANGUAGE ScopedTypeVariables #-}\n\nmodule Data.Eigen.Matrix (\n -- * Matrix type\n -- | Matrix aliases follows Eigen naming convention\n Matrix(..),\n MatrixXf,\n MatrixXd,\n MatrixXcf,\n MatrixXcd,\n I.Elem,\n I.CComplex,\n valid,\n -- * Matrix conversions\n fromList,\n toList,\n fromFlatList,\n toFlatList,\n generate,\n -- * Standard matrices and special cases\n empty,\n null,\n square,\n zero,\n ones,\n identity,\n constant,\n random,\n -- * Accessing matrix data\n cols,\n rows,\n dims,\n (!),\n coeff,\n unsafeCoeff,\n col,\n row,\n block,\n topRows,\n bottomRows,\n leftCols,\n rightCols,\n -- * Matrix properties\n sum,\n prod,\n mean,\n minCoeff,\n maxCoeff,\n trace,\n norm,\n squaredNorm,\n blueNorm,\n hypotNorm,\n determinant,\n -- * Generic reductions\n fold,\n fold',\n ifold,\n ifold',\n fold1,\n fold1',\n -- * Boolean reductions\n all,\n any,\n count,\n -- * Basic matrix algebra\n add,\n sub,\n mul,\n -- * Mapping over elements\n map,\n imap,\n filter,\n ifilter,\n -- * Matrix transformations\n diagonal,\n transpose,\n inverse,\n adjoint,\n conjugate,\n normalize,\n modify,\n convert,\n TriangularMode(..),\n triangularView,\n lowerTriangle,\n upperTriangle,\n -- * Matrix serialization\n encode,\n decode,\n -- * Mutable matrices\n thaw,\n freeze,\n unsafeThaw,\n unsafeFreeze,\n -- * Raw pointers\n unsafeWith,\n) where\n\nimport qualified Prelude as P\nimport qualified Data.List as L\nimport Prelude hiding (null, sum, all, any, map, filter)\nimport Data.Tuple\nimport Data.Complex hiding (conjugate)\nimport Data.Binary hiding (encode, decode)\nimport qualified Data.Binary as B\nimport Foreign.Ptr\nimport Foreign.C.Types\nimport Foreign.C.String\nimport Foreign.Storable\nimport Foreign.Marshal.Alloc\nimport Text.Printf\nimport Control.Monad\nimport Control.Monad.ST\nimport Control.Monad.Primitive\n#if __GLASGOW_HASKELL__ >= 710\n#else\nimport Control.Applicative hiding (empty)\n#endif\nimport qualified Data.Vector.Storable as VS\nimport qualified Data.Vector.Storable.Mutable as VSM\nimport qualified Data.Eigen.Internal as I\nimport qualified Data.Eigen.Matrix.Mutable as M\nimport qualified Data.ByteString.Lazy as BSL\n\n-- | Matrix to be used in pure computations, uses column major memory layout, features copy-free FFI with C++ library.\n\ndata Matrix a b where\n Matrix :: I.Elem a b => !Int -> !Int -> !(VS.Vector b) -> Matrix a b\n\n-- | Alias for single precision matrix\ntype MatrixXf = Matrix Float CFloat\n-- | Alias for double precision matrix\ntype MatrixXd = Matrix Double CDouble\n-- | Alias for single previsiom matrix of complex numbers\ntype MatrixXcf = Matrix (Complex Float) (I.CComplex CFloat)\n-- | Alias for double prevision matrix of complex numbers\ntype MatrixXcd = Matrix (Complex Double) (I.CComplex CDouble)\n\n-- | Pretty prints the matrix\ninstance (I.Elem a b, Show a) => Show (Matrix a b) where\n show m@(Matrix rows cols _) = concat [\n \"Matrix \", show rows, \"x\", show cols,\n \"\\n\", L.intercalate \"\\n\" $ P.map (L.intercalate \"\\t\" . P.map show) $ toList m, \"\\n\"]\n\n\n-- | Basic matrix math exposed through Num instance: @(*)@, @(+)@, @(-)@, `fromInteger`, `signum`, `abs`, `negate`\ninstance I.Elem a b => Num (Matrix a b) where\n (*) = mul\n (+) = add\n (-) = sub\n fromInteger = constant 1 1 . fromInteger\n signum = map signum\n abs = map abs\n negate = map negate\n\n-- | Matrix binary serialization\ninstance I.Elem a b => Binary (Matrix a b) where\n put (Matrix rows cols vals) = do\n put $ I.magicCode (undefined :: b)\n put rows\n put cols\n put vals\n\n get = do\n get >>= (`when` fail \"wrong matrix type\") . (/= I.magicCode (undefined :: b))\n Matrix <$> get <*> get <*> get\n\n-- | Encode the matrix as a lazy byte string\nencode :: I.Elem a b => Matrix a b -> BSL.ByteString\nencode = B.encode\n\n-- | Decode matrix from the lazy byte string\ndecode :: I.Elem a b => BSL.ByteString -> Matrix a b\ndecode = B.decode\n\n-- | Empty 0x0 matrix\n{-# INLINE empty #-}\nempty :: I.Elem a b => Matrix a b\nempty = Matrix 0 0 VS.empty\n\n-- | Is matrix empty?\n{-# INLINE null #-}\nnull :: I.Elem a b => Matrix a b -> Bool\nnull (Matrix rows cols _) = rows == 0 && cols == 0\n\n-- | Is matrix square?\n{-# INLINE square #-}\nsquare :: I.Elem a b => Matrix a b -> Bool\nsquare (Matrix rows cols _) = rows == cols\n\n-- | Matrix where all coeffs are filled with given value\n{-# INLINE constant #-}\nconstant :: I.Elem a b => Int -> Int -> a -> Matrix a b\nconstant rows cols val = Matrix rows cols $ VS.replicate (rows * cols) (I.cast val)\n\n-- | Matrix where all coeff are 0\n{-# INLINE zero #-}\nzero :: I.Elem a b => Int -> Int -> Matrix a b\nzero rows cols = constant rows cols 0\n\n-- | Matrix where all coeff are 1\n{-# INLINE ones #-}\nones :: I.Elem a b => Int -> Int -> Matrix a b\nones rows cols = constant rows cols 1\n\n-- | The identity matrix (not necessarily square).\nidentity :: I.Elem a b => Int -> Int -> Matrix a b\nidentity rows cols = I.performIO $ do\n m <- M.new rows cols\n I.call $ M.unsafeWith m I.identity\n unsafeFreeze m\n\n-- | The random matrix of a given size\nrandom :: I.Elem a b => Int -> Int -> IO (Matrix a b)\nrandom rows cols = do\n m <- M.new rows cols\n I.call $ M.unsafeWith m I.random\n unsafeFreeze m\n\n-- | Number of rows for the matrix\n{-# INLINE rows #-}\nrows :: I.Elem a b => Matrix a b -> Int\nrows (Matrix rows _ _) = rows\n\n-- | Number of columns for the matrix\n{-# INLINE cols #-}\ncols :: I.Elem a b => Matrix a b -> Int\ncols (Matrix _ cols _) = cols\n\n-- | Mtrix size as (rows, cols) pair\n{-# INLINE dims #-}\ndims :: I.Elem a b => Matrix a b -> (Int, Int)\ndims (Matrix rows cols _) = (rows, cols)\n\n-- | Matrix coefficient at specific row and col\n{-# INLINE (!) #-}\n(!) :: I.Elem a b => Matrix a b -> (Int, Int) -> a\n(!) m (row,col) = coeff row col m\n\n-- | Matrix coefficient at specific row and col\n{-# INLINE coeff #-}\ncoeff :: I.Elem a b => Int -> Int -> Matrix a b -> a\ncoeff row col m@(Matrix rows cols _)\n | not (valid m) = error \"matrix is not valid\"\n | row < 0 || row >= rows = error $ printf \"Matrix.coeff: row %d is out of bounds [0..%d)\" row rows\n | col < 0 || col >= cols = error $ printf \"Matrix.coeff: col %d is out of bounds [0..%d)\" col cols\n | otherwise = unsafeCoeff row col m\n\n-- | Unsafe version of coeff function. No bounds check performed so SEGFAULT possible\n{-# INLINE unsafeCoeff #-}\nunsafeCoeff :: I.Elem a b => Int -> Int -> Matrix a b -> a\nunsafeCoeff row col (Matrix rows _ vals) = I.cast $ VS.unsafeIndex vals $ col * rows + row\n\n-- | List of coefficients for the given col\n{-# INLINE col #-}\ncol :: I.Elem a b => Int -> Matrix a b -> [a]\ncol c m@(Matrix rows _ _) = [coeff r c m | r <- [0..pred rows]]\n\n-- | List of coefficients for the given row\n{-# INLINE row #-}\nrow :: I.Elem a b => Int -> Matrix a b -> [a]\nrow r m@(Matrix _ cols _) = [coeff r c m | c <- [0..pred cols]]\n\n-- | Extract rectangular block from matrix defined by startRow startCol blockRows blockCols\nblock :: I.Elem a b => Int -> Int -> Int -> Int -> Matrix a b -> Matrix a b\nblock startRow startCol blockRows blockCols m =\n generate blockRows blockCols $ \\row col ->\n coeff (startRow + row) (startCol + col) m\n\n-- | Verify matrix dimensions and memory layout\n{-# INLINE valid #-}\nvalid :: I.Elem a b => Matrix a b -> Bool\nvalid (Matrix rows cols vals) = rows >= 0 && cols >= 0 && VS.length vals == rows * cols\n\n-- | The maximum coefficient of the matrix\n{-# INLINE maxCoeff #-}\nmaxCoeff :: (I.Elem a b, Ord a) => Matrix a b -> a\nmaxCoeff = fold1' max\n\n-- | The minimum coefficient of the matrix\n{-# INLINE minCoeff #-}\nminCoeff :: (I.Elem a b, Ord a) => Matrix a b -> a\nminCoeff = fold1' min\n\n-- | Top @N@ rows of matrix\n{-# INLINE topRows #-}\ntopRows :: I.Elem a b => Int -> Matrix a b -> Matrix a b\ntopRows n m@(Matrix _ cols _) = block 0 0 n cols m\n\n-- | Bottom @N@ rows of matrix\n{-# INLINE bottomRows #-}\nbottomRows :: I.Elem a b => Int -> Matrix a b -> Matrix a b\nbottomRows n m@(Matrix rows cols _) = block (rows - n) 0 n cols m\n\n-- | Left @N@ columns of matrix\n{-# INLINE leftCols #-}\nleftCols :: I.Elem a b => Int -> Matrix a b -> Matrix a b\nleftCols n m@(Matrix rows _ _) = block 0 0 rows n m\n\n-- | Right @N@ columns of matrix\n{-# INLINE rightCols #-}\nrightCols :: I.Elem a b => Int -> Matrix a b -> Matrix a b\nrightCols n m@(Matrix rows cols _) = block 0 (cols - n) rows n m\n\n-- | Construct matrix from a list of rows, column count is detected as maximum row length. Missing values are filled with 0\nfromList :: I.Elem a b => [[a]] -> Matrix a b\nfromList list = Matrix rows cols vals where\n rows = length list\n cols = L.foldl' max 0 $ P.map length list\n vals = VS.create $ do\n vm <- VSM.replicate (rows * cols) (I.cast (0 `asTypeOf` (head (head list))))\n forM_ (zip [0..] list) $ \\(row, vals) ->\n forM_ (zip [0..] vals) $ \\(col, val) ->\n VSM.write vm (col * rows + row) (I.cast val)\n return vm\n\n-- | Convert matrix to a list of rows\ntoList :: I.Elem a b => Matrix a b -> [[a]]\ntoList m@(Matrix rows cols vals)\n | not (valid m) = error \"matrix is not valid\"\n | otherwise = [[I.cast $ vals `VS.unsafeIndex` (col * rows + row) | col <- [0..pred cols]] | row <- [0..pred rows]]\n\n-- | Build matrix of given dimensions and values from given list split on rows. Invalid list length results in error.\nfromFlatList :: I.Elem a b => Int -> Int -> [a] -> Matrix a b\nfromFlatList rows cols list\n | not (rows * cols == (length list)) = error $ concat [\"cannot construct \", show rows, \"x\", show cols, \" matrix from \", show $ length list, \" values\"]\n | otherwise = Matrix rows cols vals where\n vals = VS.create $ do\n vm <- VSM.replicate (rows * cols) (I.cast (0 `asTypeOf` (head list)))\n forM_ (zip [(col * rows + row) | row <- [0..pred rows], col <- [0..pred cols]] list) $ \\(idx, val) ->\n VSM.write vm idx (I.cast val)\n return vm\n\n-- | Convert matrix to a list by concatenating rows\ntoFlatList :: I.Elem a b => Matrix a b -> [a]\ntoFlatList m@(Matrix rows cols vals)\n | not (valid m) = error \"matrix is not valid\"\n | otherwise = [I.cast $ vals `VS.unsafeIndex` (col * rows + row) | row <- [0..pred rows], col <- [0..pred cols]]\n\n-- | [generate rows cols (\u03bb row col -> val)]\n--\n-- Create matrix using generator function @\u03bb row col -> val@\n--\ngenerate :: I.Elem a b => Int -> Int -> (Int -> Int -> a) -> Matrix a b\ngenerate rows cols f = Matrix rows cols $ VS.create $ do\n vals <- VSM.new (rows * cols)\n forM_ [0..pred rows] $ \\row ->\n forM_ [0..pred cols] $ \\col ->\n VSM.write vals (col * rows + row) (I.cast $ f row col)\n return vals\n\n-- | The sum of all coefficients of the matrix\nsum :: I.Elem a b => Matrix a b -> a\nsum = _prop I.sum\n\n-- | The product of all coefficients of the matrix\nprod :: I.Elem a b => Matrix a b -> a\nprod = _prop I.prod\n\n-- | The mean of all coefficients of the matrix\nmean :: I.Elem a b => Matrix a b -> a\nmean = _prop I.mean\n\n-- | The trace of a matrix is the sum of the diagonal coefficients and can also be computed as sum (diagonal m)\ntrace :: I.Elem a b => Matrix a b -> a\ntrace = _prop I.trace\n\n-- | Applied to a predicate and a matrix, all determines if all elements of the matrix satisfies the predicate\nall :: I.Elem a b => (a -> Bool) -> Matrix a b -> Bool\nall f = VS.all (f . I.cast) . _vals\n\n-- | Applied to a predicate and a matrix, any determines if any element of the matrix satisfies the predicate\nany :: I.Elem a b => (a -> Bool) -> Matrix a b -> Bool\nany f = VS.any (f . I.cast) . _vals\n\n-- | Returns the number of coefficients in a given matrix that evaluate to true\ncount :: I.Elem a b => (a -> Bool) -> Matrix a b -> Int\ncount f = VS.foldl' (\\n x -> if f (I.cast x) then succ n else n) 0 . _vals\n\n{-| For vectors, the l2 norm, and for matrices the Frobenius norm.\n In both cases, it consists in the square root of the sum of the square of all the matrix entries.\n For vectors, this is also equals to the square root of the dot product of this with itself.\n-}\nnorm :: I.Elem a b => Matrix a b -> a\nnorm = _prop I.norm\n\n-- | For vectors, the squared l2 norm, and for matrices the Frobenius norm. In both cases, it consists in the sum of the square of all the matrix entries. For vectors, this is also equals to the dot product of this with itself.\nsquaredNorm :: I.Elem a b => Matrix a b -> a\nsquaredNorm = _prop I.squaredNorm\n\n-- | The l2 norm of the matrix using the Blue's algorithm. A Portable Fortran Program to Find the Euclidean Norm of a Vector, ACM TOMS, Vol 4, Issue 1, 1978.\nblueNorm :: I.Elem a b => Matrix a b -> a\nblueNorm = _prop I.blueNorm\n\n-- | The l2 norm of the matrix avoiding undeflow and overflow. This version use a concatenation of hypot calls, and it is very slow.\nhypotNorm :: I.Elem a b => Matrix a b -> a\nhypotNorm = _prop I.hypotNorm\n\n-- | The determinant of the matrix\ndeterminant :: I.Elem a b => Matrix a b -> a\ndeterminant m\n | square m = _prop I.determinant m\n | otherwise = error \"Matrix.determinant: non-square matrix\"\n\n-- | Adding two matrices by adding the corresponding entries together. You can use @(+)@ function as well.\nadd :: I.Elem a b => Matrix a b -> Matrix a b -> Matrix a b\nadd m1 m2\n | dims m1 == dims m2 = _binop const I.add m1 m2\n | otherwise = error \"Matrix.add: matrices should have the same size\"\n\n-- | Subtracting two matrices by subtracting the corresponding entries together. You can use @(-)@ function as well.\nsub :: I.Elem a b => Matrix a b -> Matrix a b -> Matrix a b\nsub m1 m2\n | dims m1 == dims m2 = _binop const I.sub m1 m2\n | otherwise = error \"Matrix.add: matrices should have the same size\"\n\n-- | Matrix multiplication. You can use @(*)@ function as well.\nmul :: I.Elem a b => Matrix a b -> Matrix a b -> Matrix a b\nmul m1 m2\n | cols m1 == rows m2 = _binop (\\(rows, _) (_, cols) -> (rows, cols)) I.mul m1 m2\n | otherwise = error \"Matrix.mul: number of columns for lhs matrix should be the same as number of rows for rhs matrix\"\n\n{- | Apply a given function to each element of the matrix.\n\nHere is an example how to implement scalar matrix multiplication:\n\n>>> let a = fromList [[1,2],[3,4]] :: MatrixXf\n\n>>> a\nMatrix 2x2\n1.0 2.0\n3.0 4.0\n\n>>> map (*10) a\nMatrix 2x2\n10.0 20.0\n30.0 40.0\n\n-}\nmap :: I.Elem a b => (a -> a) -> Matrix a b -> Matrix a b\nmap f (Matrix rows cols vals) = Matrix rows cols (VS.map (I.cast . f . I.cast) vals)\n\n{- | Apply a given function to each element of the matrix.\n\nHere is an example how upper triangular matrix can be implemented:\n\n>>> let a = fromList [[1,2,3],[4,5,6],[7,8,9]] :: MatrixXf\n\n>>> a\nMatrix 3x3\n1.0 2.0 3.0\n4.0 5.0 6.0\n7.0 8.0 9.0\n\n>>> imap (\\row col val -> if row <= col then val else 0) a\nMatrix 3x3\n1.0 2.0 3.0\n0.0 5.0 6.0\n0.0 0.0 9.0\n\n-}\n\nimap :: I.Elem a b => (Int -> Int -> a -> a) -> Matrix a b -> Matrix a b\nimap f (Matrix rows cols vals) = Matrix rows cols (VS.imap (\\n -> let (c, r) = divMod n rows in I.cast . f r c . I.cast) vals)\n\ndata TriangularMode\n -- | View matrix as a lower triangular matrix.\n = Lower\n -- | View matrix as an upper triangular matrix.\n | Upper\n -- | View matrix as a lower triangular matrix with zeros on the diagonal.\n | StrictlyLower\n -- | View matrix as an upper triangular matrix with zeros on the diagonal.\n | StrictlyUpper\n -- | View matrix as a lower triangular matrix with ones on the diagonal.\n | UnitLower\n -- | View matrix as an upper triangular matrix with ones on the diagonal.\n | UnitUpper deriving (Eq, Enum, Show, Read)\n\n-- | Triangular view extracted from the current matrix\ntriangularView :: I.Elem a b => TriangularMode -> Matrix a b -> Matrix a b\ntriangularView Lower = imap $ \\row col val -> case compare row col of { LT -> 0; _ -> val }\ntriangularView Upper = imap $ \\row col val -> case compare row col of { GT -> 0; _ -> val }\ntriangularView StrictlyLower = imap $ \\row col val -> case compare row col of { GT -> val; _ -> 0 }\ntriangularView StrictlyUpper = imap $ \\row col val -> case compare row col of { LT -> val; _ -> 0 }\ntriangularView UnitLower = imap $ \\row col val -> case compare row col of { GT -> val; LT -> 0; EQ -> 1 }\ntriangularView UnitUpper = imap $ \\row col val -> case compare row col of { LT -> val; GT -> 0; EQ -> 1 }\n\n-- | Lower trinagle of the matrix. Shortcut for @triangularView Lower@\nlowerTriangle :: I.Elem a b => Matrix a b -> Matrix a b\nlowerTriangle = triangularView Lower\n\n-- | Upper trinagle of the matrix. Shortcut for @triangularView Upper@\nupperTriangle :: I.Elem a b => Matrix a b -> Matrix a b\nupperTriangle = triangularView Upper\n\n-- | Filter elements in the matrix. Filtered elements will be replaced by 0\nfilter :: I.Elem a b => (a -> Bool) -> Matrix a b -> Matrix a b\nfilter f = map (\\x -> if f x then x else 0)\n\n-- | Filter elements in the matrix. Filtered elements will be replaced by 0\nifilter :: I.Elem a b => (Int -> Int -> a -> Bool) -> Matrix a b -> Matrix a b\nifilter f = imap (\\r c x -> if f r c x then x else 0)\n\n-- | Reduce matrix using user provided function applied to each element.\nfold :: I.Elem a b => (c -> a -> c) -> c -> Matrix a b -> c\nfold f a (Matrix _ _ vals) = VS.foldl (\\a x -> f a (I.cast x)) a vals\n\n-- | Reduce matrix using user provided function applied to each element. This is strict version of 'fold'\nfold' :: I.Elem a b => (c -> a -> c) -> c -> Matrix a b -> c\nfold' f a (Matrix _ _ vals) = VS.foldl' (\\a x -> f a (I.cast x)) a vals\n\n-- | Reduce matrix using user provided function applied to each element and it's index\nifold :: I.Elem a b => (Int -> Int -> c -> a -> c) -> c -> Matrix a b -> c\nifold f a (Matrix rows _ vals) = VS.ifoldl (\\a n x -> let (c,r) = divMod n rows in f r c a (I.cast x)) a vals\n\n-- | Reduce matrix using user provided function applied to each element and it's index. This is strict version of 'ifold'\nifold' :: I.Elem a b => (Int -> Int -> c -> a -> c) -> c -> Matrix a b -> c\nifold' f a (Matrix rows _ vals) = VS.ifoldl' (\\a n x -> let (c,r) = divMod n rows in f r c a (I.cast x)) a vals\n\n-- | Reduce matrix using user provided function applied to each element.\nfold1 :: I.Elem a b => (a -> a -> a) -> Matrix a b -> a\nfold1 f = foldl1 f . P.map I.cast . VS.toList . _vals\n\n-- | Reduce matrix using user provided function applied to each element. This is strict version of 'fold'\nfold1' :: I.Elem a b => (a -> a -> a) -> Matrix a b -> a\nfold1' f = L.foldl1' f . P.map I.cast . VS.toList . _vals\n\n-- | Diagonal of the matrix\ndiagonal :: I.Elem a b => Matrix a b -> Matrix a b\ndiagonal = _unop (\\(rows, cols) -> (min rows cols, 1)) I.diagonal\n\n{- | Inverse of the matrix\n\nFor small fixed sizes up to 4x4, this method uses cofactors. In the general case, this method uses PartialPivLU decomposition\n-}\ninverse :: I.Elem a b => Matrix a b -> Matrix a b\ninverse m\n | square m = _unop id I.inverse m\n | otherwise = error \"Matrix.inverse: non-square matrix\"\n\n-- | Adjoint of the matrix\nadjoint :: I.Elem a b => Matrix a b -> Matrix a b\nadjoint = _unop swap I.adjoint\n\n-- | Transpose of the matrix\ntranspose :: I.Elem a b => Matrix a b -> Matrix a b\ntranspose = _unop swap I.transpose\n\n-- | Conjugate of the matrix\nconjugate :: I.Elem a b => Matrix a b -> Matrix a b\nconjugate = _unop id I.conjugate\n\n-- | Nomalize the matrix by deviding it on its 'norm'\nnormalize :: I.Elem a b => Matrix a b -> Matrix a b\nnormalize (Matrix rows cols vals) = I.performIO $ do\n vals <- VS.thaw vals\n VSM.unsafeWith vals $ \\p ->\n I.call $ I.normalize p (I.cast rows) (I.cast cols)\n Matrix rows cols <$> VS.unsafeFreeze vals\n\n-- | Apply a destructive operation to a matrix. The operation will be performed in place if it is safe to do so and will modify a copy of the matrix otherwise.\nmodify :: I.Elem a b => (forall s. M.MMatrix a b s -> ST s ()) -> Matrix a b -> Matrix a b\nmodify f (Matrix rows cols vals) = Matrix rows cols (VS.modify (f . M.MMatrix rows cols) vals)\n\n-- | Convert matrix to different type using user provided element converter\nconvert :: (I.Elem a b, I.Elem c d) => (a -> c) -> Matrix a b -> Matrix c d\nconvert f (Matrix rows cols vals) = Matrix rows cols $ VS.map (I.cast . f . I.cast) vals\n\n-- | Yield an immutable copy of the mutable matrix\nfreeze :: I.Elem a b => PrimMonad m => M.MMatrix a b (PrimState m) -> m (Matrix a b)\nfreeze (M.MMatrix mrows mcols mvals) = VS.freeze mvals >>= return . Matrix mrows mcols\n\n-- | Yield a mutable copy of the immutable matrix\nthaw :: I.Elem a b => PrimMonad m => Matrix a b -> m (M.MMatrix a b (PrimState m))\nthaw (Matrix rows cols vals) = VS.thaw vals >>= return . M.MMatrix rows cols\n\n-- | Unsafe convert a mutable matrix to an immutable one without copying. The mutable matrix may not be used after this operation.\nunsafeFreeze :: I.Elem a b => PrimMonad m => M.MMatrix a b (PrimState m) -> m (Matrix a b)\nunsafeFreeze (M.MMatrix mrows mcols mvals) = VS.unsafeFreeze mvals >>= return . Matrix mrows mcols\n\n-- | Unsafely convert an immutable matrix to a mutable one without copying. The immutable matrix may not be used after this operation.\nunsafeThaw :: I.Elem a b => PrimMonad m => Matrix a b -> m (M.MMatrix a b (PrimState m))\nunsafeThaw (Matrix rows cols vals) = VS.unsafeThaw vals >>= return . M.MMatrix rows cols\n\n-- | Pass a pointer to the matrix's data to the IO action. The data may not be modified through the pointer.\nunsafeWith :: I.Elem a b => Matrix a b -> (Ptr b -> CInt -> CInt -> IO c) -> IO c\nunsafeWith m@(Matrix rows cols vals) f\n | not (valid m) = fail \"Matrix.unsafeWith: matrix layout is invalid\"\n | otherwise = VS.unsafeWith vals $ \\p -> f p (I.cast rows) (I.cast cols)\n\n{-# INLINE _prop #-}\n_prop :: I.Elem a b => (Ptr b -> Ptr b -> CInt -> CInt -> IO CString) -> Matrix a b -> a\n_prop f m = I.cast $ I.performIO $ alloca $ \\p -> do\n I.call $ unsafeWith m (f p)\n peek p\n\n{-# INLINE _binop #-}\n_binop :: I.Elem a b => ((Int, Int) -> (Int, Int) -> (Int, Int)) -> (Ptr b -> CInt -> CInt -> Ptr b -> CInt -> CInt -> Ptr b -> CInt -> CInt -> IO CString) -> Matrix a b -> Matrix a b -> Matrix a b\n_binop f g m1 m2 = I.performIO $ do\n m0 <- uncurry M.new $ f (dims m1) (dims m2)\n M.unsafeWith m0 $ \\vals0 rows0 cols0 ->\n unsafeWith m1 $ \\vals1 rows1 cols1 ->\n unsafeWith m2 $ \\vals2 rows2 cols2 ->\n I.call $ g\n vals0 rows0 cols0\n vals1 rows1 cols1\n vals2 rows2 cols2\n unsafeFreeze m0\n\n{-# INLINE _unop #-}\n_unop :: I.Elem a b => ((Int,Int) -> (Int,Int)) -> (Ptr b -> CInt -> CInt -> Ptr b -> CInt -> CInt -> IO CString) -> Matrix a b -> Matrix a b\n_unop f g m1 = I.performIO $ do\n m0 <- uncurry M.new $ f (dims m1)\n M.unsafeWith m0 $ \\vals0 rows0 cols0 ->\n unsafeWith m1 $ \\vals1 rows1 cols1 ->\n I.call $ g\n vals0 rows0 cols0\n vals1 rows1 cols1\n unsafeFreeze m0\n\n{-# INLINE _vals #-}\n_vals :: I.Elem a b => Matrix a b -> VS.Vector b\n_vals (Matrix _ _ vals) = vals\n", "meta": {"hexsha": "76c22d03b4ea80352e8427cb39b92acbd7aa22b2", "size": 23325, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "Data/Eigen/Matrix.hs", "max_stars_repo_name": "osidorkin/haskell-eigen", "max_stars_repo_head_hexsha": "2537faa99d3714d6a4c7621433f854e46f07f296", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 25, "max_stars_repo_stars_event_min_datetime": "2015-04-06T06:36:43.000Z", "max_stars_repo_stars_event_max_datetime": "2021-04-14T08:19:06.000Z", "max_issues_repo_path": "Data/Eigen/Matrix.hs", "max_issues_repo_name": "osidorkin/haskell-eigen", "max_issues_repo_head_hexsha": "2537faa99d3714d6a4c7621433f854e46f07f296", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 15, "max_issues_repo_issues_event_min_datetime": "2015-04-06T06:36:06.000Z", "max_issues_repo_issues_event_max_datetime": "2018-09-21T18:13:08.000Z", "max_forks_repo_path": "Data/Eigen/Matrix.hs", "max_forks_repo_name": "osidorkin/haskell-eigen", "max_forks_repo_head_hexsha": "2537faa99d3714d6a4c7621433f854e46f07f296", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 14, "max_forks_repo_forks_event_min_datetime": "2015-03-29T07:08:15.000Z", "max_forks_repo_forks_event_max_datetime": "2020-02-09T03:08:23.000Z", "avg_line_length": 36.9066455696, "max_line_length": 227, "alphanum_fraction": 0.6356698821, "num_tokens": 6753, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6370307944803831, "lm_q2_score": 0.5, "lm_q1q2_score": 0.31851539724019157}} {"text": "{-# LANGUAGE QuasiQuotes #-}\nmodule Myelin.PyNN.SpiNNakerSpec where\n\nimport Control.Lens\nimport Control.Monad.State.Lazy\nimport Control.Monad.Trans.Except\nimport Data.Aeson\nimport Data.ByteString.Lazy.Char8\nimport Data.Either\nimport qualified Data.Map.Strict as Map\nimport Data.String.Interpolate\nimport Numeric.LinearAlgebra\nimport Text.Regex as Regex\n\nimport Myelin.Model\nimport Myelin.Neuron\nimport Myelin.PyNN.PyNN\nimport Myelin.SNN\n\nimport Test.Hspec\n\nmain :: IO ()\nmain = hspec spec\n\neval :: PyNNState a -> Either String a\neval s = evalState (runExceptT s) emptyPyNNModel\n\nexec :: PyNNState a -> PyNNModel\nexec s = execState (runExceptT s) emptyPyNNModel\n\nspec :: Spec\nspec = do\n describe \"PyNN backend\" $ do\n it \"can translate an entire SNN model to a SpiNNaker script\" $ do\n let input = Population 2 if_cond_exp \"p0\" 0\n let hidden = Population 4 if_cond_exp \"p1\" 1\n let output = Population 3 if_cond_exp \"p2\" 2\n let dictWithType = unpack $ encode if_cond_exp\n let dict = Regex.subRegex typeRegex dictWithType \"\"\n let effect1 = Static Excitatory (AllToAll (BiasGenerator (Constant 0)) (WeightGenerator (Constant 1)))\n let effect2 = Static Excitatory (AllToAll (Biases [0.0, 1.1, 2.2]) (WeightGenerator (GaussianRandom 2 1)))\n let edges = [ DenseProjection effect1 input hidden, DenseProjection effect2 hidden output ]\n let network = Network 0 [input] [hidden] edges [output]\n let task = Task SpiNNaker network 50\n let preample = PyNNPreample \"# some config\"\n let code = [i|import numpy as np\nimport volrpynn.spiNNaker as v\nimport pyNN.spiNNaker as pynn\n\n# some config\n\np0 = pynn.Population(2, pynn.IF_cond_exp(**#{dict}))\np1 = pynn.Population(4, pynn.IF_cond_exp(**#{dict}))\np2 = pynn.Population(3, pynn.IF_cond_exp(**#{dict}))\nlayer0 = v.Dense(p0, p1, weights=1.0, biases=0.0)\nlayer1 = v.Dense(p1, p2, weights=np.random.normal(2.0, 1.0, (4, 3)), biases=np.array([0.0,1.1,2.2]))\nl_decode = v.Decode(p2)\nmodel = v.Model(layer0, layer1, l_decode)\n\noptimiser = v.GradientDescentOptimiser(0.1, simulation_time=50.0)\nif __name__ == \"__main__\":\n v.Main(model).train(optimiser)\n|]\n translate task preample `shouldBe` Right code", "meta": {"hexsha": "14daee98ea4200eac50fb16d0dc67132b28a037b", "size": 2199, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "test/Myelin/PyNN/SpiNNakerSpec.hs", "max_stars_repo_name": "volr/myelin", "max_stars_repo_head_hexsha": "aaae7ab6f6db85c60fd7940accbb834e0068752e", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "test/Myelin/PyNN/SpiNNakerSpec.hs", "max_issues_repo_name": "volr/myelin", "max_issues_repo_head_hexsha": "aaae7ab6f6db85c60fd7940accbb834e0068752e", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "test/Myelin/PyNN/SpiNNakerSpec.hs", "max_forks_repo_name": "volr/myelin", "max_forks_repo_head_hexsha": "aaae7ab6f6db85c60fd7940accbb834e0068752e", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 34.359375, "max_line_length": 112, "alphanum_fraction": 0.7248749432, "num_tokens": 666, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6959583124210896, "lm_q2_score": 0.45713671682749485, "lm_q1q2_score": 0.31814809798898086}} {"text": "{-# LANGUAGE CPP #-}\n{-# LANGUAGE FlexibleContexts #-}\n{-# LANGUAGE TypeApplications #-}\n{-# LANGUAGE ScopedTypeVariables #-}\n{-# LANGUAGE ConstraintKinds #-}\n{-# LANGUAGE TypeFamilies #-}\n{-# LANGUAGE TypeOperators #-}\n{-# LANGUAGE DataKinds #-}\n\n-- For OkLC as a class\n{-# LANGUAGE UndecidableInstances #-}\n{-# LANGUAGE FlexibleInstances #-}\n{-# LANGUAGE MultiParamTypeClasses #-}\n\n{-# OPTIONS_GHC -Wall #-}\n\n{-# OPTIONS -Wno-type-defaults #-}\n\n{-# OPTIONS_GHC -Wno-missing-signatures #-}\n{-# OPTIONS_GHC -Wno-unused-imports #-}\n\n{-# OPTIONS_GHC -fsimpl-tick-factor=500 #-}\n{-# OPTIONS_GHC -dsuppress-idinfo #-}\n{-# OPTIONS_GHC -fdicts-strict #-}\n{-# OPTIONS_GHC -Wno-orphans #-}\n\nmodule Main where\n\nimport Prelude hiding (unzip,zip,zipWith) -- (id,(.),curry,uncurry)\nimport qualified Prelude as P\n\nimport Data.Monoid (Sum(..))\nimport Data.Foldable (fold)\nimport Control.Applicative (liftA2)\nimport Control.Arrow (second)\nimport Control.Monad ((<=<))\nimport Data.List (unfoldr) -- TEMP\nimport Data.Complex (Complex)\nimport GHC.Float (int2Double)\n\n\n\nimport qualified ConCat.AltCat as A\nimport ConCat.AltCat\n (toCcc,toCcc',unCcc,unCcc',conceal,(:**:)(..),Ok,Ok2,U2,equal)\n\nimport ConCat.Rebox\n\nimport ConCat.Circuit (GenBuses,(:>))\nimport ConCat.Syntactic (Syn,render)\nimport ConCat.RunCircuit (run)\n\ntype EC = Syn :**: (:>)\n\nrunU2 :: U2 a b -> IO ()\nrunU2 = print\n{-# INLINE runU2 #-}\n\n\ntype GO a b = (GenBuses a, Ok2 (:>) a b)\n\nrunSyn :: Syn a b -> IO ()\nrunSyn syn = putStrLn ('\\n' : render syn)\n{-# INLINE runSyn #-}\n\nrunSynCirc :: GO a b => String -> EC a b -> IO ()\nrunSynCirc nm (syn :**: circ) = runSyn syn >> runCirc nm circ\n{-# INLINE runSynCirc #-}\n\nrunCirc :: GO a b => String -> (a :> b) -> IO ()\nrunCirc nm circ = run nm [] circ\n{-# INLINE runCirc #-}\n\n\nadd5 :: Double -> Double\nadd5 x = x + 5\n\ndecide :: Int -> Bool\ndecide 4 = True\ndecide _ = False\n\nfix :: (a -> a) -> a\nfix f = let {x = f x} in x\n\nfac :: Int -> Int\nfac 1 = 1\nfac n = n*fac(n-1)\n\nmain :: IO ()\n--main = print \"hello world!\"\n\nmain = sequence_ [\n putChar '\\n' -- return ()\n\n-- -- Circuit graphs\n , runSynCirc \"add\" $ toCcc $ (+) @Double\n , runSynCirc \"add5\" $ toCcc add5\n , runSynCirc \"add-uncurry\" $ toCcc $ uncurry ((+) @Double)\n , runSynCirc \"decide\" $ toCcc $ decide\n-- , runSynCirc \"fac\" $ toCcc (fix (\\rec n -> if n == 0 then 1 else n * rec (n-1)) :: Int -> Int)\n\n-- , runSynCirc \"fac\" $ toCcc $ fac\n-- , runSynCirc \"dup\" $ toCcc $ A.dup @(->) @Int\n-- , runSynCirc \"fst\" $ toCcc $ fst @R @R\n-- , runSynCirc \"twice\" $ toCcc $ twice @R\n-- , runSynCirc \"sqr\" $ toCcc $ sqr @R\n-- , runSynCirc \"complex-mul\" $ toCcc $ uncurry ((*) @C)\n-- , runSynCirc \"magSqr\" $ toCcc $ magSqr @R\n-- , runSynCirc \"cosSinProd\" $ toCcc $ cosSinProd @R\n-- , runSynCirc \"xp3y\" $ toCcc $ \\ (x,y) -> x + 3 * y :: R\n-- , runSynCirc \"horner\" $ toCcc $ horner @R [1,3,5]\n-- , runSynCirc \"cos-2xx\" $ toCcc $ \\ x -> cos (2 * x * x) :: R\n--\n ]\n\n", "meta": {"hexsha": "d66d6cac634d9cc67c543444a000b94a408696a7", "size": 3098, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "app/Main.hs", "max_stars_repo_name": "thma/ccc", "max_stars_repo_head_hexsha": "7b69dc601c58ee4ff467d617ce33db9d48d5e79b", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "app/Main.hs", "max_issues_repo_name": "thma/ccc", "max_issues_repo_head_hexsha": "7b69dc601c58ee4ff467d617ce33db9d48d5e79b", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "app/Main.hs", "max_forks_repo_name": "thma/ccc", "max_forks_repo_head_hexsha": "7b69dc601c58ee4ff467d617ce33db9d48d5e79b", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 26.7068965517, "max_line_length": 106, "alphanum_fraction": 0.5813428018, "num_tokens": 1029, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6619228758499941, "lm_q2_score": 0.48047867804790706, "lm_q1q2_score": 0.3180398283580741}} {"text": "module HScheme.Data where\n\nimport Control.Monad.Except\nimport Data.Complex ( Complex )\nimport Text.ParserCombinators.Parsec ( ParseError )\nimport qualified Data.Vector as V\n\ndata Value = Atom String\n | List [Value]\n | DottedList [Value] Value\n | Vector (V.Vector Value)\n | Number Integer \n | Float Double\n | Ratio Rational\n | Complex (Complex Double)\n | String String\n | Character Char\n | Bool Bool\n deriving (Eq)\n\ninstance Show Value where\n show (String s) = \"\\\"\" ++ s ++ \"\\\"\"\n show (Character c) = \"#\\\\\" ++ [c]\n show (Atom name) = name\n show (Number n) = show n\n show (Float n) = show n\n show (Ratio n) = show n\n show (Complex n) = show n\n show (Bool True) = \"#t\"\n show (Bool False) = \"#f\"\n show (List xs) = \"(\" ++ unwordsList xs ++ \")\"\n show (DottedList head tail) = \"(\" ++ unwordsList head ++ \" . \" ++ show tail ++ \")\"\n show (Vector vs) = \"#(\" ++ unwordsList (V.toList vs) ++ \")\"\n\nunwordsList :: [Value] -> String\nunwordsList = unwords . map show\n\n{-\n -- Error handling --\n-}\n\ndata Error = NumArgs Integer [Value]\n | TypeMismatch String Value\n | Parser ParseError\n | BadSpecialForm String Value\n | NotFunction String String\n | UnboundVar String String\n | Default String\n\ninstance Show Error where\n show (NumArgs expected found) = \"Expected \" ++ show expected \n ++ \" args; found values \" ++ unwordsList found\n show (TypeMismatch expected found) = \"Invalid Type: expected \" ++ expected\n ++ \", found \" ++ show found\n show (Parser err) = \"Parse error at \" ++ show err\n show (BadSpecialForm message form) = message ++ \": \" ++ show form\n show (NotFunction message func) = message ++ \": \" ++ show func\n show (UnboundVar message varname) = message ++ \": \" ++ varname\n show (Default message) = message\n\ntype ThrowsErr = Either Error\n\ntrapErr :: (MonadError a m, Show a) => m String -> m String\ntrapErr action = catchError action (return . show)\n\nextractValue :: ThrowsErr a -> a\nextractValue (Right val) = val", "meta": {"hexsha": "89cb27b9c56f612ed63cefbab6f09a2dd5a3b1d6", "size": 2138, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/HScheme/Data.hs", "max_stars_repo_name": "dvdvgt/hScheme", "max_stars_repo_head_hexsha": "861d1d22db332d0b2bc74a3544d6d77543fa7ca3", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/HScheme/Data.hs", "max_issues_repo_name": "dvdvgt/hScheme", "max_issues_repo_head_hexsha": "861d1d22db332d0b2bc74a3544d6d77543fa7ca3", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/HScheme/Data.hs", "max_forks_repo_name": "dvdvgt/hScheme", "max_forks_repo_head_hexsha": "861d1d22db332d0b2bc74a3544d6d77543fa7ca3", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 31.9104477612, "max_line_length": 86, "alphanum_fraction": 0.5940130964, "num_tokens": 552, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.5774953651858118, "lm_q2_score": 0.5506073655352404, "lm_q1q2_score": 0.3179732016337714}} {"text": "\nmodule Statistics.Classification (\n module Classification\n ) where\n\nimport Statistics.Classification.ConfusionMatrix as Classification\nimport Statistics.Classification.ROC as Classification\nimport Statistics.Classification.Types as Classification\n", "meta": {"hexsha": "8157a38590f74810b857d853370eaa9ec2d7d95c", "size": 252, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/Statistics/Classification.hs", "max_stars_repo_name": "tsbattman/rochs", "max_stars_repo_head_hexsha": "b8a229ca906ae36a6b93e59db8de88d077644a55", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/Statistics/Classification.hs", "max_issues_repo_name": "tsbattman/rochs", "max_issues_repo_head_hexsha": "b8a229ca906ae36a6b93e59db8de88d077644a55", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/Statistics/Classification.hs", "max_forks_repo_name": "tsbattman/rochs", "max_forks_repo_head_hexsha": "b8a229ca906ae36a6b93e59db8de88d077644a55", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 28.0, "max_line_length": 66, "alphanum_fraction": 0.8571428571, "num_tokens": 41, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO\n\n", "lm_q1_score": 0.6406358411176238, "lm_q2_score": 0.4960938294709195, "lm_q1q2_score": 0.3178154877163656}} {"text": "module Vote\n ( processVote,\n reprocessVotes,\n encryptBallot,\n decryptBallot,\n )\nwhere\n\nimport Conduit (foldlC, mapC)\nimport Control.Lens\nimport Control.Monad.Trans.Reader (ReaderT)\nimport Data.Binary.Get (getWord32be, runGet)\nimport Data.Binary.Put (putWord32be, runPut)\nimport qualified Data.ByteString as B\nimport qualified Data.ByteString.Char8 as BC\nimport qualified Data.Map.Strict as M\nimport qualified Data.Text as T\nimport Data.Time (NominalDiffTime, UTCTime, addUTCTime, getCurrentTime)\nimport Data.Time.Clock.POSIX (posixSecondsToUTCTime, utcTimeToPOSIXSeconds)\nimport Database.Persist.Sql (SqlBackend)\nimport Import hiding (toList)\nimport Model.IsaacVersion\nimport Numeric.LinearAlgebra\nimport Ranks\nimport qualified Web.ClientSession as WS\n\nprocessVote :: (MonadIO m) => IsaacVersion -> Int -> Int -> UTCTime -> Text -> Text -> ReaderT SqlBackend m ()\nprocessVote ver w l timestamp voter rawBallot = do\n Entity w' _ <- getBy404 $ UniqueItem ver w\n Entity l' _ <- getBy404 $ UniqueItem ver l\n insert400_ $ Ballot rawBallot timestamp\n insert400_ $ Vote ver w' l' timestamp voter\n return ()\n\nreprocessVotes :: (MonadIO m, MonadResource m) => ReaderT SqlBackend m ()\nreprocessVotes = do\n items <- M.fromList . map (\\(Entity a b) -> (a, b)) <$> selectList [] []\n bms <- runConduit $ selectSource [] [] .| mapC entityVal .| beatMatrix\n recalculatePairs items bms\n now <- liftIO getCurrentTime\n deleteWhere [BallotTimestamp <=. (- validTime) `addUTCTime` now]\n return ()\n\ntype Matchup = (Key Item, Key Item)\n\ntype BeatMatrix = M.Map Matchup Int\n\nbeatMatrix :: Monad m => ConduitT Vote o m (M.Map IsaacVersion BeatMatrix)\nbeatMatrix = foldlC upd M.empty\n where\n upd bm v = bm & at ver . non M.empty . at (w, l) . non 0 +~ 1\n where\n w = v ^. voteWinner\n l = v ^. voteLoser\n ver = v ^. voteVersion\n\nranks :: BeatMatrix -> [Key Item] -> [(Key Item, R)]\nranks bm items =\n zip items . toList $ ilsrPairwise bm' 0.01\n where\n n = length items\n itemToIdx = M.fromList (zip items [0 ..])\n bm' = assoc (n, n) 0 (convR <$> M.toList bm)\n convR ((w, l), s) = ((itemToIdx M.! w, itemToIdx M.! l), fromIntegral s)\n\nrecalculatePairs :: (MonadIO m, MonadResource m) => M.Map (Key Item) Item -> M.Map IsaacVersion BeatMatrix -> ReaderT SqlBackend m ()\nrecalculatePairs items bms =\n ifor_ bms $ \\ver bm ->\n for_ (ranks bm (itemsFor ver items)) $ \\(itemId, rating) ->\n update\n itemId\n [ ItemRating =. rating,\n ItemVotes =. sumOf (ifolded . ifiltered (\\(i1, i2) _ -> i1 == itemId || i2 == itemId)) bm\n ]\n where\n itemsFor ver = findIndicesOf ifolded (\\i -> i ^. itemVersion == ver)\n\nencodeBallot :: UTCTime -> Int -> Int -> B.ByteString\nencodeBallot expiry winner loser = toStrict . runPut $ do\n putWord32be (truncate . utcTimeToPOSIXSeconds $ expiry)\n putWord32be (fromIntegral winner)\n putWord32be (fromIntegral loser)\n\ndecodeBallot :: B.ByteString -> (UTCTime, Int, Int)\ndecodeBallot = go . fromStrict\n where\n go = runGet $ do\n expiry <- getWord32be\n winner <- getWord32be\n loser <- getWord32be\n return\n ( posixSecondsToUTCTime (fromIntegral expiry),\n fromIntegral winner,\n fromIntegral loser\n )\n\n-- 1 hour\nvalidTime :: NominalDiffTime\nvalidTime = 3600\n\nencryptBallot :: UTCTime -> Int -> Int -> Handler Text\nencryptBallot now winner loser = do\n key <- getsYesod appBallotKey\n out <- liftIO $ WS.encryptIO key (encodeBallot (validTime `addUTCTime` now) winner loser)\n return . T.pack . BC.unpack $ out\n\ndecryptBallot :: UTCTime -> Text -> Handler (Int, Int)\ndecryptBallot now b = do\n key <- getsYesod appBallotKey\n (expiry, winner, loser) <-\n case decodeBallot <$> (WS.decrypt key . BC.pack . T.unpack) b of\n Just r -> pure r\n Nothing -> error \"invalid ballot!\"\n if expiry < now\n then error \"expired ballot!\"\n else return (winner, loser)\n", "meta": {"hexsha": "a8a8cb0d61d69d56358927ec3a4cdb3d09915dba", "size": 3916, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "Vote.hs", "max_stars_repo_name": "jsza/isaacranks", "max_stars_repo_head_hexsha": "e36caf44f89e4a71050fad160e8b4cf566da7b98", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 4, "max_stars_repo_stars_event_min_datetime": "2015-01-03T14:13:34.000Z", "max_stars_repo_stars_event_max_datetime": "2021-05-17T19:56:36.000Z", "max_issues_repo_path": "Vote.hs", "max_issues_repo_name": "jsza/isaacranks", "max_issues_repo_head_hexsha": "e36caf44f89e4a71050fad160e8b4cf566da7b98", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 23, "max_issues_repo_issues_event_min_datetime": "2015-10-03T19:01:47.000Z", "max_issues_repo_issues_event_max_datetime": "2021-08-04T08:39:25.000Z", "max_forks_repo_path": "Vote.hs", "max_forks_repo_name": "jsza/isaacranks", "max_forks_repo_head_hexsha": "e36caf44f89e4a71050fad160e8b4cf566da7b98", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2020-10-07T10:31:01.000Z", "max_forks_repo_forks_event_max_datetime": "2021-02-18T14:57:23.000Z", "avg_line_length": 33.4700854701, "max_line_length": 133, "alphanum_fraction": 0.6802860061, "num_tokens": 1128, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.7057850278370112, "lm_q2_score": 0.44939263446475963, "lm_q1q2_score": 0.3171745930254582}} {"text": "{-# LANGUAGE OverloadedStrings #-}\n\nmodule JsonParser where\n\nimport Data.Aeson hiding ( Series )\nimport Data.Aeson.Types ( parseMaybe )\nimport qualified Data.ByteString.Lazy as BSL\nimport Data.Complex ( Complex((:+)) )\n\nimport Form\n\ndata Vec = Vec {\n number :: Int,\n real :: Double,\n imag :: Double\n} deriving (Show)\n\ninstance ToJSON Vec where\n toJSON (Vec number real imag) =\n object [\"number\" .= number, \"real\" .= real, \"imag\" .= imag]\n\ninstance FromJSON Vec where\n parseJSON = withObject \"Vec\"\n $ \\v -> Vec <$> v .: \"number\" <*> v .: \"real\" <*> v .: \"imag\"\n\nnewtype Series = Series {\n series :: [Vec]\n} deriving (Show)\n\ninstance ToJSON Series where\n toJSON (Series series) = object [\"series\" .= series]\n\ninstance FromJSON Series where\n parseJSON = withObject \"Series\" $ \\s -> Series <$> s .: \"series\"\n\ninstance Semigroup Series where\n (Series xs) <> (Series ys) = Series (xs <> ys)\n\ninstance Monoid Series where\n mempty = Series []\n\nconvert :: Vec -> Form\nconvert (Vec n r i) = form (r :+ i) n\n\ngetForm :: Series -> [Form]\ngetForm (Series xs) = map convert xs\n\njsonToCoord :: FilePath -> IO [(Int, Int)]\njsonToCoord path = formsToCoords <$> jsonToForm path\n\njsonToForm :: FilePath -> IO [Form]\njsonToForm path = do\n json <- BSL.readFile path\n case decode json of\n Just js -> return $ getForm js\n Nothing -> error $ \"invalid json file: \" ++ path\n\njsonToCoords :: [FilePath] -> IO [(Int, Int)]\njsonToCoords = foldr (mappend . jsonToCoord) mempty\n", "meta": {"hexsha": "63c00ffc0d3b1ebaa6ab2f8f989181e4f21b3299", "size": 1609, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/JsonParser.hs", "max_stars_repo_name": "HE7086/Fourier", "max_stars_repo_head_hexsha": "b0de486a165442e04941ad0db0f293cd907ad634", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-03-27T14:22:24.000Z", "max_stars_repo_stars_event_max_datetime": "2020-03-27T14:22:24.000Z", "max_issues_repo_path": "src/JsonParser.hs", "max_issues_repo_name": "HE7086/Fourier", "max_issues_repo_head_hexsha": "b0de486a165442e04941ad0db0f293cd907ad634", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/JsonParser.hs", "max_forks_repo_name": "HE7086/Fourier", "max_forks_repo_head_hexsha": "b0de486a165442e04941ad0db0f293cd907ad634", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 26.8166666667, "max_line_length": 69, "alphanum_fraction": 0.6047234307, "num_tokens": 414, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.5156199157230157, "lm_q2_score": 0.6150878555160665, "lm_q1q2_score": 0.31715154822344466}} {"text": "{-# LANGUAGE CPP #-}\n{-# LANGUAGE DataKinds #-}\n{-# LANGUAGE DeriveGeneric #-}\n{-# LANGUAGE FlexibleContexts #-}\n{-# LANGUAGE FlexibleInstances #-}\n{-# LANGUAGE MultiParamTypeClasses #-}\n{-# LANGUAGE RankNTypes #-}\n{-# LANGUAGE ScopedTypeVariables #-}\n{-# LANGUAGE TypeFamilies #-}\n{-# LANGUAGE UndecidableInstances #-}\n{-# LANGUAGE TypeOperators #-}\n{-# LANGUAGE OverloadedStrings #-}\n{-# LANGUAGE OverloadedLabels #-}\n{-# OPTIONS_GHC -Wno-incomplete-uni-patterns #-}\n\nmodule Grenade.Layers.FullyConnected (\n FullyConnected (..)\n , FullyConnected' (..)\n , randomFullyConnected\n ) where\n\nimport Control.DeepSeq\nimport Control.Monad.Primitive (PrimBase, PrimState)\nimport GHC.Generics (Generic)\nimport GHC.TypeLits\nimport System.Random.MWC hiding (create)\nimport Data.List (foldl1')\nimport Data.Either (fromRight)\nimport Data.Proxy\nimport Data.Serialize\n\nimport qualified Numeric.LinearAlgebra as LA\nimport Numeric.LinearAlgebra.Static\n\nimport Grenade.Core\nimport Grenade.Layers.Internal.Update\nimport Grenade.Onnx\nimport Grenade.Utils.LinearAlgebra\nimport Grenade.Utils.ListStore\nimport Grenade.Types\n\nimport Lens.Micro\n\n-- | A basic fully connected (or inner product) neural network layer.\ndata FullyConnected i o = FullyConnected\n !(FullyConnected' i o) -- Neuron weights\n !(ListStore (FullyConnected' i o)) -- momentum store\n deriving (Generic)\n\ninstance NFData (FullyConnected i o) where\n rnf (FullyConnected w store) = rnf w `seq` rnf store\n\n\ndata FullyConnected' i o = FullyConnected'\n !(R o) -- Bias\n !(L o i) -- Activations\n deriving (Generic)\n\ninstance NFData (FullyConnected' i o) where\n rnf (FullyConnected' b w) = rnf b `seq` rnf w\n\n\ninstance Show (FullyConnected i o) where\n show FullyConnected {} = \"FullyConnected\"\n\n\ninstance (KnownNat i, KnownNat o, KnownNat (i * o)) => UpdateLayer (FullyConnected i o) where\n type Gradient (FullyConnected i o) = (FullyConnected' i o)\n type MomentumStore (FullyConnected i o) = ListStore (FullyConnected' i o)\n runUpdate opt@OptSGD{} x@(FullyConnected (FullyConnected' oldBias oldActivations) store) (FullyConnected' biasGradient activationGradient) =\n let (FullyConnected' oldBiasMomentum oldMomentum) = getData opt x store\n VectorResultSGD newBias newBiasMomentum = descendVector opt (VectorValuesSGD oldBias biasGradient oldBiasMomentum)\n MatrixResultSGD newActivations newMomentum = descendMatrix opt (MatrixValuesSGD oldActivations activationGradient oldMomentum)\n newStore = setData opt x store (FullyConnected' newBiasMomentum newMomentum)\n in FullyConnected (FullyConnected' newBias newActivations) newStore\n runUpdate opt@OptAdam{} x@(FullyConnected (FullyConnected' oldBias oldActivations) store) (FullyConnected' biasGradient activationGradient) =\n let [FullyConnected' oldMBias oldMActivations, FullyConnected' oldVBias oldVActivations] = getData opt x store\n VectorResultAdam newBias newMBias newVBias = descendVector opt (VectorValuesAdam (getStep store) oldBias biasGradient oldMBias oldVBias)\n MatrixResultAdam newActivations newMActivations newVActivations = descendMatrix opt (MatrixValuesAdam (getStep store) oldActivations activationGradient oldMActivations oldVActivations)\n newStore = setData opt x store [FullyConnected' newMBias newMActivations, FullyConnected' newVBias newVActivations]\n in FullyConnected (FullyConnected' newBias newActivations) newStore\n\n reduceGradient grads = FullyConnected' (dvmap (/l) bs) (dmmap (/l) as)\n where\n FullyConnected' bs as = foldl1' (\\(FullyConnected' bs as) (FullyConnected' bs' as') -> FullyConnected' (bs + bs') (as + as')) grads\n l = fromIntegral $ length grads :: RealNum\n\ninstance (KnownNat i, KnownNat o, KnownNat (i * o)) => LayerOptimizerData (FullyConnected i o) (Optimizer 'SGD) where\n type MomentumDataType (FullyConnected i o) (Optimizer 'SGD) = FullyConnected' i o\n getData opt x store = head $ getListStore opt x store\n setData opt x store = setListStore opt x store . return\n newData _ _ = FullyConnected' (konst 0) (konst 0)\n\ninstance (KnownNat i, KnownNat o, KnownNat (i * o)) => LayerOptimizerData (FullyConnected i o) (Optimizer 'Adam) where\n type MomentumDataType (FullyConnected i o) (Optimizer 'Adam) = FullyConnected' i o\n type MomentumExpOptResult (FullyConnected i o) (Optimizer 'Adam) = [FullyConnected' i o]\n getData = getListStore\n setData = setListStore\n newData _ _ = FullyConnected' (konst 0) (konst 0)\n\n\ninstance (KnownNat i, KnownNat o) => FoldableGradient (FullyConnected' i o) where\n mapGradient f (FullyConnected' bias activations) = FullyConnected' (dvmap f bias) (dmmap f activations)\n squaredSums (FullyConnected' bias activations) = [sumV . squareV $ bias, sumM . squareM $ activations]\n\ninstance (KnownNat i, KnownNat o, KnownNat (i * o)) => Layer (FullyConnected i o) ('D1 i) ('D1 o) where\n type Tape (FullyConnected i o) ('D1 i) ('D1 o) = R i\n -- Do a matrix vector multiplication and return the result.\n runForwards (FullyConnected (FullyConnected' wB wN) _) (S1D v) = (v, S1D (wB + wN #> v))\n\n -- Run a backpropogation step for a full connected layer.\n runBackwards (FullyConnected (FullyConnected' _ wN) _) x (S1D dEdy) =\n let wB' = dEdy\n mm' = dEdy `outer` x\n -- calcluate derivatives for next step\n dWs = tr wN #> dEdy\n in (FullyConnected' wB' mm', S1D dWs)\n\n\ninstance (KnownNat i, KnownNat o) => Serialize (FullyConnected i o) where\n put (FullyConnected w ms) = put w >> put ms\n get = FullyConnected <$> get <*> get\n\n\ninstance (KnownNat i, KnownNat o) => Serialize (FullyConnected' i o) where\n put (FullyConnected' b w) = do\n putListOf put . LA.toList . extract $ b\n putListOf put . LA.toList . LA.flatten . extract $ w\n get = do\n let f = fromIntegral $ natVal (Proxy :: Proxy i)\n b <- maybe (fail \"Vector of incorrect size\") return . create . LA.fromList =<< getListOf get\n k <- maybe (fail \"Vector of incorrect size\") return . create . LA.reshape f . LA.fromList =<< getListOf get\n return $ FullyConnected' b k\n\n\ninstance (KnownNat i, KnownNat o, KnownNat (i*o)) => RandomLayer (FullyConnected i o) where\n createRandomWith = randomFullyConnected\n\n\nrandomFullyConnected :: forall m i o . (PrimBase m, KnownNat i, KnownNat o, KnownNat (i*o))\n => WeightInitMethod -> Gen (PrimState m) -> m (FullyConnected i o)\nrandomFullyConnected m gen = do\n wN <- getRandomMatrix i o m gen\n wB <- getRandomVector i o m gen\n return $ FullyConnected (FullyConnected' wB wN) mkListStore\n where i = natVal (Proxy :: Proxy i)\n o = natVal (Proxy :: Proxy o)\n\n\ninstance OnnxOperator (FullyConnected i o) where\n onnxOpTypeNames _ = [\"Gemm\"]\n\ninstance (KnownNat i, KnownNat o) => OnnxLoadable (FullyConnected i o) where\n loadOnnxNode inits node = case (node ^. #input) of\n [_, b, c] -> do\n -- FIXME: Proper attribute checking\n -- node `doesNotHaveAttribute` \"alpha\"\n -- node `doesNotHaveAttribute` \"transA\"\n -- node `doesNotHaveAttribute` \"transB\"\n\n let beta = fromRight 1 (readFloatAttributeToRealNum \"beta\" node)\n loadedB <- readInitializerMatrix inits b\n loadedC <- readInitializerVector inits c\n\n return $ FullyConnected (FullyConnected' loadedC (dmmap (*beta) loadedB)) mkListStore\n _ -> onnxIncorrectNumberOfInputs\n \n\n", "meta": {"hexsha": "42834767d0b0896c44bc7e814506b32bea672301", "size": 7843, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/Grenade/Layers/FullyConnected.hs", "max_stars_repo_name": "th-char/grenade", "max_stars_repo_head_hexsha": "0be658e7cf07562cd5e4170ed1e8875ccec14cdb", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-06-09T06:06:26.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-09T06:06:26.000Z", "max_issues_repo_path": "src/Grenade/Layers/FullyConnected.hs", "max_issues_repo_name": "th-char/grenade", "max_issues_repo_head_hexsha": "0be658e7cf07562cd5e4170ed1e8875ccec14cdb", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/Grenade/Layers/FullyConnected.hs", "max_forks_repo_name": "th-char/grenade", "max_forks_repo_head_hexsha": "0be658e7cf07562cd5e4170ed1e8875ccec14cdb", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 46.4082840237, "max_line_length": 192, "alphanum_fraction": 0.676399337, "num_tokens": 2012, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.8080672135527632, "lm_q2_score": 0.39233683016710835, "lm_q1q2_score": 0.31703452912725893}} {"text": "{-# LANGUAGE TypeFamilies #-}\n{-# LANGUAGE FlexibleContexts #-}\n{-# LANGUAGE UndecidableInstances #-}\nmodule Math.HiddenMarkovModel.Private where\n\nimport qualified Math.HiddenMarkovModel.Distribution as Distr\nimport qualified Math.HiddenMarkovModel.CSV as HMMCSV\nimport Math.HiddenMarkovModel.Distribution (State(State))\n\nimport qualified Numeric.LinearAlgebra.Algorithms as Algo\nimport qualified Numeric.LinearAlgebra.Util as LinAlg\nimport qualified Numeric.Container as NC\nimport qualified Data.Packed.Development as Dev\nimport qualified Data.Packed.Matrix as Matrix\nimport qualified Data.Packed.Vector as Vector\nimport Numeric.Container ((<>))\nimport Data.Packed.Matrix (Matrix)\nimport Data.Packed.Vector (Vector)\n\nimport Control.DeepSeq (NFData, rnf)\nimport Foreign.Storable (Storable)\n\nimport qualified Data.NonEmpty.Class as NonEmptyC\nimport qualified Data.NonEmpty as NonEmpty\nimport qualified Data.Semigroup as Sg\nimport qualified Data.List as List\nimport Data.Traversable (Traversable, mapAccumL)\nimport Data.Tuple.HT (mapPair, mapFst, mapSnd, swap)\n\n\n{- |\nA Hidden Markov model consists of a number of (hidden) states\nand a set of emissions.\nThere is a vector for the initial probability of each state\nand a matrix containing the probability for switching\nfrom one state to another one.\nThe 'distribution' field points to probability distributions\nthat associate every state with emissions of different probability.\nFamous distribution instances are discrete and Gaussian distributions.\nSee \"Math.HiddenMarkovModel.Distribution\" for details.\n\nThe transition matrix is transposed\nwith respect to popular HMM descriptions.\nBut I think this is the natural orientation, because this way\nyou can write \\\"transition matrix times probability column vector\\\".\n\nThe type has two type parameters,\nalthough the one for the distribution would be enough.\nHowever, replacing @prob@ by @Distr.Probability distr@\nwould prohibit the derived Show and Read instances.\n-}\ndata T distr prob =\n Cons {\n initial :: Vector prob,\n transition :: Matrix prob,\n distribution :: distr\n }\n deriving (Show, Read)\n\ninstance\n (NFData distr, NFData prob, Storable prob) =>\n NFData (T distr prob) where\n rnf hmm = rnf (initial hmm, transition hmm, distribution hmm)\n\n\nemission ::\n (Distr.EmissionProb distr,\n Distr.Probability distr ~ prob, Distr.Emission distr ~ emission) =>\n T distr prob -> emission -> Vector prob\nemission = Distr.emissionProb . distribution\n\n\nforward ::\n (Distr.EmissionProb distr,\n Distr.Probability distr ~ prob, Distr.Emission distr ~ emission,\n Traversable f) =>\n T distr prob -> NonEmpty.T f emission -> prob\nforward hmm = NC.sumElements . NonEmpty.last . alpha hmm\n\nalpha ::\n (Distr.EmissionProb distr,\n Distr.Probability distr ~ prob, Distr.Emission distr ~ emission,\n Traversable f) =>\n T distr prob ->\n NonEmpty.T f emission -> NonEmpty.T f (Vector prob)\nalpha hmm (NonEmpty.Cons x xs) =\n NonEmpty.scanl\n (\\alphai xi -> NC.mul (emission hmm xi) (transition hmm <> alphai))\n (NC.mul (emission hmm x) (initial hmm))\n xs\n\n\nbackward ::\n (Distr.EmissionProb distr,\n Distr.Probability distr ~ prob, Distr.Emission distr ~ emission,\n Traversable f) =>\n T distr prob -> NonEmpty.T f emission -> prob\nbackward hmm (NonEmpty.Cons x xs) =\n NC.sumElements $\n NC.mul (initial hmm) $\n NC.mul (emission hmm x) $\n NonEmpty.head $ beta hmm xs\n\nbeta ::\n (Distr.EmissionProb distr,\n Distr.Probability distr ~ prob, Distr.Emission distr ~ emission,\n Traversable f) =>\n T distr prob ->\n f emission -> NonEmpty.T f (Vector prob)\nbeta hmm =\n NonEmpty.scanr\n (\\xi betai -> NC.mul (emission hmm xi) betai <> transition hmm)\n (NC.constant 1 (NC.dim $ initial hmm))\n\n\nalphaBeta ::\n (Distr.EmissionProb distr,\n Distr.Probability distr ~ prob, Distr.Emission distr ~ emission,\n Traversable f) =>\n T distr prob ->\n NonEmpty.T f emission ->\n (prob, NonEmpty.T f (Vector prob), NonEmpty.T f (Vector prob))\nalphaBeta hmm xs =\n let alphas = alpha hmm xs\n betas = beta hmm $ NonEmpty.tail xs\n recipLikelihood = recip $ NC.sumElements $ NonEmpty.last alphas\n in (recipLikelihood, alphas, betas)\n\n\n\nxiFromAlphaBeta ::\n (Distr.EmissionProb distr,\n Distr.Probability distr ~ prob, Distr.Emission distr ~ emission) =>\n T distr prob -> prob ->\n NonEmpty.T [] emission ->\n NonEmpty.T [] (Vector prob) ->\n NonEmpty.T [] (Vector prob) ->\n [Matrix prob]\nxiFromAlphaBeta hmm recipLikelihood xs alphas betas =\n zipWith3\n (\\x alpha0 beta1 ->\n NC.scale recipLikelihood $\n NC.mul\n (NC.outer (NC.mul (emission hmm x) beta1) alpha0)\n (transition hmm))\n (NonEmpty.tail xs)\n (NonEmpty.init alphas)\n (NonEmpty.tail betas)\n\nzetaFromXi ::\n (NC.Product prob) => T distr prob -> [Matrix prob] -> [Vector prob]\nzetaFromXi hmm xis =\n map (NC.constant 1 (Matrix.rows $ transition hmm) <>) xis\n\nzetaFromAlphaBeta ::\n (NC.Container Vector prob) =>\n prob ->\n NonEmpty.T [] (Vector prob) ->\n NonEmpty.T [] (Vector prob) ->\n NonEmpty.T [] (Vector prob)\nzetaFromAlphaBeta recipLikelihood alphas betas =\n fmap (NC.scale recipLikelihood) $\n NonEmptyC.zipWith NC.mul alphas betas\n\n\n{- |\nIn constrast to Math.HiddenMarkovModel.reveal\nthis does not normalize the vector.\nThis is slightly simpler but for long sequences\nthe product of probabilities might be smaller\nthan the smallest representable number.\n-}\nreveal ::\n (Distr.EmissionProb distr,\n Distr.Probability distr ~ prob, Distr.Emission distr ~ emission,\n Traversable f) =>\n T distr prob -> NonEmpty.T f emission -> NonEmpty.T f State\nreveal hmm (NonEmpty.Cons x xs) =\n fmap State $\n uncurry (NonEmpty.scanr Dev.at') $\n mapFst NC.maxIndex $\n mapAccumL\n (\\alphai xi ->\n swap $ mapSnd (NC.mul (emission hmm xi)) $\n matrixMaxMul (transition hmm) alphai)\n (NC.mul (emission hmm x) (initial hmm)) xs\n\nmatrixMaxMul ::\n (NC.Container Vector a) =>\n Matrix a -> Vector a -> (Vector Int, Vector a)\nmatrixMaxMul m v =\n mapPair (Vector.fromList, Vector.fromList) $ unzip $\n map ((\\x -> (NC.maxIndex x, NC.maxElement x)) . NC.mul v) $\n Matrix.toRows m\n\n\n\n{- |\nA trained model is a temporary form of a Hidden Markov model\nthat we need during the training on multiple training sequences.\nIt allows to collect knowledge over many sequences with 'mergeTrained',\neven with mixed supervised and unsupervised training.\nYou finish the training by converting the trained model\nback to a plain modul using 'finishTraining'.\n\nYou can create a trained model in three ways:\n\n* supervised training using an emission sequence with associated states,\n\n* unsupervised training using an emission sequence and an existing Hidden Markov Model,\n\n* derive it from state sequence patterns, cf. \"Math.HiddenMarkovModel.Pattern\".\n-}\ndata Trained distr prob =\n Trained {\n trainedInitial :: Vector prob,\n trainedTransition :: Matrix prob,\n trainedDistribution :: distr\n }\n deriving (Show, Read)\n\ninstance\n (NFData distr, NFData prob, Storable prob) =>\n NFData (Trained distr prob) where\n rnf hmm =\n rnf (trainedInitial hmm, trainedTransition hmm, trainedDistribution hmm)\n\n\nsumTransitions ::\n (NC.Container Vector e) =>\n T distr e -> [Matrix e] -> Matrix e\nsumTransitions hmm =\n List.foldl' NC.add (NC.konst 0 $ LinAlg.size $ transition hmm)\n\n{- |\nBaum-Welch algorithm\n-}\ntrainUnsupervised ::\n (Distr.Estimate tdistr, Distr.Distribution tdistr ~ distr,\n Distr.Probability distr ~ prob, Distr.Emission distr ~ emission) =>\n T distr prob -> NonEmpty.T [] emission -> Trained tdistr prob\ntrainUnsupervised hmm xs =\n let (recipLikelihood, alphas, betas) = alphaBeta hmm xs\n zetas = zetaFromAlphaBeta recipLikelihood alphas betas\n\n in Trained {\n trainedInitial = NonEmpty.head zetas,\n trainedTransition =\n sumTransitions hmm $\n xiFromAlphaBeta hmm recipLikelihood xs alphas betas,\n trainedDistribution =\n Distr.accumulateEmissions $ map (zip (NonEmpty.flatten xs)) $\n List.transpose $ map Vector.toList $ NonEmpty.flatten zetas\n }\n\n\nmergeTrained ::\n (Distr.Estimate tdistr, Distr.Distribution tdistr ~ distr,\n Distr.Probability distr ~ prob) =>\n Trained tdistr prob -> Trained tdistr prob -> Trained tdistr prob\nmergeTrained hmm0 hmm1 =\n Trained {\n trainedInitial = NC.add (trainedInitial hmm0) (trainedInitial hmm1),\n trainedTransition =\n NC.add (trainedTransition hmm0) (trainedTransition hmm1),\n trainedDistribution =\n Distr.combine\n (trainedDistribution hmm0) (trainedDistribution hmm1)\n }\n\ninstance\n (Distr.Estimate tdistr, Distr.Distribution tdistr ~ distr,\n Distr.Probability distr ~ prob) =>\n Sg.Semigroup (Trained tdistr prob) where\n (<>) = mergeTrained\n\n\ntoCells ::\n (Distr.CSV distr, Algo.Field prob, Show prob) =>\n T distr prob -> [[String]]\ntoCells hmm =\n (HMMCSV.cellsFromVector $ initial hmm) :\n (HMMCSV.cellsFromMatrix $ transition hmm) ++\n [] :\n (Distr.toCells $ distribution hmm)\n\nparseCSV ::\n (Distr.CSV distr, Algo.Field prob, Read prob) =>\n HMMCSV.CSVParser (T distr prob)\nparseCSV = do\n v <- HMMCSV.parseNonEmptyVectorCells\n m <- HMMCSV.parseSquareMatrixCells $ Vector.dim v\n HMMCSV.skipEmptyRow\n distr <- Distr.parseCells $ Vector.dim v\n return $ Cons {\n initial = v,\n transition = m,\n distribution = distr\n }\n", "meta": {"hexsha": "6ce10e1b7467da03ca19aee547ee254e7b53e71a", "size": 9524, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/Math/HiddenMarkovModel/Private.hs", "max_stars_repo_name": "rybern/hmm-hmatrix", "max_stars_repo_head_hexsha": "3f1c44aa630e0c7a662c1abe100ea8e783e3c44e", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/Math/HiddenMarkovModel/Private.hs", "max_issues_repo_name": "rybern/hmm-hmatrix", "max_issues_repo_head_hexsha": "3f1c44aa630e0c7a662c1abe100ea8e783e3c44e", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/Math/HiddenMarkovModel/Private.hs", "max_forks_repo_name": "rybern/hmm-hmatrix", "max_forks_repo_head_hexsha": "3f1c44aa630e0c7a662c1abe100ea8e783e3c44e", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 31.7466666667, "max_line_length": 87, "alphanum_fraction": 0.705900882, "num_tokens": 2401, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6859494678483918, "lm_q2_score": 0.4610167793123159, "lm_q1q2_score": 0.31623421443846256}} {"text": "{-# LANGUAGE RankNTypes #-}\n{-# LANGUAGE TypeApplications #-}\n{-# LANGUAGE ScopedTypeVariables #-}\n{-# LANGUAGE TypeOperators #-}\n{-# LANGUAGE DataKinds #-}\n{-# LANGUAGE FlexibleContexts #-}\nmodule Main where\n\nimport qualified AnalyticsLaop as LM\nimport qualified AnalyticsHMatrix as HM\nimport qualified AnalyticsMatrix as DM\nimport qualified LAoP.Matrix.Type as LM\nimport qualified Numeric.LinearAlgebra as HM\nimport qualified Numeric.LinearAlgebra.Data as HM\nimport qualified Numeric.LinearAlgebra.HMatrix as HM\nimport qualified Data.Matrix as DM\nimport GHC.TypeLits\nimport Data.Proxy\nimport Criterion.Main\nimport Test.QuickCheck\n\nrandomBDLaop ::\n forall jn en .\n ( KnownNat jn,\n KnownNat en,\n LM.FromLists Int (LM.FromNat (jn + 1)) (LM.FromNat 3),\n LM.FromLists Int (LM.FromNat (jn + 1)) (),\n LM.FromLists Int (LM.FromNat (en + 1)) (LM.FromNat 5),\n LM.FromLists Int (LM.FromNat (en + 1)) (LM.FromNat 3),\n LM.FromLists Int (LM.FromNat (en + 1)) (LM.FromNat 2)\n ) => Gen (LM.BD jn en)\nrandomBDLaop = do\n let jn' = fromInteger (natVal (Proxy :: Proxy jn)) + 1\n en' = fromInteger (natVal (Proxy :: Proxy en)) + 1\n descs <- vectorOf (jn' * 3) (elements [0, 1])\n salary <- vectorOf jn' (choose (0, 10000))\n code <- vectorOf (jn' * 3) (elements [0, 1])\n let jobs = LM.JT {\n LM.jDesc = LM.fromLists (buildList descs jn'),\n LM.jSalary = LM.fromLists (buildList salary jn'),\n LM.jCode = LM.fromLists (buildList code jn')\n }\n name <- vectorOf (en' * 5) (elements [0, 1])\n job <- vectorOf (en' * 3) (elements [0, 1])\n country <- vectorOf (en' * 2) (elements [0, 1])\n branch <- vectorOf (en' * 2) (elements [0, 1])\n let employees = LM.ET {\n LM.eName = LM.fromLists (buildList name en'),\n LM.eJob = LM.fromLists (buildList job en'),\n LM.eCountry = LM.fromLists (buildList country en'),\n LM.eBranch = LM.fromLists (buildList branch en')\n }\n return LM.BD { LM.jobsTable = jobs, LM.employeesTable = employees }\n\nrandomBDHMatrix ::\n forall jn en .\n ( KnownNat jn,\n KnownNat en\n ) => Gen (HM.BD jn en)\nrandomBDHMatrix = do\n let jn' = fromInteger (natVal (Proxy :: Proxy jn)) + 1\n en' = fromInteger (natVal (Proxy :: Proxy en)) + 1\n descs <- vectorOf (jn' * 3) (elements [0, 1])\n salary <- vectorOf jn' (choose (0, 10000))\n code <- vectorOf (jn' * 3) (elements [0, 1])\n let jobs = HM.JT {\n HM.jDesc = HM.fromLists (buildList descs jn'),\n HM.jSalary = HM.fromLists (buildList salary jn'),\n HM.jCode = HM.fromLists (buildList code jn')\n }\n name <- vectorOf (en' * 5) (elements [0, 1])\n job <- vectorOf (en' * 3) (elements [0, 1])\n country <- vectorOf (en' * 2) (elements [0, 1])\n branch <- vectorOf (en' * 2) (elements [0, 1])\n let employees = HM.ET {\n HM.eName = HM.fromLists (buildList name en'),\n HM.eJob = HM.fromLists (buildList job en'),\n HM.eCountry = HM.fromLists (buildList country en'),\n HM.eBranch = HM.fromLists (buildList branch en')\n }\n return HM.BD { HM.jobsTable = jobs, HM.employeesTable = employees }\n\nrandomBDMatrix ::\n forall jn en .\n ( KnownNat jn,\n KnownNat en\n ) => Gen (DM.BD jn en)\nrandomBDMatrix = do\n let jn' = fromInteger (natVal (Proxy :: Proxy jn)) + 1\n en' = fromInteger (natVal (Proxy :: Proxy en)) + 1\n descs <- vectorOf (jn' * 3) (elements [0, 1])\n salary <- vectorOf jn' (choose (0, 10000))\n code <- vectorOf (jn' * 3) (elements [0, 1])\n let jobs = DM.JT {\n DM.jDesc = DM.fromLists (buildList descs jn'),\n DM.jSalary = DM.fromLists (buildList salary jn'),\n DM.jCode = DM.fromLists (buildList code jn')\n }\n name <- vectorOf (en' * 5) (elements [0, 1])\n job <- vectorOf (en' * 3) (elements [0, 1])\n country <- vectorOf (en' * 2) (elements [0, 1])\n branch <- vectorOf (en' * 2) (elements [0, 1])\n let employees = DM.ET {\n DM.eName = DM.fromLists (buildList name en'),\n DM.eJob = DM.fromLists (buildList job en'),\n DM.eCountry = DM.fromLists (buildList country en'),\n DM.eBranch = DM.fromLists (buildList branch en')\n }\n return DM.BD { DM.jobsTable = jobs, DM.employeesTable = employees }\n\nbuildList [] _ = []\nbuildList l r = take r l : buildList (drop r l) r\n\nsetupEnv1 = do\n -- HMatrix\n bd1 <- generate (resize 1 (randomBDHMatrix @999 @999))\n -- Matrix\n bd2 <- generate (resize 1 (randomBDMatrix @999 @999))\n -- Laop\n bd3 <- generate (resize 1 (randomBDLaop @999 @999))\n return (bd1, bd2, bd3)\n\nbenchmark :: IO ()\nbenchmark = do\n print \"Starting benchmarks...\"\n defaultMain [\n env setupEnv1 $ \\ ~(bd1, bd2, bd3) -> bgroup \"DB query\" [\n bgroup \"1000 entries\" [\n bench \"hmatrix\" $ nf HM.query bd1\n , bench \"matrix\" $ nf DM.query bd2\n , bench \"laop\" $ nf LM.query bd3\n ] ] ]\n\nmain :: IO ()\nmain = benchmark\n", "meta": {"hexsha": "7714a6fe10f04ee3fd0284566329abc97c12cb46", "size": 5005, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "app/Main.hs", "max_stars_repo_name": "bolt12/laop-analytics", "max_stars_repo_head_hexsha": "6c0642250c62c60e3cf74f2867281374f979bae9", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "app/Main.hs", "max_issues_repo_name": "bolt12/laop-analytics", "max_issues_repo_head_hexsha": "6c0642250c62c60e3cf74f2867281374f979bae9", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "app/Main.hs", "max_forks_repo_name": "bolt12/laop-analytics", "max_forks_repo_head_hexsha": "6c0642250c62c60e3cf74f2867281374f979bae9", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 36.8014705882, "max_line_length": 69, "alphanum_fraction": 0.5984015984, "num_tokens": 1548, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6688802603710085, "lm_q2_score": 0.4726834766204328, "lm_q1q2_score": 0.31616864691494856}} {"text": "{-# LANGUAGE CPP #-}\n{-# LANGUAGE DataKinds #-}\n{-# LANGUAGE FlexibleContexts #-}\n{-# LANGUAGE FlexibleInstances #-}\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE MultiParamTypeClasses #-}\n{-# LANGUAGE RankNTypes #-}\n{-# LANGUAGE ScopedTypeVariables #-}\n{-# LANGUAGE TypeFamilies #-}\n{-# LANGUAGE TypeOperators #-}\n{-# LANGUAGE UndecidableInstances #-}\n\nmodule Grenade.Dynamic.Layers.Deconvolution \n ( SpecDeconvolution (..)\n , specDeconvolution2DInput\n , specDeconvolution3DInput\n , deconvolution\n ) where\n\nimport Control.Monad.Primitive (PrimBase, PrimState)\nimport Data.Constraint (Dict (..))\nimport Data.Proxy\nimport Data.Reflection (reifyNat)\nimport Data.Singletons\nimport Data.Singletons.Prelude.Num ((%*))\nimport Data.Singletons.TypeLits hiding (natVal)\nimport GHC.TypeLits\n\nimport Numeric.LinearAlgebra.Static hiding (build, toRows, (&),\n (|||), size)\nimport System.Random.MWC (Gen)\nimport Unsafe.Coerce (unsafeCoerce)\n\nimport Grenade.Core\nimport Grenade.Dynamic.Internal.Build\nimport Grenade.Dynamic.Specification\nimport Grenade.Dynamic.Network\nimport Grenade.Layers.Deconvolution\nimport Grenade.Utils.ListStore\n\n-------------------- DynamicNetwork instance --------------------\n\ninstance (KnownNat channels, KnownNat filters, KnownNat kernelRows, KnownNat kernelColumns, KnownNat strideRows, KnownNat strideColumns) =>\n FromDynamicLayer (Deconvolution channels filters kernelRows kernelColumns strideRows strideColumns) where\n fromDynamicLayer inp _ _ =\n SpecNetLayer $\n SpecDeconvolution\n (tripleFromSomeShape inp)\n (natVal (Proxy :: Proxy channels))\n (natVal (Proxy :: Proxy filters))\n (natVal (Proxy :: Proxy kernelRows))\n (natVal (Proxy :: Proxy kernelColumns))\n (natVal (Proxy :: Proxy strideRows))\n (natVal (Proxy :: Proxy strideColumns))\n\n\ninstance ToDynamicLayer SpecDeconvolution where\n toDynamicLayer = toDynamicLayer'\n\ntoDynamicLayer' :: (PrimBase m) => WeightInitMethod -> Gen (PrimState m) -> SpecDeconvolution -> m SpecNetwork\ntoDynamicLayer' _ _ (SpecDeconvolution inp@(_, 1, 1) _ _ _ _ _ _) = error $ \"1D input to a deconvolutional layer is not permited! you specified: \" ++ show inp\ntoDynamicLayer' wInit gen (SpecDeconvolution (rows, cols, depth) ch fil kerRows kerCols strRows strCols) =\n reifyNat ch $ \\(pxCh :: (KnownNat channels) => Proxy channels) ->\n reifyNat fil $ \\(pxFil :: (KnownNat filters) => Proxy filters) ->\n reifyNat kerRows $ \\(pxKerRows :: (KnownNat kernelRows) => Proxy kernelRows) ->\n reifyNat kerCols $ \\(pxKerCols :: (KnownNat kernelCols) => Proxy kernelCols) ->\n reifyNat strRows $ \\(_ :: (KnownNat strideRows) => Proxy strideRows) ->\n reifyNat strCols $ \\(_ :: (KnownNat strideCols) => Proxy strideCols) ->\n reifyNat rows $ \\(pxRows :: (KnownNat rows) => Proxy rows) ->\n reifyNat cols $ \\(_ :: (KnownNat cols) => Proxy cols) ->\n reifyNat depth $ \\(_ :: (KnownNat depth) => Proxy depth) ->\n reifyNat ((rows - 1) * strRows + kerRows) $ \\(pxOutRows :: (KnownNat outRows) => Proxy outRows) ->\n reifyNat ((cols - 1) * strCols + kerCols) $ \\(_ :: (KnownNat outCols) => Proxy outCols) ->\n case ( (singByProxy pxKerRows %* singByProxy pxKerCols) %* singByProxy pxFil\n , (singByProxy pxKerRows %* singByProxy pxKerCols) %* singByProxy pxCh -- this is the input: i = (kernelRows * kernelCols) * channels)\n , singByProxy pxCh %* ((singByProxy pxKerRows %* singByProxy pxKerCols) %* singByProxy pxFil)\n , singByProxy pxOutRows %* singByProxy pxFil -- 'D3 representation\n , singByProxy pxRows %* singByProxy pxCh -- 'D3 representation\n ) of\n (SNat, SNat, SNat, SNat, SNat) | ch == 1 && fil == 1 && depth == 0 ->\n case (unsafeCoerce (Dict :: Dict()) :: Dict (channels ~ 1, filters ~ 1, ((rows - 1) * strideRows) ~ (outRows - kernelRows), ((cols - 1) * strideCols) ~ (outCols - kernelCols)) ) of\n Dict -> do\n (layer :: Deconvolution 1 1 kernelRows kernelCols strideRows strideCols) <- createRandomWith wInit gen\n return $ SpecLayer layer (sing :: Sing ('D2 rows cols)) (sing :: Sing ('D2 outRows outCols))\n (SNat, SNat, SNat, SNat, SNat) | ch == 1 ->\n case (unsafeCoerce (Dict :: Dict()) :: Dict (channels ~ 1, ((rows - 1) * strideRows) ~ (outRows - kernelRows), ((cols - 1) * strideCols) ~ (outCols - kernelCols)) ) of\n Dict -> do\n (layer :: Deconvolution 1 filters kernelRows kernelCols strideRows strideCols) <- createRandomWith wInit gen\n return $ SpecLayer layer (sing :: Sing ('D2 rows cols)) (sing :: Sing ('D3 outRows outCols filters))\n (SNat, SNat, SNat, SNat, SNat) | fil == 1 ->\n case (unsafeCoerce (Dict :: Dict()) :: Dict (filters ~ 1, ((rows - 1) * strideRows) ~ (outRows - kernelRows), ((cols - 1) * strideCols) ~ (outCols - kernelCols)) ) of\n Dict -> do\n (layer :: Deconvolution channels 1 kernelRows kernelCols strideRows strideCols) <- createRandomWith wInit gen\n return $ SpecLayer layer (sing :: Sing ('D3 rows cols channels)) ( sing :: Sing ('D2 outRows outCols))\n (SNat, SNat, SNat, SNat, SNat) ->\n case (unsafeCoerce (Dict :: Dict()) :: Dict (((rows - 1) * strideRows) ~ (outRows - kernelRows), ((cols - 1) * strideCols) ~ (outCols - kernelCols)) ) of\n Dict -> do\n (layer :: Deconvolution channels filters kernelRows kernelCols strideRows strideCols) <- createRandomWith wInit gen\n return $ SpecLayer layer (sing :: Sing ('D3 rows cols channels)) ( sing :: Sing ('D3 outRows outCols filters))\n\n\n-- | Creates a specification for a deconvolutional layer with 2D input to the layer. If channels and filters are both 1 then the output is 2D otherwise it is 3D. The output sizes are `out = (in - 1) *\n-- stride + kernel`, for rows and cols and the depth is filters for 3D output.\nspecDeconvolution2DInput ::\n (Integer, Integer) -- ^ Number of input rows.\n -> Integer -- ^ Number of channels, for the first layer this could be RGB for instance.\n -> Integer -- ^ Number of filters, this is the number of channels output by the layer.\n -> Integer -- ^ The number of rows in the kernel filter\n -> Integer -- ^ The number of column in the kernel filter\n -> Integer -- ^ The row stride of the deconvolution filter\n -> Integer -- ^ The cols stride of the deconvolution filter\n -> SpecNet\nspecDeconvolution2DInput (rows, cols) = specDeconvolution3DInput (rows, cols, 1)\n\n-- | Creates a specification for a deconvolutional layer with 3D input to the layer. If the filter is 1 then the output is 2D, otherwise it is 3D. The output sizes are `out = (in - 1) * stride +\n-- kernel`, for rows and cols and the depth is filters for 3D output.\nspecDeconvolution3DInput ::\n (Integer, Integer, Integer) -- ^ Input to layer (rows, cols, depths). Use 1 if not used or the function @specDeconvolution1DInput@ and @specDeconvolution2DInput@.\n -> Integer -- ^ Number of channels, for the first layer this could be RGB for instance.\n -> Integer -- ^ Number of filters, this is the number of channels output by the layer.\n -> Integer -- ^ The number of rows in the kernel filter\n -> Integer -- ^ The number of column in the kernel filter\n -> Integer -- ^ The row stride of the deconvolution filter\n -> Integer -- ^ The cols stride of the deconvolution filter\n -> SpecNet\nspecDeconvolution3DInput inp channels filters kernelRows kernelCols strideRows strideCols =\n SpecNetLayer $ SpecDeconvolution inp channels filters kernelRows kernelCols strideRows strideCols\n\n\n-- | A deconvolution layer. 2D and 3D input/output only!\ndeconvolution ::\n Integer -- ^ Number of channels, for the first layer this could be RGB for instance.\n -> Integer -- ^ Number of filters, this is the number of channels output by the layer.\n -> Integer -- ^ The number of rows in the kernel filter\n -> Integer -- ^ The number of column in the kernel filter\n -> Integer -- ^ The row stride of the deconvolution filter\n -> Integer -- ^ The cols stride of the deconvolution filter\n -> BuildM ()\ndeconvolution channels filters kernelRows kernelCols strideRows strideCols = do\n inp@(r, c, _) <- buildRequireLastLayerOut IsNot1D\n let outRows = (r - 1) * strideRows + kernelRows\n outCols = (c - 1) * strideCols + kernelCols\n buildAddSpec $ SpecNetLayer $ SpecDeconvolution inp channels filters kernelRows kernelCols strideRows strideCols\n buildSetLastLayer (outRows, outCols, filters)\n\n-------------------- GNum instances --------------------\n\n\ninstance (KnownNat strideCols, KnownNat strideRows, KnownNat kernelCols, KnownNat kernelRows, KnownNat filters, KnownNat channels, KnownNat ((kernelRows * kernelCols) * filters)) =>\n GNum (Deconvolution channels filters kernelRows kernelCols strideRows strideCols) where\n n |* (Deconvolution w store) = Deconvolution (dmmap (fromRational n *) w) (n |* store)\n (Deconvolution w1 store1) |+ (Deconvolution w2 store2) = Deconvolution (w1 + w2) (store1 |+ store2)\n gFromRational r = Deconvolution (fromRational r) mkListStore\n\n\ninstance (KnownNat strideCols, KnownNat strideRows, KnownNat kernelCols, KnownNat kernelRows, KnownNat filters, KnownNat channels, KnownNat ((kernelRows * kernelCols) * filters)) =>\n GNum (Deconvolution' channels filters kernelRows kernelCols strideRows strideCols) where\n n |* (Deconvolution' g) = Deconvolution' (dmmap (fromRational n *) g)\n (Deconvolution' g) |+ (Deconvolution' g2) = Deconvolution' (g + g2)\n gFromRational r = Deconvolution' (fromRational r)\n", "meta": {"hexsha": "24d5294067d3f4aa08cd80932e24b88ca6c7a7e8", "size": 9915, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/Grenade/Dynamic/Layers/Deconvolution.hs", "max_stars_repo_name": "th-char/grenade", "max_stars_repo_head_hexsha": "0be658e7cf07562cd5e4170ed1e8875ccec14cdb", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-06-09T06:06:26.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-09T06:06:26.000Z", "max_issues_repo_path": "src/Grenade/Dynamic/Layers/Deconvolution.hs", "max_issues_repo_name": "th-char/grenade", "max_issues_repo_head_hexsha": "0be658e7cf07562cd5e4170ed1e8875ccec14cdb", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/Grenade/Dynamic/Layers/Deconvolution.hs", "max_forks_repo_name": "th-char/grenade", "max_forks_repo_head_hexsha": "0be658e7cf07562cd5e4170ed1e8875ccec14cdb", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 61.5838509317, "max_line_length": 200, "alphanum_fraction": 0.6616238023, "num_tokens": 2607, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO\n\n", "lm_q1_score": 0.7549149868676283, "lm_q2_score": 0.41869690935568665, "lm_q1q2_score": 0.3160805718277647}} {"text": "{-# LANGUAGE GADTs, RankNTypes, MultiParamTypeClasses, FlexibleInstances, UndecidableInstances, KindSignatures, ScopedTypeVariables, ConstraintKinds, TemplateHaskell, GeneralizedNewtypeDeriving, TypeFamilies #-}\n\nmodule Numeric.Trainee.Types (\n\tGradee(..),\n\tOw(..),\n\tparams, forwardPass, Learnee(..),\n\tLoss, Regularization, HasNorm(..),\n\tSample(..), (\u21e2),\n\tSamples, samples,\n\n\tmodule Numeric.Trainee.Params\n\t) where\n\nimport Prelude hiding (id, (.))\nimport Prelude.Unicode\n\nimport Control.Category\nimport Control.DeepSeq\nimport Control.Lens\nimport qualified Data.Vector as V\nimport Numeric.LinearAlgebra (Normed(norm_1), R, Vector)\n\nimport Numeric.Trainee.Params\n\nnewtype Gradee a b = Gradee {\n\trunGradee \u2237 Lens' a b }\n\ninstance Category Gradee where\n\tid = Gradee id\n\tGradee f . Gradee g = Gradee (g . f)\n\nclass Category a \u21d2 Ow a where\n\tfirst \u2237 a b c \u2192 a (b, d) (c, d)\n\tfirst = flip stars id\n\n\tsecond \u2237 a b c \u2192 a (d, b) (d, c)\n\tsecond = stars id\n\n\tstars \u2237 a b c \u2192 a b' c' \u2192 a (b, b') (c, c')\n\tvstars \u2237 a b c \u2192 a (V.Vector b) (V.Vector c)\n\ninstance Ow Gradee where\n\tstars (Gradee f) (Gradee g) = Gradee $ lens g' s' where\n\t\tg' (x, y) = (view f x, view g y)\n\t\ts' (x, y) (x', y') = (set f x' x, set g y' y)\n\n\tvstars (Gradee f) = Gradee $ lens g' s' where\n\t\tg' = V.map (view f)\n\t\ts' = V.zipWith (flip (set f))\n\ndata Learnee a b = Learnee {\n\t_params \u2237 Params,\n\t_forwardPass \u2237 Params \u2192 a \u2192 (b, b \u2192 (Params, a)) }\n\nmakeLenses ''Learnee\n\ninstance NFData (Learnee a b) where\n\trnf (Learnee ws _) = rnf ws\n\ninstance Show (Learnee a b) where\n\tshow (Learnee ws _) = show ws\n\ninstance Category Learnee where\n\tid = Learnee (Params NoParams) fn where\n\t\tfn _ x = (x, const (Params NoParams, x))\n\tLearnee rws g . Learnee lws f = lws `deepseq` rws `deepseq` Learnee (Params (lws, rws)) (h \u2218 castParams) where\n\t\th (lws', rws') x = x `seq` y `seq` lws' `deepseq` rws' `deepseq` (z, up) where\n\t\t\t(y, f') = f lws' x\n\t\t\t(z, g') = g rws' y\n\t\t\tup dz = dz `seq` dy `seq` lws'' `deepseq` rws'' `deepseq` (Params (lws'', rws''), dx) where\n\t\t\t\t(rws'', dy) = g' dz\n\t\t\t\t(lws'', dx) = f' dy\n\ntype Loss b = b \u2192 b \u2192 (b, b)\n\ntype Regularization b = b \u2192 (b, b)\n\nclass HasNorm a where\n\ttype Norm a\n\tnorm \u2237 a \u2192 Norm a\n\ninstance HasNorm Float where\n\ttype Norm Float = Float\n\tnorm = id\n\ninstance HasNorm Double where\n\ttype Norm Double = Double\n\tnorm = id\n\ninstance Normed (Vector a) \u21d2 HasNorm (Vector a) where\n\ttype Norm (Vector a) = R\n\tnorm = norm_1\n\ndata Sample a b = Sample {\n\tsampleInput \u2237 a,\n\tsampleOutput \u2237 b }\n\t\tderiving (Eq, Ord)\n\n(\u21e2) \u2237 a \u2192 b \u2192 Sample a b\n(\u21e2) = Sample\n\ninstance Bifunctor Sample where\n\tbimap f g (Sample x y) = Sample (f x) (g y)\n\ninstance (Show a, Show b) \u21d2 Show (Sample a b) where\n\tshow (Sample xs ys) = show xs ++ \" => \" ++ show ys\n\ninstance (NFData a, NFData b) \u21d2 NFData (Sample a b) where\n\trnf (Sample i o) = rnf i `seq` rnf o\n\ntype Samples a b = V.Vector (Sample a b)\n\nsamples \u2237 [Sample a b] \u2192 Samples a b\nsamples = V.fromList\n", "meta": {"hexsha": "242ea913e1432adf7561cbc375d9879c29050e49", "size": 2915, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/Numeric/Trainee/Types.hs", "max_stars_repo_name": "mvoidex/trainee", "max_stars_repo_head_hexsha": "60a935e53cabcf145736716829ee1be986b0ffc7", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2017-04-25T19:54:44.000Z", "max_stars_repo_stars_event_max_datetime": "2020-01-20T03:03:26.000Z", "max_issues_repo_path": "src/Numeric/Trainee/Types.hs", "max_issues_repo_name": "mvoidex/trainee", "max_issues_repo_head_hexsha": "60a935e53cabcf145736716829ee1be986b0ffc7", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/Numeric/Trainee/Types.hs", "max_forks_repo_name": "mvoidex/trainee", "max_forks_repo_head_hexsha": "60a935e53cabcf145736716829ee1be986b0ffc7", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 25.347826087, "max_line_length": 211, "alphanum_fraction": 0.6473413379, "num_tokens": 1022, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6791786861878392, "lm_q2_score": 0.4649015713733885, "lm_q1q2_score": 0.31575123845203995}} {"text": "{-# LANGUAGE FlexibleContexts #-}\n\nmodule Lib\n ( someFunc,\n )\nwhere\n\nimport Control.Exception (throw)\nimport Data.Char (digitToInt, isHexDigit, toLower, toUpper)\nimport Data.Complex (Complex ((:+)))\nimport Data.Foldable (Foldable (foldl'))\nimport qualified Data.Functor\nimport Data.Ratio (Ratio, denominator, numerator)\nimport Foreign.C (isValidErrno)\nimport GHC.Arr (Array, listArray)\nimport GHC.Float (rationalToDouble)\nimport GHC.Real ((%))\nimport GHC.Unicode (isHexDigit)\nimport Numeric (readFloat, readHex, readOct)\nimport System.Environment (getArgs)\nimport Text.Parsec (ParseError, alphaNum, anyChar, digit, optional, sepBy, sepEndBy, skipMany)\nimport Text.Parsec.Char (digit)\nimport Text.ParserCombinators.Parsec\n ( Parser,\n char,\n digit,\n endBy,\n hexDigit,\n letter,\n many,\n many1,\n noneOf,\n notFollowedBy,\n octDigit,\n oneOf,\n parse,\n sepBy,\n skipMany1,\n space,\n string,\n try,\n (),\n (<|>),\n )\nimport Text.ParserCombinators.Parsec.Char (digit)\nimport Text.Show (Show)\nimport Control.Monad.Except (throwError, catchError)\n\nsomeFunc :: IO ()\nsomeFunc = do\n (expr : _) <- getArgs\n let evaled = fmap show $ readExpr expr >>= eval\n putStrLn $ extractValue $ trapError evaled\n\ntrapError :: ThrowsError String -> ThrowsError String\ntrapError action = catchError action (return . show)\n\nsymbol :: Parser Char\nsymbol = oneOf \"!$%|*+-/:<=>?@^_~\"\n\nreadExpr :: String -> ThrowsError LispVal\nreadExpr input = case parse parseExpr \"lisp\" input of\n Left err -> throwError $ Parser err\n Right val -> return val\n\nspaces :: Parser ()\nspaces = skipMany1 space\n\nspaces1 :: Parser ()\nspaces1 = skipMany space\n\ndata LispVal\n = Atom String\n | List [LispVal]\n | DottedList [LispVal] LispVal\n | String String\n | Bool Bool\n | Character Char\n | Number Integer\n | Float Double\n | Ratio Rational\n | Complex (Complex Double)\n | Vector (Array Int LispVal)\n\ninstance Show LispVal where show = showVal\n\nshowVal :: LispVal -> String\nshowVal (String contents) = \"\\\"\" ++ contents ++ \"\\\"\"\nshowVal (Atom name) = name\nshowVal (Number contents) = show contents\nshowVal (Bool True) = \"#t\"\nshowVal (Bool False) = \"#f\"\nshowVal (Character c) = \"\\'\" ++ show c ++ \"\\'\"\nshowVal (Float f) = show f\nshowVal (Ratio r) = show r\nshowVal (Complex c) = show c\nshowVal (List contents) = \"(\" ++ unwordsList contents ++ \")\"\nshowVal (DottedList head tail) =\n \"(\" ++ unwordsList head ++ \" . \"\n ++ showVal tail\n ++ \")\"\nshowVal (Vector array) = show array\n\nunwordsList :: [LispVal] -> String\nunwordsList = unwords . map showVal\n\nparseString :: Parser LispVal\nparseString = do\n char '\"'\n x <- many $ escapedChar <|> noneOf \"\\\\\\\"\"\n char '\"'\n return $ String x\n\nescapedChar :: Parser Char\nescapedChar = do\n char '\\\\'\n oneOf \"\\\\\\\"\\n\\r\\t\"\n\nparseAtom :: Parser LispVal\nparseAtom = do\n first <- letter <|> symbol\n rest <- many (letter <|> digit <|> symbol)\n let atom = first : rest\n return $ case atom of\n \"#t\" -> Bool True\n \"#f\" -> Bool False\n _ -> Atom atom\n\nparseNumber :: Parser LispVal\nparseNumber =\n parseDecimal1\n <|> parseDecimal2\n <|> parseHex\n <|> parseOct\n <|> parseBin\n\nparseDecimal1 :: Parser LispVal\nparseDecimal1 = Number . read <$> many1 digit\n\nparseDecimal2 :: Parser LispVal\nparseDecimal2 = do\n try $ string \"#d\"\n x <- many1 digit\n return $ (Number . read) x\n\nparseHex :: Parser LispVal\nparseHex = do\n try $ string \"#x\"\n x <- many1 hexDigit\n return $ Number $ hex2dig x\n\nparseOct :: Parser LispVal\nparseOct = do\n try $ string \"#o\"\n x <- many1 octDigit\n return $ Number $ oct2dig x\n\nparseBin :: Parser LispVal\nparseBin = do\n try $ string \"#b\"\n x <- many1 (oneOf \"10\")\n return $ Number $ bin2dig x\n\noct2dig :: (Eq a, Num a) => String -> a\noct2dig x = fst $ head $ readOct x\n\nhex2dig :: (Eq a, Num a) => String -> a\nhex2dig x = fst $ head $ readHex x\n\nbin2dig :: [Char] -> Integer\nbin2dig = foldl' (\\acc x -> acc * 2 + (toInteger . digitToInt) x) 0\n\nparseBool :: Parser LispVal\nparseBool = do\n char '#'\n (char 't' >> return (Bool True))\n <|> (char 'f' >> return (Bool False))\n\nparseChar :: Parser LispVal\nparseChar = try parseCharacter <|> parseCharacterName\n\nparseCharacter :: Parser LispVal\nparseCharacter =\n do\n string \"#\\\\\"\n x <- anyChar\n notFollowedBy alphaNum\n return $ Character x\n\nparseCharacterName :: Parser LispVal\nparseCharacterName =\n do\n string \"#\\\\\"\n val <- caseInsensitiveString \"newline\" <|> caseInsensitiveString \"space\"\n return $\n Character $ case val of\n \"space\" -> ' '\n \"newline\" -> '\\n'\n _ -> ' '\n\ncaseInsensitiveChar :: Char -> Parser Char\ncaseInsensitiveChar c = char (toLower c) <|> char (toUpper c)\n\ncaseInsensitiveString :: String -> Parser String\ncaseInsensitiveString s = mapM caseInsensitiveChar s \"\\\"\" ++ s ++ \"\\\"\"\n\nparseFloat :: Parser LispVal\nparseFloat = do\n x <- many1 digit\n char '.'\n y <- many1 digit\n return $ Float (fst . head $ readFloat $ x ++ \".\" ++ y)\n\nparseRatio :: Parser LispVal\nparseRatio = do\n x <- many1 digit\n char '/'\n y <- many1 digit\n return $ Ratio $ read x % read y\n\nparseComplex :: Parser LispVal\nparseComplex = do\n x <- try parseFloat <|> parseNumber\n char '+'\n y <- try parseFloat <|> parseNumber\n char 'i'\n return $ Complex $ toDouble x :+ toDouble y\n\ntoDouble :: LispVal -> Double\ntoDouble (Float f) = realToFrac f\ntoDouble (Number n) = fromIntegral n\ntoDouble (Ratio r) = rationalToDouble (numerator r) (denominator r)\ntoDouble _ = error \"not implement\"\n\n-- parse list\nparseList :: Parser LispVal\nparseList = List <$> sepBy parseExpr spaces\n\nparseDottedList :: Parser LispVal\nparseDottedList = do\n head <- endBy parseExpr spaces\n tail <- char '.' >> spaces >> parseExpr\n return $ DottedList head tail\n\nparseListAll :: Parser LispVal\nparseListAll = do\n char '('\n spaces1\n x <- try parseList <|> parseDottedList\n spaces1\n char ')'\n return x\n\nparseListAllWithoutTry :: Parser LispVal\nparseListAllWithoutTry = do\n char '('\n spaces1\n head <- sepEndBy parseExpr spaces\n do\n char '.' >> spaces\n tail <- parseExpr\n spaces1 >> char ')'\n return $ DottedList head tail\n <|> (char ')' >> return (List head))\n\nparseQuoted :: Parser LispVal\nparseQuoted = do\n char '\\''\n x <- parseExpr\n return $ List [Atom \"quote\", x]\n\nparseBackQuoted :: Parser LispVal\nparseBackQuoted = do\n char '`'\n x <- parseExpr\n return $ List [Atom \"quasiquote\", x]\n\nparseUnquote :: Parser LispVal\nparseUnquote = do\n try $ char ','\n x <- parseExpr\n return $ List [Atom \"unquote\", x]\n\nparseUnquoteSplicing :: Parser LispVal\nparseUnquoteSplicing = do\n try $ string \",@\"\n x <- parseExpr\n return $ List [Atom \"unquote-splicing\", x]\n\nparseVector :: Parser LispVal\nparseVector = do\n string \"#(\"\n arrayVal <- sepBy parseExpr spaces\n char ')'\n return $ Vector $ listArray (0, length arrayVal - 1) arrayVal\n\nparseNumber1 :: Parser LispVal\nparseNumber1 = do\n num <- many1 digit\n return $ (Number . read) num\n\nparseNumber2 :: Parser LispVal\nparseNumber2 = many1 digit Data.Functor.<&> (Number . read)\n\nparseExpr :: Parser LispVal\nparseExpr =\n parseAtom\n <|> parseString\n <|> try parseComplex\n <|> try parseFloat\n <|> try parseRatio\n <|> try parseNumber -- we need the 'try' because these can all\n <|> try parseBool -- start with the '#' char\n <|> try parseChar\n <|> parseQuoted\n <|> parseBackQuoted\n <|> parseUnquoteSplicing\n <|> parseUnquote\n <|> try parseVector\n <|> parseListAllWithoutTry\n\neval :: LispVal -> ThrowsError LispVal\neval val@(String _) = return val\neval val@(Number _) = return val\neval val@(Bool _) = return val\neval val@(Character _) = return val\neval val@(Float _) = return val\neval val@(Ratio _) = return val\neval val@(Complex _) = return val\neval val@(Vector _) = return val\neval val@(DottedList _ _) = return val\neval (List [Atom \"quote\", val]) = return val\neval (List [Atom \"quasiquote\", val]) = return val\neval (List (Atom func : args)) = mapM eval args >>= apply func\neval badForm = throwError $ BadSpecialForm \"Unrecognized special form\" badForm\n\napply :: String -> [LispVal] -> ThrowsError LispVal\napply func args =\n maybe\n (throwError $ NotFunction \"Unrecognized primitive function args\" func)\n ($ args)\n (lookup func primitives)\n\n{-\nboolean? --Boolean? returns #t if obj is either #t or #f and returns #f otherwise.\npair? --Pair? returns #t if obj is a pair, and otherwise returns #f.\nnull? --Returns #t if obj is the empty list, otherwise returns #f.\nlist? --Returns #t if obj is a list, otherwise returns #f.\nsymbol? --Returns #t if obj is a symbol, otherwise returns #f.\nchar? --Returns #t if obj is a character, otherwise returns #f.\nstring? --Returns #t if obj is a string, otherwise returns #f.\nvector? --Returns #t if obj is a vector, otherwise returns #f.\n\nnumber?\ncomplex?\nreal?\nrational?\ninteger?\n-}\nprimitives :: [(String, [LispVal] -> ThrowsError LispVal)]\nprimitives =\n [ (\"+\", numericBinop (+)),\n (\"-\", numericBinop (-)),\n (\"*\", numericBinop (*)),\n (\"/\", numericBinop div),\n (\"mod\", numericBinop mod),\n (\"quotient\", numericBinop quot),\n (\"remainder\", numericBinop rem),\n (\"boolean?\", unaryOp booleanOp),\n (\"pair?\", unaryOp pairOp),\n (\"null?\", unaryOp nullOp),\n (\"list?\", unaryOp listOp),\n (\"symbol?\", unaryOp symbolOp),\n (\"char?\", unaryOp charOp),\n (\"string?\", unaryOp stringOp),\n (\"vector?\", unaryOp vectorOp),\n (\"integer?\", unaryOp integerOp),\n (\"rational?\", unaryOp rationalOp),\n (\"real?\", unaryOp realOp),\n (\"complex?\", unaryOp complexOp),\n (\"number?\", unaryOp numberOp),\n -- symbol handler\n (\"symbol->string\", unaryOp symbol2stringOp),\n (\"string->symbol\", unaryOp string2symbolOp)\n ]\n\nstring2symbolOp :: LispVal -> LispVal\nstring2symbolOp (String s) = Atom s\nstring2symbolOp n = error $ show n ++ \" is not string.\"\n\nsymbol2stringOp :: LispVal -> LispVal\nsymbol2stringOp (Atom a) = String a\nsymbol2stringOp n = error $ show n ++ \" is not atom.\"\n\nintegerOp :: LispVal -> LispVal\nintegerOp (Number _) = Bool True\nintegerOp _ = Bool False\n\nrationalOp :: LispVal -> LispVal\nrationalOp (Number _) = Bool True\nrationalOp (Ratio _) = Bool True\nrationalOp _ = Bool False\n\nrealOp :: LispVal -> LispVal\nrealOp (Number _) = Bool True\nrealOp (Ratio _) = Bool True\nrealOp (Float _) = Bool True\nrealOp _ = Bool False\n\ncomplexOp :: LispVal -> LispVal\ncomplexOp (Number _) = Bool True\ncomplexOp (Ratio _) = Bool True\ncomplexOp (Float _) = Bool True\ncomplexOp (Complex _) = Bool True\ncomplexOp _ = Bool False\n\nnumberOp :: LispVal -> LispVal\nnumberOp = complexOp\n\nvectorOp :: LispVal -> LispVal\nvectorOp (Vector _) = Bool True\nvectorOp _ = Bool False\n\nstringOp :: LispVal -> LispVal\nstringOp (String _) = Bool True\nstringOp _ = Bool False\n\ncharOp :: LispVal -> LispVal\ncharOp (Character _) = Bool True\ncharOp _ = Bool False\n\nsymbolOp :: LispVal -> LispVal\nsymbolOp (Atom _) = Bool True\nsymbolOp _ = Bool False\n\nlistOp :: LispVal -> LispVal\nlistOp (List _) = Bool True\nlistOp _ = Bool False\n\nnullOp :: LispVal -> LispVal\nnullOp (List []) = Bool True\nnullOp _ = Bool False\n\npairOp :: LispVal -> LispVal\npairOp (List (a : _)) = Bool True\npairOp (DottedList _ _) = Bool True\npairOp _ = Bool False\n\nbooleanOp :: LispVal -> LispVal\nbooleanOp (Bool _) = Bool True\nbooleanOp _ = Bool False\n\nunaryOp :: (LispVal -> LispVal) -> [LispVal] -> ThrowsError LispVal\nunaryOp f [v] = return $ f v\nunaryOp _ _ = error \"only support one argument.\"\n\nnumericBinop :: (Integer -> Integer -> Integer) -> [LispVal] -> ThrowsError LispVal\nnumericBinop op [] = throwError $ NumArgs 2 []\nnumericBinop op singleVal@[_] = throwError $ NumArgs 2 singleVal\nnumericBinop op params = mapM unpackNum params >>= return . Number . foldl1 op\n\nunpackNum :: LispVal -> ThrowsError Integer\nunpackNum (Number n) = return n\nunpackNum notNum = throwError $ TypeMismatch \"number\" notNum\n\n-- error checking and exceptions\n\ndata LispError\n = NumArgs Integer [LispVal]\n | TypeMismatch String LispVal\n | Parser ParseError\n | BadSpecialForm String LispVal\n | NotFunction String String\n | UnboundVar String String\n | Default String\n\nshowError :: LispError -> String\nshowError (UnboundVar message varname) = message ++ \": \" ++ varname\nshowError (BadSpecialForm message form) = message ++ \": \" ++ show form\nshowError (NotFunction message func) = message ++ \": \" ++ show func\nshowError (NumArgs expected found) =\n \"Expected \" ++ show expected\n ++ \" args; found values \"\n ++ unwordsList found\nshowError (TypeMismatch expected found) =\n \"Invalid type: expected \" ++ expected\n ++ \", found \"\n ++ show found\nshowError (Parser parseErr) = \"Parse error at \" ++ show parseErr\nshowError (Default str) = show str\n\ninstance Show LispError where show = showError\n\ntype ThrowsError = Either LispError\n\n\n\nextractValue :: ThrowsError a -> a\nextractValue (Right val) = val\n", "meta": {"hexsha": "1bba9580d06dad0a53a342ad149f4f7d96901a6d", "size": 12789, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/Lib.hs", "max_stars_repo_name": "chonhnm/wyas", "max_stars_repo_head_hexsha": "364d2fe8275251e82676dd9123e6566273f85552", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/Lib.hs", "max_issues_repo_name": "chonhnm/wyas", "max_issues_repo_head_hexsha": "364d2fe8275251e82676dd9123e6566273f85552", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/Lib.hs", "max_forks_repo_name": "chonhnm/wyas", "max_forks_repo_head_hexsha": "364d2fe8275251e82676dd9123e6566273f85552", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 25.578, "max_line_length": 94, "alphanum_fraction": 0.6734693878, "num_tokens": 3640, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6513548646660542, "lm_q2_score": 0.48438008427698437, "lm_q1q2_score": 0.31550332424116706}} {"text": "{-# LANGUAGE BangPatterns #-}\nmodule Polestar.Core.Eval where\nimport Polestar.Core.Type\nimport Polestar.Core.TypeCheck\nimport Data.Complex\nimport GHC.Float (expm1, log1p)\n\ntermSubstD :: Int -> Term -> Int -> Term -> Term\ntermSubstD !depth s !i t = case t of\n TmAbs name ty body -> TmAbs name (typeShift (-1) i ty) (termSubstD (depth + 1) s (i + 1) body)\n TmRef j | j == i -> termShift depth 0 s\n | j > i -> TmRef (j - 1)\n | otherwise -> t\n TmApp u v -> TmApp (termSubstD depth s i u) (termSubstD depth s i v)\n TmLet name def body -> TmLet name (termSubstD depth s i def) (termSubstD (depth + 1) s (i + 1) body)\n TmTypedLet name ty def body -> TmTypedLet name ty (termSubstD depth s i def) (termSubstD (depth + 1) s (i + 1) body)\n TmIf cond then_ else_ -> TmIf (termSubstD depth s i cond) (termSubstD depth s i then_) (termSubstD depth s i else_)\n TmPrim _ -> t\n TmTuple components -> TmTuple $ termSubstD depth s i <$> components\n TmProj tuple j -> TmProj (termSubstD depth s i tuple) j\n TmIterate n init succ -> TmIterate (termSubstD depth s i n) (termSubstD depth s i init) (termSubstD depth s i succ)\n\n-- replaces occurrences of TRef j (j > i) with TRef (j-1), and TRef i with the given term\ntermSubst = termSubstD 0\n\nnatFromValue :: Term -> Either String Integer\nnatFromValue (TmPrim (PVNat x)) = return x\nnatFromValue x = Left (\"type error (expected a natural number, but got \" ++ show x ++ \")\")\n\nintFromValue :: Term -> Either String Integer\nintFromValue (TmPrim (PVInt x)) = return x\nintFromValue x = Left (\"type error (expected an integer, but got \" ++ show x ++ \")\")\n\nrealFromValue :: Term -> Either String Double\nrealFromValue (TmPrim (PVReal x)) = return x\nrealFromValue x = Left (\"type error (expected a real number, but got \" ++ show x ++ \")\")\n\nboolFromValue :: Term -> Either String Bool\nboolFromValue (TmPrim (PVBool x)) = return x\nboolFromValue x = Left (\"type error (expected a boolean, but got \" ++ show x ++ \")\")\n\napplyBuiltinUnary :: UnaryFn -> Term -> Either String Term\napplyBuiltinUnary f v = case f of\n UNegateInt -> (TmPrim . PVInt) <$> intFromValue v\n UNegateReal -> (TmPrim . PVReal) <$> realFromValue v\n UNatToInt -> (TmPrim . PVInt) <$> natFromValue v\n UIntToReal -> (TmPrim . PVReal . fromInteger) <$> intFromValue v\n UIntToNat -> (TmPrim . PVNat . max 0) <$> intFromValue v\n\napplyBuiltinBinary :: BinaryFn -> Term -> Term -> Either String Term\napplyBuiltinBinary f u v = case f of\n UAddNat -> (TmPrim . PVNat) <$> ((+) <$> natFromValue u <*> natFromValue v)\n UMulNat -> (TmPrim . PVNat) <$> ((*) <$> natFromValue u <*> natFromValue v)\n UTSubNat -> (TmPrim . PVNat . max 0) <$> ((-) <$> natFromValue u <*> natFromValue v)\n UPowNatNat -> (TmPrim . PVNat) <$> ((^) <$> natFromValue u <*> natFromValue v)\n UEqualNat -> (TmPrim . PVBool) <$> ((==) <$> natFromValue u <*> natFromValue v)\n ULessThanNat -> (TmPrim . PVBool) <$> ((<) <$> natFromValue u <*> natFromValue v)\n ULessEqualNat -> (TmPrim . PVBool) <$> ((<=) <$> natFromValue u <*> natFromValue v)\n UAddInt -> (TmPrim . PVInt) <$> ((+) <$> intFromValue u <*> intFromValue v)\n USubInt -> (TmPrim . PVInt) <$> ((-) <$> intFromValue u <*> intFromValue v)\n UMulInt -> (TmPrim . PVInt) <$> ((*) <$> intFromValue u <*> intFromValue v)\n UPowIntNat -> (TmPrim . PVInt) <$> ((^) <$> intFromValue u <*> natFromValue v)\n UEqualInt -> (TmPrim . PVBool) <$> ((==) <$> intFromValue u <*> intFromValue v)\n ULessThanInt -> (TmPrim . PVBool) <$> ((<) <$> intFromValue u <*> intFromValue v)\n ULessEqualInt -> (TmPrim . PVBool) <$> ((<=) <$> intFromValue u <*> intFromValue v)\n UAddReal -> (TmPrim . PVReal) <$> ((+) <$> realFromValue u <*> realFromValue v)\n USubReal -> (TmPrim . PVReal) <$> ((-) <$> realFromValue u <*> realFromValue v)\n UMulReal -> (TmPrim . PVReal) <$> ((*) <$> realFromValue u <*> realFromValue v)\n UDivReal -> (TmPrim . PVReal) <$> ((/) <$> realFromValue u <*> realFromValue v)\n UPowRealReal -> (TmPrim . PVReal) <$> ((**) <$> realFromValue u <*> realFromValue v)\n UEqualReal -> (TmPrim . PVBool) <$> ((==) <$> realFromValue u <*> realFromValue v)\n ULessThanReal -> (TmPrim . PVBool) <$> ((<) <$> realFromValue u <*> realFromValue v)\n ULessEqualReal -> (TmPrim . PVBool) <$> ((<=) <$> realFromValue u <*> realFromValue v)\n\ndata ValueBinding = ValueBind !Term\n | TypeBind\n deriving (Eq,Show)\n\ngetValueFromContext :: [ValueBinding] -> Int -> Term\ngetValueFromContext ctx i\n | i < length ctx = case ctx !! i of\n ValueBind x -> x\n b -> error (\"TRef: expected a variable binding, found \" ++ show b)\n | otherwise = error \"TRef: index out of bounds\"\n\neval1 :: [ValueBinding] -> Term -> Either String Term\neval1 ctx t = case t of\n TmPrim _ -> return t\n TmAbs _ _ _ -> return t\n TmRef i -> return $ getValueFromContext ctx i\n TmApp u v\n | isValue u && isValue v -> case u of\n TmAbs _name _ty body -> return $ termSubst v 0 body -- no type checking here\n TmPrim (PVUnary f) -> applyBuiltinUnary f v\n TmPrim (PVBinary _) -> return t -- partial application\n TmApp (TmPrim (PVBinary f)) u' -> applyBuiltinBinary f u' v\n _ -> Left \"invalid function application (expected function type)\"\n | isValue u -> TmApp u <$> (eval1 ctx v)\n | otherwise -> TmApp <$> (eval1 ctx u) <*> pure v\n TmLet name def body\n | isValue def -> return $ termSubst def 0 body\n | otherwise -> TmLet name <$> eval1 ctx def <*> pure body\n TmTypedLet name ty def body\n | isValue def -> return $ termSubst def 0 body\n | otherwise -> TmTypedLet name ty <$> eval1 ctx def <*> pure body\n TmIf cond then_ else_\n | isValue cond -> case cond of\n TmPrim (PVBool True) -> return then_ -- no type checking here\n TmPrim (PVBool False) -> return else_ -- no type checking here\n _ -> Left \"if-then-else: condition must be boolean\"\n | otherwise -> TmIf <$> (eval1 ctx cond) <*> pure then_ <*> pure else_\n TmTuple components -> case span isValue components of\n (_,[]) -> return t\n (v,w:ws) -> eval1 ctx w >>= \\w' -> return (TmTuple (v ++ (w':ws)))\n TmProj tuple j\n | isValue tuple -> case tuple of\n TmTuple components | length components > j -> return $ components !! j\n | otherwise -> Left \"tuple too short\"\n _ -> Left \"projection: not a tuple\"\n | otherwise -> TmProj <$> eval1 ctx tuple <*> pure j\n TmIterate n init succ\n | isValue n && isValue init && isValue succ -> do\n n' <- natFromValue n\n if n' == 0\n then return $ init\n else return $ TmIterate (TmPrim (PVNat (n' - 1))) (TmApp succ init) succ\n | isValue n && isValue init -> TmIterate n init <$> eval1 ctx succ\n | isValue n -> TmIterate n <$> eval1 ctx init <*> pure succ\n | otherwise -> TmIterate <$> eval1 ctx n <*> pure init <*> pure succ\n\neval :: [ValueBinding] -> Term -> Either String Term\neval ctx t | isValue t = return t\n | otherwise = eval1 ctx t >>= eval ctx\n", "meta": {"hexsha": "18bbc18930fe0abcbba302733f66b8a683eedefa", "size": 6991, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/Polestar/Core/Eval.hs", "max_stars_repo_name": "minoki/polestar", "max_stars_repo_head_hexsha": "df73b793c65b1f6e7bc618b3175d6661a6722240", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/Polestar/Core/Eval.hs", "max_issues_repo_name": "minoki/polestar", "max_issues_repo_head_hexsha": "df73b793c65b1f6e7bc618b3175d6661a6722240", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/Polestar/Core/Eval.hs", "max_forks_repo_name": "minoki/polestar", "max_forks_repo_head_hexsha": "df73b793c65b1f6e7bc618b3175d6661a6722240", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 52.171641791, "max_line_length": 118, "alphanum_fraction": 0.6239450722, "num_tokens": 2200, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.6187804337438501, "lm_q2_score": 0.5078118642792044, "lm_q1q2_score": 0.3142240456389592}} {"text": "-- |\n-- Module : Cartesian.Internal.Types\n-- Description :\n-- Copyright : (c) Jonatan H Sundqvist, 2015\n-- License : MIT\n-- Maintainer : Jonatan H Sundqvist\n-- Stability : experimental|stable\n-- Portability : POSIX (not sure)\n--\n\n-- Created October 31 2015\n\n-- TODO | - Use TemplateHaskell (?)\n-- - Strictness\n-- - Performance, inlining\n\n-- SPEC | -\n-- -\n\n\n\n------------------------------------------------------------------------------------------------------------------------------------------------------\n-- GHC Pragmas\n------------------------------------------------------------------------------------------------------------------------------------------------------\n{-# LANGUAGE TemplateHaskell #-}\n{-# LANGUAGE MultiParamTypeClasses #-}\n{-# LANGUAGE FunctionalDependencies #-}\n{-# LANGUAGE RankNTypes #-}\n{-# LANGUAGE FlexibleInstances #-}\n\n\n------------------------------------------------------------------------------------------------------------------------------------------------------\n-- API\n------------------------------------------------------------------------------------------------------------------------------------------------------\nmodule Cartesian.Internal.Types where\n\n\n\n------------------------------------------------------------------------------------------------------------------------------------------------------\n-- We'll need these\n------------------------------------------------------------------------------------------------------------------------------------------------------\nimport Control.Lens (Simple, Lens, lens)\n\nimport Data.Complex (Complex(..))\n\nimport Linear.V1\nimport Linear.V2\nimport Linear.V3\nimport Linear.V4\n\n\n\n------------------------------------------------------------------------------------------------------------------------------------------------------\n-- Types\n------------------------------------------------------------------------------------------------------------------------------------------------------\n\n-- Synonyms ------------------------------------------------------------------------------------------------------------------------------------------\n\n-- TODO: Add some aliased lenses for these aliased types (?)\n\n-- | A lens focusing on a single [vector-]component in a BoundingBox\ntype BoxLens v v' f f' = Lens (BoundingBox (v f)) (BoundingBox (v' f')) f f'\n\n\n-- | An axis represented as (begin, length)\ntype Axis a = (a, a)\n\n\n-- | A vector where each component represents a single axis (cf. 'Axis')\ntype Axes v a = v (Axis a)\n\n\n-- |\n-- type Domain\n\n\n-- |\n-- TODO: Rename (eg. 'Shape') (?)\ntype Polygon m v f = m (v f)\n\n\n-- | Coordinate system wrappers\nnewtype Normalised v = Normalised { absolute :: v } -- \nnewtype Absolute v = Absoloute { normalised :: v } -- \n\n-- Types ---------------------------------------------------------------------------------------------------------------------------------------------\n\n-- |\n-- TODO: Anchors (eg. C, N, S, E W and combinations thereof, perhaps represented as relative Vectors)\n-- TODO: Define some standard instances (eg. Functor, Applicative)\ndata BoundingBox v = BoundingBox { cornerOf :: v, sizeOf :: v } deriving (Show, Eq)\n\n\n-- |\n-- TODO: Use record (eg. from, to) (?)\ndata Line v = Line v v deriving (Show, Eq)\n\n\n-- |\ndata Linear f = Linear { interceptOf :: f, slopeOf :: f } deriving (Show, Eq)\n\n\n-- |\ndata Inclusivity r = Inclusive r | Exclusive r -- TODO: Rename (?)\ndata Interval r = Interval (Inclusivity r) (Inclusivity r)\n\n\n-- |\n-- TODO: Use existing type instead (?)\n-- data Side = SideLeft | SideRight | SideTop | SideBottom\n\n-- Classes -------------------------------------------------------------------------------------------------------------------------------------------\n\n-- TODO: How do you generate lenses for non-record types (?)\nclass HasX a f | a -> f where { x :: Simple Lens a f }\nclass HasY a f | a -> f where { y :: Simple Lens a f }\nclass HasZ a f | a -> f where { z :: Simple Lens a f }\n\n-- Instances -----------------------------------------------------------------------------------------------------------------------------------------\n\n\n-- TODO: Generate these instances with TemplateHaskell (?)\n\ninstance HasX (V1 f) f where\n x = lens (\\(V1 x') -> x') (\\_ x' -> V1 x')\n\n\ninstance HasX (V2 f) f where\n x = lens (\\(V2 x' _) -> x') (\\(V2 _ y') x' -> V2 x' y')\n\n\ninstance HasY (V2 f) f where\n y = lens (\\(V2 _ y') -> y') (\\(V2 x' _) y' -> V2 x' y')\n\n\ninstance HasX (V3 f) f where\n x = lens (\\(V3 x' _ _) -> x') (\\(V3 _ y' z') x' -> V3 x' y' z')\n\n\ninstance HasY (V3 f) f where\n y = lens (\\(V3 _ y' _) -> y') (\\(V3 x' _ z') y' -> V3 x' y' z')\n\n\ninstance HasZ (V3 f) f where\n z = lens (\\(V3 _ _ z') -> z') (\\(V3 x' y' _) z' -> V3 x' y' z')\n\n\ninstance HasX (V4 f) f where\n x = lens (\\(V4 x' _ _ _) -> x') (\\(V4 _ y' z' w') x' -> V4 x' y' z' w')\n\n\ninstance HasY (V4 f) f where\n y = lens (\\(V4 _ y' _ _) -> y') (\\(V4 x' _ z' w') y' -> V4 x' y' z' w')\n\n\ninstance HasZ (V4 f) f where\n z = lens (\\(V4 _ _ z' _) -> z') (\\(V4 x' y' _ w') z' -> V4 x' y' z' w')\n\n\ninstance HasX (Complex f) f where\n x = lens (\\(x':+_) -> x') (\\(_:+y') x' -> x':+y')\n\n\ninstance HasY (Complex f) f where\n y = lens (\\(_':+y') -> y') (\\(x':+_) y' -> x':+y')\n\n", "meta": {"hexsha": "d5debf4bc75ac8818ad4dd49c745d17d69e3719a", "size": 5270, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/Cartesian/Internal/Types.hs", "max_stars_repo_name": "SwiftsNamesake/Cartesian", "max_stars_repo_head_hexsha": "42791378b1453b422692dd78e05977e5f8f577f5", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2016-01-05T13:11:24.000Z", "max_stars_repo_stars_event_max_datetime": "2016-01-05T13:11:24.000Z", "max_issues_repo_path": "src/Cartesian/Internal/Types.hs", "max_issues_repo_name": "SwiftsNamesake/Cartesian", "max_issues_repo_head_hexsha": "42791378b1453b422692dd78e05977e5f8f577f5", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/Cartesian/Internal/Types.hs", "max_forks_repo_name": "SwiftsNamesake/Cartesian", "max_forks_repo_head_hexsha": "42791378b1453b422692dd78e05977e5f8f577f5", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-02-12T23:31:50.000Z", "max_forks_repo_forks_event_max_datetime": "2021-02-12T23:31:50.000Z", "avg_line_length": 31.5568862275, "max_line_length": 150, "alphanum_fraction": 0.3865275142, "num_tokens": 1174, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.5234203340678567, "lm_q2_score": 0.600188359260205, "lm_q1q2_score": 0.31415079150761527}} {"text": "{-# LANGUAGE AllowAmbiguousTypes #-}\n{-# OPTIONS_GHC -fno-warn-orphans #-}\n\nmodule Main (main) where\n\nimport Injection\nimport Projection\n\nimport Data.Complex (Complex ((:+)))\nimport Data.Dynamic (Dynamic)\nimport Data.Fixed (Fixed, E6)\nimport Data.Functor.Const (Const)\nimport Data.Functor.Identity (Identity)\nimport Data.List.NonEmpty (NonEmpty ((:|)))\nimport Data.Map (Map)\nimport qualified Data.Map as Map\nimport Data.Monoid (Dual)\nimport Data.Monoid (Product)\nimport Data.Monoid (Sum)\nimport Data.Monoid (All, Any)\nimport qualified Data.Monoid as Monoid (First, Last)\nimport Data.Ord (Down (..))\nimport Data.Ratio (Ratio, (%))\nimport Data.Semigroup (Max, Min)\nimport qualified Data.Semigroup as Semigroup (First, Last)\nimport Data.Set (Set)\nimport qualified Data.Set as Set\nimport Data.Text (Text)\nimport qualified Data.Text.Lazy as Lazy (Text)\nimport Numeric.Natural (Natural)\nimport Test.Hspec\nimport Test.QuickCheck hiding (Fixed)\nimport Test.QuickCheck.Instances ()\n\nmain :: IO ()\nmain = hspec $ do\n describe \"instance Injection Integer Integer\" $ do\n it \"is resolvable\" (resolveInjection @Integer @Integer)\n describe \"instance Injection String String\" $ do\n it \"is resolvable\" (resolveInjection @String @String)\n describe \"instance Injection Text Text\" $ do\n it \"is resolvable\" (resolveInjection @Text @Text)\n describe \"instance Injection Lazy.Text Lazy.Text\" $ do\n it \"is resolvable\" (resolveInjection @Lazy.Text @Lazy.Text)\n describe \"instance Retraction Integer Dynamic\" $ do\n it \"is resolvable\" (resolveRetraction @Integer @Dynamic)\n it \"is the left inverse of inject\" (lawLeftInverse @Integer @Dynamic)\n describe \"instance Injection (Maybe Integer) [Integer]\" $ do\n it \"is resolvable\" (resolveInjection @(Maybe Integer) @[Integer])\n it \"outputs a value with the same length as the input\" $ do\n let test = inject @(Maybe Integer) @[Integer]\n length (test Nothing) `shouldBe` 0\n length (test (Just 1)) `shouldBe` 1\n it \"is injective\" (lawInjective @(Maybe Integer) @[Integer])\n describe \"instance Retraction (Maybe Integer) [Integer]\" $ do\n it \"is resolvable\" (resolveRetraction @(Maybe Integer) @[Integer])\n it \"is the left inverse of inject\" (lawLeftInverse @(Maybe Integer) @[Integer])\n describe \"instance Injection Natural Integer\" $ do\n it \"is resolvable\" (resolveInjection @Natural @Integer)\n it \"injects the value itself\" $ do\n let test = inject @Natural @Integer\n test 0 `shouldBe` 0\n test 1 `shouldBe` 1\n test 2 `shouldBe` 2\n it \"is injective\" (lawInjective @Natural @Integer)\n describe \"instance Retraction Natural Integer\" $ do\n it \"is resolvable\" (resolveRetraction @Natural @Integer)\n it \"is the left inverse of inject\" (lawLeftInverse @Natural @Integer)\n it \"is defined over non-negative integers\" $ do\n retract @Natural @Integer 0 `shouldBe` Just 0\n retract @Natural @Integer 1 `shouldBe` Just 1\n it \"is not defined over negative integers\" $ do\n retract @Natural @Integer (-1) `shouldBe` Nothing\n describe \"instance Injection Text String\" $ do\n it \"is resolvable\" (resolveInjection @Text @String)\n it \"is injective\" (lawInjective @Text @String)\n describe \"instance Injection Lazy.Text String\" $ do\n it \"is resolvable\" (resolveInjection @Lazy.Text @String)\n it \"is injective\" (lawInjective @Lazy.Text @String)\n describe \"instance Injection Text Lazy.Text\" $ do\n it \"is resolvable\" (resolveInjection @Text @Lazy.Text)\n it \"is injective\" (lawInjective @Text @Lazy.Text)\n describe \"instance Injection Lazy.Text Text\" $ do\n it \"is resolvable\" (resolveInjection @Lazy.Text @Text)\n it \"is injective\" (lawInjective @Lazy.Text @Text)\n describe \"instance Injection Integer (Fixed a)\" $ do\n it \"is resolvable\" (resolveInjection @Integer @(Fixed E6))\n it \"is injective\" (lawInjective @Integer @(Fixed E6))\n describe \"instance Retraction Integer (Fixed a)\" $ do\n it \"is resolvable\" (resolveRetraction @Integer @(Fixed E6))\n it \"is the left inverse of inject\" (lawLeftInverse @Integer @(Fixed E6))\n it \"is defined over integers\" $ do\n retract @Integer @(Fixed E6) 0 `shouldBe` Just 0\n retract @Integer @(Fixed E6) 1 `shouldBe` Just 1\n retract @Integer @(Fixed E6) (-1) `shouldBe` Just (-1)\n it \"is not defined over fractions\" $ do\n retract @Integer @(Fixed E6) (1 / 2) `shouldBe` Nothing\n describe \"instance Injection Integer (Const Integer String)\" $ do\n it \"is resolvable\" (resolveInjection @Integer @(Const Integer String))\n it \"is injective\" (lawInjective @Integer @(Const Integer String))\n describe \"instance Injection (Const Integer String) Integer\" $ do\n it \"is resolvable\" (resolveInjection @(Const Integer String) @Integer)\n it \"is injective\" (lawInjective @(Const Integer String) @Integer)\n describe \"instance Injection Integer (Ratio Integer)\" $ do\n it \"is resolvable\" (resolveInjection @Integer @(Ratio Integer))\n it \"is injective\" (lawInjective @Integer @(Ratio Integer))\n describe \"instance Retraction Integer (Ratio Integer)\" $ do\n it \"is resolvable\" (resolveRetraction @Integer @(Ratio Integer))\n it \"is the left inverse of inject\" (lawLeftInverse @Integer @(Ratio Integer))\n it \"is defined over integers\" $ do\n retract @Integer @(Ratio Integer) (0 % 1) `shouldBe` Just 0\n retract @Integer @(Ratio Integer) (1 % 1) `shouldBe` Just 1\n retract @Integer @(Ratio Integer) (1 % (-1)) `shouldBe` Just (-1)\n it \"is not defined over fractions\" $ do\n retract @Integer @(Ratio Integer) (1 % 2) `shouldBe` Nothing\n describe \"instance Injection Double (Complex Double)\" $ do\n it \"is resolvable\" (resolveInjection @Double @(Complex Double))\n it \"is injective\" (lawInjective @Double @(Complex Double))\n describe \"instance Retraction Double (Complex Double)\" $ do\n it \"is resolvable\" (resolveRetraction @Double @(Complex Double))\n it \"is the left inverse of inject\" (lawLeftInverse @Double @(Complex Double))\n it \"is defined over real numbers\" $ do\n retract @Double @(Complex Double) (0 :+ 0) `shouldBe` Just 0\n retract @Double @(Complex Double) (1 :+ 0) `shouldBe` Just 1\n retract @Double @(Complex Double) ((-1) :+ 0) `shouldBe` Just (-1)\n it \"is not defined over imaginary and complex numbers\" $ do\n retract @Double @(Complex Double) (0 :+ 1) `shouldBe` Nothing\n retract @Double @(Complex Double) (1 :+ 1) `shouldBe` Nothing\n describe \"instance Injection Integer (Identity Integer)\" $ do\n it \"is resolvable\" (resolveInjection @Integer @(Identity Integer))\n it \"is injective\" (lawInjective @Integer @(Identity Integer))\n describe \"instance Injection (Identity Integer) Integer\" $ do\n it \"is resolvable\" (resolveInjection @(Identity Integer) @Integer)\n it \"is injective\" (lawInjective @(Identity Integer) @Integer)\n describe \"instance Injection (NonEmpty Integer) [Integer]\" $ do\n it \"is resolvable\" (resolveInjection @(NonEmpty Integer) @[Integer])\n it \"is injective\" (lawInjective @(NonEmpty Integer) @[Integer])\n describe \"instance Retraction (NonEmpty Integer) [Integer]\" $ do\n it \"is resolvable\" (resolveRetraction @(NonEmpty Integer) @[Integer])\n it \"is the left inverse of inject\" (lawLeftInverse @(NonEmpty Integer) @[Integer])\n it \"is not defined on the empty list\" $ do\n retract @(NonEmpty Integer) @[Integer] [] `shouldBe` Nothing\n it \"is defined over non-empty lists\" $ do\n retract @(NonEmpty Integer) @[Integer] [0] `shouldBe` Just (0 :| [])\n retract @(NonEmpty Integer) @[Integer] [0, 1] `shouldBe` Just (0 :| [1])\n describe \"instance Injection Integer (Down Integer)\" $ do\n it \"is resolvable\" (resolveInjection @Integer @(Down Integer))\n it \"is injective\" (lawInjective @Integer @(Down Integer))\n describe \"instance Injection (Down Integer) Integer\" $ do\n it \"is resolvable\" (resolveInjection @(Down Integer) @Integer)\n it \"is injective\" (lawInjective @(Down Integer) @Integer)\n describe \"instance Injection Integer (Product Integer)\" $ do\n it \"is resolvable\" (resolveInjection @Integer @(Product Integer))\n it \"is injective\" (lawInjective @Integer @(Product Integer))\n describe \"instance Injection (Product Integer) Integer\" $ do\n it \"is resolvable\" (resolveInjection @(Product Integer) @Integer)\n it \"is injective\" (lawInjective @(Product Integer) @Integer)\n describe \"instance Injection Integer (Sum Integer)\" $ do\n it \"is resolvable\" (resolveInjection @Integer @(Sum Integer))\n it \"is injective\" (lawInjective @Integer @(Sum Integer))\n describe \"instance Injection (Sum Integer) Integer\" $ do\n it \"is resolvable\" (resolveInjection @(Sum Integer) @Integer)\n it \"is injective\" (lawInjective @(Sum Integer) @Integer)\n describe \"instance Injection Integer (Dual Integer)\" $ do\n it \"is resolvable\" (resolveInjection @Integer @(Dual Integer))\n it \"is injective\" (lawInjective @Integer @(Dual Integer))\n describe \"instance Injection (Dual Integer) Integer\" $ do\n it \"is resolvable\" (resolveInjection @(Dual Integer) @Integer)\n it \"is injective\" (lawInjective @(Dual Integer) @Integer)\n describe \"instance Injection Integer (Monoid.Last Integer)\" $ do\n it \"is resolvable\" (resolveInjection @Integer @(Monoid.Last Integer))\n it \"is injective\" (lawInjective @Integer @(Monoid.Last Integer))\n describe \"instance Retraction Injection (Monoid.Last Integer)\" $ do\n it \"is resolvable\" (resolveRetraction @Integer @(Monoid.Last Integer))\n it \"is the left inverse of inject\" (lawLeftInverse @Integer @(Monoid.Last Integer))\n it \"is not defined over mempty\" $ do\n retract @Integer @(Monoid.Last Integer) mempty `shouldBe` Nothing\n describe \"instance Injection Integer (Monoid.First Integer)\" $ do\n it \"is resolvable\" (resolveInjection @Integer @(Monoid.First Integer))\n it \"is injective\" (lawInjective @Integer @(Monoid.First Integer))\n describe \"instance Retraction Injection (Monoid.First Integer)\" $ do\n it \"is resolvable\" (resolveRetraction @Integer @(Monoid.First Integer))\n it \"is the left inverse of inject\" (lawLeftInverse @Integer @(Monoid.First Integer))\n it \"is not defined over mempty\" $ do\n retract @Integer @(Monoid.First Integer) mempty `shouldBe` Nothing\n describe \"instance Injection Integer (Semigroup.First Integer)\" $ do\n it \"is resolvable\" (resolveInjection @Integer @(Semigroup.First Integer))\n it \"is injective\" (lawInjective @Integer @(Semigroup.First Integer))\n describe \"instance Injection (Semigroup.First Integer) Integer\" $ do\n it \"is resolvable\" (resolveInjection @(Semigroup.First Integer) @Integer)\n it \"is injective\" (lawInjective @(Semigroup.First Integer) @Integer)\n describe \"instance Injection Integer (Semigroup.Last Integer)\" $ do\n it \"is resolvable\" (resolveInjection @Integer @(Semigroup.Last Integer))\n it \"is injective\" (lawInjective @Integer @(Semigroup.Last Integer))\n describe \"instance Injection (Semigroup.Last Integer) Integer\" $ do\n it \"is resolvable\" (resolveInjection @(Semigroup.Last Integer) @Integer)\n it \"is injective\" (lawInjective @(Semigroup.Last Integer) @Integer)\n describe \"instance Injection Integer (Max Integer)\" $ do\n it \"is resolvable\" (resolveInjection @Integer @(Max Integer))\n it \"is injective\" (lawInjective @Integer @(Max Integer))\n describe \"instance Injection (Max Integer) Integer\" $ do\n it \"is resolvable\" (resolveInjection @(Max Integer) @Integer)\n it \"is injective\" (lawInjective @(Max Integer) @Integer)\n describe \"instance Injection Integer (Min Integer)\" $ do\n it \"is resolvable\" (resolveInjection @Integer @(Min Integer))\n it \"is injective\" (lawInjective @Integer @(Min Integer))\n describe \"instance Injection (Min Integer) Integer\" $ do\n it \"is resolvable\" (resolveInjection @(Min Integer) @Integer)\n it \"is injective\" (lawInjective @(Min Integer) @Integer)\n describe \"instance Injection Integer (String -> Integer)\" $ do\n it \"is resolvable\" (resolveInjection @Integer @(String -> Integer))\n describe \"instance Injection Bool Any\" $ do\n it \"is resolvable\" (resolveInjection @Bool @Any)\n it \"is injective\" (lawInjective @Bool @Any)\n describe \"instance Injection Any Bool\" $ do\n it \"is resolvable\" (resolveInjection @Any @Bool)\n it \"is injective\" (lawInjective @Any @Bool)\n describe \"instance Injection Bool All\" $ do\n it \"is resolvable\" (resolveInjection @Bool @All)\n it \"is injective\" (lawInjective @Bool @All)\n describe \"instance Injection All Bool\" $ do\n it \"is resolvable\" (resolveInjection @All @Bool)\n it \"is injective\" (lawInjective @All @Bool)\n describe \"instance Projection Integer Integer\" $ do\n it \"is resolvable\" (resolveProjection @Integer @Integer)\n it \"is surjective\" (lawSurjective @Integer @Integer id)\n describe \"instance Section Integer Integer\" $ do\n it \"is resolvable\" (resolveSection @Integer @Integer)\n it \"is the right inverse of project\" (lawRightInverse @Integer @Integer)\n describe \"instance Projection [(Integer, Integer)] (Map Integer Integer)\" $ do\n it \"is resolvable\" (resolveProjection @[(Integer, Integer)] @(Map Integer Integer))\n it \"is surjective\" (lawSurjective @[(Integer, Integer)] @(Map Integer Integer) Map.toList)\n describe \"instance Projection [Integer] (Set Integer)\" $ do\n it \"is resolvable\" (resolveProjection @[Integer] @(Set Integer))\n it \"is surjective\" (lawSurjective @[Integer] @(Set Integer) Set.toList)\n\nresolveInjection :: forall from into. Injection from into => Expectation\nresolveInjection = seq (inject @from @into) return ()\n\nresolveRetraction :: forall from into. Retraction from into => Expectation\nresolveRetraction = seq (retract @from @into) return ()\n\nresolveProjection :: forall whole part. Projection whole part => Expectation\nresolveProjection = seq (project @whole @part) return ()\n\nresolveSection :: forall whole part. Section whole part => Expectation\nresolveSection = seq (update @whole @part) return ()\n\nlawInjective\n :: forall from into\n . Injection from into\n => Arbitrary from\n => (Eq from, Show from)\n => (Eq into, Show into)\n => Property\nlawInjective = property $ \\from1 from2 ->\n let into1 = inject @from @into from1\n into2 = inject @from @into from2\n in (from1 /= from2) ==> (into1 =/= into2)\n\nlawLeftInverse\n :: forall from into\n . Retraction from into\n => Arbitrary from\n => (Eq from, Show from)\n => Property\nlawLeftInverse = property $ \\from ->\n let into = inject @from @into from\n from' = retract @from @into into\n in Just from === from'\n\nlawSurjective\n :: forall whole part\n . Projection whole part\n => Arbitrary part\n => (Eq part, Show part)\n => (part -> whole) -- ^ any total right inverse of @project@\n -> Property\nlawSurjective rightInverse = property $ \\part ->\n -- This test actually proves nothing: that a right inverse of 'project'\n -- merely exists proves that it is surjective. Here, we are just probing the\n -- putative right inverse.\n project (rightInverse part) === part\n\nlawRightInverse\n :: forall whole part\n . Section whole part\n => Arbitrary whole\n => Show whole\n => Arbitrary part\n => (Eq part, Show part)\n => Property\nlawRightInverse = property $ \\part whole ->\n project @whole @part (update whole part) === part\n\ninstance Arbitrary a => Arbitrary (Down a) where\n arbitrary = Down <$> arbitrary\n", "meta": {"hexsha": "df6103c6967a84b3d3b6fc247fbd8005cb8696a2", "size": 16106, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "test/Spec.hs", "max_stars_repo_name": "ttuegel/injection", "max_stars_repo_head_hexsha": "e5741923a59c6e762ca776569a3008a13892f06e", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "test/Spec.hs", "max_issues_repo_name": "ttuegel/injection", "max_issues_repo_head_hexsha": "e5741923a59c6e762ca776569a3008a13892f06e", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "test/Spec.hs", "max_forks_repo_name": "ttuegel/injection", "max_forks_repo_head_hexsha": "e5741923a59c6e762ca776569a3008a13892f06e", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 54.0469798658, "max_line_length": 98, "alphanum_fraction": 0.6737861666, "num_tokens": 3946, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6477982043529716, "lm_q2_score": 0.48438008427698437, "lm_q1q2_score": 0.31378054881897155}} {"text": "{-# LANGUAGE FlexibleContexts #-}\n{-# LANGUAGE FlexibleInstances #-}\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE TypeSynonymInstances #-}\n\n-- |\n-- Module : Spiral.Util.Pretty.Maple\n-- Copyright : (c) 2017-2020 Drexel University\n-- License : BSD-style\n-- Maintainer : mainland@drexel.edu\n\nmodule Spiral.Util.Pretty.Maple (\n Pretty(..)\n ) where\n\nimport Data.Ratio\nimport Data.Complex (Complex(..))\nimport Data.Monoid ((<>))\nimport Data.Set (Set)\nimport qualified Data.Set as Set\nimport qualified Data.Vector as V\nimport Text.PrettyPrint.Mainland\nimport qualified Text.PrettyPrint.Mainland.Class as Pretty\n\nimport Spiral.Array\nimport Spiral.Exp\nimport Spiral.SPL\nimport Spiral.Util.Pretty (Assoc(..),\n Fixity(..),\n HasFixity(..),\n addPrec,\n mulPrec,\n mulPrec1,\n infixl_,\n precOf)\n\nclass Pretty a where\n {-# MINIMAL pprPrec | ppr #-}\n ppr :: a -> Doc\n pprPrec :: Int -> a -> Doc\n\n pprList :: [a] -> Doc\n pprPrecList :: Int -> [a] -> Doc\n\n ppr = pprPrec 0\n pprPrec _ = ppr\n\n pprPrecList _ = pprList\n pprList xs = list (map ppr xs)\n\ninstance Pretty a => Pretty [a] where\n ppr = pprList\n pprPrec = pprPrecList\n\ninstance Pretty Bool where\n ppr True = text \"true\"\n ppr False = text \"false\"\n\ninstance Pretty Char where\n ppr = char\n\ninstance Pretty Int where\n ppr = int\n\ninstance Pretty Integer where\n ppr = integer\n\npprRealFrac :: (RealFrac a, Pretty.Pretty a) => a -> Doc\npprRealFrac x\n | isIntegral = Pretty.ppr (ceiling x :: Integer)\n | otherwise = Pretty.ppr x\n where\n x' :: Integer\n x' = ceiling x\n\n isIntegral :: Bool\n isIntegral = fromIntegral x' == x\n\ninstance Pretty Float where\n ppr = pprRealFrac\n\ninstance Pretty Double where\n ppr = pprRealFrac\n\ninstance Pretty a => Pretty (Ratio a) where\n ppr x = text \"Fraction\" <> parens (commasep [ppr (numerator x), ppr (denominator x)])\n\ninstance Pretty a => Pretty (Set a) where\n ppr xs = enclosesep lbrace rbrace comma (map ppr (Set.toList xs))\n\ninstance (Pretty e, IArray r DIM2 e) => Pretty (Matrix r e) where\n ppr m = text \"Matrix\" <> (parens . ppr . toLists) m\n\ninstance Pretty (Const a) where\n pprPrec _ (BoolC x) = ppr x\n pprPrec _ (IntC x) = ppr x\n pprPrec _ (IntegerC x) = ppr x\n pprPrec _ (FloatC x) = ppr x\n pprPrec _ (DoubleC x) = ppr x\n pprPrec _ (RationalC x) = ppr x\n\n pprPrec _ (ComplexC r i)\n | r == 0 && i == 0 = char '0'\n | r == 0 && i == 1 = char 'I'\n | r == 0 && i == (-1) = text \"-I\"\n | r == 0 = ppr i <> char '*' <> char 'I'\n | i == 0 = ppr r\n | otherwise = text \"Complex\" <> pprArgs [ppr r, ppr i]\n\n pprPrec _ (W _ 0 _) = text \"1\"\n pprPrec _ (W n 1 _) = text \"w_\" <> Pretty.ppr n\n pprPrec _ (W n k _) = text \"w_\" <> Pretty.ppr n <> char '^' <> Pretty.ppr k\n\n pprPrec p (CycC x) = text (showsPrec p x \"\")\n\n pprPrec p (PiC x) = parensIf (p > mulPrec) $\n Pretty.pprPrec mulPrec1 x <> char '*' <> text \"Pi\"\n\n pprPrec p (ModularC x) = Pretty.pprPrec p x\n\ninstance Pretty Var where\n ppr = Pretty.ppr\n\ninstance Pretty (Exp a) where\n pprPrec p (ConstE c) = pprPrec p c\n pprPrec p (VarE v) = pprPrec p v\n\n pprPrec p (UnopE op@Neg e) =\n unop p op e\n\n pprPrec _ (UnopE op e) =\n Pretty.ppr op <> parens (Pretty.ppr e)\n\n pprPrec _ (BinopE Quot e1 e2) =\n text \"iquo\" <> pprArgs [ppr e1, ppr e2]\n\n pprPrec _ (BinopE Rem e1 e2) =\n text \"irem\" <> pprArgs [ppr e1, ppr e2]\n\n pprPrec p (BinopE op e1 e2) =\n infixop p op e1 e2\n\n pprPrec _ (IdxE ev eis) =\n ppr ev <> (brackets . commasep) [ppr (ix+1) | ix <- eis]\n\n pprPrec p (ComplexE er ei) =\n parensIf (p > addPrec) $\n pprComplex (er :+ ei)\n\n pprPrec _ (ReE e) =\n text \"Re\" <> parens (ppr e)\n\n pprPrec _ (ImE e) =\n text \"Im\" <> parens (ppr e)\n\n pprPrec p (BBinopE op e1 e2) =\n infixop p op e1 e2\n\n pprPrec _ (IfE e1 e2 e3) =\n text \"if\" <+> ppr e1 <+>\n text \"then\" <+> ppr e2 <+>\n text \"else\" <+> ppr e3 <+>\n text \"end if\"\n\ninstance Pretty Unop where\n ppr Neg = char '-'\n ppr Abs = text \"abs\"\n ppr Signum = text \"signum\"\n ppr Exp = text \"exp\"\n ppr Log = text \"log\"\n ppr Sqrt = text \"sqrt\"\n ppr Sin = text \"sin\"\n ppr Cos = text \"cos\"\n ppr Asin = text \"asin\"\n ppr Acos = text \"acos\"\n ppr Atan = text \"atan\"\n ppr Sinh = text \"sinh\"\n ppr Cosh = text \"cosh\"\n ppr Asinh = text \"asinh\"\n ppr Acosh = text \"acosh\"\n ppr Atanh = text \"atanh\"\n\ninstance Pretty Binop where\n ppr Add = char '+'\n ppr Sub = char '-'\n ppr Mul = char '*'\n ppr Quot = text \"`quot`\"\n ppr Rem = text \"`rem`\"\n ppr Div = text \"`div`\"\n ppr Mod = text \"`mod`\"\n ppr FDiv = char '/'\n\ninstance Pretty BBinop where\n ppr Eq = text \"=\"\n ppr Ne = text \"<>\"\n ppr Lt = text \"<\"\n ppr Le = text \"<=\"\n ppr Ge = text \">=\"\n ppr Gt = text \">\"\n\ninstance (Num e, Pretty e) => Pretty (SPL e) where\n pprPrec _ (I n) = text \"IdentityMatrix\" <> parens (ppr n)\n pprPrec _ (Diag xs) = text \"DiagonalMatrix\" <> parens (list (map ppr (V.toList xs)))\n pprPrec _ (Kron a b) = text \"KroneckerProduct\" <> pprArgs [ppr a, ppr b]\n pprPrec _ (DSum a b) = text \"DiagonalMatrix\" <> parens (list [ppr a, ppr b])\n pprPrec p (Prod a b) = infixop p POp a b\n --pprPrec _ (Prod a b) = text \"MatrixMatrixMultiply\" <> pprArgs [ppr a, ppr b]\n pprPrec p m = pprPrec p (toMatrix m)\n\ndata MatrixBinop = POp\n deriving (Eq, Ord, Show)\n\ninstance HasFixity MatrixBinop where\n fixity POp = infixl_ 7\n\ninstance Pretty MatrixBinop where\n ppr POp = char '.'\n\npprArgs :: [Doc] -> Doc\npprArgs = parens . commasep\n\npprComplex :: (Eq a, Num a, Pretty a) => Complex a -> Doc\npprComplex (r :+ 0) = ppr r\npprComplex (0 :+ i) = ppr i <> char '*' <> char 'I'\npprComplex (r :+ i) = ppr r <+> char '+' <+> ppr i <> char '*' <> char 'I'\n\nunop :: (Pretty a, Pretty op, HasFixity op)\n => Int -- ^ precedence of context\n -> op -- ^ operator\n -> a\n -> Doc\nunop prec op x =\n parensIf (prec > precOf op) $\n ppr op <> pprPrec (precOf op) x\n\ninfixop :: (Pretty a, Pretty b, Pretty op, HasFixity op)\n => Int -- ^ precedence of context\n -> op -- ^ operator\n -> a -- ^ left argument\n -> b -- ^ right argument\n -> Doc\ninfixop prec op l r =\n parensIf (prec > opPrec) $\n pprPrec leftPrec l <+> ppr op <+/> pprPrec rightPrec r\n where\n leftPrec | opAssoc == RightAssoc = opPrec + 1\n | otherwise = opPrec\n\n rightPrec | opAssoc == LeftAssoc = opPrec + 1\n | otherwise = opPrec\n\n Fixity opAssoc opPrec = fixity op\n", "meta": {"hexsha": "a66da4a64f12cd57516bba9d88cbd711bbd96f75", "size": 6996, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "Spiral/Util/Pretty/Maple.hs", "max_stars_repo_name": "mainland/hspiral", "max_stars_repo_head_hexsha": "16cc5b9732286de38b89d1a983e64d23646a05d3", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 7, "max_stars_repo_stars_event_min_datetime": "2017-05-21T21:29:06.000Z", "max_stars_repo_stars_event_max_datetime": "2021-03-28T04:48:25.000Z", "max_issues_repo_path": "Spiral/Util/Pretty/Maple.hs", "max_issues_repo_name": "mainland/hspiral", "max_issues_repo_head_hexsha": "16cc5b9732286de38b89d1a983e64d23646a05d3", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Spiral/Util/Pretty/Maple.hs", "max_forks_repo_name": "mainland/hspiral", "max_forks_repo_head_hexsha": "16cc5b9732286de38b89d1a983e64d23646a05d3", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 27.652173913, "max_line_length": 89, "alphanum_fraction": 0.5537449971, "num_tokens": 2338, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.5428632831725051, "lm_q2_score": 0.5774953651858118, "lm_q1q2_score": 0.3135010299616746}} {"text": "{-# LANGUAGE BangPatterns #-}\n\nimport Gauge.Main (defaultMain, bench, whnf)\n\nimport Data.List (unfoldr)\nimport Data.Maybe (fromJust)\nimport Data.Primitive.Contiguous (PrimArray, fromListN)\nimport Statistics.Array.Types (AscList)\nimport System.Random (random, mkStdGen)\n\nimport qualified Statistics.Array as Stats\nimport qualified Statistics.Array.Types as Asc\n\nmain :: IO ()\nmain = defaultMain\n [ bench \"sort-16\" $ whnf (fromJust . Asc.fromArray) input16\n , bench \"sort-128\" $ whnf (fromJust . Asc.fromArray) input128\n , bench \"sort-1024\" $ whnf (fromJust . Asc.fromArray) input1024\n , bench \"sort-65536\" $ whnf (fromJust . Asc.fromArray) input65536\n , bench \"list-derivative\" $ whnf Stats.listDerivative asc1024\n , bench \"median-of-absolute-deviations\" $ whnf Stats.mad asc1024\n ]\n where\n input16, input128, input1024, input65536 :: PrimArray Int\n !input16 = fromListN 16 $ take 16 . drop 0 $ inputInf\n !input128 = fromListN 128 $ take 128 . drop 16 $ inputInf\n !input1024 = fromListN 1024 $ take 1024 . drop (16+128) $ inputInf\n !input65536 = fromListN 65536 $ take 65536 . drop (16+128+1024) $ inputInf\n asc1024 :: AscList PrimArray Int\n asc1024 = fromJust $ Asc.fromArray input1024\n\ninputInf :: [Int]\ninputInf = unfoldr (Just . random) seed\n where\n seed = mkStdGen 1234567\n", "meta": {"hexsha": "eddc7f86c2119d4eac1081cf4e3eb6c3ba7bd56f", "size": 1294, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "bench/Main.hs", "max_stars_repo_name": "andrewthad/array-statistics", "max_stars_repo_head_hexsha": "1ec543d46acf0995a40e37db83c79f03b37967fc", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "bench/Main.hs", "max_issues_repo_name": "andrewthad/array-statistics", "max_issues_repo_head_hexsha": "1ec543d46acf0995a40e37db83c79f03b37967fc", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "bench/Main.hs", "max_forks_repo_name": "andrewthad/array-statistics", "max_forks_repo_head_hexsha": "1ec543d46acf0995a40e37db83c79f03b37967fc", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 35.9444444444, "max_line_length": 76, "alphanum_fraction": 0.7295208655, "num_tokens": 405, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.5774953506426082, "lm_q2_score": 0.5428632831725052, "lm_q1q2_score": 0.3135010220667034}} {"text": "{-# LANGUAGE ScopedTypeVariables #-}\n{-# LANGUAGE OverloadedStrings #-}\n{-# LANGUAGE TypeApplications #-}\n{-# LANGUAGE TypeOperators #-}\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE DataKinds #-}\n{-# LANGUAGE KindSignatures #-}\n{-# LANGUAGE ConstraintKinds #-}\n{-# LANGUAGE LambdaCase #-}\n{-# LANGUAGE FlexibleContexts #-}\n{-# LANGUAGE AllowAmbiguousTypes #-}\n{-# Language QuasiQuotes #-}\n\nmodule MLP.App (\n runInIO,\n run,\n train,\n) where\n\nimport MLP.Types\n ( curEpoch,\n curError,\n dataSet,\n epochs,\n hiddenLayers,\n learningRate,\n minErrorRate,\n network,\n numInputs,\n numOutputs,\n params,\n runApp,\n topology,\n testSet,\n trainSet,\n App,\n MonadFileSystem(printText),\n Parameters,\n Pattern(Pattern),\n State(State) )\nimport MLP.Config (readConf, mkDataSet)\nimport MLP.Network (AllCon, ArrList, Learn(..), Net, MLP(..), NetInstance, arrLast)\nimport Numeric.LinearAlgebra.Static (R)\nimport Control.Lens (view, use, (+=), (^.), (.=))\nimport Control.Monad (when, forM_, forM)\nimport qualified Data.Vector.Storable as V (snoc, sum)\nimport Control.Monad.Writer.Class (tell)\nimport PyF (fmt)\nimport qualified Data.Text.Lazy as TL\nimport Control.Monad.Random.Class ( MonadRandom )\nimport Data.Singletons ( withSomeSing )\nimport Data.Singletons.Prelude.Tuple ()\nimport Data.Singletons.Prelude.List ()\nimport Fcf ()\nimport Fcf.Data.List ()\nimport Data.Singletons.TypeLits ( KnownNat, Nat, SNat(..) )\nimport Data.Constraint ( Dict(..) )\nimport Numeric.Natural ()\nimport Data.Maybe ( fromJust )\nimport MLP.NatList ( List(List), SNatList(..) )\n\ntype NetConstraints (i :: Nat) (hs :: [Nat]) (o :: Nat) =\n (AllCon KnownNat (i ': o ': hs), AllCon KnownNat (Topo (Net i hs o)), Learn (Net i hs o))\n\nnetDict :: forall (i :: Nat) (o :: Nat) (hs :: [Nat]). (AllCon KnownNat (i ': o ': hs)) =>\n SNatList ('List hs) -> \n Dict (NetConstraints i hs o)\nnetDict =\n \\case\n SNatNil -> Dict\n SNatCons _ SNatNil -> Dict\n SNatCons _ (SNatCons _ SNatNil) -> Dict\n SNatCons _ (SNatCons _ (SNatCons _ SNatNil)) -> Dict\n\n\nrunInIO :: FilePath -> IO ()\nrunInIO fl = do\n conf <- readConf fl\n let i = conf ^. topology.numInputs\n hs = conf ^. topology.hiddenLayers\n o = conf ^. topology.numOutputs\n\n withSomeSing i $ \\(SNat :: SNat i) ->\n withSomeSing o $ \\(SNat :: SNat o) ->\n withSomeSing (List (0:hs)) $\n \\case \n (SNatCons _ snatlist) -> \n case netDict @i @o snatlist of\n (Dict :: Dict (NetConstraints i hs o)) -> run @i @hs @o @IO conf\n\nrun :: forall i hs o m. (NetConstraints i hs o, MonadFileSystem m, MonadRandom m) => Parameters -> m ()\nrun conf = do\n dt <- mkDataSet @i @o conf\n net <- create @(Net i hs o)\n\n let st = State dt conf net 0 0\n ((a, st'),log) = runApp train st\n\n mapM_ printText log\n\ntrainOnSet :: forall i o hs. NetConstraints i hs o => App i hs o Double\ntrainOnSet = do\n trainset <- use (dataSet.trainSet)\n lr <- use (params.learningRate)\n\n errorRates <- forM trainset $ \\(Pattern i o) -> do\n net <- use network\n\n let outs = netOut i net\n deltas = mkDeltas outs o net\n actOut = fromJust $ arrLast @o outs\n err = netError @(Net i hs o) actOut o\n \n network .= newNet lr i deltas outs net\n\n -- tell [fmt| \\n ==> Pattern Error {err:.4f} \\n |]\n -- tell [fmt| \\n ==> Deltas {deltas:s} \\n |]\n -- tell [fmt| \\n ==> Expected Output {o:s} \\n |]\n -- tell [fmt| \\n ==> Actual Output {actOut:s} \\n |]\n -- tell [fmt| \\n Network Dump \\n {net:s} \\n|]\n\n return err\n\n let totalErr = sum errorRates / fromIntegral (length trainset)\n\n tell [[fmt| \\n ==> Epoch Train Error {totalErr:f} \\n |]]\n\n return totalErr\n\nevaluateOnSet :: forall i o hs. NetConstraints i hs o => App i hs o Double\nevaluateOnSet = do\n testset <- use (dataSet.testSet)\n net <- use network\n\n errorRates <- forM testset $ \\(Pattern i o) -> do\n\n let outs = netOut i net\n deltas = mkDeltas outs o net\n actOut = fromJust $ arrLast @o outs\n err = netError @(Net i hs o) actOut o\n\n return err\n\n let totalErr = sum errorRates / fromIntegral (length testset)\n curError .= totalErr\n\n tell [[fmt| \\n ==> Epoch Test Error {totalErr:f} \\n |]]\n\n return totalErr\n\nloop :: App i hs o () -> App i hs o ()\nloop trainAction = do\n epochTotal <- use (params.epochs)\n epochNow <- use curEpoch\n\n when (epochNow < epochTotal) $ do\n trainAction\n\n curError <- use curError\n minError <- use (params.minErrorRate)\n\n when (curError > minError) $ do\n loop trainAction\n\ntrain :: NetConstraints i hs o => App i hs o ()\ntrain = do\n tell [\"Starting Training process...\\n\"]\n\n loop $ do\n epoch <- use curEpoch\n\n tell [[fmt| \\n ==> Epoch {epoch:d} \\n |]]\n \n trainOnSet\n evaluateOnSet\n\n\n curEpoch += 1", "meta": {"hexsha": "041677e9cc0f2f95307ff7b21e70df1b313e361f", "size": 4953, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/MLP/App.hs", "max_stars_repo_name": "ovanr/Typed-MLP", "max_stars_repo_head_hexsha": "c6cf0d5295048f0aa4bfe9b4628ccb59cb92b80c", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/MLP/App.hs", "max_issues_repo_name": "ovanr/Typed-MLP", "max_issues_repo_head_hexsha": "c6cf0d5295048f0aa4bfe9b4628ccb59cb92b80c", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/MLP/App.hs", "max_forks_repo_name": "ovanr/Typed-MLP", "max_forks_repo_head_hexsha": "c6cf0d5295048f0aa4bfe9b4628ccb59cb92b80c", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 27.8258426966, "max_line_length": 103, "alphanum_fraction": 0.6046840299, "num_tokens": 1377, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.7461389930307512, "lm_q2_score": 0.41869690935568665, "lm_q1q2_score": 0.3124060903317397}} {"text": "{-# LANGUAGE ForeignFunctionInterface #-}\n{-# LANGUAGE GADTs #-}\nmodule Grenade.Layers.Internal.Update (\n descendMatrix\n , descendVector\n , MatrixInputValues (..)\n , MatrixResult (..)\n , VectorInputValues (..)\n , VectorResult (..)\n ) where\n\nimport Data.Maybe (fromJust)\nimport qualified Data.Vector.Storable as U (unsafeFromForeignPtr0,\n unsafeToForeignPtr0)\nimport Foreign (mallocForeignPtrArray, withForeignPtr)\nimport Foreign.Ptr (Ptr)\nimport GHC.TypeLits\nimport Numeric.LinearAlgebra (Vector, flatten)\nimport qualified Numeric.LinearAlgebra.Devel as U\nimport Numeric.LinearAlgebra.Static\nimport System.IO.Unsafe (unsafePerformIO)\n\nimport Grenade.Core.Optimizer\nimport Grenade.Types\n\ndata MatrixInputValues rows columns\n = MatrixValuesSGD\n !(L rows columns) -- ^ current weights\n !(L rows columns) -- ^ gradients\n !(L rows columns) -- ^ last update (old momentum)\n | MatrixValuesAdam\n !Int -- ^ Step\n !(L rows columns) -- ^ current weights\n !(L rows columns) -- ^ gradients\n !(L rows columns) -- ^ current m\n !(L rows columns) -- ^ current v\n\n\ndata MatrixResult rows columns\n = MatrixResultSGD\n { matrixActivations :: !(L rows columns) -- ^ new activations (weights)\n , matrixMomentum :: !(L rows columns) -- ^ new momentum\n }\n | MatrixResultAdam\n { matrixActivations :: !(L rows columns) -- ^ new activations (weights)\n , matrixM :: !(L rows columns) -- ^ new m\n , matrixV :: !(L rows columns) -- ^ new v\n }\n\ndata VectorInputValues r\n = VectorValuesSGD\n !(R r) -- ^ current weights\n !(R r) -- ^ gradients\n !(R r) -- ^ last update (old momentum)\n | VectorValuesAdam\n !Int -- ^ Step\n !(R r) -- ^ current weights\n !(R r) -- ^ current gradients\n !(R r) -- ^ current m\n !(R r) -- ^ current v\n\ndata VectorResult r\n = VectorResultSGD\n { vectorBias :: !(R r) -- ^ new activations (bias)\n , vectorMomentum :: !(R r) -- ^ new momentum\n }\n | VectorResultAdam\n { vectorBias :: !(R r) -- ^ new activations (bias)\n , vectorM :: !(R r) -- ^ new m\n , vectorV :: !(R r) -- ^ new v\n }\n\ndescendMatrix :: (KnownNat rows, KnownNat columns) => Optimizer o -> MatrixInputValues rows columns -> MatrixResult rows columns\ndescendMatrix (OptSGD rate momentum regulariser) (MatrixValuesSGD weights gradient lastUpdate) =\n let (rows, cols) = size weights\n len = rows * cols\n -- Most gradients come in in ColumnMajor,\n -- so we'll transpose here before flattening them\n -- into a vector to prevent a copy.\n --\n -- This gives ~15% speed improvement for LSTMs.\n weights' = flatten . tr . extract $ weights\n gradient' = flatten . tr . extract $ gradient\n lastUpdate' = flatten . tr . extract $ lastUpdate\n (vw, vm) = descendUnsafeSGD len rate momentum regulariser weights' gradient' lastUpdate'\n\n -- Note that it's ColumnMajor, as we did a transpose before\n -- using the internal vectors.\n mw = U.matrixFromVector U.ColumnMajor rows cols vw\n mm = U.matrixFromVector U.ColumnMajor rows cols vm\n in MatrixResultSGD (fromJust . create $ mw) (fromJust . create $ mm)\ndescendMatrix (OptAdam alpha beta1 beta2 epsilon lambda) (MatrixValuesAdam step weights gradient m v) =\n let (rows, cols) = size weights\n len = rows * cols\n -- Most gradients come in in ColumnMajor,\n -- so we'll transpose here before flattening them\n -- into a vector to prevent a copy.\n --\n -- This gives ~15% speed improvement for LSTMs.\n weights' = flatten . tr . extract $ weights\n gradient' = flatten . tr . extract $ gradient\n m' = flatten . tr . extract $ m\n v' = flatten . tr . extract $ v\n (vw, vm, vv) = descendUnsafeAdam len step alpha beta1 beta2 epsilon lambda weights' gradient' m' v'\n\n -- Note that it's ColumnMajor, as we did a transpose before\n -- using the internal vectors.\n mw = U.matrixFromVector U.ColumnMajor rows cols vw\n mm = U.matrixFromVector U.ColumnMajor rows cols vm\n mv = U.matrixFromVector U.ColumnMajor rows cols vv\n in MatrixResultAdam (fromJust . create $ mw) (fromJust . create $ mm) (fromJust . create $ mv)\ndescendMatrix opt _ = error $ \"optimzer does not match to MatrixInputValues in implementation! Optimizer: \" ++ show opt\n\ndescendVector :: (KnownNat r) => Optimizer o -> VectorInputValues r -> VectorResult r\ndescendVector (OptSGD rate momentum regulariser) (VectorValuesSGD weights gradient lastUpdate) =\n let len = size weights\n weights' = extract weights\n gradient' = extract gradient\n lastUpdate' = extract lastUpdate\n (vw, vm) = descendUnsafeSGD len rate momentum regulariser weights' gradient' lastUpdate'\n in VectorResultSGD (fromJust $ create vw) (fromJust $ create vm)\ndescendVector (OptAdam alpha beta1 beta2 epsilon lambda) (VectorValuesAdam step weights gradient m v) =\n let len = size weights\n weights' = extract weights\n gradient' = extract gradient\n m' = extract m\n v' = extract v\n (vw, vm, vv) = descendUnsafeAdam len step alpha beta1 beta2 epsilon lambda weights' gradient' m' v'\n in VectorResultAdam (fromJust $ create vw) (fromJust $ create vm) (fromJust $ create vv)\ndescendVector opt _ = error $ \"optimzer does not match to VectorInputValues in implementation! Optimizer: \" ++ show opt\n\ndescendUnsafeSGD :: Int -> RealNum -> RealNum -> RealNum -> Vector RealNum -> Vector RealNum -> Vector RealNum -> (Vector RealNum, Vector RealNum)\ndescendUnsafeSGD len rate momentum regulariser weights gradient lastUpdate =\n unsafePerformIO $ do\n outWPtr <- mallocForeignPtrArray len\n outMPtr <- mallocForeignPtrArray len\n let (wPtr, _) = U.unsafeToForeignPtr0 weights\n let (gPtr, _) = U.unsafeToForeignPtr0 gradient\n let (lPtr, _) = U.unsafeToForeignPtr0 lastUpdate\n\n withForeignPtr wPtr $ \\wPtr' ->\n withForeignPtr gPtr $ \\gPtr' ->\n withForeignPtr lPtr $ \\lPtr' ->\n withForeignPtr outWPtr $ \\outWPtr' ->\n withForeignPtr outMPtr $ \\outMPtr' ->\n descend_sgd_cpu len rate momentum regulariser wPtr' gPtr' lPtr' outWPtr' outMPtr'\n\n return (U.unsafeFromForeignPtr0 outWPtr len, U.unsafeFromForeignPtr0 outMPtr len)\n\n\ndescendUnsafeAdam ::\n Int -- Len\n -> Int -- Step\n -> RealNum -- Alpha\n -> RealNum -- Beta1\n -> RealNum -- Beta2\n -> RealNum -- Epsilon\n -> RealNum -- Lambda\n -> Vector RealNum -- Weights\n -> Vector RealNum -- Gradient\n -> Vector RealNum -- M\n -> Vector RealNum -- V\n -> (Vector RealNum, Vector RealNum, Vector RealNum)\ndescendUnsafeAdam len step alpha beta1 beta2 epsilon lambda weights gradient m v =\n unsafePerformIO $ do\n outWPtr <- mallocForeignPtrArray len\n outMPtr <- mallocForeignPtrArray len\n outVPtr <- mallocForeignPtrArray len\n let (wPtr, _) = U.unsafeToForeignPtr0 weights\n let (gPtr, _) = U.unsafeToForeignPtr0 gradient\n let (mPtr, _) = U.unsafeToForeignPtr0 m\n let (vPtr, _) = U.unsafeToForeignPtr0 v\n withForeignPtr wPtr $ \\wPtr' ->\n withForeignPtr gPtr $ \\gPtr' ->\n withForeignPtr mPtr $ \\mPtr' ->\n withForeignPtr vPtr $ \\vPtr' ->\n withForeignPtr outWPtr $ \\outWPtr' ->\n withForeignPtr outMPtr $ \\outMPtr' ->\n withForeignPtr outVPtr $ \\outVPtr' -> descend_adam_cpu len step alpha beta1 beta2 epsilon lambda wPtr' gPtr' mPtr' vPtr' outWPtr' outMPtr' outVPtr'\n return (U.unsafeFromForeignPtr0 outWPtr len, U.unsafeFromForeignPtr0 outMPtr len, U.unsafeFromForeignPtr0 outVPtr len)\n\n\nforeign import ccall unsafe\n descend_sgd_cpu\n :: Int -> RealNum -> RealNum -> RealNum -> Ptr RealNum -> Ptr RealNum -> Ptr RealNum -> Ptr RealNum -> Ptr RealNum -> IO ()\n\nforeign import ccall unsafe\n descend_adam_cpu\n :: Int -> Int -> RealNum -> RealNum -> RealNum -> RealNum -> RealNum -> Ptr RealNum -> Ptr RealNum -> Ptr RealNum -> Ptr RealNum -> Ptr RealNum -> Ptr RealNum -> Ptr RealNum -> IO ()\n\n", "meta": {"hexsha": "fe4ff9efb24a339c80f3dcff65c93d73d8f65b68", "size": 8384, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/Grenade/Layers/Internal/Update.hs", "max_stars_repo_name": "th-char/grenade", "max_stars_repo_head_hexsha": "0be658e7cf07562cd5e4170ed1e8875ccec14cdb", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-06-09T06:06:26.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-09T06:06:26.000Z", "max_issues_repo_path": "src/Grenade/Layers/Internal/Update.hs", "max_issues_repo_name": "th-char/grenade", "max_issues_repo_head_hexsha": "0be658e7cf07562cd5e4170ed1e8875ccec14cdb", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/Grenade/Layers/Internal/Update.hs", "max_forks_repo_name": "th-char/grenade", "max_forks_repo_head_hexsha": "0be658e7cf07562cd5e4170ed1e8875ccec14cdb", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 43.8952879581, "max_line_length": 188, "alphanum_fraction": 0.6371660305, "num_tokens": 2188, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.7520125737597972, "lm_q2_score": 0.41489884579676883, "lm_q1q2_score": 0.31200914887759734}} {"text": "module Statistics.Quantile.Bench where\n\nimport Control.Applicative\n\nimport Criterion\n\nimport Pipes\nimport qualified Pipes.Prelude as P\n\nimport Statistics.Quantile.Types\nimport Statistics.Quantile.Util\n\nimport System.IO\n\ndummy :: Selector IO\ndummy = Selector dummy'\n\ndummy' :: Quantile -> Stream IO -> IO Double\ndummy' _ (Stream src) = do\n runEffect $ src >-> P.map show >-> P.stdoutLn\n pure 0\n\nbenchSelector :: [Int]\n -> String\n -> Quantile\n -> Selector IO\n -> FilePath\n -> Benchmark\nbenchSelector ns name q (Selector select) fp = \n bgroup name $ benchSelector' <$> ns\n where benchSelector' n = bench' n fp (select q)\n\nbenchBufferingSelector :: (Int -> Int)\n -> [Int]\n -> String\n -> Quantile\n -> (Int -> Int -> Selector IO)\n -> FilePath\n -> Benchmark\nbenchBufferingSelector f ns name q select fp = \n bgroup name $ benchSelector' <$> ns\n where benchSelector' n = bench' n fp (select' n q)\n\n select' n = unSelector (select (f n) n)\n\nbench' :: Int -> FilePath -> (Stream IO -> IO Double) -> Benchmark\nbench' n fp f = do\n bench (show n) $ nfIO $ do\n fh <- liftIO $ openFile fp ReadMode\n (f . takeStream n $ streamHandle fh)\n\nbufSize :: (Int -> Int)\n -> Int\n -> Int\nbufSize f n\n | n < 10000 = n\n | otherwise = f n\n\nsqrtN :: Int -> Int\nsqrtN = bufSize (floor . sqrt . fromIntegral)\n\nlogN :: Int -> Int\nlogN = bufSize (floor . logBase 2 . fromIntegral)\n\n", "meta": {"hexsha": "30a63b696f0cee8ce293f6d471b552fc972c2787", "size": 1581, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "2015-08-26-fp-syd-approx-quantiles/approx-quantile/src/Statistics/Quantile/Bench.hs", "max_stars_repo_name": "fractalcat/slides", "max_stars_repo_head_hexsha": "338db16c6998dc4add9d1ebd511b3faf3a4420dc", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "2015-08-26-fp-syd-approx-quantiles/approx-quantile/src/Statistics/Quantile/Bench.hs", "max_issues_repo_name": "fractalcat/slides", "max_issues_repo_head_hexsha": "338db16c6998dc4add9d1ebd511b3faf3a4420dc", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "2015-08-26-fp-syd-approx-quantiles/approx-quantile/src/Statistics/Quantile/Bench.hs", "max_forks_repo_name": "fractalcat/slides", "max_forks_repo_head_hexsha": "338db16c6998dc4add9d1ebd511b3faf3a4420dc", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 24.3230769231, "max_line_length": 66, "alphanum_fraction": 0.5743200506, "num_tokens": 405, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.6001883592602049, "lm_q2_score": 0.5195213219520929, "lm_q1q2_score": 0.3118106498231193}} {"text": "\n\nmodule Numerical.HBLAS.Lapack.FFI where\nimport Foreign.Ptr\nimport Foreign()\nimport Foreign.C.Types\nimport Data.Complex\nimport Data.Int\n\n\n\n{-\n\nstylenote: we will not use the LAPACKE_* operations, only the\nLAPACKE_*_work variants that require an explicitly provided work buffer.\n\nThis is to ensure that solver routine allocation behavior is transparent\n\n\n-}\n\n\n\n{-\nvoid LAPACK_dgesvx( char* fact, char* trans, lapack_int* n, lapack_int* nrhs,\n double* a, lapack_int* lda, double* af, lapack_int* ldaf,\n lapack_int* ipiv, char* equed, double* r, double* c,\n double* b, lapack_int* ldb, double* x, lapack_int* ldx,\n double* rcond, double* ferr, double* berr, double* work,\n lapack_int* iwork, lapack_int *info );\n\n\n\n-}\n\n\n{-\n fortran FFI conventions!\n-}\n\n--type Stride_C =\n\nnewtype Fact_C = Fact_C CChar\nnewtype Trans_C = Trans_C CChar\nnewtype Stride_C = Stride_C Int32\nnewtype Equilib_C = Equilib_C CChar\n\ntype Fun_FFI_GESVX el = Ptr Fact_C {- fact -}-> Ptr Trans_C {- trans -}\n -> Ptr Int32 {-n -}-> Ptr Int32 {- NRHS -}->\n Ptr el {- a -} -> Ptr Stride_C {- lda -} -> Ptr Double {- af -} -> Ptr Stride_C {- ldf-}->\n Ptr Int32 -> Ptr Equilib_C {- equed -} -> Ptr el {- r -} -> Ptr el ->\n Ptr el {- b -} -> Ptr Stride_C {- ld b -} -> Ptr el {- x -} -> Ptr Stride_C {- ldx -}->\n Ptr el {-rcond -}-> Ptr el {- ferr-} -> Ptr el {-berr-} -> Ptr el {-work-}->\n Ptr Int32 {-iwork -}-> Ptr Int32 {-info -} -> IO ()\n\n\n\n{-\n\nthe prefixes mean s=single,d=double,c=complex float,d=complex double\n\n\n\nfact will be a 1 character C string\neither\n \"F\", then the inputs af and ipiv already contain the permuted LU factorization\n (act as input rather than result params)\n \"E\", Matrix input A will be equilibriated if needed, then copied to AF and Factored\n \"N\", matrix input A will be copied to AF\n\n-}\n\n\n{-\nXgesvx is the s -sing\n\n\nim assuming for now that any real use of *gesvx routines, or any other\nn^3 complexity algs from LAPACK, are on inputs typically n>=15, which means > 1000 flops,\nwhich is > 1\u00b5s, and thus ok to\n-}\n\n--need to get around to wrapping these, but thats for another day\nforeign import ccall \"sgesvx_\" sgesvx :: Fun_FFI_GESVX Float\nforeign import ccall \"dgesvx_\" dgesvx :: Fun_FFI_GESVX Double\nforeign import ccall \"cgesvx_\" cgesvx :: Fun_FFI_GESVX (Complex Float)\nforeign import ccall \"zgesvx_\" zgesvx :: Fun_FFI_GESVX (Complex Double)\n\n\n\n--lapack_int ?syev_( char *jobz, char *uplo, lapack_int *n, ?* a, lapack_int * lda, ?* w );\n-- ? is Double or Float\n\nnewtype JobTy = JBT CChar\nnewtype UploTy = UPLT CChar\nnewtype Info = Info Int32\n\n--basic symmetric eigen value solvers\ntype SYEV_FUN_FFI elem = Ptr JobTy -> Ptr UploTy -> Ptr Int32 -> Ptr elem -> Ptr Int32 -> Ptr elem -> Ptr Info-> IO ()\nforeign import ccall \"ssyev_\" ssyev_ffi :: SYEV_FUN_FFI Float\nforeign import ccall \"dsyev_\" dsyev_ffi :: SYEV_FUN_FFI Double\n\n{-unsafe versions of lapack routines are meant to ONLY be used for workspace queries-}\nforeign import ccall unsafe \"ssyev_\" ssyev_ffi_unsafe :: SYEV_FUN_FFI Float\nforeign import ccall unsafe \"dsyev_\" dsyev_ffi_unsafe :: SYEV_FUN_FFI Double\n\n--lapack_int LAPACKE_gesv( int matrix_order, lapack_int n, lapack_int nrhs, * a, lapack_int lda, lapack_int* ipiv, * b, lapack_int ldb );\n--call sgesv( n, nrhs, a, lda, ipiv, b, ldb, info )\n\ntype GESV_FUN_FFI elem = Ptr Int32 {- n -} -> Ptr Int32 {- nrhs -} -> Ptr elem {- a -}\n -> Ptr Int32 {- lda -} -> Ptr Int32 {- permutation vector -}\n -> Ptr elem {- b -} -> Ptr Int32 {- ldb -} -> Ptr Info -> IO ()\n-- | basic Linear system solvers. they act inplace\nforeign import ccall \"sgesv_\" sgesv_ffi ::GESV_FUN_FFI Float\nforeign import ccall \"dgesv_\" dgesv_ffi :: GESV_FUN_FFI Double\nforeign import ccall \"cgesv_\" cgesv_ffi :: GESV_FUN_FFI (Complex Float)\nforeign import ccall \"zgesv_\" zgesv_ffi :: GESV_FUN_FFI (Complex Double)\n\n-- / not sure if linear solvers ever are run in < 1 microsecond size instances in practice\nforeign import ccall unsafe \"sgesv_\" sgesv_ffi_unsafe ::GESV_FUN_FFI Float\nforeign import ccall unsafe \"dgesv_\" dgesv_ffi_unsafe :: GESV_FUN_FFI Double\nforeign import ccall unsafe \"cgesv_\" cgesv_ffi_unsafe :: GESV_FUN_FFI (Complex Float)\nforeign import ccall unsafe \"zgesv_\" zgesv_ffi_unsafe :: GESV_FUN_FFI (Complex Double)\n\n{- only provide -}\n\n\n\n\n", "meta": {"hexsha": "c209bb5bf1989464dab67471e2aee39989222dcb", "size": 4441, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/Numerical/HBLAS/Lapack/FFI.hs", "max_stars_repo_name": "archblob/hblas", "max_stars_repo_head_hexsha": "7165a333c356963fbcc5e05648b9bb8b300af0e5", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/Numerical/HBLAS/Lapack/FFI.hs", "max_issues_repo_name": "archblob/hblas", "max_issues_repo_head_hexsha": "7165a333c356963fbcc5e05648b9bb8b300af0e5", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/Numerical/HBLAS/Lapack/FFI.hs", "max_forks_repo_name": "archblob/hblas", "max_forks_repo_head_hexsha": "7165a333c356963fbcc5e05648b9bb8b300af0e5", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 34.1615384615, "max_line_length": 160, "alphanum_fraction": 0.6827291151, "num_tokens": 1400, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.5156199306096344, "lm_q2_score": 0.6039318337259584, "lm_q1q2_score": 0.3113992901987279}} {"text": "module Numeric.Digamma (digamma) where\n\nimport Numeric.SpecFunctions (digamma)\n", "meta": {"hexsha": "334d8b966c714d37dc61d54a269ce4a00c23e310", "size": 79, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "Numeric/Digamma.hs", "max_stars_repo_name": "bgamari/digamma", "max_stars_repo_head_hexsha": "9ac21068d5b89b1d6be0442849bd84f78fdddd56", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2015-05-19T06:45:25.000Z", "max_stars_repo_stars_event_max_datetime": "2019-11-27T09:09:14.000Z", "max_issues_repo_path": "Numeric/Digamma.hs", "max_issues_repo_name": "bgamari/digamma", "max_issues_repo_head_hexsha": "9ac21068d5b89b1d6be0442849bd84f78fdddd56", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Numeric/Digamma.hs", "max_forks_repo_name": "bgamari/digamma", "max_forks_repo_head_hexsha": "9ac21068d5b89b1d6be0442849bd84f78fdddd56", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 19.75, "max_line_length": 38, "alphanum_fraction": 0.8227848101, "num_tokens": 19, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO\n\n", "lm_q1_score": 0.6926419831347361, "lm_q2_score": 0.44939263446475963, "lm_q1q2_score": 0.31126820554181467}} {"text": "{-# LANGUAGE BangPatterns #-}\n{-# LANGUAGE CPP #-}\n{-# LANGUAGE DefaultSignatures #-}\n{-# LANGUAGE MagicHash #-}\n{-# LANGUAGE ScopedTypeVariables #-}\n-- |\n-- Module : Graphics.Color.Algebra.Elevator\n-- Copyright : (c) Alexey Kuleshevich 2018-2020\n-- License : BSD3\n-- Maintainer : Alexey Kuleshevich \n-- Stability : experimental\n-- Portability : non-portable\n--\nmodule Graphics.Color.Algebra.Elevator\n ( Elevator(..)\n , module Data.Word\n , clamp01\n ) where\n\nimport Data.Complex\nimport Data.Int\nimport Data.Typeable\nimport Data.Vector.Storable (Storable)\nimport Data.Vector.Unboxed (Unbox)\nimport Data.Word\nimport GHC.Float\nimport Text.Printf\n\ninfixl 7 //\n\ndefFieldFormat :: FieldFormat\ndefFieldFormat = FieldFormat Nothing Nothing Nothing Nothing False \"\" 'v'\n\n-- | A class with a set of functions that allow for changing precision by shrinking and\n-- streatching the values.\nclass (Show e, Eq e, Num e, Typeable e, Unbox e, Storable e) => Elevator e where\n maxValue :: e\n\n minValue :: e\n\n fieldFormat :: e -> FieldFormat\n fieldFormat _ = defFieldFormat\n\n -- | This is a pretty printer for the value.\n toShowS :: e -> ShowS\n default toShowS :: PrintfArg e => e -> ShowS\n toShowS e = formatArg e (fieldFormat e)\n\n -- | Values are scaled to @[0, 255]@ range.\n toWord8 :: e -> Word8\n\n -- | Values are scaled to @[0, 65535]@ range.\n toWord16 :: e -> Word16\n\n -- | Values are scaled to @[0, 4294967295]@ range.\n toWord32 :: e -> Word32\n\n -- | Values are scaled to @[0, 18446744073709551615]@ range.\n toWord64 :: e -> Word64\n\n -- | Values are scaled to @[0.0, 1.0]@ range.\n toRealFloat :: (Elevator a, RealFloat a) => e -> a\n\n -- | Values are scaled from @[0.0, 1.0]@ range.\n fromRealFloat :: (Elevator a, RealFloat a) => a -> e\n\n -- | Values are scaled to @[0.0, 1.0]@ range.\n toFloat :: e -> Float\n toFloat = toRealFloat\n\n -- | Values are scaled to @[0.0, 1.0]@ range.\n toDouble :: e -> Double\n toDouble = toRealFloat\n\n -- | Values are scaled from @[0.0, 1.0]@ range.\n fromDouble :: Double -> e\n fromDouble = fromRealFloat\n\n -- | Division that works for integral types as well as floating points. May throw an exception.\n (//) :: e -> e -> e\n\n\n-- | Lower the precision\ndropDown :: forall a b. (Integral a, Bounded a, Integral b, Bounded b) => a -> b\ndropDown !e = fromIntegral $ fromIntegral e `div` ((maxBound :: a) `div`\n fromIntegral (maxBound :: b))\n{-# INLINE dropDown #-}\n\n-- | Increase the precision\nraiseUp :: forall a b. (Integral a, Bounded a, Integral b, Bounded b) => a -> b\nraiseUp !e = fromIntegral e * ((maxBound :: b) `div` fromIntegral (maxBound :: a))\n{-# INLINE raiseUp #-}\n\n-- | Convert to fractional with value less than or equal to 1.\nsquashTo1 :: forall a b. (Fractional b, Integral a, Bounded a) => a -> b\nsquashTo1 !e = fromIntegral e / fromIntegral (maxBound :: a)\n{-# INLINE squashTo1 #-}\n\n-- | Convert to integral streaching it's value up to a maximum value.\nstretch :: forall a b. (RealFloat a, Integral b, Bounded b) => a -> b\nstretch !e = round (fromIntegral (maxBound :: b) * clamp01 e)\n{-# INLINE stretch #-}\n\n-- | Clamp a value to @[0, 1]@ range.\nclamp01 :: RealFloat a => a -> a\nclamp01 !x = min (max 0 x) 1\n{-# INLINE clamp01 #-}\n\n\nfloat2Word32 :: Float -> Word32\nfloat2Word32 d'\n | d' <= 0 = 0\n | d > 4.294967e9 = maxBound\n | otherwise = round d\n where\n d = maxWord32 * d'\n{-# INLINE float2Word32 #-}\n\n-- | Same as:\n-- >>> fromIntegral (maxBound :: Word32) :: Float\n-- 4.2949673e9\n--\nmaxWord32 :: Float\nmaxWord32 = F# 4.2949673e9#\n{-# INLINE maxWord32 #-}\n\ndouble2Word64 :: Double -> Word64\ndouble2Word64 d'\n | d' <= 0 = 0\n | d > 1.844674407370955e19 = maxBound\n | otherwise = round d\n where\n d = maxWord64 * d'\n{-# INLINE double2Word64 #-}\n\n-- | Differs from `fromIntegral` due to: [GHC #17782](https://gitlab.haskell.org/ghc/ghc/issues/17782)\n--\n-- >>> fromIntegral (maxBound :: Word64) :: Double\n-- 1.844674407370955e19\n--\nmaxWord64 :: Double\nmaxWord64 = D# 1.8446744073709552e19##\n{-# INLINE maxWord64 #-}\n\n{-# RULES\n\"fromRealFloat :: Double -> Word\" fromRealFloat = fromDouble :: Double -> Word\n\"fromRealFloat :: Double -> Word64\" fromRealFloat = fromDouble :: Double -> Word64\n\"fromRealFloat :: Float -> Word32\" fromRealFloat = float2Word32\n #-}\n\n\n-- | Values between @[0, 255]]@\ninstance Elevator Word8 where\n maxValue = maxBound\n minValue = minBound\n fieldFormat _ = defFieldFormat {fmtWidth = Just 3, fmtChar = 'd'}\n toWord8 = id\n {-# INLINE toWord8 #-}\n toWord16 = raiseUp\n {-# INLINE toWord16 #-}\n toWord32 = raiseUp\n {-# INLINE toWord32 #-}\n toWord64 = raiseUp\n {-# INLINE toWord64 #-}\n toFloat = squashTo1\n {-# INLINE toFloat #-}\n toDouble = squashTo1\n {-# INLINE toDouble #-}\n fromDouble = toWord8\n {-# INLINE fromDouble #-}\n toRealFloat = squashTo1\n {-# INLINE toRealFloat #-}\n fromRealFloat = toWord8\n {-# INLINE fromRealFloat #-}\n (//) = div\n {-# INLINE (//) #-}\n\n\n-- | Values between @[0, 65535]]@\ninstance Elevator Word16 where\n maxValue = maxBound\n minValue = minBound\n fieldFormat _ = defFieldFormat { fmtWidth = Just 5, fmtChar = 'd'}\n toWord8 = dropDown\n {-# INLINE toWord8 #-}\n toWord16 = id\n {-# INLINE toWord16 #-}\n toWord32 = raiseUp\n {-# INLINE toWord32 #-}\n toWord64 = raiseUp\n {-# INLINE toWord64 #-}\n toFloat = squashTo1\n {-# INLINE toFloat #-}\n toDouble = squashTo1\n {-# INLINE toDouble #-}\n fromDouble = toWord16\n {-# INLINE fromDouble #-}\n toRealFloat = squashTo1\n {-# INLINE toRealFloat #-}\n fromRealFloat = toWord16\n {-# INLINE fromRealFloat #-}\n (//) = div\n {-# INLINE (//) #-}\n\n\n-- | Values between @[0, 4294967295]@\ninstance Elevator Word32 where\n maxValue = maxBound\n minValue = minBound\n fieldFormat _ = defFieldFormat { fmtWidth = Just 10, fmtChar = 'd'}\n toWord8 = dropDown\n {-# INLINE toWord8 #-}\n toWord16 = dropDown\n {-# INLINE toWord16 #-}\n toWord32 = id\n {-# INLINE toWord32 #-}\n toWord64 = raiseUp\n {-# INLINE toWord64 #-}\n toFloat = squashTo1\n {-# INLINE toFloat #-}\n toDouble = squashTo1\n {-# INLINE toDouble #-}\n fromDouble = toWord32\n {-# INLINE fromDouble #-}\n toRealFloat = squashTo1\n {-# INLINE toRealFloat #-}\n fromRealFloat = toWord32\n {-# INLINE fromRealFloat #-}\n (//) = div\n {-# INLINE (//) #-}\n\n\n-- | Values between @[0, 18446744073709551615]@\ninstance Elevator Word64 where\n maxValue = maxBound\n minValue = minBound\n fieldFormat _ = defFieldFormat { fmtWidth = Just 20, fmtChar = 'd'}\n toWord8 = dropDown\n {-# INLINE toWord8 #-}\n toWord16 = dropDown\n {-# INLINE toWord16 #-}\n toWord32 = dropDown\n {-# INLINE toWord32 #-}\n toWord64 = id\n {-# INLINE toWord64 #-}\n toFloat = squashTo1\n {-# INLINE toFloat #-}\n toDouble = squashTo1\n {-# INLINE toDouble #-}\n fromDouble = double2Word64\n {-# INLINE fromDouble #-}\n toRealFloat = squashTo1\n {-# INLINE toRealFloat #-}\n fromRealFloat = toWord64\n {-# INLINE fromRealFloat #-}\n (//) = div\n {-# INLINE (//) #-}\n\n-- | Values between @[0, 18446744073709551615]@ on 64bit\ninstance Elevator Word where\n maxValue = maxBound\n minValue = minBound\n#if WORD_SIZE_IN_BITS < 64\n fieldFormat _ = defFieldFormat { fmtWidth = Just 10, fmtChar = 'd'}\n toWord64 = dropDown\n {-# INLINE toWord64 #-}\n fromDouble = stretch\n {-# INLINE fromDouble #-}\n#else\n fieldFormat _ = defFieldFormat { fmtWidth = Just 20, fmtChar = 'd'}\n toWord64 (W64# w#) = (W# w#)\n {-# INLINE toWord64 #-}\n fromDouble = toWord64 . double2Word64\n {-# INLINE fromDouble #-}\n#endif\n toWord8 = dropDown\n {-# INLINE toWord8 #-}\n toWord16 = dropDown\n {-# INLINE toWord16 #-}\n toWord32 = dropDown\n {-# INLINE toWord32 #-}\n toFloat = squashTo1\n {-# INLINE toFloat #-}\n toDouble = squashTo1\n {-# INLINE toDouble #-}\n toRealFloat = squashTo1\n {-# INLINE toRealFloat #-}\n fromRealFloat = stretch\n {-# INLINE fromRealFloat #-}\n (//) = div\n {-# INLINE (//) #-}\n\n-- | Values between @[0, 127]@\ninstance Elevator Int8 where\n maxValue = maxBound\n minValue = 0\n fieldFormat _ = defFieldFormat { fmtWidth = Just 3, fmtChar = 'd'}\n toWord8 = fromIntegral . max 0\n {-# INLINE toWord8 #-}\n toWord16 = raiseUp . max 0\n {-# INLINE toWord16 #-}\n toWord32 = raiseUp . max 0\n {-# INLINE toWord32 #-}\n toWord64 = raiseUp . max 0\n {-# INLINE toWord64 #-}\n toFloat = squashTo1 . max 0\n {-# INLINE toFloat #-}\n toRealFloat = squashTo1 . max 0\n {-# INLINE toRealFloat #-}\n fromRealFloat = stretch\n {-# INLINE fromRealFloat #-}\n (//) = div\n {-# INLINE (//) #-}\n\n\n-- | Values between @[0, 32767]@\ninstance Elevator Int16 where\n maxValue = maxBound\n minValue = 0\n fieldFormat _ = defFieldFormat { fmtWidth = Just 5, fmtChar = 'd'}\n toWord8 = dropDown . max 0\n {-# INLINE toWord8 #-}\n toWord16 = fromIntegral . max 0\n {-# INLINE toWord16 #-}\n toWord32 = raiseUp . max 0\n {-# INLINE toWord32 #-}\n toWord64 = raiseUp . max 0\n {-# INLINE toWord64 #-}\n toFloat = squashTo1 . max 0\n {-# INLINE toFloat #-}\n toRealFloat = squashTo1 . max 0\n {-# INLINE toRealFloat #-}\n fromRealFloat = stretch\n {-# INLINE fromRealFloat #-}\n (//) = div\n {-# INLINE (//) #-}\n\n\n-- | Values between @[0, 2147483647]@\ninstance Elevator Int32 where\n maxValue = maxBound\n minValue = 0\n fieldFormat _ = defFieldFormat { fmtWidth = Just 10, fmtChar = 'd'}\n toWord8 = dropDown . max 0\n {-# INLINE toWord8 #-}\n toWord16 = dropDown . max 0\n {-# INLINE toWord16 #-}\n toWord32 = fromIntegral . max 0\n {-# INLINE toWord32 #-}\n toWord64 = raiseUp . max 0\n {-# INLINE toWord64 #-}\n toFloat = squashTo1 . max 0\n {-# INLINE toFloat #-}\n toRealFloat = squashTo1 . max 0\n {-# INLINE toRealFloat #-}\n fromRealFloat = stretch\n {-# INLINE fromRealFloat #-}\n (//) = div\n {-# INLINE (//) #-}\n\n\n-- | Values between @[0, 9223372036854775807]@\ninstance Elevator Int64 where\n maxValue = maxBound\n minValue = 0\n fieldFormat _ = defFieldFormat { fmtWidth = Just 19, fmtChar = 'd'}\n toWord8 = dropDown . max 0\n {-# INLINE toWord8 #-}\n toWord16 = dropDown . max 0\n {-# INLINE toWord16 #-}\n toWord32 = dropDown . max 0\n {-# INLINE toWord32 #-}\n toWord64 = fromIntegral . max 0\n {-# INLINE toWord64 #-}\n toFloat = squashTo1 . max 0\n {-# INLINE toFloat #-}\n toRealFloat = squashTo1 . max 0\n {-# INLINE toRealFloat #-}\n fromRealFloat = stretch\n {-# INLINE fromRealFloat #-}\n (//) = div\n {-# INLINE (//) #-}\n\n\n-- | Values between @[0, 9223372036854775807]@ on 64bit\ninstance Elevator Int where\n maxValue = maxBound\n minValue = 0\n#if WORD_SIZE_IN_BITS < 64\n fieldFormat _ = defFieldFormat { fmtWidth = Just 10, fmtChar = 'd'}\n toWord64 = dropDown . max 0\n {-# INLINE toWord64 #-}\n#else\n fieldFormat _ = defFieldFormat { fmtWidth = Just 19, fmtChar = 'd'}\n toWord64 = fromIntegral . max 0\n {-# INLINE toWord64 #-}\n#endif\n toWord8 = dropDown . max 0\n {-# INLINE toWord8 #-}\n toWord16 = dropDown . max 0\n {-# INLINE toWord16 #-}\n toWord32 = dropDown . max 0\n {-# INLINE toWord32 #-}\n toFloat = squashTo1 . max 0\n {-# INLINE toFloat #-}\n toRealFloat = squashTo1 . max 0\n {-# INLINE toRealFloat #-}\n fromRealFloat = stretch\n {-# INLINE fromRealFloat #-}\n (//) = div\n {-# INLINE (//) #-}\n\n\n-- | Values between @[0.0, 1.0]@\ninstance Elevator Float where\n maxValue = 1\n minValue = 0\n fieldFormat _ = defFieldFormat { fmtWidth = Just 11, fmtPrecision = Just 8, fmtChar = 'f'}\n toWord8 = stretch\n {-# INLINE toWord8 #-}\n toWord16 = stretch\n {-# INLINE toWord16 #-}\n toWord32 = float2Word32\n {-# INLINE toWord32 #-}\n toWord64 = stretch\n {-# INLINE toWord64 #-}\n toFloat = id\n {-# INLINE toFloat #-}\n toDouble = float2Double\n {-# INLINE toDouble #-}\n fromDouble = toFloat\n {-# INLINE fromDouble #-}\n toRealFloat = uncurry encodeFloat . decodeFloat\n {-# INLINE toRealFloat #-}\n fromRealFloat = uncurry encodeFloat . decodeFloat\n {-# INLINE fromRealFloat #-}\n (//) = (/)\n {-# INLINE (//) #-}\n\n\n-- | Values between @[0.0, 1.0]@\ninstance Elevator Double where\n maxValue = 1\n minValue = 0\n fieldFormat _ = defFieldFormat { fmtWidth = Just 19, fmtPrecision = Just 16, fmtChar = 'f' }\n toWord8 = stretch\n {-# INLINE toWord8 #-}\n toWord16 = stretch\n {-# INLINE toWord16 #-}\n toWord32 = stretch\n {-# INLINE toWord32 #-}\n toWord64 = double2Word64\n {-# INLINE toWord64 #-}\n toFloat = double2Float\n {-# INLINE toFloat #-}\n toDouble = id\n {-# INLINE toDouble #-}\n fromDouble = id\n {-# INLINE fromDouble #-}\n toRealFloat = uncurry encodeFloat . decodeFloat\n {-# INLINE toRealFloat #-}\n fromRealFloat = uncurry encodeFloat . decodeFloat\n {-# INLINE fromRealFloat #-}\n (//) = (/)\n {-# INLINE (//) #-}\n\n{-# RULES\n\"toRealFloat :: Double -> Double / Float -> Float\" toRealFloat = id\n\"toRealFloat :: Double -> Float\" toRealFloat = double2Float\n\"toRealFloat :: Float -> Double\" toRealFloat = float2Double\n\"fromRealFloat :: Double -> Double / Float -> Float\" fromRealFloat = id\n\"fromRealFloat :: Double -> Float\" fromRealFloat = double2Float\n\"fromRealFloat :: Float -> Double\" fromRealFloat = float2Double\n #-}\n\n\n\n-- | Discards imaginary part and changes precision of real part.\ninstance (PrintfArg e, Elevator e, RealFloat e) => Elevator (Complex e) where\n maxValue = maxValue :+ maxValue\n minValue = minValue :+ minValue\n toShowS (r :+ i) = toShowS r . formatArg i ((fieldFormat i) {fmtSign = Just SignPlus}) . ('i' :)\n toWord8 = toWord8 . realPart\n {-# INLINE toWord8 #-}\n toWord16 = toWord16 . realPart\n {-# INLINE toWord16 #-}\n toWord32 = toWord32 . realPart\n {-# INLINE toWord32 #-}\n toWord64 = toWord64 . realPart\n {-# INLINE toWord64 #-}\n toFloat = toFloat . realPart\n {-# INLINE toFloat #-}\n toDouble = toDouble . realPart\n {-# INLINE toDouble #-}\n fromDouble = (:+ 0) . fromDouble\n {-# INLINE fromDouble #-}\n toRealFloat = toRealFloat . realPart\n {-# INLINE toRealFloat #-}\n fromRealFloat = (:+ 0) . fromRealFloat\n {-# INLINE fromRealFloat #-}\n (//) = (/)\n {-# INLINE (//) #-}\n", "meta": {"hexsha": "8f9aff346fef29b97576f8268d11e75fd2396de5", "size": 13941, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "Color/src/Graphics/Color/Algebra/Elevator.hs", "max_stars_repo_name": "TravisCardwell/Color", "max_stars_repo_head_hexsha": "e36958ebfd5a98e08817c4963acc3e0602ac2f28", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 54, "max_stars_repo_stars_event_min_datetime": "2020-01-18T22:27:29.000Z", "max_stars_repo_stars_event_max_datetime": "2021-08-20T16:56:57.000Z", "max_issues_repo_path": "Color/src/Graphics/Color/Algebra/Elevator.hs", "max_issues_repo_name": "TravisCardwell/Color", "max_issues_repo_head_hexsha": "e36958ebfd5a98e08817c4963acc3e0602ac2f28", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 10, "max_issues_repo_issues_event_min_datetime": "2020-02-06T04:16:06.000Z", "max_issues_repo_issues_event_max_datetime": "2022-02-27T10:19:06.000Z", "max_forks_repo_path": "Color/src/Graphics/Color/Algebra/Elevator.hs", "max_forks_repo_name": "TravisCardwell/Color", "max_forks_repo_head_hexsha": "e36958ebfd5a98e08817c4963acc3e0602ac2f28", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 6, "max_forks_repo_forks_event_min_datetime": "2020-02-06T07:33:07.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-25T05:08:17.000Z", "avg_line_length": 27.7157057654, "max_line_length": 102, "alphanum_fraction": 0.6371852808, "num_tokens": 4421, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.6076631698328916, "lm_q2_score": 0.5117166047041652, "lm_q1q2_score": 0.31095133407065784}} {"text": "{-# LANGUAGE DeriveAnyClass #-}\n{-# LANGUAGE DeriveGeneric #-}\n{-# LANGUAGE RecursiveDo #-}\n{-# LANGUAGE TemplateHaskell #-}\nmodule Main where\n\n--import Circuits.Network\nimport Control.Lens\nimport Control.Monad.Fix\nimport qualified Data.Vector as V\nimport qualified Data.Vector.Storable as VS\nimport qualified Data.Vector.Storable.Mutable as VSM\nimport GHC.Generics\nimport qualified Numeric.LinearAlgebra as HMatrix\nimport qualified Numeric.LinearAlgebra.Data as HMatrix\nimport Text.Printf\n\nimport Circuits.Analysis.DC\nimport Circuits.Circuit\nimport Circuits.Components.Linear\n\ndata TestCircuit = TestCircuit\n { _gnd :: Node\n , _n1 :: Node\n , _vs :: VoltageSource\n , _r :: Resistor\n }\n deriving (Show, Generic, SimulateDC, HasVariables)\n\nc1 :: Circuit TestCircuit\nc1 = buildCircuit $ do\n gnd <- ground\n n1 <- newNode\n vs <- newBranch\n return TestCircuit\n { _gnd = gnd\n , _n1 = n1\n , _vs = VoltageSource (Independent 5) vs gnd n1\n , _r = Resistor 100 gnd n1\n }\n\ndata RC = RC\n { _rcGnd :: Node\n , _rcN1 :: Node\n , _rcN2 :: Node\n , _rcVS :: VoltageSource\n , _rcR :: Resistor\n , _rcC :: Capacitor\n }\n deriving (Show, Generic, SimulateDC, HasVariables)\nmakeLenses ''RC\n\nrc :: Circuit RC\nrc = buildCircuit $ do\n gnd <- ground\n n1 <- newNode\n n2 <- newNode\n vs <- newBranch\n return RC\n { _rcGnd = gnd\n , _rcN1 = n1\n , _rcN2 = n2\n , _rcVS = VoltageSource (Independent 5) vs gnd n2\n , _rcR = Resistor 100 gnd n1\n , _rcC = Capacitor 0.01 n1 n2\n }\n\nmain :: IO ()\nmain = do\n let c2 = step SteadyState c1\n print c2\n let rcs = transient (Transient 0 4 0.1) rc\n forMOf_ (traverse . Control.Lens.to (over _2 $ view $ model . rcC . voltageAcross)) rcs $ uncurry $ printf \"%.1f ~ %.2f\\n\"\n --mapM_ (\\(t, c) -> printf \"t = %.1f\\n%s\\n\\n\" t (show c)) rcs\n return ()\n\n\ndata Transient = Transient\n { _transientStartTime :: Double\n , _transientStopTime :: Double\n , _transientTimeStep :: Double\n }\n\ntransient :: (SimulateDC c, HasVariables c) => Transient -> Circuit c -> [(Double, Circuit c)]\ntransient (Transient start stop dt) c0 = go c0 start where\n go c t\n | t > stop = []\n | otherwise = (t, c) : go (step (Step t dt) c) (t + dt)\n\n {-\n sys <- newMSystem 1 1\n stamp sys (VoltageSource (Independent 5) (Var 1) Ground (Var 0))\n stamp sys (Resistor 100 Ground (Var 0) :: Resistor NodeRef NodeRef Double)\n stamp sys (Resistor 200 Ground (Var 0) :: Resistor NodeRef NodeRef Double)\n mv <- HMatrix.reshape 2 <$> VS.unsafeFreeze (_msystemCoeff sys)\n rhs <- HMatrix.asColumn <$> VS.unsafeFreeze (_msystemRhs sys)\n print mv\n print rhs\n print $ HMatrix.linearSolve mv rhs\n-}\n{- let simple = empty \"GND\"\n & part \"R1\" .~ Just (Resistor 100 \"N1\" \"GND\")\n & part \"C1\" .~ Just (Capacitor 0.01 \"N2\" \"N1\")\n & part \"Vs\" .~ Just (VoltageSource 5 \"GND\" \"N2\")\n\n case compile simple of\n Left err -> putStrLn err\n Right c -> do\n let cs = take 100 $ iterate (step 0.01) c\n mapM_ print cs\n-}\n\n", "meta": {"hexsha": "92931a86dda922c44f6ceb0c88d5d11e0bf0417e", "size": 3116, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "test/Main.hs", "max_stars_repo_name": "fatho/circuits", "max_stars_repo_head_hexsha": "78849c38fea77989d5d3b88ee04f224845f287eb", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2019-12-07T22:34:40.000Z", "max_stars_repo_stars_event_max_datetime": "2019-12-07T22:34:40.000Z", "max_issues_repo_path": "test/Main.hs", "max_issues_repo_name": "fatho/circuits", "max_issues_repo_head_hexsha": "78849c38fea77989d5d3b88ee04f224845f287eb", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "test/Main.hs", "max_forks_repo_name": "fatho/circuits", "max_forks_repo_head_hexsha": "78849c38fea77989d5d3b88ee04f224845f287eb", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2019-12-07T22:34:49.000Z", "max_forks_repo_forks_event_max_datetime": "2019-12-07T22:34:49.000Z", "avg_line_length": 27.5752212389, "max_line_length": 124, "alphanum_fraction": 0.6258023107, "num_tokens": 1024, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6859494550081926, "lm_q2_score": 0.4532618480153861, "lm_q1q2_score": 0.31091471762216033}} {"text": "{-# LANGUAGE CPP\n , GADTs\n , Rank2Types\n , DataKinds\n , TypeFamilies\n , FlexibleContexts\n , UndecidableInstances\n , LambdaCase\n , MultiParamTypeClasses\n , OverloadedStrings\n #-}\n\n{-# OPTIONS_GHC -Wall -fwarn-tabs -fsimpl-tick-factor=1000 -fno-warn-orphans #-}\nmodule Language.Hakaru.Runtime.LogFloatPrelude where\n\n#if __GLASGOW_HASKELL__ < 710\nimport Data.Functor ((<$>))\nimport Control.Applicative (Applicative(..))\n#endif\nimport Data.Foldable as F\nimport qualified System.Random.MWC as MWC\nimport qualified System.Random.MWC.Distributions as MWCD\nimport Data.Number.Natural\nimport Data.Number.LogFloat hiding (sum, product)\nimport qualified Data.Number.LogFloat as LF\nimport Data.STRef\nimport qualified Data.Vector as V\nimport qualified Data.Vector.Unboxed as U\nimport qualified Data.Vector.Generic as G\nimport qualified Data.Vector.Generic.Mutable as M\nimport Control.Monad\nimport Control.Monad.ST\nimport Numeric.SpecFunctions (logBeta)\nimport Prelude hiding (init, sum, product, exp, log, (**), pi)\nimport qualified Prelude as P\nimport Language.Hakaru.Runtime.CmdLine (Parseable(..), Measure(..), makeMeasure)\n\n-- This Read instance really should be the logfloat package\ninstance Read LogFloat where\n readsPrec p s = [(logFloat x, r) | (x, r) <- readsPrec p s]\n\ninstance Parseable LogFloat where\n parse = return . read\n\ntype family MinBoxVec (v1 :: * -> *) (v2 :: * -> *) :: * -> *\ntype instance MinBoxVec V.Vector v = V.Vector\ntype instance MinBoxVec v V.Vector = V.Vector\ntype instance MinBoxVec U.Vector U.Vector = U.Vector\n\ntype family MayBoxVec a :: * -> *\ntype instance MayBoxVec () = U.Vector\ntype instance MayBoxVec Int = U.Vector\ntype instance MayBoxVec Double = U.Vector\ntype instance MayBoxVec LogFloat = U.Vector\ntype instance MayBoxVec Bool = U.Vector\ntype instance MayBoxVec (U.Vector a) = V.Vector\ntype instance MayBoxVec (V.Vector a) = V.Vector\ntype instance MayBoxVec (a,b) = MinBoxVec (MayBoxVec a) (MayBoxVec b)\n\nnewtype instance U.MVector s LogFloat = MV_LogFloat (U.MVector s Double)\nnewtype instance U.Vector LogFloat = V_LogFloat (U.Vector Double)\n\ninstance U.Unbox LogFloat\n\ninstance M.MVector U.MVector LogFloat where\n {-# INLINE basicLength #-}\n {-# INLINE basicUnsafeSlice #-}\n {-# INLINE basicOverlaps #-}\n {-# INLINE basicUnsafeNew #-}\n#if __GLASGOW_HASKELL__ > 710\n {-# INLINE basicInitialize #-}\n#endif\n {-# INLINE basicUnsafeReplicate #-}\n {-# INLINE basicUnsafeRead #-}\n {-# INLINE basicUnsafeWrite #-}\n {-# INLINE basicClear #-}\n {-# INLINE basicSet #-}\n {-# INLINE basicUnsafeCopy #-}\n {-# INLINE basicUnsafeGrow #-}\n basicLength (MV_LogFloat v) = M.basicLength v\n basicUnsafeSlice i n (MV_LogFloat v) = MV_LogFloat $ M.basicUnsafeSlice i n v\n basicOverlaps (MV_LogFloat v1) (MV_LogFloat v2) = M.basicOverlaps v1 v2\n basicUnsafeNew n = MV_LogFloat `liftM` M.basicUnsafeNew n\n#if __GLASGOW_HASKELL__ > 710\n basicInitialize (MV_LogFloat v) = M.basicInitialize v\n#endif\n basicUnsafeReplicate n x = MV_LogFloat `liftM` M.basicUnsafeReplicate n (logFromLogFloat x)\n basicUnsafeRead (MV_LogFloat v) i = logToLogFloat `liftM` M.basicUnsafeRead v i\n basicUnsafeWrite (MV_LogFloat v) i x = M.basicUnsafeWrite v i (logFromLogFloat x)\n basicClear (MV_LogFloat v) = M.basicClear v\n basicSet (MV_LogFloat v) x = M.basicSet v (logFromLogFloat x)\n basicUnsafeCopy (MV_LogFloat v1) (MV_LogFloat v2) = M.basicUnsafeCopy v1 v2\n basicUnsafeMove (MV_LogFloat v1) (MV_LogFloat v2) = M.basicUnsafeMove v1 v2\n basicUnsafeGrow (MV_LogFloat v) n = MV_LogFloat `liftM` M.basicUnsafeGrow v n\n\ninstance G.Vector U.Vector LogFloat where\n {-# INLINE basicUnsafeFreeze #-}\n {-# INLINE basicUnsafeThaw #-}\n {-# INLINE basicLength #-}\n {-# INLINE basicUnsafeSlice #-}\n {-# INLINE basicUnsafeIndexM #-}\n {-# INLINE elemseq #-}\n basicUnsafeFreeze (MV_LogFloat v) = V_LogFloat `liftM` G.basicUnsafeFreeze v\n basicUnsafeThaw (V_LogFloat v) = MV_LogFloat `liftM` G.basicUnsafeThaw v\n basicLength (V_LogFloat v) = G.basicLength v\n basicUnsafeSlice i n (V_LogFloat v) = V_LogFloat $ G.basicUnsafeSlice i n v\n basicUnsafeIndexM (V_LogFloat v) i\n = logToLogFloat `liftM` G.basicUnsafeIndexM v i\n basicUnsafeCopy (MV_LogFloat mv) (V_LogFloat v)\n = G.basicUnsafeCopy mv v\n elemseq _ x z = G.elemseq (undefined :: U.Vector a) (logFromLogFloat x) z\n\ntype Prob = LogFloat\n\nlam :: (a -> b) -> a -> b\nlam = id\n{-# INLINE lam #-}\n\napp :: (a -> b) -> a -> b\napp f x = f x\n{-# INLINE app #-}\n\nlet_ :: a -> (a -> b) -> b\nlet_ x f = let x1 = x in f x1\n{-# INLINE let_ #-}\n\nann_ :: a -> b -> b\nann_ _ a = a\n{-# INLINE ann_ #-}\n\nexp :: Double -> Prob\nexp = logToLogFloat\n{-# INLINE exp #-}\n\nlog :: Prob -> Double\nlog = logFromLogFloat\n{-# INLINE log #-}\n\nbetaFunc :: Prob -> Prob -> Prob\nbetaFunc a b = exp (logBeta (fromProb a) (fromProb b))\n\nuniform :: Double -> Double -> Measure Double\nuniform lo hi = makeMeasure $ MWC.uniformR (lo, hi)\n{-# INLINE uniform #-}\n\nnormal :: Double -> Prob -> Measure Double\nnormal mu sd = makeMeasure $ MWCD.normal mu (fromProb sd)\n{-# INLINE normal #-}\n\nbeta :: Prob -> Prob -> Measure Prob\nbeta a b = makeMeasure $ \\g ->\n unsafeProb <$> MWCD.beta (fromProb a) (fromProb b) g\n{-# INLINE beta #-}\n\ngamma :: Prob -> Prob -> Measure Prob\ngamma a b = makeMeasure $ \\g ->\n unsafeProb <$> MWCD.gamma (fromProb a) (fromProb b) g\n{-# INLINE gamma #-}\n\ncategorical :: MayBoxVec Prob Prob -> Measure Int\ncategorical a = makeMeasure $ MWCD.categorical (U.map prep a)\n where prep p = fromLogFloat (p / m)\n m = G.maximum a\n{-# INLINE categorical #-}\n\nplate :: (G.Vector (MayBoxVec a) a) =>\n Int -> (Int -> Measure a) -> Measure (MayBoxVec a a)\nplate n f = G.generateM (fromIntegral n) $ \\x ->\n f (fromIntegral x)\n{-# INLINE plate #-}\n\nbucket :: Int -> Int -> (forall s. Reducer () s a) -> a\nbucket b e r = runST\n $ case r of Reducer{init=initR,accum=accumR,done=doneR} -> do\n s' <- initR ()\n F.mapM_ (\\i -> accumR () i s') [b .. e - 1]\n doneR s'\n{-# INLINE bucket #-}\n\ndata Reducer xs s a =\n forall cell.\n Reducer { init :: xs -> ST s cell\n , accum :: xs -> Int -> cell -> ST s ()\n , done :: cell -> ST s a\n }\n\nr_fanout :: Reducer xs s a\n -> Reducer xs s b\n -> Reducer xs s (a,b)\nr_fanout Reducer{init=initA,accum=accumA,done=doneA}\n Reducer{init=initB,accum=accumB,done=doneB} = Reducer\n { init = \\xs -> liftM2 (,) (initA xs) (initB xs)\n , accum = \\bs i (s1, s2) ->\n accumA bs i s1 >> accumB bs i s2\n , done = \\(s1, s2) -> liftM2 (,) (doneA s1) (doneB s2)\n }\n{-# INLINE r_fanout #-}\n\nr_index :: (G.Vector (MayBoxVec a) a)\n => (xs -> Int)\n -> ((Int, xs) -> Int)\n -> Reducer (Int, xs) s a\n -> Reducer xs s (MayBoxVec a a)\nr_index n f Reducer{init=initR,accum=accumR,done=doneR} = Reducer\n { init = \\xs -> V.generateM (n xs) (\\b -> initR (b, xs))\n , accum = \\bs i v ->\n let ov = f (i, bs) in\n accumR (ov,bs) i (v V.! ov)\n , done = \\v -> fmap G.convert (V.mapM doneR v)\n }\n{-# INLINE r_index #-}\n\nr_split :: ((Int, xs) -> Bool)\n -> Reducer xs s a\n -> Reducer xs s b\n -> Reducer xs s (a,b)\nr_split b Reducer{init=initA,accum=accumA,done=doneA}\n Reducer{init=initB,accum=accumB,done=doneB} = Reducer\n { init = \\xs -> liftM2 (,) (initA xs) (initB xs)\n , accum = \\bs i (s1, s2) ->\n if (b (i,bs)) then accumA bs i s1 else accumB bs i s2\n , done = \\(s1, s2) -> liftM2 (,) (doneA s1) (doneB s2)\n }\n{-# INLINE r_split #-}\n\nr_add :: Num a => ((Int, xs) -> a) -> Reducer xs s a\nr_add e = Reducer\n { init = \\_ -> newSTRef 0\n , accum = \\bs i s ->\n modifySTRef' s (+ (e (i,bs)))\n , done = readSTRef\n }\n{-# INLINE r_add #-}\n\nr_nop :: Reducer xs s ()\nr_nop = Reducer\n { init = \\_ -> return ()\n , accum = \\_ _ _ -> return ()\n , done = \\_ -> return ()\n }\n{-# INLINE r_nop #-}\n\npair :: a -> b -> (a, b)\npair = (,)\n{-# INLINE pair #-}\n\ntrue, false :: Bool\ntrue = True\nfalse = False\n\nnothing :: Maybe a\nnothing = Nothing\n\njust :: a -> Maybe a\njust = Just\n\nleft :: a -> Either a b\nleft = Left\n\nright :: b -> Either a b\nright = Right\n\nunit :: ()\nunit = ()\n\ndata Pattern = PVar | PWild\nnewtype Branch a b =\n Branch { extract :: a -> Maybe b }\n\nptrue, pfalse :: a -> Branch Bool a\nptrue b = Branch { extract = extractBool True b }\npfalse b = Branch { extract = extractBool False b }\n{-# INLINE ptrue #-}\n{-# INLINE pfalse #-}\n\nextractBool :: Bool -> a -> Bool -> Maybe a\nextractBool b a p | p == b = Just a\n | otherwise = Nothing\n{-# INLINE extractBool #-}\n\npnothing :: b -> Branch (Maybe a) b\npnothing b = Branch { extract = \\ma -> case ma of\n Nothing -> Just b\n Just _ -> Nothing }\n\npjust :: Pattern -> (a -> b) -> Branch (Maybe a) b\npjust PVar c = Branch { extract = \\ma -> case ma of\n Nothing -> Nothing\n Just x -> Just (c x) }\npjust _ _ = error \"TODO: Runtime.Prelude{pjust}\"\n\npleft :: Pattern -> (a -> c) -> Branch (Either a b) c\npleft PVar f = Branch { extract = \\ma -> case ma of\n Right _ -> Nothing\n Left x -> Just (f x) }\npleft _ _ = error \"TODO: Runtime.Prelude{pLeft}\"\n\npright :: Pattern -> (b -> c) -> Branch (Either a b) c\npright PVar f = Branch { extract = \\ma -> case ma of\n Left _ -> Nothing\n Right x -> Just (f x) }\npright _ _ = error \"TODO: Runtime.Prelude{pRight}\"\n\n\nppair :: Pattern -> Pattern -> (x -> y -> b) -> Branch (x,y) b\nppair PVar PVar c = Branch { extract = (\\(x,y) -> Just (c x y)) }\nppair _ _ _ = error \"ppair: TODO\"\n\nuncase_ :: Maybe a -> a\nuncase_ (Just a) = a\nuncase_ Nothing = error \"case_: unable to match any branches\"\n{-# INLINE uncase_ #-}\n\ncase_ :: a -> [Branch a b] -> b\ncase_ e [c1] = uncase_ (extract c1 e)\ncase_ e [c1, c2] = uncase_ (extract c1 e `mplus` extract c2 e)\ncase_ e bs_ = go bs_\n where go [] = error \"case_: unable to match any branches\"\n go (b:bs) = case extract b e of\n Just b' -> b'\n Nothing -> go bs\n{-# INLINE case_ #-}\n\nbranch :: (c -> Branch a b) -> c -> Branch a b\nbranch pat body = pat body\n{-# INLINE branch #-}\n\ndirac :: a -> Measure a\ndirac = return\n{-# INLINE dirac #-}\n\npose :: Prob -> Measure a -> Measure a\npose _ a = a\n{-# INLINE pose #-}\n\nsuperpose :: [(Prob, Measure a)]\n -> Measure a\nsuperpose pms = do\n i <- categorical (G.fromList $ map fst pms)\n snd (pms !! i)\n{-# INLINE superpose #-}\n\nreject :: Measure a\nreject = Measure $ \\_ -> return Nothing\n\nnat_ :: Int -> Int\nnat_ = id\n\nint_ :: Int -> Int\nint_ = id\n\nunsafeNat :: Int -> Int\nunsafeNat = id\n\nnat2prob :: Int -> Prob\nnat2prob = fromIntegral\n\nfromInt :: Int -> Double\nfromInt = fromIntegral\n\nnat2int :: Int -> Int\nnat2int = id\n\nnat2real :: Int -> Double\nnat2real = fromIntegral\n\nfromProb :: Prob -> Double\nfromProb = fromLogFloat\n\nunsafeProb :: Double -> Prob\nunsafeProb = logFloat\n\nreal_ :: Rational -> Double\nreal_ = fromRational\n\nprob_ :: NonNegativeRational -> Prob\nprob_ = fromRational . fromNonNegativeRational\n\ninfinity :: Double\ninfinity = 1/0\n\nabs_ :: Num a => a -> a\nabs_ = abs\n\n(**) :: Prob -> Double -> Prob\n(**) = pow\n{-# INLINE (**) #-}\n\npi :: Prob\npi = unsafeProb P.pi\n{-# INLINE pi #-}\n\nthRootOf :: Int -> Prob -> Prob\nthRootOf a b = b ** (recip $ fromIntegral a)\n{-# INLINE thRootOf #-}\n\narray\n :: (G.Vector (MayBoxVec a) a)\n => Int\n -> (Int -> a)\n -> MayBoxVec a a\narray n f = G.generate (fromIntegral n) (f . fromIntegral)\n{-# INLINE array #-}\n\narrayLit :: (G.Vector (MayBoxVec a) a) => [a] -> MayBoxVec a a\narrayLit = G.fromList\n{-# INLINE arrayLit #-}\n\n(!) :: (G.Vector (MayBoxVec a) a) => MayBoxVec a a -> Int -> a\na ! b = a G.! (fromIntegral b)\n{-# INLINE (!) #-}\n\nsize :: (G.Vector (MayBoxVec a) a) => MayBoxVec a a -> Int\nsize v = fromIntegral (G.length v)\n{-# INLINE size #-}\n\nreduce\n :: (G.Vector (MayBoxVec a) a)\n => (a -> a -> a)\n -> a\n -> MayBoxVec a a\n -> a\nreduce f n v = G.foldr f n v\n{-# INLINE reduce #-}\n\nclass Num a => Num' a where\n product :: Int -> Int -> (Int -> a) -> a\n product a b f = F.foldl' (\\x y -> x * f y) 1 [a .. b-1]\n {-# INLINE product #-}\n summate :: Int -> Int -> (Int -> a) -> a\n summate a b f = F.foldl' (\\x y -> x + f y) 0 [a .. b-1]\n {-# INLINE summate #-}\n\ninstance Num' Int\ninstance Num' Double\ninstance Num' LogFloat where\n product a b f = LF.product (map f [a .. b-1])\n {-# INLINE product #-}\n summate a b f = LF.sum (map f [a .. b-1])\n {-# INLINE summate #-}\n\nrun :: Show a\n => MWC.GenIO\n -> Measure a\n -> IO ()\nrun g k = unMeasure k g >>= \\case\n Just a -> print a\n Nothing -> return ()\n\niterateM_\n :: Monad m\n => (a -> m a)\n -> a\n -> m b\niterateM_ f = g\n where g x = f x >>= g\n\nwithPrint :: Show a => (a -> IO b) -> a -> IO b\nwithPrint f x = print x >> f x\n", "meta": {"hexsha": "350fa19d356268ab0c81de74000c0c0c793b6a6f", "size": 13691, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "haskell/Language/Hakaru/Runtime/LogFloatPrelude.hs", "max_stars_repo_name": "vmchale/hakaru", "max_stars_repo_head_hexsha": "78922e13876e449d6812a55a11bf84c8eb0af4d6", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 327, "max_stars_repo_stars_event_min_datetime": "2015-01-03T08:56:51.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-24T12:12:06.000Z", "max_issues_repo_path": "haskell/Language/Hakaru/Runtime/LogFloatPrelude.hs", "max_issues_repo_name": "vmchale/hakaru", "max_issues_repo_head_hexsha": "78922e13876e449d6812a55a11bf84c8eb0af4d6", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 155, "max_issues_repo_issues_event_min_datetime": "2015-05-05T17:57:22.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-30T15:43:39.000Z", "max_forks_repo_path": "haskell/Language/Hakaru/Runtime/LogFloatPrelude.hs", "max_forks_repo_name": "vmchale/hakaru", "max_forks_repo_head_hexsha": "78922e13876e449d6812a55a11bf84c8eb0af4d6", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 38, "max_forks_repo_forks_event_min_datetime": "2015-01-23T16:25:37.000Z", "max_forks_repo_forks_event_max_datetime": "2021-03-14T15:09:12.000Z", "avg_line_length": 29.7630434783, "max_line_length": 96, "alphanum_fraction": 0.5779709298, "num_tokens": 4046, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6619228758499942, "lm_q2_score": 0.4687906266262437, "lm_q1q2_score": 0.3103032397479641}} {"text": "{-# LANGUAGE BangPatterns, OverloadedStrings, RecordWildCards, RelaxedPolyRec, ViewPatterns #-}\n\nmodule Network.HTTP.LoadTest.Report\n (\n reportBasic\n , reportEvents\n , reportFull\n , writeReport\n -- * Other reports\n , csvEvents\n -- * Helper functions\n , buildTime\n ) where\n\nimport Control.Monad (forM_)\nimport Criterion.Analysis (SampleAnalysis(..), OutlierEffect(..),\n OutlierVariance(..))\nimport Data.Data (Data)\nimport Data.Function (on)\nimport Data.Maybe (fromMaybe)\nimport Data.Monoid (mappend, mconcat, mempty)\nimport Data.Text (Text)\nimport Data.Text.Buildable (build)\nimport Data.Text.Format (prec, shortest)\nimport Data.Text.Lazy.Builder (Builder)\nimport Data.Vector (Vector)\nimport Network.HTTP.LoadTest.Types (Analysis(..), Basic(..), Event(..),\n Summary(..), summEnd)\nimport Paths_pronk (getDataFileName)\nimport Prelude hiding (print)\nimport Statistics.Function (sort)\nimport Statistics.Resampling.Bootstrap (Estimate(..))\nimport Statistics.Sample.KernelDensity (kde)\nimport System.IO (Handle)\nimport System.IO.Unsafe (unsafePerformIO)\nimport Text.Hastache (MuType(..))\nimport Text.Hastache.Context (mkGenericContext)\nimport qualified Criterion.Report as R\nimport qualified Data.ByteString.Lazy as L\nimport qualified Data.HashMap.Strict as H\nimport qualified Data.List as List\nimport qualified Data.MeldableHeap as Q\nimport qualified Data.Text.Format as T\nimport qualified Data.Vector.Generic as G\nimport qualified Data.Vector.Unboxed as U\nimport qualified Data.Vector as V\nimport qualified Text.Hastache as H\n\nreportBasic :: Handle -> Analysis Basic -> IO ()\nreportBasic h Analysis{..} = do\n let print a b = T.hprint h a b\n print \"latency:\\n\" ()\n print \" mean: {}\\n\" [time (mean latency)]\n print \" std dev: {}\\n\" [time (stdDev latency)]\n print \" 99%: {}\\n 99.9%: {}\\n\" (time latency99, time latency999)\n print \"\\nthroughput: {}\\n\" [rate throughput]\n\nreportFull :: (IO () -> IO ()) -> Handle -> Analysis SampleAnalysis -> IO ()\nreportFull whenLoud h Analysis{..} = do\n let print a b = T.hprint h a b\n print \"latency:\\n\" ()\n print \" mean: {}\\n\" [time (estPoint (anMean latency))]\n whenLoud $ do\n print \" lower: {}\\n\" [time (estLowerBound (anMean latency))]\n print \" upper: {}\\n\" [time (estUpperBound (anMean latency))]\n print \" std dev: {}\\n\" [time (estPoint (anStdDev latency))]\n whenLoud $ do\n print \" lower: {}\\n\" [time (estLowerBound (anStdDev latency))]\n print \" upper: {}\\n\" [time (estUpperBound (anStdDev latency))]\n effect h (anOutlierVar latency)\n print \" 99%: {}\\n 99.9%: {}\\n\" (time latency99, time latency999)\n print \"\\nthroughput: {}\\n\" [rate throughput]\n\ntime :: Double -> Builder\ntime = buildTime 4\n\nrate :: Double -> Builder\nrate r = prec 4 r `mappend` \" req/sec\"\n\nbuildTime :: Int -> Double -> Builder\nbuildTime precision t\n | t < 1e-3 = prec precision (t * 1e6) `mappend` \" usec\"\n | t < 1 = prec precision (t * 1e3) `mappend` \" msec\"\n | otherwise = prec precision t `mappend` \" sec\"\n\neffect :: Handle -> OutlierVariance -> IO ()\neffect h OutlierVariance{..} =\n case ovEffect of\n Unaffected -> return ()\n _ -> T.hprint h \" estimates {} affected by outliers ({}%)\\n\"\n (howMuch, T.fixed 1 (ovFraction * 100))\n where howMuch = case ovEffect of\n Unaffected -> \"not\" :: Text\n Slight -> \"slightly\"\n Moderate -> \"moderately\"\n Severe -> \"severely\"\n\nreportEvents :: Handle -> Vector Summary -> IO ()\nreportEvents h sumv = do\n let evtMap = G.foldl' go H.empty . G.map summEvent $ sumv\n go m e = H.insertWith (+) (classify e) (1::Int) m\n classify Timeout = 0\n classify HttpResponse{..} = respCode\n T.hprint h \"responses:\\n\" ()\n forM_ (List.sort . H.toList $ evtMap) $ \\(e,n) -> do\n let nameOf 0 = \"timeout \"\n nameOf k = \"HTTP \" `mappend` build k\n T.hprint h \" {} {}\\n\" (nameOf e, T.left 7 ' ' n)\n T.hprint h \"\\n\" ()\n\ncsvEvents :: Vector Summary -> Builder\ncsvEvents sums = \"start,elapsed,event\\n\" `mappend` G.foldr go mempty sums\n where\n firstStart = summStart (G.head sums)\n go Summary{..} b = mconcat [\n shortest $ summStart - firstStart\n , \",\"\n , shortest summElapsed\n , \",\"\n , classify summEvent\n , \"\\n\"\n ] `mappend` b\n classify Timeout = \"timeout\"\n classify HttpResponse{..} = build respCode\n\n-- | The path to the template and other files used for generating\n-- reports.\ntemplateDir :: FilePath\ntemplateDir = unsafePerformIO $ getDataFileName \"templates\"\n{-# NOINLINE templateDir #-}\n\nwriteReport :: (Data a) => FilePath -> Handle -> Double -> Analysis a -> IO ()\nwriteReport template h elapsed a@Analysis{..} = do\n let context \"include\" = MuLambdaM $\n R.includeFile [templateDir, R.templateDir]\n context \"elapsed\" = MuVariable elapsed\n context \"latKdeTimes\" = R.vector \"x\" latKdeTimes\n context \"latKdePDF\" = R.vector \"x\" latKdePDF\n context \"latKde\" = R.vector2 \"time\" \"pdf\" latKdeTimes latKdePDF\n context \"latValues\" = MuList . map mkGenericContext . G.toList $ lats\n context \"thrTimes\" = R.vector \"x\" thrTimes\n context \"thrValues\" = R.vector \"x\" thrValues\n context \"concTimes\" = R.vector \"x\" . U.fromList $ map fstS conc\n context \"concValues\" = R.vector \"x\" . U.fromList $ map sndS conc\n context n = mkGenericContext a n\n (latKdeTimes,latKdePDF) = kde 128 . G.convert . G.map summElapsed $ latValues\n lats = G.map (\\s -> s { summStart = summStart s - t }) latValues\n where t = summStart . G.head $ latValues\n (thrTimes,thrValues) = graphThroughput (min (G.length latValues) 50) elapsed latValues\n conc = graphConcurrency lats\n tpl <- R.loadTemplate [\".\",templateDir] template\n bs <- H.hastacheStr H.defaultConfig tpl context\n L.hPutStr h bs\n\ndata T = T (U.Vector Double) {-# UNPACK #-} !Double\n\n-- | Compute a graph of throughput, requests completed per time\n-- interval.\ngraphThroughput :: Int -- ^ Number of time slices.\n -> Double -- ^ Amount of time elapsed.\n -> V.Vector Summary -> (U.Vector Double, U.Vector Double)\ngraphThroughput slices elapsed sumv =\n (G.generate slices $ \\i -> fromIntegral i * timeSlice,\n G.unfoldrN slices go (T endv 0))\n where go (T v i) = Just (fromIntegral (G.length a), T b j)\n where (a,b) = G.span (<=t) v\n t = start + (j * timeSlice)\n j = i+1\n timeSlice = elapsed / fromIntegral slices\n start = summStart . G.head $ sumv\n endv = G.convert . sort . G.map summEnd $ sumv\n\ndata S = S {\n fstS :: {-# UNPACK #-} !Double\n , sndS :: {-# UNPACK #-} !Int\n }\n\n-- | Compute a graph of concurrency.\ngraphConcurrency :: V.Vector Summary -> [S]\ngraphConcurrency = scanl1 f . filter ((/=0) . sndS) . map (foldl1 (flip f)) .\n List.groupBy ((==) `on` fstS) . go Q.empty . G.toList\n where\n f (S _ i) (S t j) = S t (i+j)\n go q es@(Summary{..}:xs)\n | summStart < t = S summStart 1 : go insQ xs\n | otherwise = S t (-1) : go delQ es\n where (t,delQ) = fromMaybe (1e300,q) $ Q.extractMin q\n insQ = Q.insert (summStart+summElapsed) q\n go q _ = drain q\n where drain (Q.extractMin -> Just (t,q')) = S t (-1) : drain q'\n drain _ = []\n", "meta": {"hexsha": "da494a3153f5e5def5dc2daaf544d044d54933ae", "size": 7637, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "lib/Network/HTTP/LoadTest/Report.hs", "max_stars_repo_name": "fhartwig/pronk", "max_stars_repo_head_hexsha": "e3a0f789801237b5abdd7b2c65d15b47d00d0b98", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 65, "max_stars_repo_stars_event_min_datetime": "2015-01-07T20:48:08.000Z", "max_stars_repo_stars_event_max_datetime": "2021-07-31T11:01:08.000Z", "max_issues_repo_path": "lib/Network/HTTP/LoadTest/Report.hs", "max_issues_repo_name": "liqd/pronk", "max_issues_repo_head_hexsha": "e3a0f789801237b5abdd7b2c65d15b47d00d0b98", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2015-05-07T16:41:30.000Z", "max_issues_repo_issues_event_max_datetime": "2015-05-07T16:41:30.000Z", "max_forks_repo_path": "lib/Network/HTTP/LoadTest/Report.hs", "max_forks_repo_name": "bos/pronk", "max_forks_repo_head_hexsha": "e3a0f789801237b5abdd7b2c65d15b47d00d0b98", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 7, "max_forks_repo_forks_event_min_datetime": "2015-02-06T15:09:43.000Z", "max_forks_repo_forks_event_max_datetime": "2018-02-27T21:04:00.000Z", "avg_line_length": 39.7760416667, "max_line_length": 95, "alphanum_fraction": 0.6087468901, "num_tokens": 2104, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6619228758499941, "lm_q2_score": 0.4687906266262437, "lm_q1q2_score": 0.31030323974796403}} {"text": "{-# LANGUAGE FlexibleContexts #-}\n{-# LANGUAGE FlexibleInstances #-}\n{-# LANGUAGE MultiParamTypeClasses #-}\n{-# LANGUAGE ViewPatterns #-}\n{-# LANGUAGE TypeFamilies #-}\n{-# LANGUAGE ScopedTypeVariables #-}\n{-# LANGUAGE UnicodeSyntax #-}\n--\n-- |\n-- Module : Main\n-- Description : Measures execution time of MC loop for 1D Heisenberg\n-- Hamiltonian. Try @--help@ to get usage information.\n-- Copyright : (c) Tom Westerhout, 2018\n-- License : BSD3\n-- Maintainer : t.westerhout@student.ru.nl\n-- Stability : experimental\nmodule Main where\n\nimport Prelude hiding ( map\n , zipWithM\n )\n\nimport Debug.Trace\nimport qualified System.Random.MWC as MWC\n-- import Control.Lens hiding((<.>))\nimport Control.Monad.Reader hiding ( zipWithM )\nimport Control.Monad.Primitive\nimport qualified Data.List as L\nimport Data.Complex\nimport Data.Semigroup\nimport Data.Vector.Storable ( Vector\n , (!)\n )\nimport qualified Data.Vector.Storable as V\nimport qualified Data.Vector.Storable.Mutable as MV\nimport System.Exit\nimport System.IO hiding ( hGetLine )\nimport System.Environment ( getArgs\n , getProgName\n )\nimport Foreign.Storable\nimport Data.Text ( Text )\nimport Data.Text.IO ( hGetLine )\nimport qualified Data.Text.IO as T\n\n\nimport Lens.Micro\nimport Lens.Micro.Extras\n\nimport PSO.Random\nimport PSO.FromPython\nimport NQS.Rbm (Rbm, mkRbm)\nimport NQS.Rbm.Mutable -- (sampleGradients)\nimport NQS.Internal.Hamiltonian\nimport NQS.Internal.Types -- (\u2102, \u211d)\nimport NQS.Internal.Rbm (unsafeThawRbm)\nimport NQS.Internal.LAPACK\n\nfromPyFile :: FilePath -> IO Rbm\nfromPyFile name = withFile name ReadMode toRbm\n where toRight :: Either String (Vector \u2102) -> Vector \u2102\n toRight (Right x) = x\n toRight (Left x) = error x\n toRbm h = do\n hGetLine h\n a <- trace (\"a...\") $ toRight <$> readVector <$> hGetLine h\n b <- trace (\"b...\") $ toRight <$> readVector <$> hGetLine h\n s <- hGetLine h\n T.putStrLn s\n let !w = trace (\"w...\") $ toRight $ readMatrix s\n return $ mkRbm a b w\n\nrandomRbm :: Int -> Int -> (\u211d, \u211d) -> (\u211d, \u211d) -> (\u211d, \u211d) -> IO Rbm\nrandomRbm n m (lowV, highV) (lowH, highH) (lowW, highW) = do\n g <- mkMWCGen (Just 123)\n flip runReaderT g $ do\n visible <- uniformVector n (lowV :+ lowV, highV :+ highV)\n hidden <- uniformVector m (lowH :+ lowH, highH :+ highH)\n weights <- uniformVector (n * m) (lowW :+ lowW, highW :+ highW)\n return $ trace (\"mkRbm...\") (mkRbm visible hidden weights)\n\nnumberSteps :: (Int, Int, Int) -> Int\nnumberSteps (low, high, step) = (high - low - 1) `div` step + 1\n\nmain = do -- NQS.Internal.LAPACK.test\n let filename = \"/home/tom/src/tcm-swarm/cbits/test/input/rbm_6_6_0.in\"\n rbm <- unsafeThawRbm =<< fromPyFile filename :: IO (MRbm (PrimState IO))\n -- rbm <- unsafeThawRbm =<< randomRbm 100 200 (-0.1, 0.1) (-0.1, 0.1) (-0.05, 0.05)\n let n = sizeVisible rbm\n config = defaultMCConfig & steps .~ (1000, 21000 * n, n)\n & magnetisation .~ (Just 0)\n nParams = size rbm\n nSteps = numberSteps $ config ^. steps\n print n\n hamiltonian <- heisenberg (1, 1) (Just 5.0) (zip [0..] ([1..(n - 1)] ++ [0]))\n moments <- MV.new 4\n -- f <- newDenseVector nParams\n -- grad <- newDenseMatrix (nSteps * config ^. runs) nParams\n sampleMoments config hamiltonian rbm moments -- f grad\n e <- MV.read moments 0\n print [\"Hello!\", show e]\n", "meta": {"hexsha": "aa043ac3169a3931447b8416d6e8b98d932b7667", "size": 4056, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "example/mcmc/Main.hs", "max_stars_repo_name": "twesterhout/tcm-swarm", "max_stars_repo_head_hexsha": "e632d493a9dc0b78c2634c2ac6311abc5f99168a", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "example/mcmc/Main.hs", "max_issues_repo_name": "twesterhout/tcm-swarm", "max_issues_repo_head_hexsha": "e632d493a9dc0b78c2634c2ac6311abc5f99168a", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "example/mcmc/Main.hs", "max_forks_repo_name": "twesterhout/tcm-swarm", "max_forks_repo_head_hexsha": "e632d493a9dc0b78c2634c2ac6311abc5f99168a", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 39.7647058824, "max_line_length": 85, "alphanum_fraction": 0.5438856016, "num_tokens": 1073, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.7025300573952052, "lm_q2_score": 0.4416730056646256, "lm_q1q2_score": 0.31028856201948224}} {"text": "module SimpleParser where\n\nimport SimpleDefs\nimport Control.Monad (liftM)\nimport Text.ParserCombinators.Parsec hiding (spaces)\nimport Numeric (readFloat, readHex, readOct)\nimport Data.Complex (Complex((:+)))\nimport Data.Char (toLower)\nimport Data.Ratio (Rational, (%))\n\nsymbol :: Parser Char\nsymbol = oneOf \"!$%&|*+-/:<=?>@^_~#\"\n\nspaces :: Parser ()\nspaces = skipMany1 space\n\n{-\nparseChar :: Parser LispVal\nparseChar = do string \"#\\\\\"\n c <- many1 letter\n return $ Char $ case map toLower c of\n \"space\" -> ' '\n \"newline\" -> '\\n'\n [x] -> x\n-}\n\nparseString :: Parser LispVal\nparseString = do char '\"'\n x <- many $ parseEscape <|> (noneOf \"\\\\\\\"\")\n char '\"'\n return $ String x\n\nparseEscape :: Parser Char\nparseEscape = do char '\\\\'\n c <- oneOf \"\\\\\\\"nrt\"\n return $ case c of\n '\\\\' -> c\n '\\\"' -> c\n 'n' -> '\\n'\n 'r' -> '\\r'\n 't' -> '\\t'\n\nparseAtom :: Parser LispVal\nparseAtom = do first <- letter <|> symbol\n rest <- many $ letter <|> digit <|> symbol\n let atom = first : rest\n return $ case atom of\n \"#t\" -> Bool True\n \"#f\" -> Bool False \n _ -> Atom atom\n\nparseSimpleNumber :: Parser LispVal\nparseSimpleNumber = many1 digit >>= return . Number . read\n\n{-\nparseRadixNumber :: Parser LispVal\nparseRadixNumber = char '#' >>\n ( parseDecimal\n <|> parseOctal\n <|> parseHexadecimal\n <|> parseBinary\n )\n\nparseDecimal, parseHexadecimal, parseBinary, parseOctal :: Parser LispVal\nparseDecimal = do char 'd'\n number <- many1 digit\n return . Number . read $ number\n\nparseHexadecimal = do char 'x'\n number <- many $ digit <|> (oneOf \"abcdef\")\n return . Number . fst . head . readHex $ number\n\nparseBinary = do char 'b'\n number <- many1 . oneOf $ \"01\"\n return . Number . readBin $ number\n\nparseOctal = do char 'o'\n number <- many1 . oneOf $ \"01234567\"\n return . Number . fst . head . readOct $ number\n\nreadBin :: String -> Integer\nreadBin bin = fst $ foldl (\\(n, ix) x -> (n + (num x) * (2 ^ ix), ix - 1)) \n (0, (length bin) - 1)\n bin where\n num '0' = 0\n num '1' = 1\n-}\nparseNumber :: Parser LispVal\nparseNumber = parseSimpleNumber -- <|> parseRadixNumber\n\n{- \nparseFloat :: Parser LispVal\nparseFloat = do before <- many1 digit\n char '.'\n after <- many1 digit\n return . Float . fst . head . readFloat $ before ++ '.' : after\n\nparseRational :: Parser LispVal\nparseRational = do before <- fmap read $ many1 digit\n char '/'\n after <- fmap read $ many1 digit\n return . Rational $ (before % after)\n\nparseComplex :: Parser LispVal\nparseComplex = do real <- fmap toFloat $ parseFloat <|> parseSimpleNumber\n char '+'\n imag <- fmap toFloat $ parseFloat <|> parseSimpleNumber\n char 'i'\n return . Complex $ (real :+ imag) where\n toFloat (Float x) = x\n toFloat (Number x) = fromInteger x\n-}\n\nparseQuoted :: Parser LispVal \nparseQuoted = do char '\\''\n x <- parseExpr\n return $ List [Atom \"quote\", x]\n\nparseList :: Parser LispVal\nparseList = liftM List $ sepBy parseExpr spaces\n\nparseDottedList :: Parser LispVal\nparseDottedList = do head <- endBy parseExpr spaces\n char '.'\n many1 spaces\n tail <- parseExpr\n return $ DottedList head tail\n\n\nparseExpr :: Parser LispVal\nparseExpr = parseAtom\n -- <|> parseBool\n -- <|> parseChar\n <|> parseString\n -- <|> parseComplex\n -- <|> parseRational\n -- <|> parseFloat\n <|> parseNumber\n <|> parseQuoted\n <|> do char '('\n x <- (try parseList) <|> parseDottedList\n char ')'\n return x\n", "meta": {"hexsha": "b0b4c939ec9731a8dfd28f1e5293c73ce8d31546", "size": 4362, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/SimpleParser.hs", "max_stars_repo_name": "5hubh4m/simple-scheme", "max_stars_repo_head_hexsha": "24eb864ab7ee1f372d6d309eaba85d35a075ad7d", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 4, "max_stars_repo_stars_event_min_datetime": "2016-06-18T02:50:53.000Z", "max_stars_repo_stars_event_max_datetime": "2018-05-09T10:17:44.000Z", "max_issues_repo_path": "src/SimpleParser.hs", "max_issues_repo_name": "5hubh4m/simple-scheme", "max_issues_repo_head_hexsha": "24eb864ab7ee1f372d6d309eaba85d35a075ad7d", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/SimpleParser.hs", "max_forks_repo_name": "5hubh4m/simple-scheme", "max_forks_repo_head_hexsha": "24eb864ab7ee1f372d6d309eaba85d35a075ad7d", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 30.2916666667, "max_line_length": 79, "alphanum_fraction": 0.492434663, "num_tokens": 1021, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.5926665999540698, "lm_q2_score": 0.523420348936324, "lm_q1q2_score": 0.31021375855086397}} {"text": "{-# LANGUAGE RecordWildCards #-}\n{-# LANGUAGE BangPatterns #-}\n{-# LANGUAGE TypeSynonymInstances #-}\n{-# LANGUAGE FlexibleInstances #-}\nmodule Statistics.BBVI.Propagator\n ( DistCell(..)\n , DistCells\n , DistCellss\n , SampleVector\n , SampleDouble\n , Gradient\n , Memory\n , Time\n , mergeGeneric\n , mergeGenerics\n , mergeGenericss\n , dist\n , time\n , defaultDistCell\n )\nwhere\n\nimport Statistics.BBVI.Class\nimport qualified Data.Vector as V\nimport Data.Propagator\n\n-- | a sample with a vector type e.g. sample from a dirichlet\ntype SampleVector = V.Vector Double\n\n-- | a sample with a real type e.g. number sampled from a gaussian\ntype SampleDouble = Double\n\ntype Gradient = V.Vector Double\n\ntype Memory = V.Vector Double\n\n-- | number of times a distribution cell has been updated\ntype Time = Int\n\n-- | distribution cell\ndata DistCell a\n =\n U !Memory !Gradient -- ^ update to a distribution cell\n | Node !Time !Memory !a -- ^ distribution cell with a distribution\n -- of type a\n deriving (Show, Eq, Ord, Read)\n\n-- !(Gradient -> DistCell a -> (Memory, Gradient))\n\n-- | helper function for initializing distribution cells\ndefaultDistCell\n :: DistUtil a\n => a -- ^ initial point for distribution\n -> DistCell a -- ^ distribution cell\ndefaultDistCell d = Node 1 (V.replicate (nParams d) 0) d\n\n-- | time accessor for a distribution cell\ntime :: DistCell a -> Time\ntime (Node t _ _) = t\ntime (U{} ) = error \"called time on update propnode!\"\n-- memory (Node _ m _) = m\n\n-- | distribution accessor for a distribution cell\ndist :: DistCell a -> a\ndist (Node _ _ d) = d\ndist (U{} ) = error \"called dist on update propnode!\"\n\n-- | single cell representing a vector of distribution cells\ntype DistCells a = V.Vector (DistCell a)\n\n-- | single cell representing an array (vector of vector) of distribution cells\ntype DistCellss a = V.Vector (V.Vector (DistCell a))\n\n-- | generic merge for DistCells: useful for customizing\n-- \"quiesence\" thresholds with cellWith\nmergeGeneric\n :: DistUtil a\n => Time -- ^ maximum number of updates to a cell\n -> Double -- ^ threshold for information to be considered \"new\"; if\n -- the l2-norm of the change in the distribution's\n -- parameters is less than this threshold, the cell\n -- remains unchanged\n -> DistCell a -- ^ current cell\n -> DistCell a -- ^ proposed update to cell\n -> Change (DistCell a)\nmergeGeneric maxStep delta !x1 !x2 = m x1 x2\n where\n m no@(Node t memory d) (U memUp gradUp)\n | norm gradUp < delta = Change False no\n | t >= maxStep = Change False no\n | otherwise = Change True updateNode\n where\n updateNode = Node (t + 1)\n (V.zipWith (+) memory memUp)\n (fromParamVector newQ)\n where newQ = V.zipWith (+) (toParamVector d) gradUp\n m (U _ _) _ = Contradiction mempty \"Trying to update a gradient\"\n -- CAREFUL: below is dangerous if I start doing the ideas i thought\n -- about: changing maxstep and elta node for local optmizations\n m no1@(Node t1 _m1 d1) no2@(Node t2 _m2 d2)\n | t1 >= maxStep\n = Change False no1\n | (t2 > t1)\n && (norm (V.zipWith (-) (toParamVector d1) (toParamVector d2)) >= delta)\n = Change True no2\n | otherwise\n = Change False no1\n\n-- | generalization of 'mergeGeneric' to cells of vectors of distributions\nmergeGenerics\n :: DistUtil a\n => Time -- ^ maximum number of updates to the cells\n -> Double -- ^ threshold for information to be considered \"new\"; if\n -- the l2-norm of change in the distribution's parameters\n -- is less than this threshold for all distributions, the\n -- cell remains unchanged\n -> DistCells a -- ^ current cells\n -> DistCells a -- ^ proposed update to cells\n -> Change (DistCells a)\nmergeGenerics m d x1 x2 = V.sequence . V.zipWith (mergeGeneric m d) x1 $ x2\n\n-- | generalization of 'mergeGeneric' to cells of arrays of distributions\nmergeGenericss\n :: DistUtil a\n => Time -- ^ maximum number of updates to the cells\n -> Double -- ^ threshold for information to be considered \"new\"; if\n -- the l2-norm of change in the distribution's parameters\n -- is less than this threshold for all distributions, the\n -- cell remains unchanged\n -> DistCellss a -- ^ current cell\n -> DistCellss a -- ^ proposed update to cell\n -> Change (DistCellss a)\nmergeGenericss m d v1 v2 = V.sequence . V.zipWith (mergeGenerics m d) v1 $ v2\n\ninstance DistUtil a => Propagated (DistCell a) where\n merge = mergeGeneric 1000000 1e-16\n\ninstance DistUtil a => Propagated (DistCells a) where\n merge ns updates = V.sequence $ V.zipWith merge ns updates\n\ninstance DistUtil a => Propagated (DistCellss a) where\n merge ns updates = V.sequence $ V.zipWith merge ns updates\n\nnorm :: V.Vector Double -> Double\nnorm = sqrt . V.sum . V.map (^ (2 :: Int))\n", "meta": {"hexsha": "8aa7e35db5de324dd5a70032d8c493e6107c01ef", "size": 4920, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/Statistics/BBVI/Propagator.hs", "max_stars_repo_name": "massma/propagator-bbvi", "max_stars_repo_head_hexsha": "7a29a1e28a401d7c5e6a41b7ed3eebcf166b113a", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/Statistics/BBVI/Propagator.hs", "max_issues_repo_name": "massma/propagator-bbvi", "max_issues_repo_head_hexsha": "7a29a1e28a401d7c5e6a41b7ed3eebcf166b113a", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/Statistics/BBVI/Propagator.hs", "max_forks_repo_name": "massma/propagator-bbvi", "max_forks_repo_head_hexsha": "7a29a1e28a401d7c5e6a41b7ed3eebcf166b113a", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 33.698630137, "max_line_length": 79, "alphanum_fraction": 0.662804878, "num_tokens": 1300, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.603931819468636, "lm_q2_score": 0.5117166047041654, "lm_q1q2_score": 0.3090419401312994}} {"text": "{-# LANGUAGE ScopedTypeVariables #-}\r\n{-# LANGUAGE FlexibleContexts #-}\r\n\r\n-- This file is the new version for C-code FFT algorithm with Nyquist allready on position 1.\r\n\r\n-- | This module imports the C-functions for a Fast Fourier Transform and encapsulates them in\r\n-- list-mapping functions. (At first it was a DFT algoritm which I changed, but I didn'd change\r\n-- all the names of the functions, so it is called dft...)\r\n-- The functionality of this module is used for filtering audio data, i. e. for building\r\n-- audio filters.\r\n\r\nmodule Sound.Hommage.DFTFilter\r\n (\r\n\r\n-- | Filtering is done with an FFT algorithm written in C (in the file dft.c).\r\n-- This module imports the c-functions for fft ('analyseDFT') and inverse fft ('syntheseDFT'),\r\n-- which operate on Arrays with 1024 Double values.\r\n-- The array-operations are embedded in a mechanism that does buffering, overlapping and windowing\r\n-- and works like a black box that maps one input value to one output value in the IO monad\r\n-- ('mkAnalyse', 'mkSynthese', 'mkFilterBuffered').\r\n-- Around these IO's some list mapping functions are wrapped ('dftanalyse', 'dftsynthese', 'dftfilter',\r\n-- 'dftfilterBy') for convenient use in a Haskell programm.\r\n--\r\n-- Mapping the Fourier coefficients during the filter process means filtering the data.\r\n-- The result depends on the way the coefficients are mapped resp. modified while mapping.\r\n-- The function to do this has the type of 'CoeffMap'.\r\n--\r\n-- /Description of the filtering process:/\r\n--\r\n-- Filtering is done by mapping the coefficients with 'CoeffMap'.\r\n-- For this the wave data is split into parts of 1024 values, where every part overlaps with the\r\n-- preceeding and succeeding part by 512 values. Via the fourier-transform (analyse) every part\r\n-- is mapped to its frequency spectrum, i. e. its fourier coefficients.\r\n--\r\n-- The 'CoeffMap' action is applied to every frequency spectrum (see 'CoeffArr') in sequence.\r\n-- It reads the coefficients from the first 'CoeffArr' where the input is stored and writes it\r\n-- (or some data derived from it) to the second one. This is the point where the \\'real\\' filtering\r\n-- happens. Via the inverse fourier-transform (synthese) the resulting coefficients are mapped\r\n-- to their real signal values. These signal values are multiplied with a half cosinus curve for\r\n-- fading in and out (windowing). Then they are mixed in the way their source data was split:\r\n-- Every part overlaps for 512 values with the last and the next one.\r\n\r\n -- * User-Level Filter Functions\r\n dftanalyse\r\n , dftsynthese\r\n , dftfilter\r\n , dftfilterBy\r\n , dftfilterBy'\r\n\r\n -- * CoeffArr\r\n , CoeffArr\r\n , readCoeffArr\r\n-- , readCoeffArr'\r\n , writeCoeffArr\r\n-- , writeCoeffArr'\r\n , storeCoeff\r\n , unstoreCoeff\r\n -- * CoeffMap\r\n , CoeffMap\r\n , mkCoeffMap\r\n , coeffmap\r\n -- * IO Wrapper\r\n , mkAnalyse\r\n , mkSynthese\r\n , mkFilterBuffered\r\n -- * Interface to C-code\r\n , analyseDFT\r\n , syntheseDFT\r\n , kurveDFT\r\n )\r\n where\r\n\r\nimport GHC.Weak\r\nimport GHC.IO\r\nimport Foreign.ForeignPtr\r\nimport Foreign.Ptr\r\nimport Foreign.Storable\r\nimport Data.Array.Storable\r\nimport Data.Complex\r\nimport Data.Array.IO\r\nimport Data.IORef\r\n\r\nimport Sound.Hommage.Misc\r\n---------------------------------------------------------------------------------------------------\r\n-- ([Complex Double] -> [Complex Double]) -> IO CoeffMap\r\n\r\n-- | (Fast) Fourier Transformation and Inverse with a buffer-mapping action for filtering.\r\ndftfilterBy :: IO (CoeffMap ()) -> [Double] -> [Double]\r\ndftfilterBy cm = drop 1536 . inList (mkFilterBuffered cm) . (++ replicate 512 0.0)\r\n\r\n-- | (Fast) Fourier Transformation and Inverse with a buffer-mapping action for filtering.\r\ndftfilterBy' :: s -> IO (s -> CoeffMap s) -> [Double] -> [Double]\r\ndftfilterBy' s cm = drop 1536 . inList (mkFilterBuffered' s cm) . (++ replicate 512 0.0)\r\n\r\n-- | (Fast) Fourier Transformation and Inverse with an additional argument with sublists of\r\n-- factors to weight the coefficients. See 'mkCoeffMap' for a decription of that argument.\r\ndftfilter :: [Double] -> [Double] -> [Double]\r\ndftfilter ds = dftfilterBy (mkCoeffMap (replicate 512 0 ++ ds))\r\n\r\n-- | Inverse (Fast) Fourier Transformation\r\ndftsynthese :: [Complex Double] -> [Double]\r\ndftsynthese = inList mkSynthese\r\n\r\n-- | (Fast) Fourier Transformation.\r\ndftanalyse :: [Double] -> [(Complex Double)]\r\ndftanalyse = inList mkAnalyse\r\n\r\n---------------------------------------------------------------------------------------------------\r\nforeign import ccall \"cinit\" initfou :: Int\r\n\r\nforeign import ccall \"canalyse\" cAnalyse :: Ptr Double -> Ptr Double -> IO ()\r\n\r\nforeign import ccall \"csynthese\" cSynthese :: Ptr Double -> Ptr Double -> IO ()\r\n\r\nforeign import ccall \"ckurve\" cKurve :: Ptr Double -> IO ()\r\n---------------------------------------------------------------------------------------------------\r\n-- | Maps an array with 1024 real values to its frequency spectrum with 512 complex values.\r\n-- The spectrum is stored in the second array with 1024 Doubles which are the real and imaginary\r\n-- parts of the complex values. See 'CoeffArr' for a detailed frequency spectrum\r\n-- desription.\r\nanalyseDFT :: StorableArray Int Double -> StorableArray Int Double -> IO ()\r\nanalyseDFT wave coeffs = seq initfou $\r\n withStorableArray wave $ \\ptr_w ->\r\n withStorableArray coeffs $ \\ptr_c ->\r\n cAnalyse ptr_w ptr_c\r\n\r\n-- | Maps a frequency spectrum to its signal value. Both arrays have a length of 1024; the first one\r\n-- contains the 512 complex values of the spectrum. The real signal value will be stored in\r\n-- the second array. See 'CoeffArr' for a detailed frequency spectrum\r\n-- desription.\r\nsyntheseDFT :: StorableArray Int Double -> StorableArray Int Double -> IO ()\r\nsyntheseDFT coeffs wave = seq initfou $\r\n withStorableArray wave $ \\ptr_w ->\r\n withStorableArray coeffs $ \\ptr_c ->\r\n cSynthese ptr_c ptr_w\r\n\r\n-- | Fades a signal which is stored in an array of length 1024 in and out.\r\n-- The signal is multiplied with a cosinus curve with range 0..pi.\r\nkurveDFT :: StorableArray Int Double -> IO ()\r\nkurveDFT wave = seq initfou $\r\n withStorableArray wave $ \\ptr_w ->\r\n cKurve ptr_w\r\n---------------------------------------------------------------------------------------------------\r\n--\r\n---------------------------------------------------------------------------------------------------\r\n-- | Represents a frequency spectrum.\r\n-- Range is from 0 to 1023 (N=1024).\r\n-- Index 0 is constant value, index 1 is Nyquest frequency (real part of the N\\/2 frequency).\r\n-- Index 2 and 3 are the complex value for the basefrequency, index 4 and 5\r\n-- are the complex value for the double basefrequency, 6 and 7 for 3 * basefrequency and so on:\r\n--\r\n-- > arr [0] = real part of zero frequency (imaginary part is allways 0)\r\n-- > arr [1] = real part of Nyquest frequency (N/2) (imaginary part is allways 0)\r\n-- > arr [2] = real part of base frequency\r\n-- > arr [3] = imag part of base frequency\r\n-- > arr [4] = real part of base frequency * 2\r\n-- > arr [5] = imag part of base frequency * 2\r\n-- > arr [6] = real part of base frequency * 3\r\n-- > arr [7] = imag part of base frequency * 3\r\n-- > ...\r\n-- > arr [N-4] = real part of base frequency * (N/2 - 2)\r\n-- > arr [N-3] = imag part of base frequency * (N/2 - 2)\r\n-- > arr [N-2] = real part of base frequency * (N/2 - 1)\r\n-- > arr [N-1] = imag part of base frequency * (N/2 - 1)\r\n--\r\n-- Pseudocode:\r\n--\r\n-- > c (0) = (arr [0] :+ 0)\r\n-- > c (512) = (arr [1] :+ 0)\r\n--\r\n-- and for all i=[1..511]:\r\n--\r\n-- > c (i) = (arr [i*2] :+ arr [i*2+1])\r\n--\r\ntype CoeffArr = StorableArray Int Double\r\n\r\n{-\r\n-- | Reads a Complex value of a CoeffArr as described at 'CoeffArr'.\r\nreadCoeffArr :: CoeffArr -> Int -> IO (Complex Double)\r\nreadCoeffArr arr n = if n == 0 then readArray arr 0 >>= \\x -> readArray arr 1023 >>= \\y -> return (x :+ y)\r\n else let j = 2*n\r\n j' = j-1\r\n in readArray arr j' >>= \\x -> readArray arr j >>= \\y -> return (x :+ y)\r\n\r\n-- | Writes a Complex value of a CoeffArr as described at 'CoeffArr'.\r\nwriteCoeffArr :: CoeffArr -> Int -> Complex Double -> IO ()\r\nwriteCoeffArr arr n c = if n == 0 then writeArray arr 0 (realPart c) >> writeArray arr 1023 (imagPart c)\r\n else let j = 2*n\r\n j' = j-1\r\n in writeArray arr j' (realPart c) >> writeArray arr j (imagPart c)\r\n-}\r\n\r\n-- | Reads a Complex value of a CoeffArr (with Nyquest as imaginary part of coeff 0).\r\nreadCoeffArr :: CoeffArr -> Int -> IO (Complex Double)\r\nreadCoeffArr arr n =\r\n let j = 2*n\r\n j' = j+1\r\n in readArray arr j >>= \\x -> readArray arr j' >>= \\y -> return (x :+ y)\r\n\r\n-- | Writes a Complex value of a CoeffArr (with Nyquest as imaginary part of coeff 0).\r\nwriteCoeffArr :: CoeffArr -> Int -> Complex Double -> IO ()\r\nwriteCoeffArr arr n c =\r\n let j = 2*n\r\n j' = j+1\r\n in writeArray arr j (realPart c) >> writeArray arr j' (imagPart c)\r\n\r\nstoreCoeff :: IOArray Int (Complex Double) -> CoeffArr -> IO ()\r\nstoreCoeff arr brr = do\r\n for 0 (<512) (+1) $ \\i -> let i1 = i * 2\r\n i2 = i1 + 1\r\n in do (x :+ y) <- readArray arr i\r\n writeArray brr i1 x\r\n writeArray brr i2 y\r\n\r\nunstoreCoeff :: CoeffArr -> IOArray Int (Complex Double) -> IO ()\r\nunstoreCoeff brr arr = do\r\n for 0 (<512) (+1) $ \\i -> let i1 = i * 2\r\n i2 = i1 + 1\r\n in do x <- readArray brr i1\r\n y <- readArray brr i2\r\n writeArray arr i (x :+ y)\r\n---------------------------------------------------------------------------------------------------\r\n-- | An action that maps the fourier coefficients from the first array to the second.\r\n-- Modifying the data while mapping means filtering. See 'CoeffArr' for a description of the arrays.\r\ntype CoeffMap a = CoeffArr -> CoeffArr -> IO a\r\n\r\n-- | Constructs a Coeffmap.\r\n-- The sublists contain the 512 real values with which the basefrequency and the 511 complex fourier coefficients\r\n-- are multiplied (the Nyquist frequency will be zero).\r\n-- The first value is the factor for the constant coefficient, the second for the base frequency, the next one\r\n-- for the double base freq and so on.\r\n-- If the sublists have more than 512 elements, these elements are thrown away.\r\n-- If it is shorter, the array will be filled up with zeros.\r\n{-\r\nmkCoeffMap :: [[Double]] -> IO (CoeffMap ())\r\nmkCoeffMap cs = do\r\n r <- newIORef cs\r\n b <- newArray (0,511) 0.0\r\n return $ \\a1 a2 -> let loop i (x:xs) = if i >= 512 then return () else\r\n writeArray b i x >> loop (i+1) xs\r\n loop i [] = for i (<512) (+1) (\\i -> writeArray b i 0.0)\r\n in do xs <- readIORef r\r\n let (xi,xr) | null xs = ([], [])\r\n | otherwise = (head xs, tail xs)\r\n writeIORef r xr\r\n loop 0 xi\r\n coeffmap b a1 a2\r\n-}\r\n\r\nmkCoeffMap :: [Double] -> IO (CoeffMap ())\r\nmkCoeffMap cs = do\r\n r <- newIORef cs\r\n b <- newArray (0,511) 0.0\r\n return $ \\a1 a2 -> let loop i (x:xs) = if i >= 512\r\n then writeIORef r (x:xs)\r\n else writeArray b i x >> loop (i+1) xs\r\n loop i [] = for i (<512) (+1) (\\i -> writeArray b i 0.0)\r\n >> writeIORef r []\r\n in do xs <- readIORef r\r\n loop 0 xs\r\n coeffmap b a1 a2\r\n\r\n\r\n-- | 'coeffmap' takes an Array with 512 values and uses them for a weigted map of the fourier\r\n-- coefficients. The Nyquist frequency is muliplied with 0.0.\r\ncoeffmap :: StorableArray Int Double -> CoeffMap ()\r\ncoeffmap filt coeffs coeffs' = do\r\n for 0 (<512) (+1) (\\i -> let j = 2*i\r\n j' = j + 1\r\n in\r\n readArray filt i >>= \\c ->\r\n readArray coeffs j >>= \\c1 ->\r\n readArray coeffs j' >>= \\c2 ->\r\n writeArray coeffs' j (c * c1) >>\r\n writeArray coeffs' j' (c * c2) )\r\n writeArray coeffs' 1 0.0\r\n\r\n{-\r\ncoeffmap' :: ([Complex Double] -> [Complex Double]) -> IO (CoeffMap ())\r\ncoeffmap' f = do\r\n let toDest arr 1024 _ = return ()\r\n toDest arr n (x:xs) = writeArray arr n x >> toDest arr (n+1) xs\r\n toDest arr n [] = writeArray arr n 0 >> toDest arr (n+1) []\r\n return $ \\arr brr -> getElems arr >>= toDest brr 0 . f\r\n-}\r\n---------------------------------------------------------------------------------------------------\r\n-- | Constructs an action that maps wave-data to coefficient-data.\r\n-- Has a delay of 512, i. e. the first 512 elements are zero and the result has (these)\r\n-- 512 elemets more than the input.\r\nmkAnalyse :: IO (Maybe Double -> IO (Maybe (Complex Double)))\r\nmkAnalyse = do\r\n warr <- newArray (0, 1023) 0.0\r\n carr <- newArray (0, 1023) 0.0\r\n oarr <- newArray (0, 511) (0.0 :+ 0.0)\r\n-- SIGNALSTREAM reada closea <- openSignalStream sa\r\n rpos <- newIORef 0\r\n rcnt <- newIORef Nothing\r\n let read ma = checkpos >> readIORef rcnt >>= maybe (more ma) rest\r\n more ma = maybe irest snext ma\r\n rest k | k <= 0 = return Nothing\r\n | otherwise = do writeIORef rcnt $ Just (k-1)\r\n pos <- readIORef rpos\r\n x <- readArray oarr pos\r\n writeIORef rpos (pos + 1)\r\n return $ Just x\r\n irest = do writeIORef rcnt (Just 511)\r\n pos <- readIORef rpos\r\n fillrest pos\r\n x <- readArray oarr pos\r\n writeIORef rpos (pos + 1)\r\n return $ Just x\r\n snext a = do pos <- readIORef rpos\r\n x <- readArray oarr pos\r\n writeArray warr (pos+512) a\r\n writeIORef rpos (pos + 1)\r\n return $ Just x\r\n checkpos = readIORef rpos >>= \\p -> if p < 512 then return () else do\r\n writeIORef rpos 0\r\n analyseDFT warr carr\r\n unstoreCoeff carr oarr\r\n for 0 (<512) (+1) (\\i -> readArray warr (i+512) >>= writeArray warr i)\r\n fillrest k = for (512+k) (<1024) (+1) (\\i -> writeArray warr i 0.0)\r\n return read\r\n---------------------------------------------------------------------------------------------------\r\n-- | Constructs an action that maps coefficient-data to wave-data.\r\n-- Has a delay of 512, i. e. the first 512 elements are zero and the result has (these)\r\n-- 512 elemets more than the input.\r\nmkSynthese :: IO (Maybe (Complex Double) -> IO (Maybe Double))\r\nmkSynthese = do\r\n iarr <- newArray (0, 511) (0.0 :+ 0.0)\r\n carr <- newArray (0, 1023) 0.0\r\n warr <- newArray (0, 1023) 0.0\r\n (oarr :: IOArray Int Double) <- newArray (0, 511) 0.0\r\n-- SIGNALSTREAM reada closea <- openSignalStream sa\r\n rpos <- newIORef 0\r\n rcnt <- newIORef Nothing\r\n let read ma = checkpos >> readIORef rcnt >>= maybe (more ma) rest\r\n more ma = maybe irest snext ma\r\n rest k | k <= 0 = return Nothing\r\n | otherwise = do writeIORef rcnt $ Just (k-1)\r\n pos <- readIORef rpos\r\n x <- readArray oarr pos\r\n writeIORef rpos (pos + 1)\r\n return $ Just x\r\n irest = do writeIORef rcnt (Just 511)\r\n pos <- readIORef rpos\r\n fillrest pos\r\n x <- readArray oarr pos\r\n writeIORef rpos (pos + 1)\r\n return $ Just x\r\n snext a = do pos <- readIORef rpos\r\n x <- readArray oarr pos\r\n writeArray iarr pos a\r\n writeIORef rpos (pos + 1)\r\n return $ Just x\r\n checkpos = readIORef rpos >>= \\p -> if p < 512 then return () else do\r\n writeIORef rpos 0\r\n storeCoeff iarr carr\r\n for 0 (<512) (+1) (\\i -> readArray warr (i+512) >>= writeArray oarr i)\r\n syntheseDFT carr warr\r\n kurveDFT warr\r\n for 0 (<512) (+1) (\\i -> readArray warr i >>= \\x ->\r\n readArray oarr i >>= \\y -> writeArray oarr i (x+y))\r\n fillrest k = for k (<512) (+1) (\\i -> writeArray iarr i (0.0 :+ 0.0))\r\n return read\r\n---------------------------------------------------------------------------------------------------\r\n-- | Constructs an action that maps wave-data to wave-data via a Fast Foutrier Transform and inverse,\r\n-- filtered by the given 'CoeffMap'.\r\n-- Has a delay of 1024.\r\nmkFilterBuffered :: IO (CoeffMap ()) -> IO (Maybe Double -> IO (Maybe Double))\r\nmkFilterBuffered mkf = do\r\n f <- mkf\r\n warr <- newArray (0, 1023) 0.0\r\n carr <- newArray (0, 1023) 0.0\r\n carr' <- newArray (0, 1023) 0.0\r\n warr' <- newArray (0, 1023) 0.0\r\n (oarr :: IOArray Int Double) <- newArray (0, 511) 0.0\r\n-- SIGNALSTREAM reada closea <- openSignalStream sa\r\n rpos <- newIORef 0\r\n rcnt <- newIORef Nothing\r\n let read ma = checkpos >> readIORef rcnt >>= maybe (more ma) rest\r\n more ma = maybe irest snext ma\r\n rest k | k <= 0 = return Nothing\r\n | otherwise = do writeIORef rcnt $ Just (k-1)\r\n pos <- readIORef rpos\r\n x <- readArray oarr pos\r\n writeIORef rpos (pos + 1)\r\n return $ Just x\r\n irest = do writeIORef rcnt (Just 511)\r\n pos <- readIORef rpos\r\n fillrest pos\r\n x <- readArray oarr pos\r\n writeIORef rpos (pos + 1)\r\n return $ Just x\r\n snext a = do pos <- readIORef rpos\r\n x <- readArray oarr pos\r\n writeArray warr (pos+512) a\r\n writeIORef rpos (pos + 1)\r\n return $ Just x\r\n checkpos = readIORef rpos >>= \\p -> if p < 512 then return () else do\r\n writeIORef rpos 0\r\n analyseDFT warr carr\r\n for 0 (<512) (+1) (\\i -> readArray warr (i+512) >>= writeArray warr i >>\r\n readArray warr' (i+512) >>= writeArray oarr i)\r\n f carr carr'\r\n syntheseDFT carr' warr'\r\n kurveDFT warr'\r\n for 0 (<512) (+1) (\\i -> readArray warr' i >>= \\x ->\r\n readArray oarr i >>= \\y -> writeArray oarr i (x+y))\r\n\r\n fillrest k = for (512+k) (<1024) (+1) (\\i -> writeArray warr i 0.0)\r\n return read\r\n---------------------------------------------------------------------------------------------------\r\n\r\n-- | Constructs an action that maps wave-data to wave-data via a Fast Foutrier Transform and inverse,\r\n-- filtered by the given 'CoeffMap'.\r\n-- Has a delay of 1024.\r\nmkFilterBuffered' :: s -> IO (s -> CoeffMap s) -> IO (Maybe Double -> IO (Maybe Double))\r\nmkFilterBuffered' st mkf = do\r\n stref <- newIORef st\r\n f <- mkf\r\n warr <- newArray (0, 1023) 0.0\r\n carr <- newArray (0, 1023) 0.0\r\n carr' <- newArray (0, 1023) 0.0\r\n warr' <- newArray (0, 1023) 0.0\r\n (oarr :: IOArray Int Double) <- newArray (0, 511) 0.0\r\n-- SIGNALSTREAM reada closea <- openSignalStream sa\r\n rpos <- newIORef 0\r\n rcnt <- newIORef Nothing\r\n let read ma = checkpos >> readIORef rcnt >>= maybe (more ma) rest\r\n more ma = maybe irest snext ma\r\n rest k | k <= 0 = return Nothing\r\n | otherwise = do writeIORef rcnt $ Just (k-1)\r\n pos <- readIORef rpos\r\n x <- readArray oarr pos\r\n writeIORef rpos (pos + 1)\r\n return $ Just x\r\n irest = do writeIORef rcnt (Just 511)\r\n pos <- readIORef rpos\r\n fillrest pos\r\n x <- readArray oarr pos\r\n writeIORef rpos (pos + 1)\r\n return $ Just x\r\n snext a = do pos <- readIORef rpos\r\n x <- readArray oarr pos\r\n writeArray warr (pos+512) a\r\n writeIORef rpos (pos + 1)\r\n return $ Just x\r\n checkpos = readIORef rpos >>= \\p -> if p < 512 then return () else do\r\n writeIORef rpos 0\r\n analyseDFT warr carr\r\n for 0 (<512) (+1) (\\i -> readArray warr (i+512) >>= writeArray warr i >>\r\n readArray warr' (i+512) >>= writeArray oarr i)\r\n s <- readIORef stref\r\n s' <- f s carr carr'\r\n writeIORef stref s'\r\n syntheseDFT carr' warr'\r\n kurveDFT warr'\r\n for 0 (<512) (+1) (\\i -> readArray warr' i >>= \\x ->\r\n readArray oarr i >>= \\y -> writeArray oarr i (x+y))\r\n\r\n fillrest k = for (512+k) (<1024) (+1) (\\i -> writeArray warr i 0.0)\r\n return read\r\n---------------------------------------------------------------------------------------------------\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n{-\r\n-- | Reads a Complex value of a CoeffArr\r\nreadCoeffArr :: CoeffArr -> Int -> IO (Complex Double)\r\nreadCoeffArr arr n = if n == 0 then readArray arr 0 >>= \\x -> readArray arr 1023 >>= \\y -> return (x :+ y)\r\n else let j = 2*n\r\n j' = j-1\r\n in readArray arr j' >>= \\x -> readArray arr j >>= \\y -> return (x :+ y)\r\n\r\n-- | Writes a Complex value of a CoeffArr\r\nwriteCoeffArr :: CoeffArr -> Int -> Complex Double -> IO ()\r\nwriteCoeffArr arr n c = if n == 0 then writeArray arr 0 (realPart c) >> writeArray arr 1023 (imagPart c)\r\n else let j = 2*n\r\n j' = j-1\r\n in writeArray arr j' (realPart c) >> writeArray arr j (imagPart c)\r\n\r\n-- | Copies coefficient data from an IOArray with Complex values (512 elements) to a\r\n-- StorableArray with Doubles (1024 elements)\r\nstoreCoeff :: IOArray Int (Complex Double) -> CoeffArr -> IO ()\r\nstoreCoeff arr brr = do\r\n for 1 (<512) (+1) $ \\i -> let i2 = i * 2\r\n i1 = i2 - 1\r\n in do (x :+ y) <- readArray arr i\r\n writeArray brr i1 x\r\n writeArray brr i2 y\r\n (x :+ y) <- readArray arr 0\r\n writeArray brr 0 x\r\n writeArray brr 1023 y\r\n\r\n-- | Copies coefficient data from a StorableArray with Doubles (1024 elements) to\r\n-- an IOArray with Complex values (512 elements).\r\nunstoreCoeff :: CoeffArr -> IOArray Int (Complex Double) -> IO ()\r\nunstoreCoeff brr arr = do\r\n for 1 (<512) (+1) $ \\i -> let i2 = i * 2\r\n i1 = i2 - 1\r\n in do x <- readArray brr i1\r\n y <- readArray brr i2\r\n writeArray arr i (x :+ y)\r\n x <- readArray brr 0\r\n y <- readArray brr 1023\r\n writeArray arr 0 (x :+ y)\r\n\r\ncoeffmap :: StorableArray Int Double -> CoeffMap ()\r\ncoeffmap filt coeffs coeffs' = do\r\n for 1 (<512) (+1) (\\i -> let j' = 2*i\r\n j = j' - 1\r\n in\r\n readArray filt i >>= \\c ->\r\n readArray coeffs j >>= \\c1 ->\r\n readArray coeffs j' >>= \\c2 ->\r\n writeArray coeffs' j (c * c1) >>\r\n writeArray coeffs' j' (c * c2) )\r\n readArray filt 0 >>= \\c -> readArray coeffs 0 >>= \\c' -> writeArray coeffs' 0 (c * c')\r\n writeArray coeffs' 1023 0.0\r\n-}\r\n", "meta": {"hexsha": "cb7287c43d62b51db4db600965d56058f92edd37", "size": 24501, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/Sound/Hommage/DFTFilter.hs", "max_stars_repo_name": "aische/hommage", "max_stars_repo_head_hexsha": "5285b0b3ce347b90ed9cafb517cd1917b0733c4f", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2017-06-23T12:17:56.000Z", "max_stars_repo_stars_event_max_datetime": "2017-06-23T12:17:56.000Z", "max_issues_repo_path": "src/Sound/Hommage/DFTFilter.hs", "max_issues_repo_name": "aische/hommage", "max_issues_repo_head_hexsha": "5285b0b3ce347b90ed9cafb517cd1917b0733c4f", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/Sound/Hommage/DFTFilter.hs", "max_forks_repo_name": "aische/hommage", "max_forks_repo_head_hexsha": "5285b0b3ce347b90ed9cafb517cd1917b0733c4f", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 45.8820224719, "max_line_length": 116, "alphanum_fraction": 0.5182645606, "num_tokens": 6261, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO\n\n", "lm_q1_score": 0.6477982315512488, "lm_q2_score": 0.47657965106367595, "lm_q1q2_score": 0.3087274551523605}} {"text": "\nimport System.Environment\nimport Data.Complex\nimport Paraiso\n\n\nmain = do\n args <- getArgs\n let arch = if \"--cuda\" `elem` args then\n CUDA 128 128\n else\n X86\n putStrLn $ compile arch code\n where\n code = do\n parallel 16384 $ do\n r <- allocate\n x <- allocate \n r =$ Rand 0.0 (4.0::Double) \n x =$ Rand 0.0 (1.0::Double) \n cuda $ do\n sequential 65536 $ do\n x =$ r * x * (1-x)\n output [r,x]\n\n\n", "meta": {"hexsha": "49f05bf0557287c2c37060d8cab9cd07b90ce9e6", "size": 532, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "attic/paraiso-2008-ODEsolver/MainLogistics.hs", "max_stars_repo_name": "nushio3/Paraiso", "max_stars_repo_head_hexsha": "e9eaea7a8c7384ceb43f8761e4af2f9206a5bbc7", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 21, "max_stars_repo_stars_event_min_datetime": "2015-02-09T22:41:26.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-20T07:13:43.000Z", "max_issues_repo_path": "attic/paraiso-2008-ODEsolver/MainLogistics.hs", "max_issues_repo_name": "nushio3/Paraiso", "max_issues_repo_head_hexsha": "e9eaea7a8c7384ceb43f8761e4af2f9206a5bbc7", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2016-09-30T07:17:17.000Z", "max_issues_repo_issues_event_max_datetime": "2016-09-30T07:17:17.000Z", "max_forks_repo_path": "attic/paraiso-2008-ODEsolver/MainLogistics.hs", "max_forks_repo_name": "nushio3/Paraiso", "max_forks_repo_head_hexsha": "e9eaea7a8c7384ceb43f8761e4af2f9206a5bbc7", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 8, "max_forks_repo_forks_event_min_datetime": "2015-05-15T01:41:47.000Z", "max_forks_repo_forks_event_max_datetime": "2018-11-18T17:41:56.000Z", "avg_line_length": 19.7037037037, "max_line_length": 41, "alphanum_fraction": 0.4605263158, "num_tokens": 148, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO\n\n", "lm_q1_score": 0.6370307944803831, "lm_q2_score": 0.48438008427698437, "lm_q1q2_score": 0.3085650299174423}} {"text": "{-| Provides 'hash' function for many data types\n-}\nmodule Hash(Hash, combineHash, emptyHash, hashToInt, hashToMax, Hashable(..)) where\n--\n-- Hash a value. Hashing produces an Int of\n-- unspecified range.\n--\nimport Data.Array\nimport Data.Complex\nimport Data.Ratio\n\n\n\nnewtype Hash = H Int deriving (Eq)\n\n----instance Show Hash where\n-- showsType _ = showString \"Hash\"\n\ncombineHash :: Hash -> Hash -> Hash\ncombineHash (H x) (H y) = H (x+y)\n\nemptyHash :: Hash\nemptyHash = H 0\n\nclass Hashable a where\n hash :: a -> Hash\n\ninstance Hashable Char where\n hash x = H $ fromEnum x\n\ninstance Hashable Int where\n hash x = H $ x\n\ninstance Hashable Integer where\n hash x = H $ fromInteger x\n\ninstance Hashable Float where\n hash x = H $ truncate x\n\ninstance Hashable Double where\n hash x = H $ truncate x\n\ninstance Hashable (IO a) where\n hash x = H 0\n\ninstance Hashable () where\n hash x = H 0\n\ninstance Hashable (a -> b) where\n hash x = H 0\n\ninstance (Hashable a) => Hashable (Maybe a) where\n hash Nothing = H 0\n hash (Just x) = hash x\n\ninstance (Hashable a, Hashable b) => Hashable (Either a b) where\n hash (Left x) = hash x\n hash (Right y) = hash y\n\n\n-- Denna b\u00f6r inte vara bortkommenterad men jag kunde inte\n-- g\u00f6ra en instans med String nedan\n--instance Hashable a => Hashable [a] where\n-- hash l = H $ f l 0\n-- where f :: (Hashable a) => [a] -> Int -> Int\n-- f [] r = r\n-- f (c:cs) r = f cs (3*r + (case hash ( c ) of H h -> h) )\n\n\ninstance (Hashable a,Enum a) => Hashable [a] where\n hash l = H $ f l 0\n where f :: Enum b => [b] -> Int -> Int\n f [] r = r\n f (c:cs) r = f cs (3*r + fromEnum c)\n\n\ninstance (Hashable a, Hashable b) => Hashable (a,b) where\n hash (a,b) = H $ (case hash ( a ) of H h -> h) + 3 * (case hash ( b ) of H h -> h)\n\ninstance (Hashable a, Hashable b, Hashable c) => Hashable (a,b,c) where\n hash (a,b,c) = H $ (case hash ( a ) of H h -> h) + 3 * (case hash ( b ) of H h -> h) + 5 * (case hash ( c ) of H h -> h)\n\ninstance (Hashable a, Hashable b, Hashable c, Hashable d) => Hashable (a,b,c,d) where\n hash (a,b,c,d) = H $ (case hash ( a ) of H h -> h) + 3 * (case hash ( b ) of H h -> h) + 5 * (case hash ( c ) of H h -> h) + 7 * (case hash ( d ) of H h -> h)\n\ninstance (Hashable a, Hashable b, Hashable c, Hashable d, Hashable e) => Hashable (a,b,c,d,e) where\n hash (a,b,c,d,e) = H $ (case hash ( a ) of H h -> h) + 3 * (case hash ( b ) of H h -> h) + 5 * (case hash ( c ) of H h -> h) + 7 * (case hash ( d ) of H h -> h) + 9 * (case hash ( e ) of H h -> h)\n\ninstance Hashable Bool where\n hash False = H 0\n hash True = H 1\n\ninstance (Integral a, Hashable a) => Hashable (Ratio a) where\n hash x = H $ (case hash ( denominator x ) of H h -> h) + (case hash ( numerator x ) of H h -> h)\n\ninstance (RealFloat a, Hashable a) => Hashable (Complex a) where\n hash (x :+ y) = H $ (case hash ( x ) of H h -> h) + (case hash ( y ) of H h -> h)\n\ninstance (Ix a) => Hashable (Array a b) where\n hash x = H $ 0 -- !!!\n\nhashToInt :: Int -> Hash -> Int\nhashToInt maxhash x =\n case x of\n H h ->\n if h < 0 then\n if -h < 0 then 0\n else (-h) `rem` maxhash\n else h `rem` maxhash\n\nhashToMax maxhash x =\n case hash x of\n H h ->\n if h < 0 then\n if -h < 0 then 0\n else (-h) `rem` maxhash\n else h `rem` maxhash\n", "meta": {"hexsha": "a75b91e74ae018917a353e27bdcc5a4b89b1906c", "size": 3426, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/transl/agda/Hash.hs", "max_stars_repo_name": "asr/agda-kanso", "max_stars_repo_head_hexsha": "aa10ae6a29dc79964fe9dec2de07b9df28b61ed5", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2019-11-27T04:41:05.000Z", "max_stars_repo_stars_event_max_datetime": "2019-11-27T04:41:05.000Z", "max_issues_repo_path": "src/transl/agda/Hash.hs", "max_issues_repo_name": "masondesu/agda", "max_issues_repo_head_hexsha": "70c8a575c46f6a568c7518150a1a64fcd03aa437", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/transl/agda/Hash.hs", "max_forks_repo_name": "masondesu/agda", "max_forks_repo_head_hexsha": "70c8a575c46f6a568c7518150a1a64fcd03aa437", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2022-03-12T11:35:18.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-12T11:35:18.000Z", "avg_line_length": 29.0338983051, "max_line_length": 204, "alphanum_fraction": 0.5642148278, "num_tokens": 1166, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.5851011397337391, "lm_q2_score": 0.5273165233795671, "lm_q1q2_score": 0.3085334988298176}} {"text": "{-# LANGUAGE ForeignFunctionInterface #-}\nmodule Data.Matrix.Static.Internal\n ( c_dd_mul\n , c_ds_mul\n , c_sd_mul\n , c_ss_mul\n , c_ss_cmul\n , c_sd_plus\n , c_ss_plus\n , c_inverse\n , c_cholesky\n , c_eig\n , c_eigs\n , c_eigsh\n , c_seigs\n , c_seigsh\n , c_geigsh\n , c_bdcsvd\n\n , computationInfo\n ) where\n\nimport Data.Complex (Complex)\nimport Foreign\nimport Foreign.C.Types\nimport Foreign.C.String\n\n-------------------------------------------------------------------------------\n-- Arithmetic\n-------------------------------------------------------------------------------\nforeign import ccall \"eigen_dd_mul\"\n c_dd_mul :: CInt\n -> Ptr a -> CInt -> CInt\n -> Ptr a -> CInt -> CInt\n -> Ptr a -> CInt -> CInt\n -> IO CString\n\nforeign import ccall \"eigen_ds_mul\"\n c_ds_mul :: CInt\n -> Ptr a -> CInt -> CInt\n -> Ptr a -> CInt -> CInt\n -> Ptr a -> Ptr CInt -> Ptr CInt -> CInt -> CInt -> CInt\n -> IO CString\n\nforeign import ccall \"eigen_sd_mul\"\n c_sd_mul :: CInt\n -> Ptr a -> CInt -> CInt\n -> Ptr a -> Ptr CInt -> Ptr CInt -> CInt -> CInt -> CInt\n -> Ptr a -> CInt -> CInt\n -> IO CString\n\nforeign import ccall \"eigen_sd_plus\"\n c_sd_plus :: CInt\n -> Ptr a -> CInt -> CInt\n -> Ptr a -> Ptr CInt -> Ptr CInt -> CInt -> CInt -> CInt\n -> Ptr a -> CInt -> CInt\n -> IO CString\n\nforeign import ccall \"eigen_ss_mul\"\n c_ss_mul :: CInt\n -> Ptr (Ptr a) -> Ptr CInt -> Ptr (Ptr CInt) -> CInt -> CInt -> Ptr CInt\n -> Ptr a -> Ptr CInt -> Ptr CInt -> CInt -> CInt -> CInt\n -> Ptr a -> Ptr CInt -> Ptr CInt -> CInt -> CInt -> CInt\n -> IO CString\n\nforeign import ccall \"eigen_ss_cmul\"\n c_ss_cmul :: CInt\n -> Ptr (Ptr a) -> Ptr CInt -> Ptr (Ptr CInt) -> CInt -> CInt -> Ptr CInt\n -> Ptr a -> Ptr CInt -> Ptr CInt -> CInt -> CInt -> CInt\n -> Ptr a -> Ptr CInt -> Ptr CInt -> CInt -> CInt -> CInt\n -> IO CString\n\nforeign import ccall \"eigen_ss_plus\"\n c_ss_plus :: CInt\n -> Ptr (Ptr a) -> Ptr CInt -> Ptr (Ptr CInt) -> CInt -> CInt -> Ptr CInt\n -> Ptr a -> Ptr CInt -> Ptr CInt -> CInt -> CInt -> CInt\n -> Ptr a -> Ptr CInt -> Ptr CInt -> CInt -> CInt -> CInt\n -> IO CString\n \nforeign import ccall \"eigen_inverse\"\n c_inverse :: CInt\n -> Ptr a -> CInt -> CInt\n -> Ptr a -> CInt -> CInt\n -> IO CString\n\nforeign import ccall \"eigen_cholesky\"\n c_cholesky :: CInt\n -> Ptr a -> Ptr a -> CInt -> IO CString\n\nforeign import ccall \"eigen_eig\"\n c_eig :: Ptr (Complex Double) -> Ptr (Complex Double)\n -> Ptr Double -> CInt -> IO CString\n\nforeign import ccall \"spectral_eigs\"\n c_eigs :: CInt -- ^ The number of eigenvectors to search\n -> Ptr (Complex Double) -- ^ \n -> Ptr (Complex Double) -- ^ \n -> Ptr Double -- ^ Input matrix\n -> CInt -- ^ Matrix size\n -> CInt -- ^ ncv\n -> CInt -- ^ max iterations\n -> Double -- ^ tolerance\n -> CInt\n -> Double\n -> CInt\n -> IO CInt\n\nforeign import ccall \"spectral_eigsh\"\n c_eigsh :: CInt\n -> Ptr Double -> Ptr Double\n -> Ptr Double -> CInt\n -> CInt -> CInt -> Double -> CInt -> Double -> CInt\n -> IO CInt\n\nforeign import ccall \"spectral_seigs\"\n c_seigs :: CInt\n -> Ptr (Complex Double) -> Ptr (Complex Double)\n -> Ptr Double -> Ptr CInt -> Ptr CInt -> CInt -> CInt\n -> CInt -> CInt -> Double -> CInt -> Double -> CInt\n -> IO CInt\n\nforeign import ccall \"spectral_seigsh\"\n c_seigsh :: CInt\n -> Ptr Double -> Ptr Double\n -> Ptr Double -> Ptr CInt -> Ptr CInt -> CInt -> CInt\n -> CInt -> CInt -> Double -> CInt -> Double -> CInt\n -> IO CInt\n\nforeign import ccall \"spectral_geigsh\"\n c_geigsh :: CInt\n -> Ptr Double -> Ptr Double\n -> Ptr Double -> CInt\n -> Ptr Double -> Ptr CInt -> Ptr CInt -> CInt\n -> CInt -> CInt -> Double -> CInt\n -> IO CInt\n\nforeign import ccall \"eigen_bdcsvd\"\n c_bdcsvd :: CInt -> Ptr a -> Ptr b -> Ptr a\n -> Ptr a -> CInt -> CInt -> IO CString\n\ncomputationInfo :: CInt -> Maybe String\ncomputationInfo 0 = Nothing\ncomputationInfo 1 = Just \"NOT_COMPUTED\"\ncomputationInfo 2 = Just \"NOT_CONVERGING\"\ncomputationInfo 3 = Just \"NUMERICAL_ISSUE\"\ncomputationInfo _ = Just \"UNKNOWN ERROR\"\n{-# INLINE computationInfo #-}", "meta": {"hexsha": "9895d391897669fc7303c0598f70263c6fcd82a6", "size": 4687, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/Data/Matrix/Static/Internal.hs", "max_stars_repo_name": "kaizhang/matrix-sized", "max_stars_repo_head_hexsha": "aed69651b2da5ca4c9076c8c4d981b876932e5b8", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/Data/Matrix/Static/Internal.hs", "max_issues_repo_name": "kaizhang/matrix-sized", "max_issues_repo_head_hexsha": "aed69651b2da5ca4c9076c8c4d981b876932e5b8", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/Data/Matrix/Static/Internal.hs", "max_forks_repo_name": "kaizhang/matrix-sized", "max_forks_repo_head_hexsha": "aed69651b2da5ca4c9076c8c4d981b876932e5b8", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 31.8843537415, "max_line_length": 82, "alphanum_fraction": 0.504587156, "num_tokens": 1330, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6619228625116081, "lm_q2_score": 0.4649015713733885, "lm_q1q2_score": 0.30772897890961803}} {"text": "-- This file is part of Quipper. Copyright (C) 2011-2016. Please see the\n-- file COPYRIGHT for a list of authors, copyright holders, licensing,\n-- and other details. All rights reserved.\n-- \n-- ======================================================================\n\n{-# LANGUAGE MultiParamTypeClasses #-}\r\n{-# LANGUAGE FunctionalDependencies #-}\r\n{-# LANGUAGE FlexibleContexts #-}\r\n{-# LANGUAGE TypeSynonymInstances #-}\r\n\r\n{-# OPTIONS -fcontext-stack=50 #-}\r\n\r\n-- | This module contains the Quipper implementation of the Quantum\r\n-- Linear Systems Algorithm.\r\n-- \r\n-- The algorithm estimates the radar cross section for a FEM\r\n-- scattering problem by using amplitude estimation to calculate\r\n-- probability amplitudes. \r\n-- \r\n-- The notations are based on the paper \r\n-- \r\n-- * B. D. Clader, B. C. Jacobs, C. R. Sprouse. Quantum algorithm to\r\n-- calculate electromagnetic scattering cross\r\n-- sections. .\r\nmodule Algorithms.QLS.QLS where\r\n\r\nimport Quipper\r\n\r\nimport QuipperLib.QFT\r\nimport QuipperLib.Arith\r\nimport QuipperLib.Decompose\r\n\r\nimport Data.Complex\r\nimport qualified Data.Map as Map\r\n\r\nimport qualified Algorithms.QLS.TemplateOracle as Template\r\nimport Algorithms.QLS.QDouble\r\nimport Algorithms.QLS.QSignedInt\r\nimport Algorithms.QLS.CircLiftingImport\r\nimport Algorithms.QLS.Utils\r\n\r\nimport Libraries.Auxiliary(boollist_of_int_bh)\r\n\r\n\r\n-- | The type of 'oracle_A' input arguments during runtime.\r\ntype OracleARunTime = Double -- ^Value resolution.\r\n -> Int -- ^Band.\r\n -> Bool -- ^Argflag.\r\n -> ([Qubit],[Qubit],[Qubit]) -- ^(x=index,y+node,z+value).\r\n -> Circ ([Qubit],[Qubit],[Qubit])\r\n\r\n-- | The type of 'oracle_b' and 'oracle_r' input arguments during runtime.\r\ntype OracleBRRunTime = Double -- ^Magnitude resolution.\r\n -> Double -- ^Phase resolution.\r\n -> ([Qubit],[Qubit],[Qubit]) -- ^(x=index,m+magnitude,p+phase).\r\n -> Circ ([Qubit],[Qubit],[Qubit])\r\n\r\n\r\n-- | A type to encapsulate all three oracles.\r\ndata Oracle = Oracle {\r\n oracle_A :: RunTimeParam -> OracleARunTime,\r\n oracle_b :: RunTimeParam -> OracleBRRunTime,\r\n oracle_r :: RunTimeParam -> OracleBRRunTime\r\n}\r\n\r\n\r\n-- | A set of oracles using only blackboxes.\r\ndummy_oracle :: Oracle\r\ndummy_oracle = Oracle {\r\n oracle_A = \\d r i b x -> named_gate \"Oracle A\" x,\r\n oracle_b = \\d1 d2 r x -> named_gate \"Oracle b\" x,\r\n oracle_r = \\d1 d2 r x -> named_gate \"Oracle r\" x\r\n}\r\n\r\n\r\n\r\n-- | A type to hold the runtime parameters.\r\ndata RunTimeParam = RT_param {\r\n k :: Double, -- ^ Wave number.\r\n theta :: Double, -- ^ Incident wave angle.\r\n phi :: Double, -- ^ Direction of desired far field radiation pattern.\r\n e0 :: Double, -- ^ Incident wave amplitude.\r\n lambda :: Double, -- ^ Wavelength.\r\n xlength :: Double, -- ^ /x/-length of square scattering region.\r\n ylength :: Double, -- ^ /y/-length of square scattering region.\r\n\r\n scatteringnodes :: [(Int,Int)], -- ^ Metallic region.\r\n \r\n nx :: Int,\r\n ny :: Int,\r\n lx :: Double,\r\n ly :: Double,\r\n\r\n kappa :: Double,\r\n epsilon :: Double,\r\n t0 :: Double,\r\n r :: Double,\r\n b_max :: Double,\r\n r_max :: Double,\r\n d :: Int,\r\n nb :: Int,\r\n p2 :: Double,\r\n n0 :: Int,\r\n n1 :: Int,\r\n n2 :: Int,\r\n n4 :: Int,\r\n\r\n -- argflags for oracle_A\r\n magnitudeArgflag :: Bool,\r\n phaseArgflag :: Bool\r\n} deriving (Show)\r\n\r\n\r\n-- | A convenient set of runtime parameters for testing. \r\ndummy_RT_param :: RunTimeParam\r\ndummy_RT_param = RT_param {\r\n\r\n k = 2.0*pi*1.0,\r\n theta = 0.0*pi/4.0,\r\n phi = 0.0,\r\n e0 = 1.0,\r\n lambda = (k dummy_RT_param)/(2.0*pi),\r\n xlength = 2.0*(lambda dummy_RT_param),\r\n ylength = 2.0*(lambda dummy_RT_param),\r\n \r\n scatteringnodes = \r\n let rt = dummy_RT_param in\r\n let xul = round((fromIntegral $ nx rt)/2)\r\n - round((xlength rt)/(2.0*(lx rt))) in -- Upper left x index\r\n let yul = round((fromIntegral $ ny rt)/2)\r\n - round((ylength rt)/(2.0*(ly rt))) in -- Upper left y index\r\n let xlr = round((fromIntegral $ nx rt)/2)\r\n + round((xlength rt)/(2.0*(lx rt))) in -- Lower right x index\r\n let ylr = round((fromIntegral $ ny rt)/2)\r\n + round((ylength rt)/(2.0*(ly rt))) in -- Lower right y in\r\n [(xul, yul), (xlr, ylr)],\r\n\r\n nx = 12885,\r\n ny = 12885,\r\n lx = 0.1,\r\n ly = 0.1,\r\n\r\n kappa = 1.0,\r\n epsilon = 1.0,\r\n t0 = 1.0,\r\n r = 1.0,\r\n b_max = 1.0,\r\n r_max = 1.0,\r\n d = 3,\r\n nb = 2,\r\n p2 = 3,\r\n n0 = 3, \r\n n1 = 3,\r\n n2 = 3,\r\n n4 = 3, \r\n\r\n -- argflags for oracle_A\r\n magnitudeArgflag = False,\r\n phaseArgflag = True\r\n}\r\n\r\n\r\n-- | A set of larger values, for testing scalability.\r\nlarge_RT_param :: RunTimeParam\r\nlarge_RT_param = RT_param {\r\n\r\n k = 2.0*pi*1.0,\r\n theta = 0.0*pi/4.0,\r\n phi = 0.0,\r\n e0 = 1.0,\r\n lambda = (k large_RT_param)/(2.0*pi),\r\n xlength = 2.0*(lambda large_RT_param),\r\n ylength = 2.0*(lambda large_RT_param),\r\n \r\n scatteringnodes = \r\n let rt = large_RT_param in\r\n let xul = round((fromIntegral $ nx rt)/2)\r\n - round((xlength rt)/(2.0*(lx rt))) in -- Upper left x index\r\n let yul = round((fromIntegral $ ny rt)/2)\r\n - round((ylength rt)/(2.0*(ly rt))) in -- Upper left y index\r\n let xlr = round((fromIntegral $ nx rt)/2)\r\n + round((xlength rt)/(2.0*(lx rt))) in -- Lower right x index\r\n let ylr = round((fromIntegral $ ny rt)/2)\r\n + round((ylength rt)/(2.0*(ly rt))) in -- Lower right y in\r\n [(xul, yul), (xlr, ylr)],\r\n\r\n nx = 12885,\r\n ny = 12885,\r\n lx = 0.1,\r\n ly = 0.1,\r\n\r\n kappa = 1e4,\r\n epsilon = 0.01,\r\n t0 = 7.0e6,\r\n r = 2.5e12,\r\n b_max = 5.0,\r\n r_max = 1.01,\r\n d = 7,\r\n nb = 9,\r\n p2 = ( 1.0 / (4-(4**(1/3))) ),\r\n n0 = 14,\r\n n1 = 24,\r\n n2 = 30,\r\n n4 = 65, \r\n\r\n -- argflags for oracle_A\r\n magnitudeArgflag = False,\r\n phaseArgflag = True\r\n}\r\n\r\n\r\n-- | A set of smaller values, for manageable yet meaningful output.\r\nsmall_RT_param :: RunTimeParam\r\nsmall_RT_param = RT_param {\r\n\r\n k = 2.0*pi*1.0,\r\n theta = 0.0*pi/4.0,\r\n phi = 0.0,\r\n e0 = 1.0,\r\n lambda = (k small_RT_param)/(2.0*pi),\r\n xlength = 2.0*(lambda small_RT_param),\r\n ylength = 2.0*(lambda small_RT_param),\r\n \r\n scatteringnodes = \r\n let xul = 2 in\r\n let yul = 2 in\r\n let xlr = 3 in\r\n let ylr = 3 in\r\n [(xul, yul), (xlr, ylr)],\r\n\r\n nx = 4,\r\n ny = 4,\r\n lx = 0.1,\r\n ly = 0.1,\r\n\r\n kappa = 1e4,\r\n epsilon = 0.01,\r\n t0 = 7.0e6,\r\n r = 2.5e12,\r\n b_max = 5.0,\r\n r_max = 1.01,\r\n d = 7,\r\n nb = 9,\r\n p2 = ( 1.0 / (4-(4**(1/3))) ),\r\n n0 = 14,\r\n n1 = 24,\r\n n2 = 6,\r\n n4 = 65, \r\n\r\n -- argflags for oracle_A\r\n magnitudeArgflag = False,\r\n phaseArgflag = True\r\n}\r\n\r\n\r\n\r\n-- | Apply an [exp \u2212/iYt/] gate. The timestep /t/ is a parameter.\r\nexpYt :: Timestep -> Qubit -> Circ Qubit\r\nexpYt = named_rotation \"exp(-i%Y)\"\r\n\r\n\r\n-- | Apply an [exp \u2212/iYt/] gate. The timestep /t/ is a parameter.\r\nexpYt_at :: Timestep -> Qubit -> Circ ()\r\nexpYt_at = named_rotation_at \"exp(-i%Y)\"\r\n\r\n\r\n-- | Read a list of bits and make it into a 'Double', by multiplying\r\n-- its integer value by the provided factor.\r\ndynamic_lift_double :: Double -> [Bit] -> Circ Double\r\ndynamic_lift_double factor cl = do\r\n cdiscard cl\r\n\r\n-- Implementation note: removed dynamic_lift as for now it breaks all\r\n-- output formats except ASCII.\r\n\r\n-- bl <- dynamic_lift cl\r\n let sign = 1 -- if (head $ reverse bl) then 1 else -1\r\n let unsigned_value = 1 -- integer_of_intm_unsigned $ \r\n -- intm_of_boollist_bh (tail $ reverse bl)\r\n return (sign * factor * (fromIntegral unsigned_value))\r\n\r\n\r\n-- | A black box gate to stand in as a replacement for QFT.\r\nqft_for_show :: [Qubit] -> Circ [Qubit]\r\nqft_for_show qs = named_gate \"QFT\" qs\r\n\r\n\r\n\r\n-- | Main function: for estimating the radar cross section for a FEM\r\n-- scattering problem. The problem can be reduced to the calculation\r\n-- of four angles: \u03c6[sub /b/], \u03c6[sub /bx/], \u03c6[sub /r/1] and \u03c6[sub /r/0].\r\nqlsa_FEM_main :: RunTimeParam -> Oracle -> Circ Double\r\nqlsa_FEM_main param oracle = do\r\n comment \"FEM_main\"\r\n phi_b <- qlsa_AmpEst_phi_b param oracle\r\n phi_bx <- qlsa_AmpEst_phi_bx param oracle\r\n phi_r1 <- qlsa_AmpEst_phi_bxr param oracle True\r\n phi_r0 <- qlsa_AmpEst_phi_bxr param oracle False\r\n let sigma = ((((fromIntegral $ nb param) ^ 2) * ((b_max param) ^ 2) * ((r_max param) ^ 2) * ((sin phi_b) ^ 2)) / ( 4 * pi))\r\n comment \"FEM_main\"\r\n return sigma\r\n\r\n\r\n\r\n\r\n-- * Amplitude Estimation Functions\r\n\r\n-- | Estimates \u03c6[sub /b/], related to the probability of success for the\r\n-- preparation of the known state /b/, using amplitude amplification.\r\nqlsa_AmpEst_phi_b :: RunTimeParam -> Oracle -> Circ Double\r\nqlsa_AmpEst_phi_b param oracle = do\r\n g <- qinit $ replicate (n0 param) False\r\n with_ancilla_init (replicate (n2 param) False) $ \\x -> do\r\n label (g,x) (\"g\",\"x\")\r\n with_ancilla $ \\a -> do\r\n label (a) (\"anc. a\")\r\n with_ancilla $ \\b -> do\r\n label (b) (\"anc. b\")\r\n g <- map_hadamard g \r\n u_b (x,b) \r\n loop g u_g (x,b,a)\r\n return ()\r\n return ()\r\n g' <- qft_big_endian g -- QFT : Is it really big-endian?\r\n value_bits <- measure g'\r\n value_double <- dynamic_lift_double 1.0 value_bits\r\n return (pi * value_double / (2 ** (fromIntegral $ n0 param))) \r\n where\r\n loop :: [Qubit] -> (a -> Circ ()) -> a -> Circ ()\r\n loop [] f x = return ()\r\n loop (h:t) f x = do\r\n f x `controlled` h\r\n loop t f' x;\r\n where\r\n f' x = do f x; f x \r\n\r\n u_b :: ([Qubit],Qubit) -> Circ ()\r\n u_b xb = qlsa_StatePrep param xb (oracle_b oracle param) (1.0/(b_max param))\r\n\r\n\r\n u_g :: ([Qubit],Qubit,Qubit) -> Circ ()\r\n u_g (x,b,a) = do \r\n comment \"U_g starts\"\r\n gate_Z_at b\r\n -- For unitrary linear transformation, adjoint == inverse, hence reverse_...\r\n (reverse_generic_imp u_b) (x,b) \r\n qnot_at a `controlled` x .==. (map (\\x -> False) x)\r\n gate_X_at a\r\n gate_Z_at a\r\n gate_X_at a\r\n qnot_at a `controlled` x .==. (map (\\x -> False) x)\r\n u_b (x,b)\r\n comment \"U_g ends\"\r\n return ()\r\n\r\n \r\n \r\n-- | Testing function for 'qlsa_AmpEst_phi_b'.\r\ntest_qlsa_AmpEst_phi_b :: Bool -> IO ()\r\ntest_qlsa_AmpEst_phi_b dummyRTParamFlag = do\r\n let param = if dummyRTParamFlag then dummy_RT_param else large_RT_param \r\n print_simple GateCount (qlsa_AmpEst_phi_b param dummy_oracle)\r\n print_simple Preview (qlsa_AmpEst_phi_b param dummy_oracle)\r\n\r\n\r\n-- | Estimates \u03c6[sub /bx/], related to the probability of success in\r\n-- computing solution value /x/.\r\nqlsa_AmpEst_phi_bx :: RunTimeParam -> Oracle -> Circ Double\r\nqlsa_AmpEst_phi_bx param oracle = do\r\n g <- qinit (take (n0 param) (repeat False))\r\n with_ancilla_init (take (n2 param) (repeat False)) $ \\x -> do\r\n with_ancilla $ \\a -> do \r\n with_ancilla $ \\b -> do\r\n with_ancilla $ \\s -> do\r\n g <- map_hadamard g \r\n u_bx (x,b,s)\r\n loop g u_g (x,b,s,a)\r\n return ()\r\n return () \r\n return ()\r\n g' <- qft_big_endian g -- QFT : Is it really big-endian?\r\n value_bits <- measure g'\r\n value_double <- dynamic_lift_double 1.0 value_bits\r\n return (pi * value_double / (2 ** (fromIntegral $ n0 param)))\r\n where\r\n loop :: [Qubit] -> (a -> Circ ()) -> a -> Circ ()\r\n loop [] f x = return ()\r\n loop (h:t) f x = do\r\n f x `controlled` h\r\n loop t f' x\r\n where\r\n f' x = do f x; f x\r\n \r\n u_bx :: ([Qubit],Qubit,Qubit) -> Circ ()\r\n u_bx (x,b,s) = do \r\n qlsa_StatePrep param (x,b) (oracle_b oracle param) (1.0/(b_max param)) \r\n qlsa_Solve_x param (x,s) oracle\r\n return ()\r\n\r\n u_g :: ([Qubit],Qubit,Qubit,Qubit) -> Circ ()\r\n u_g (x,b,s,a) = do --named_gate_at \"Ug_phi_bx\" (x,b,s,a)\r\n qnot_at a `controlled` b .&&. s\r\n gate_Z_at a\r\n qnot_at a `controlled` b .&&. s\r\n (reverse_generic_imp u_bx) (x,b,s)\r\n qnot_at a `controlled` [ q .==. 0 | q <- x ] .&&. b .==. 0 .&&. s .==. 0\r\n gate_X_at a\r\n gate_Z_at a\r\n gate_X_at a\r\n qnot_at a `controlled` [ q .==. 0 | q <- x ] .&&. b .==. 0 .&&. s .==. 0\r\n u_bx (x,b,s)\r\n return ()\r\n \r\n\r\n \r\n \r\n-- | Estimates \u03c6[sub /r/0] and \u03c6[sub /r/1] (depending on the boolean\r\n-- parameter), related to the overlap of the solution with the\r\n-- arbitrary state /r/.\r\nqlsa_AmpEst_phi_bxr :: RunTimeParam -> Oracle -> Bool -> Circ Double\r\nqlsa_AmpEst_phi_bxr param oracle target = do\r\n g <- qinit (take (n0 param) (repeat False))\r\n with_ancilla_init (take (n2 param) (repeat False)) $ \\x -> do\r\n with_ancilla_init (take (n2 param) (repeat False)) $ \\y -> do \r\n with_ancilla $ \\a -> do \r\n with_ancilla $ \\b -> do\r\n with_ancilla $ \\s -> do\r\n with_ancilla $ \\r -> do \r\n with_ancilla $ \\c -> do\r\n g <- map_hadamard g \r\n u_r (x,y,b,s,r,c)\r\n loop g u_g (x,y,b,s,r,c,a)\r\n return ()\r\n return ()\r\n return ()\r\n return ()\r\n return () \r\n g' <- qft_big_endian g -- QFT : Is it really big-endian?\r\n value_bits <- measure g'\r\n value_double <- dynamic_lift_double 1.0 value_bits\r\n return (pi * value_double / (2 ** (fromIntegral $ n0 param)))\r\n where\r\n loop :: [Qubit] -> (a -> Circ ()) -> a -> Circ ()\r\n loop [] f x = return ()\r\n loop (h:t) f x = do\r\n f x `controlled` h\r\n loop t f' x\r\n where\r\n f' x = do f x; f x\r\n \r\n u_r :: ([Qubit],[Qubit],Qubit,Qubit,Qubit,Qubit) -> Circ ()\r\n u_r (x,y,b,s,r,c) = do \r\n qlsa_Solve_xr param (x,y,b,s,r,c) oracle\r\n return ()\r\n\r\n u_g :: ([Qubit],[Qubit],Qubit,Qubit,Qubit,Qubit,Qubit) -> Circ ()\r\n u_g (x,y,b,s,r,c,a) = do --named_gate_at \"Ug_phi_bxr\" (x,y,b,s,r,c,a)\r\n qnot_at a `controlled` (b .==. 1 .&&. s .==. 1 .&&. r .==. 1 .&&. c .==. target)\r\n gate_Z_at a\r\n qnot_at a `controlled` (b .==. 1 .&&. s .==. 1 .&&. r .==. 1 .&&. c .==. target)\r\n (reverse_generic_imp u_r) (x,y,b,s,r,c)\r\n qnot_at a `controlled` [ q .==. 0 | q <- x ] .&&. [ q .==. 0 | q <- y ] .&&. b .==. 0 .&&. s .==. 0 .&&. r .==. 0 .&&. c .==. 0\r\n gate_X_at a\r\n gate_Z_at a\r\n gate_X_at a\r\n qnot_at a `controlled` [ q .==. 0 | q <- x ] .&&. [ q .==. 0 | q <- y ] .&&. b .==. 0 .&&. s .==. 0 .&&. r .==. 0 .&&. c .==. 0\r\n u_r (x,y,b,s,r,c)\r\n return ()\r\n\r\n\r\n-- * State Preparation.\r\n\r\n-- | Prepares a quantum state /x/, as specified by an oracle function,\r\n-- entangled with a single qubit flag /q/ marking the desired state.\r\nqlsa_StatePrep :: \r\n RunTimeParam\r\n -> ([Qubit], Qubit) -- x & qare handles to wires to be changed by StatePrep \r\n -> OracleBRRunTime -- Common type of (oracle_b oracle) and (oracle_r oracle), if oracle is typed Oracle\r\n -> Double\r\n -> Circ ()\r\nqlsa_StatePrep param (x, q) oracle phi0 = do\r\n _ <- (flip $ box (\"qlsa_StatePrep_\" ++ (show phi0))) (x,q) $ \\(x,q) -> do\r\n -- comment \"StatePrep starts\"\r\n label (x,q) (\"x\", \"q\")\r\n with_ancilla_list (n4 param) $ \\m -> do\r\n label (m) (\"anc. m\")\r\n with_ancilla_list (n4 param) $ \\p -> do\r\n label (p) (\"anc. p\")\r\n x <- map_hadamard x\r\n (x, m, p) <- oracle phi0 (epsilon param) (x, m, p)\r\n qlsa_ControlledPhase p (epsilon param) False\r\n qlsa_ControlledRotation (m, q) phi0 False\r\n (x, m, p) <- oracle phi0 (epsilon param) (x, m, p)\r\n return (x,q)\r\n -- comment \"StatePrep ends\"\r\n return ()\r\n\r\n\r\n-- | Testing function for 'qlsa_StatePrep'.\r\ntest_qlsa_StatePrep :: Bool -> IO ()\r\ntest_qlsa_StatePrep dummyRTParamFlag = do\r\n let param = if dummyRTParamFlag then dummy_RT_param else large_RT_param\r\n let oraclebRunTime = (oracle_b dummy_oracle param) \r\n let testCirc = do\r\n x <- qinit $ replicate (n2 param) False\r\n q <- qinit False\r\n qlsa_StatePrep param (x,q) oraclebRunTime 1.0\r\n print_simple GateCount testCirc\r\n print_simple Preview testCirc\r\n\r\n\r\n\r\n\r\n-- * Linear System Solver Functions\r\n\r\n-- | Implements the QLSA procedure to generate the solution state |/x/\u232a.\r\nqlsa_Solve_x :: RunTimeParam ->([Qubit],Qubit) -> Oracle -> Circ () \r\nqlsa_Solve_x param (x,s) oracle = do\r\n _ <- (flip $ box \"qlsa_Solve_x\") (x,s) $ \\(x,s) -> do\r\n with_ancilla_list (n1 param) $ \\t -> do \r\n with_ancilla_list (length t) $ \\f -> do \r\n let phi0 = 2 * pi / (2 ** (fromIntegral $ n1 param) - (epsilon param))\r\n t <- map_hadamard t\r\n u_hs (t,x)\r\n t <- qft_big_endian t\r\n integer_inverse (t,f) \r\n qlsa_ControlledRotation (f,s) phi0 False\r\n integer_inverse (t,f)\r\n (reverse_generic_endo qft_big_endian) t\r\n (reverse_generic_imp u_hs) (t,x)\r\n t <- map_hadamard t\r\n return() \r\n return ()\r\n return (x,s)\r\n return ()\r\n where\r\n u_hs :: ([Qubit],[Qubit]) -> Circ ()\r\n u_hs (t,x) = do \r\n qlsa_HamiltonianSimulation param (t,x) (oracle_A oracle param)\r\n return ()\r\n \r\n\r\n-- | Implementation of the integer division. The two registers are\r\n-- supposed to be of the same size and represent little-headian\r\n-- unsigned integers, i.e., the head of the list holds the least\r\n-- significant bit.\r\ninteger_inverse :: ([Qubit],[Qubit]) -> Circ ()\r\ninteger_inverse (t,f) = do\r\n _ <- (flip $ box \"integer_inverse\") (t,f) $ \\(t,f) -> do\r\n -- sanity check\r\n if (length t /= length f) \r\n then error \"integer_inverse: registers of distinct sizes\" \r\n else return ()\r\n -- initialize an unsigned integer to 2^(length t) - 1\r\n with_ancilla_init (map (\\_ -> True) t) $ \\num -> do\r\n -- perform the division (encapsulated in a subroutine)\r\n let d = classical_to_reversible $ \\(t,num) -> do\r\n let x = ((qdint_of_qulist_lh num),(qdint_of_qulist_lh t))\r\n (_,_,f') <- uncurry q_div_unsigned x\r\n return $ qulist_of_qdint_lh f'\r\n d ((t,num),f)\r\n return (t,f)\r\n return ()\r\n\r\n\r\n\r\n\r\n \r\n-- | Implements the complete QLSA procedure to find the\r\n-- solution state |/x/\u232a and then implements the swap protocol\r\n-- required for estimation of \u2329/x/|/r/\u232a.\r\nqlsa_Solve_xr :: RunTimeParam ->([Qubit],[Qubit],Qubit,Qubit,Qubit,Qubit) -> Oracle -> Circ () \r\n-- qlsa_Solve_xr param (x,y,b,s,r,c) oracle = named_gate_at \"Solve_xr\" (x,y,b,s,r,c)\r\nqlsa_Solve_xr param (x,y,b,s,r,c) oracle = do\r\n _ <- (flip $ box \"qlsa_Solve_xr\") (x,y,b,s,r,c) $ \\(x,y,b,s,r,c) -> do\r\n qlsa_StatePrep param (x,b) (oracle_b oracle param) (1.0/(b_max param)) \r\n qlsa_Solve_x param (x,s) oracle \r\n qlsa_StatePrep param (y,r) (oracle_r oracle param) (1.0/(r_max param)) \r\n hadamard_at c\r\n swap_at y x `controlled` c\r\n hadamard_at c\r\n return (x,y,b,s,r,c)\r\n return ()\r\n \r\n\r\n-- * Hamiltonian Simulation Functions.\r\n\r\n-- | Uses a quantum register |/t/\u232a to control the\r\n-- implementation of the Suzuki method for simulating a Hamiltonian\r\n-- specified by an oracle function.\r\nqlsa_HamiltonianSimulation :: \r\n RunTimeParam \r\n -> ([Qubit], [Qubit])\r\n -> OracleARunTime \r\n -> Circ ()\r\nqlsa_HamiltonianSimulation param (t, x) oracleA = do\r\n _ <- (flip $ box \"qlsa_HamiltonianSimulation\") (t,x) $ \\(t,x) -> do\r\n -- Code the first line in a way that depends on the length of t rather \r\n -- explicitly on (n1 param) which is supposed to be the length of t\r\n -- Hence replaced the line below by the line after it.\r\n -- let denom = 2 * (r param) * (fromIntegral ((n1 param) - 1))\r\n let denom = 2 * (r param) * ( 2^((length t) - 1) )\r\n let t1 = (p2 param) * (t0 param) / denom\r\n let t2 = (1.0 - 4.0 * (p2 param)) * (t0 param) / denom\r\n (t,x) <- box_loopM \"TrotterLoop\" (round $ r param) (t,x) (hs_loop t1 t2)\r\n return (t,x)\r\n return ()\r\n where \r\n hs_loop :: Double -> Double -> ([Qubit], [Qubit]) -> Circ ([Qubit], [Qubit])\r\n hs_loop t1 t2 (t,x) = do \r\n u_z_at (t,x) t1\r\n u_z_at (t,x) t1\r\n u_z_at (t,x) t2\r\n u_z_at (t,x) t1\r\n u_z_at (t,x) t1\r\n return (t,x)\r\n\r\n u_z_at :: ([Qubit], [Qubit]) -> Double -> Circ ()\r\n u_z_at (t, x) timeStep = do\r\n for (nb param) 1 (-1) $ \\jj -> do\r\n qlsa_HsimKernel param (t, x) jj timeStep oracleA \r\n endfor\r\n for 1 (nb param) 1 $ \\jj -> do\r\n qlsa_HsimKernel param (t, x) jj timeStep oracleA \r\n endfor\r\n return ()\r\n\r\n-- | Testing function for 'qlsa_HamiltonianSimulation'.\r\ntest_qlsa_HamiltonianSimulation :: Bool -> IO ()\r\ntest_qlsa_HamiltonianSimulation dummyRTParamFlag = do\r\n let param = if dummyRTParamFlag then dummy_RT_param else large_RT_param\r\n let oracleARunTime = (oracle_A dummy_oracle param) \r\n let testCirc = do\r\n t <- qinit (take (n0 param) (repeat False))\r\n x <- qinit (take (n4 param) (repeat False))\r\n label(t,x) (\"t\", \"x\")\r\n qlsa_HamiltonianSimulation param (t,x) oracleARunTime\r\n print_simple GateCount testCirc\r\n-- print_simple Preview testCirc\r\n\r\n\r\n\r\n-- | Uses an oracle function and timestep control register (/t/) to\r\n-- apply 1-sparse Hamiltonian to the input state |/t/, /x/\u232a.\r\nqlsa_HsimKernel :: \r\n RunTimeParam\r\n -> ([Qubit], [Qubit]) \r\n -> Int \r\n -> Double \r\n -> OracleARunTime\r\n -> Circ ()\r\n-- qlsa_HsimKernel param tx band timeStep oracleA = named_gate_at \"HsimKernel\" tx\r\n\r\nqlsa_HsimKernel param (t, x) band timeStep oracleA = do\r\n _ <- (flip $ box (\"qlsa_HsimKernel\" ++ (show band) ++ (show timeStep))) (t,x) $ \\(t,x) -> do\r\n let phiP = (epsilon param)\r\n with_ancilla_list (n2 param) $ \\y -> do\r\n with_ancilla_list (n4 param) $ \\m -> do \r\n with_ancilla_list (n4 param) $ \\p -> do \r\n label (y,m,p) (\"y\",\"m\",\"p\")\r\n -- phases\r\n oracleA phiP band (phaseArgflag param) (x,y,p)\r\n qlsa_ControlledPhase p phiP False\r\n oracleA phiP band (phaseArgflag param) (x,y,p)\r\n -- magnitudes\r\n let phiMag = 2 ** (negate $ fromIntegral $ after_radix_length)\r\n oracleA phiMag band (magnitudeArgflag param) (x,y,m)\r\n for 0 ((length t) - 1) 1 $ \\ii -> do \r\n let phi_mt = timeStep * phiMag * (2^ii)\r\n qlsa_ApplyHmag param (x,y,m) phi_mt `controlled` (t !! ii)\r\n endfor\r\n oracleA phiMag band (magnitudeArgflag param) (x,y,m)\r\n -- phases again\r\n oracleA phiP band (phaseArgflag param) (x,y,p)\r\n qlsa_ControlledPhase p phiP True\r\n oracleA phiP band (phaseArgflag param) (x,y,p)\r\n return ()\r\n return ()\r\n return () \r\n return (t,x)\r\n return ()\r\n\r\n-- | Testing function for 'qlsa_HsimKernel'.\r\ntest_qlsa_HsimKernel :: Bool -> IO ()\r\ntest_qlsa_HsimKernel dummyRTParamFlag = do\r\n let param = if dummyRTParamFlag then dummy_RT_param else large_RT_param\r\n let oracleARunTime = (oracle_A dummy_oracle param) \r\n let testCirc = do\r\n t <- qinit (take (n0 param) (repeat False))\r\n x <- qinit (take (n4 param) (repeat False))\r\n label(t,x) (\"t\", \"x\")\r\n qlsa_HsimKernel param (t,x) 1 0.1 oracleARunTime\r\n print_simple GateCount testCirc\r\n-- print_simple Preview testCirc\r\n\r\n\r\n-- | Applies the magnitude component of coupling elements in a\r\n-- 1-sparse Hamiltonian.\r\nqlsa_ApplyHmag :: RunTimeParam -> ([Qubit], [Qubit], [Qubit]) -> Double -> Circ ()\r\nqlsa_ApplyHmag param (x,y,m) phi0 = do\r\n _ <- (flip $ box (\"qlsa_ApplyHmag \" ++ (show phi0))) (x,y,m) $ \\(x,y,m) -> do\r\n let (onOne, onZero) = (True, False)\r\n with_ancilla $ \\a -> do -- Assume initialized to False (0)\r\n label (a) (\"anc. a\")\r\n if (length x /= length y) \r\n then error \"qlsa_ApplyHmag: Input registers x and y have different lengths.\" \r\n else return ()\r\n let length_xy = length x\r\n for 0 (length_xy - 1) 1 $ \\ii -> do\r\n let (xi, yi) = (x !! ii, y !! ii)\r\n w (xi, yi)\r\n qnot_at a `controlled` (xi .==. onOne .&&. yi .==. onZero)\r\n endfor\r\n qlsa_ControlledPhase (m ++ [a]) phi0 False\r\n for (length_xy - 1) 0 (-1) $ \\ii -> do\r\n let (xi, yi) = (x !! ii, y !! ii)\r\n qnot_at a `controlled` (xi .==. onOne .&&. yi .==. onZero)\r\n w (xi, yi)\r\n endfor \r\n return ()\r\n return (x,y,m)\r\n return ()\r\n\r\n\r\n-- | Testing function for 'qlsa_ApplyHmag'.\r\ntest_qlsa_ApplyHmag :: Bool -> IO ()\r\ntest_qlsa_ApplyHmag dummyRTParamFlag = do\r\n let param = if dummyRTParamFlag then dummy_RT_param else large_RT_param\r\n let testCirc = do\r\n x <- qinit (take (n2 param) (repeat False))\r\n y <- qinit (take (n2 param) (repeat False))\r\n m <- qinit (take (n4 param) (repeat False))\r\n label(x,y,m) (\"x\", \"y\", \"m\")\r\n qlsa_ApplyHmag param (x,y,m) 0.1 \r\n print_simple GateCount testCirc\r\n print_simple Preview testCirc\r\n\r\n\r\n\r\n\r\n\r\n-- | Auxiliary function: the /W/-gate.\r\nw :: (Qubit, Qubit) -> Circ ()\r\n-- w xy = named_gate_at \"W\" xy\r\nw (xi,yi) = do\r\n _ <- box \"w\" (\\(xi, yi) -> do\r\n label (xi,yi) (\"x[i]\",\"y[i]\")\r\n gate_X_at xi `controlled` yi\r\n gate_X_at yi `controlled` xi\r\n hadamard_at yi `controlled` xi\r\n gate_X_at yi `controlled` xi\r\n gate_X_at xi `controlled` yi\r\n return (xi,yi)) (xi,yi)\r\n return ()\r\n\r\n-- | Testing function for 'w'.\r\ntest_w :: IO ()\r\ntest_w = do\r\n let testCirc = do\r\n xi <- qinit False \r\n yi <- qinit False\r\n w (xi, yi)\r\n print_simple GateCount testCirc\r\n print_simple Preview testCirc\r\n\r\n\r\n-- * Controlled Logic Operations\r\n\r\n\r\n-- | Applies a phase shift of \u03c6\\/2 to the signed input register |\u03c6\u232a.\r\n\r\n-- For c, bit locations are counted starting from 0 (least significant) to (length c - 2) (most significant)\r\n-- last c (or c !! (n-1)) is the sign bit\r\nqlsa_ControlledPhase :: [Qubit] -> Double -> Bool -> Circ ()\r\n-- qlsa_ControlledPhase c phi0 f = named_gate_at \"CPhase\" c\r\nqlsa_ControlledPhase c phi0 f = do\r\n _ <- (flip $ box (\"qlsa_ControlledPhase \" ++ (show phi0) ++ \" \" ++ (show f))) c $ \\c -> do\r\n with_ancilla $ \\a -> do -- ancilla is initialized to False\r\n if f then (qnot_at a) else return ()\r\n let signQubit = last c\r\n qnot_at a `controlled` signQubit\r\n for 0 (length c - 2) 1 $ \\ii -> do \r\n let theta = ( (2.0^(ii)) * phi0 / 2.0) -- Note the divide by 2\r\n -- The following three lines are equivalent\r\n expZt_at theta a `controlled` (c !! ii)\r\n -- a <- expZt theta a `controlled` (c !! ii); return ()\r\n -- qlsa_ControlledU (c !! ii, a) (expZt theta) False \r\n endfor\r\n qnot_at a `controlled` signQubit \r\n return c\r\n return ()\r\n\r\n\r\n-- | Applies a rotation of \u03c6\\/2 to the signed input register |\u03c6\u232a.\r\nqlsa_ControlledRotation :: ([Qubit], Qubit) -> Double -> Bool -> Circ ()\r\n-- qlsa_ControlledRotation ct phi0 f = named_gate_at \"CRotate\" ct\r\nqlsa_ControlledRotation (c, t) phi0 f = do\r\n _ <- (flip $ box (\"qlsa_ControlledRotation \" ++ (show phi0) ++ \" \" ++ (show f))) (c,t) $ \\(c,t) -> do\r\n if f then (qnot_at t) else return ()\r\n let signQubit = last c\r\n qnot_at t `controlled` signQubit\r\n for 0 (length c - 2) 1 $ \\ii -> do\r\n let theta = (2.0^(ii)) * phi0 / 2.0\r\n expYt_at theta t `controlled` (c !! ii)\r\n endfor\r\n qnot_at t `controlled` signQubit\r\n if f then (qnot_at t) else return ()\r\n return (c,t)\r\n return ()\r\n\r\n\r\n----------------------------------------------------------------------\r\n-- * Oracles\r\n\r\n-- | Map a 'QDouble' into an integer, understood as being scaled by\r\n-- the given factor. Take the factor and the size of the output\r\n-- register as parameter.\r\nmake_factor_rep :: Double -> Int -> QDouble -> Circ [Qubit]\r\nmake_factor_rep factor size p = do\r\n -- number of high bits of p\r\n let p_int_size = (xdouble_length p) - (xdouble_exponent p)\r\n -- get the required number of bits for doing the encoding\r\n let auxsize = max (size - 1) p_int_size\r\n -- do the operation:\r\n -- (1) build a QDouble from the factor: need (size-1) bits of integer part\r\n qfactor <- qinit $ fdouble_of_double (xdouble_exponent p) \r\n (auxsize + xdouble_exponent p) factor\r\n -- (2) scale p\r\n p_large <- qdouble_pad_to_extent (auxsize,- (xdouble_exponent p)) p\r\n -- (3) divide p by factor\r\n qreal_multiples <- unpack template_symb_slash_ p_large qfactor\r\n -- (4) get the floor of the result\r\n q_floor <- template_floor\r\n qmultiples <- q_floor qreal_multiples\r\n -- (5) set them in the right format (it has size elements)\r\n let (SInt tp bp) = qmultiples\r\n let new_p = (take (size - 1) $ reverse tp) ++ [bp]\r\n return new_p\r\n\r\n\r\n\r\n-- | Implements the oracle for the arbitrary state |/r/\u232a, using the\r\n-- Template Haskell implementation of 'calcRweights'.\r\ninline_oracle_r :: RunTimeParam -> Double -> Double -> ([Qubit],[Qubit],[Qubit]) -> Circ ([Qubit],[Qubit],[Qubit])\r\ninline_oracle_r rt factor_m factor_p = box (\"Or \" ++ (show factor_m) ++ \" \" ++ (show factor_p)) $ decompose_generic Toffoli $ \\(x',m',p') ->\r\n with_ancilla_init (fromIntegral $ nx rt :: FSignedInt) $ \\qnx -> \r\n with_ancilla_init (fromIntegral $ ny rt :: FSignedInt) $ \\qny -> \r\n with_ancilla_init (fdouble $ lx rt) $ \\qlx ->\r\n with_ancilla_init (fdouble $ ly rt) $ \\qly ->\r\n with_ancilla_init (fdouble $ k rt) $ \\qk ->\r\n with_ancilla_init (fdouble $ theta rt) $ \\qtheta ->\r\n with_ancilla_init (fdouble $ phi rt) $ \\qphi -> \r\n -- the x register is smaller than the size of a QSInt,\r\n -- and x is an unsigned integer: make up a positive\r\n -- sign and a pad\r\n \r\n with_ancilla_init False $ \\bx -> do\r\n with_ancilla_init (replicate (fixed_int_register_length - (n2 rt)) \r\n False) $ \\pad_x -> do\r\n \r\n let x = SInt (pad_x ++ (reverse x')) bx\r\n let f = classical_to_reversible $ \r\n \\(x,nx,ny,lx,ly,k,theta,phi) -> do \r\n (m,p) <- unpack Template.template_calcRweights \r\n x nx ny lx ly k theta phi\r\n new_p <- make_factor_rep factor_p (n4 rt) p\r\n new_m <- make_factor_rep factor_m (n4 rt) m\r\n return (new_m, new_p)\r\n f ((x,qnx,qny,qlx,qly,qk,qtheta,qphi),(m',p'))\r\n return (x',m',p')\r\n\r\n\r\n\r\n\r\n\r\n-- | Implements the oracle for the known state |/b/\u232a, using the\r\n-- Template Haskell implementation of 'getKnownWeights'.\r\ninline_oracle_b :: RunTimeParam -> Double -> Double -> ([Qubit],[Qubit],[Qubit]) -> Circ ([Qubit],[Qubit],[Qubit])\r\ninline_oracle_b rt factor_m factor_p = box (\"Ob \" ++ (show factor_m) ++ \" \" ++ (show factor_p)) $ decompose_generic Toffoli $ \\(x',m',p') -> \r\n -- Make ancillas for constant values\r\n \r\n with_ancilla_init (listpair_fmap fromIntegral $ scatteringnodes rt :: [(FDouble,FDouble)]) $ \\qscatteringnodes ->\r\n with_ancilla_init (fromIntegral $ ny rt :: FSignedInt) $ \\qny -> \r\n with_ancilla_init (fdouble $ lx rt) $ \\qlx ->\r\n with_ancilla_init (fdouble $ ly rt) $ \\qly ->\r\n with_ancilla_init (fdouble $ k rt) $ \\qk ->\r\n with_ancilla_init (fdouble $ theta rt) $ \\qtheta ->\r\n with_ancilla_init (fdouble $ e0 rt) $ \\qe0 ->\r\n with_ancilla_init (fromIntegral $ nx rt :: FSignedInt) $ \\qnx -> do\r\n\r\n -- the x register is smaller than the size of a QSInt,\r\n -- and x is an unsigned integer: make up a positive\r\n -- sign and a pad\r\n \r\n with_ancilla_init False $ \\bx -> do\r\n with_ancilla_init (replicate (fixed_int_register_length - (n2 rt)) \r\n False) $ \\pad_x -> do\r\n \r\n let x = SInt (pad_x ++ (reverse x')) bx\r\n \r\n let f = classical_to_reversible $ \r\n \\(y,nx,ny,scatteringnodes,lx,ly,k,theta,e0) -> do\r\n -- get some QSInt and QDouble\r\n (m,p) <- unpack Template.template_getKnownWeights \r\n y nx ny scatteringnodes lx ly k theta e0 7\r\n new_p <- make_factor_rep factor_p (n4 rt) p\r\n new_m <- make_factor_rep factor_m (n4 rt) m\r\n \r\n return (new_m, new_p)\r\n \r\n f ((x,qnx,qny,qscatteringnodes,qlx,qly,qk,qtheta,qe0),(m',p'))\r\n return (x',m',p')\r\n\r\n\r\n-- | Implementation of the oracle calculating the matrix /A/\r\n-- corresponding to the discretization of the scattering problem,\r\n-- using the Template Haskell implementation of\r\n-- 'getNodeValuesMoreOutputs'.\r\ninline_oracle_A :: RunTimeParam -> Double -> Int -> Bool -> ([Qubit],[Qubit],[Qubit]) -> Circ ([Qubit],[Qubit],[Qubit])\r\ninline_oracle_A rt factor band argflag = box (\"OA \" ++ (show band) ++ \" \" ++ (show argflag)) $ decompose_generic Toffoli $ \\(x',y',p') -> do\r\n\r\n let argflag' = if argflag then PTrue else PFalse\r\n \r\n -- Make ancillas for constant values\r\n \r\n with_ancilla_init (listpair_fmap fromIntegral $ scatteringnodes rt :: [(FDouble, FDouble)]) $ \\qscatteringnodes -> \r\n with_ancilla_init (fromIntegral $ ny rt :: FSignedInt) $ \\qny -> \r\n with_ancilla_init (fromRational $ toRational $ lx rt) $ \\qlx ->\r\n with_ancilla_init (fromRational $ toRational $ ly rt) $ \\qly ->\r\n with_ancilla_init (fromRational $ toRational $ k rt) $ \\qk ->\r\n with_ancilla_init (fromIntegral $ nx rt :: FSignedInt) $ \\qnx -> do\r\n\r\n -- the x register is smaller than the size of a QSInt,\r\n -- and x is an unsigned integer: make up a positive\r\n -- sign and a pad\r\n \r\n with_ancilla_init False $ \\bx -> do\r\n with_ancilla_init (replicate (fixed_int_register_length - (n2 rt))\r\n False) $ \\pad_x -> do\r\n \r\n let x = SInt (pad_x ++ (reverse x')) bx\r\n \r\n let f = classical_to_reversible $ \r\n \\(v,nx,ny,scatteringnodes,lx,ly,k) -> do\r\n -- get some QSInt and QDouble\r\n (y,p) <- unpack Template.template_getNodeValuesMoreOutputs\r\n v band nx ny scatteringnodes lx ly k argflag' 7\r\n \r\n new_p <- make_factor_rep factor (n4 rt) p \r\n \r\n -- set y in the correct format (it has n2 elements)\r\n -- we can assume that the sign is positive.\r\n -- we also assume that n2 < size of QSInt register\r\n let (SInt ty _) = y\r\n let new_y = (take (n2 rt) $ reverse ty)\r\n \r\n -- return the values in the right format.\r\n return (new_y,new_p)\r\n \r\n f ((x,qnx,qny,qscatteringnodes,qlx,qly,qk),(y',p'))\r\n \r\n return (x',y',p')\r\n \r\n\r\n-- | Encapsulate the inline oracles in Template Haskell into an object\r\n-- of type 'Oracle'.\r\ninline_oracle :: Oracle\r\ninline_oracle = Oracle {\r\n oracle_A = inline_oracle_A,\r\n oracle_b = inline_oracle_b,\r\n oracle_r = inline_oracle_r\r\n}\r\n", "meta": {"hexsha": "31937d630e85d9586a21d297c7fb1b29e03b2acf", "size": 36919, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "Algorithms/QLS/QLS.hs", "max_stars_repo_name": "silky/quipper", "max_stars_repo_head_hexsha": "1ef6d031984923d8b7ded1c14f05db0995791633", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 9, "max_stars_repo_stars_event_min_datetime": "2015-07-28T07:00:10.000Z", "max_stars_repo_stars_event_max_datetime": "2021-01-13T02:51:59.000Z", "max_issues_repo_path": "Algorithms/QLS/QLS.hs", "max_issues_repo_name": "qbit-/quipper", "max_issues_repo_head_hexsha": "5adba47b53c50e348517a0b30637b8b959a40c0d", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2015-11-15T04:27:40.000Z", "max_issues_repo_issues_event_max_datetime": "2016-04-28T09:17:08.000Z", "max_forks_repo_path": "Algorithms/QLS/QLS.hs", "max_forks_repo_name": "qbit-/quipper", "max_forks_repo_head_hexsha": "5adba47b53c50e348517a0b30637b8b959a40c0d", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 5, "max_forks_repo_forks_event_min_datetime": "2016-12-31T21:26:59.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-26T13:10:17.000Z", "avg_line_length": 37.9045174538, "max_line_length": 142, "alphanum_fraction": 0.5430807985, "num_tokens": 10634, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.7090191337850933, "lm_q2_score": 0.43398146480389854, "lm_q1q2_score": 0.3077011622540461}} {"text": "{-# LANGUAGE ConstraintKinds #-}\n{-# LANGUAGE FlexibleContexts #-}\n{-# LANGUAGE QuasiQuotes #-}\n\nmodule Layers\n ( ForwardLayer(..)\n , OutputLayer(..)\n , ForwardNN(..)\n , BackwardLayer(..)\n , BackputLayer(..)\n , BackwardNN(..)\n , TrainBatch(..)\n , NElement(..)\n , (<~)\n , (~>)\n , forward\n , output\n , backward\n , backput\n , learnForward\n , learnBackward\n , learn\n , learnAll\n , predict\n , evaluate\n ) where\n\nimport Control.Arrow\nimport Control.Lens hiding ((<~))\nimport Data.String.Interpolate as S (i)\nimport Debug.Trace\nimport Numeric\nimport Numeric.LinearAlgebra\nimport Synapse\n\ntype Weight a = Matrix a\n\ntype Bias a = Vector a\n\ntype SignalX a = Matrix a\n\ntype SignalY a = Matrix a\n\ntype Diff a = Matrix a\n\ntype TeacherBatch a = Matrix a\n\ntype InputBatch a = Matrix a\n\nnewtype TrainBatch a =\n TrainBatch (TeacherBatch a, InputBatch a)\n deriving (Show)\n\ndata ForwardLayer a\n = AffineForward (Weight a) (Bias a)\n | SigmoidForward\n | ReLUForward\n | JoinedForwardLayer (ForwardLayer a) (ForwardLayer a)\n deriving (Show)\n\ninstance (Numeric a, Eq a) => Eq (ForwardLayer a) where\n AffineForward w b == AffineForward w' b' = w == w' && b == b'\n SigmoidForward == SigmoidForward = True\n ReLUForward == ReLUForward = True\n JoinedForwardLayer a b == JoinedForwardLayer a' b' = a == a' && b == b'\n _ == _ = False\n\ninfixl 4 ~>\n\n(~>) :: ForwardLayer a -> ForwardLayer a -> ForwardLayer a\na ~> (JoinedForwardLayer x y) = (a ~> x) ~> y\na ~> b = JoinedForwardLayer a b\n\ndata OutputLayer a =\n SoftmaxWithCrossForward\n deriving (Show)\n\ndata ForwardNN a =\n ForwardNN (ForwardLayer a) (OutputLayer a)\n deriving (Show)\n\ndata BackwardLayer a\n = AffineBackward (Weight a) (Bias a) (SignalX a)\n | SigmoidBackward (SignalY a)\n | ReLUBackward (SignalX a)\n | JoinedBackwardLayer (BackwardLayer a) (BackwardLayer a)\n deriving (Show)\n\ninstance (Numeric a, Eq a) => Eq (BackwardLayer a) where\n AffineBackward w b d == AffineBackward w' b' d' =\n w == w' && b == b' && d == d'\n SigmoidBackward y == SigmoidBackward y' = y == y'\n ReLUBackward x == ReLUBackward x' = x == x'\n JoinedBackwardLayer a b == JoinedBackwardLayer a' b' = a == a' && b == b'\n _ == _ = False\n\ninfixr 4 <~\n\n(<~) :: BackwardLayer a -> BackwardLayer a -> BackwardLayer a\n(JoinedBackwardLayer x y) <~ b = x <~ (y <~ b)\na <~ b = JoinedBackwardLayer a b\n\ndata BackputLayer a =\n SoftmaxWithCrossBackward (TeacherBatch a) (SignalY a)\n\ndata BackwardNN a =\n BackwardNN (BackwardLayer a) (BackputLayer a)\n\ntype NElement a = (Ord a, Floating a, Numeric a, Num (Vector a), Show a)\n\nforward ::\n NElement a => ForwardLayer a -> SignalX a -> (BackwardLayer a, SignalY a)\nforward (AffineForward w b) x = (AffineBackward w b x, affinem w b x)\nforward SigmoidForward x = (SigmoidBackward y, y)\n where\n y = sigmoidm x\nforward ReLUForward x = (ReLUBackward x, relum x)\nforward (JoinedForwardLayer a b) x0 = (a' <~ b', x2)\n where\n (a', x1) = forward a x0\n (b', x2) = forward b x1\n\nbackward ::\n NElement a => a -> BackwardLayer a -> Diff a -> (ForwardLayer a, Diff a)\nbackward rate (AffineBackward w b x) d =\n (AffineForward (w - scale rate w') (b - scale rate b'), x')\n where\n (x', w', b') = affinemBackward w x d\nbackward _ (SigmoidBackward y) d = (SigmoidForward, sigmoidBackward y d)\nbackward _ (ReLUBackward x) d = (ReLUForward, relumBackward x d)\nbackward r (JoinedBackwardLayer a b) d0 = (a' ~> b', d2)\n where\n (b', d1) = backward r b d0\n (a', d2) = backward r a d1\n\noutput ::\n NElement a\n => OutputLayer a\n -> TeacherBatch a\n -> SignalY a\n -> (BackputLayer a, a)\noutput SoftmaxWithCrossForward t y = (SoftmaxWithCrossBackward t y', loss)\n where\n (y', loss) = softmaxWithCross t y\n\nbackput :: NElement a => BackputLayer a -> (OutputLayer a, Diff a)\nbackput (SoftmaxWithCrossBackward t y) =\n (SoftmaxWithCrossForward, softmaxWithCrossBackward t y)\n\nlearnForward :: NElement a => ForwardNN a -> TrainBatch a -> (BackwardNN a, a)\nlearnForward (ForwardNN layers loss) (TrainBatch (t, x)) =\n result `seq` (BackwardNN layers' loss', result)\n where\n (layers', y) = forward layers x\n (loss', result) = output loss t y\n\nlearnBackward :: NElement a => a -> BackwardNN a -> ForwardNN a\nlearnBackward rate (BackwardNN layers loss) = ForwardNN layers' loss'\n where\n (loss', d) = backput loss\n (layers', _) = backward rate layers d\n\nlearn :: NElement a => a -> ForwardNN a -> TrainBatch a -> (ForwardNN a, a)\nlearn rate a = first (learnBackward rate) . learnForward a\n\nlearnAll ::\n NElement a => a -> ForwardNN a -> [TrainBatch a] -> (ForwardNN a, [a])\nlearnAll rate origin batches = ls `seq` (nn, ls)\n where\n (nn, ls) = foldr f (origin, []) batches\n f batch (a, ls) = ls `seq` second (~: ls) $ learn rate a batch\n x ~: xs = trace [i|[#{length xs + 1}/#{n}] #{show x}|] (x : xs)\n n = length batches\n\npredict :: NElement a => ForwardLayer a -> Vector a -> Int\npredict layers = maxIndex . flatten . snd . forward layers . asRow\n\nevaluate :: NElement a => ForwardLayer a -> [(Int, Vector a)] -> Double\nevaluate layers samples = fromIntegral nOk / fromIntegral (length samples)\n where\n nOk = length $ filter (uncurry (==)) results\n results = map (second $ predict layers) samples\n", "meta": {"hexsha": "d94cc7661d2cf4784c0aca3cc7707f36829b361c", "size": 5309, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/Layers.hs", "max_stars_repo_name": "sawatani/simple_mnist", "max_stars_repo_head_hexsha": "3aa8f9ccaa9a3a58fed123a81e24ce7feab3e977", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/Layers.hs", "max_issues_repo_name": "sawatani/simple_mnist", "max_issues_repo_head_hexsha": "3aa8f9ccaa9a3a58fed123a81e24ce7feab3e977", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/Layers.hs", "max_forks_repo_name": "sawatani/simple_mnist", "max_forks_repo_head_hexsha": "3aa8f9ccaa9a3a58fed123a81e24ce7feab3e977", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 29.0109289617, "max_line_length": 78, "alphanum_fraction": 0.649086457, "num_tokens": 1645, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.7279754489059775, "lm_q2_score": 0.4225046348141882, "lm_q1q2_score": 0.3075730011937148}} {"text": "{-# LANGUAGE DataKinds #-}\n{-# LANGUAGE DeriveGeneric #-}\n{-# LANGUAGE FlexibleInstances #-}\n{-# LANGUAGE GeneralizedNewtypeDeriving #-}\n{-# LANGUAGE MultiParamTypeClasses #-}\n{-# LANGUAGE OverloadedStrings #-}\n{-# LANGUAGE ScopedTypeVariables #-}\n{-# LANGUAGE TypeOperators #-}\n{-# LANGUAGE GeneralizedNewtypeDeriving #-}\n{-#LANGUAGE OverloadedLists#-}\n\nmodule Lib\n ( app\n , main'\n ) where\n\nimport Network.Wai\nimport Network.Wai.Handler.Warp\nimport Servant\nimport Servant.API\nimport Data.Aeson\nimport GHC.Generics\nimport Data.String.Conversions\nimport Text.Read (readMaybe)\nimport Servant.HTML.Lucid\nimport Lucid\nimport Data.Time.Calendar\nimport Data.List (sortBy)\nimport Data.Complex\n\nimport Data.HashMap.Strict\nimport Data.Text(Text(..))\n\n------------------------ API SPEC ---------------------------\ntype UserAPI = \n \"users\" :> QueryParam \"sortby\" SortBy :> Get '[JSON] [User]\n :<|> \"members\" :> Get '[JSON] (Headers '[Header \"Access-Control-Allow-Origin\" String] Members)\n :<|> \"albert\" :> Get '[JSON] User\n :<|> \"isaac\" :> Get '[JSON] User\n\ntype MathAPI = \n \"sum\" :> Capture \"x\" Int :> Capture \"y\" Int :> Get '[JSON] Int\n :<|> \"conjugate\" :> Capture \"x\" (Complex Int) :> Get '[JSON] String\n\ntype MyAPI = UserAPI :<|> MathAPI\n\ndata User = User\n { name :: String\n , age :: Int\n , img :: String\n } deriving (Eq, Show, Generic)\n\nnewtype Members = Members [User]\n\n--------------------- INSTANCES ---------------------\ninstance ToJSON User \n\ninstance ToJSON Members where \n toJSON (Members us) = Object [(\"members\", toJSON us)] \n\ninstance ToHtml User where\n toHtml u = tr_ $ do\n td_ $ toHtml (name u)\n td_ $ toHtml (show $ age u)\n\n toHtmlRaw = toHtml\n\ninstance ToHtml [User] where\n toHtml u = table_ $ do\n tr_ $ do\n th_ $ toHtml (\"Name\"::String)\n th_ $ toHtml (\"Age\"::String)\n foldMap toHtml u\n\n toHtmlRaw = toHtml\n\ndata SortBy = Age | Name deriving (Generic, Show,Eq)\n\ninstance FromHttpApiData SortBy where\n parseQueryParam \"age\" = Right Age\n parseQueryParam \"name\" = Right Name\n parseQueryParam _ = Left \"Not valid query param\"\n\ninstance (Num a,Read a) => FromHttpApiData (Complex a) where\n --parseUrlPiece :: Text -> Either Text a\n parseUrlPiece txt = maybe (Left \"Cant parse complex num\") (Right) (readMaybe $ cs txt)\n\n---------------------- ENDPOINT HANDLERS -------------------\nusers :: [User]\nusers =\n [ User \"Isaac Newton\" 372 \"http://placehold.it/250x250\"\n , User \"Albert Einstein\" 136 \"http://placehold.it/250x250\" \n , User \"Haskell Curry\" 200 \"http://placehold.it/250x250\"\n ]\n\nmembers :: Monad m => m (Headers '[Header \"Access-Control-Allow-Origin\" String] Members)\nmembers = return $ addHeader \"*\" (Members users)\n\nalbert = users !! 0\nisaac = users !! 1\n\nsortedUsers Age = sortBy (compareWith age)\nsortedUsers Name = sortBy (compareWith name)\n\n-- m is actually a EitherT ServantErr IO, in the abscense of SortBy query param users gets returned\nsortUsers :: Monad m => Maybe SortBy -> m [User]\nsortUsers = return . maybe users (flip sortedUsers users)\n\n\n\nserver1 :: Server UserAPI\nserver1 = \n sortUsers\n :<|> members\n :<|> return isaac\n :<|> return albert\n\nserver2 :: Server MathAPI\nserver2 = sum\n :<|> showConjugate\n where\n sum = return <.. (+)\n\n showConjugate :: Monad m => Complex Int -> m String\n showConjugate = return . show . conjugate\n\nserver :: Server MyAPI\nserver = server1 :<|> server2\n\nmyAPI :: Proxy MyAPI\nmyAPI = Proxy\n\n---------------------------------- SERVER --------------------------------\n{- 'serve' comes from servant and hands you a WAI Application,\nwhich you can think of as an \"abstract\" web application,\nnot yet a webserver. -}\n\napp :: Application\napp = serve myAPI server\n\nmain' = do \n let hostIP = \"0.0.0.0\"\n let port = 5000\n putStrLn $ \"Server running in \" ++ (show hostIP) ++ \" port \" ++ (show port)\n let settings = setPort port $ setHost hostIP defaultSettings\n runSettings settings app\n\n\n----------------------------- UTILITIES -----------------------------\n(<..) = (.) . (.)\ncompareWith f x y = compare (f x) (f y) \n", "meta": {"hexsha": "815a4ca9febde922c52afdda9d0ade396210edd8", "size": 4186, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/Lib.hs", "max_stars_repo_name": "DanielCardonaRojas/LearnServant", "max_stars_repo_head_hexsha": "5b51b4eef2e7555d4a7510016ad30012794d7b48", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/Lib.hs", "max_issues_repo_name": "DanielCardonaRojas/LearnServant", "max_issues_repo_head_hexsha": "5b51b4eef2e7555d4a7510016ad30012794d7b48", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/Lib.hs", "max_forks_repo_name": "DanielCardonaRojas/LearnServant", "max_forks_repo_head_hexsha": "5b51b4eef2e7555d4a7510016ad30012794d7b48", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 27.5394736842, "max_line_length": 100, "alphanum_fraction": 0.613473483, "num_tokens": 1117, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.600188359260205, "lm_q2_score": 0.5117166047041654, "lm_q1q2_score": 0.3071263493835959}} {"text": "{-# LANGUAGE ForeignFunctionInterface #-}\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE Strict #-}\nmodule Grenade.Layers.Internal.Update (\n descendMatrix\n , descendVector\n , MatrixInputValues (..)\n , MatrixResult (..)\n , VectorInputValues (..)\n , VectorResult (..)\n , descendMatrixV\n , descendVectorV\n , MatrixInputValuesV (..)\n , MatrixResultV (..)\n , VectorInputValuesV (..)\n , VectorResultV (..)\n ) where\n\nimport Control.Parallel.Strategies\nimport Data.Maybe (fromJust, fromMaybe)\nimport qualified Data.Vector.Storable as U (unsafeFromForeignPtr0,\n unsafeToForeignPtr0)\nimport qualified Data.Vector.Storable as V\nimport Foreign (mallocForeignPtrArray, withForeignPtr)\nimport Foreign.Ptr (Ptr)\nimport GHC.TypeLits\nimport Numeric.LinearAlgebra (Vector, flatten)\nimport qualified Numeric.LinearAlgebra.Devel as U\nimport Numeric.LinearAlgebra.Static\nimport System.IO.Unsafe (unsafePerformIO)\n\nimport Grenade.Core.Optimizer\nimport Grenade.Layers.Internal.CUDA\nimport Grenade.Types\n\ndata MatrixInputValues rows columns\n = MatrixValuesSGD\n !(L rows columns) -- ^ current weights\n !(L rows columns) -- ^ gradients\n !(L rows columns) -- ^ last update (old momentum)\n | MatrixValuesAdam\n !Int -- ^ Step\n !(L rows columns) -- ^ current weights\n !(L rows columns) -- ^ gradients\n !(L rows columns) -- ^ current m\n !(L rows columns) -- ^ current v\n\ndata MatrixInputValuesV\n = MatrixValuesSGDV\n !(V.Vector RealNum) -- ^ current weights\n !(V.Vector RealNum) -- ^ gradients\n !(V.Vector RealNum) -- ^ old momentum\n | MatrixValuesAdamV\n !Int -- ^ Step\n !(V.Vector RealNum) -- ^ current weights\n !(V.Vector RealNum) -- ^ gradients\n !(V.Vector RealNum) -- ^ current m\n !(V.Vector RealNum) -- ^ current v\n\n\ndata MatrixResult rows columns\n = MatrixResultSGD\n { matrixActivations :: !(L rows columns) -- ^ new activations (weights)\n , matrixMomentum :: !(L rows columns) -- ^ new momentum\n }\n | MatrixResultAdam\n { matrixActivations :: !(L rows columns) -- ^ new activations (weights)\n , matrixM :: !(L rows columns) -- ^ new m\n , matrixV :: !(L rows columns) -- ^ new v\n }\n\ndata MatrixResultV\n = MatrixResultSGDV\n { matrixActivationsV :: !(V.Vector RealNum) -- ^ new activations (weights)\n , matrixMV :: !(V.Vector RealNum) -- ^ new m\n }\n | MatrixResultAdamV\n { matrixActivationsV :: !(V.Vector RealNum) -- ^ new activations (weights)\n , matrixMV :: !(V.Vector RealNum) -- ^ new m\n , matrixVV :: !(V.Vector RealNum) -- ^ new v\n }\n\ndata VectorInputValues r\n = VectorValuesSGD\n !(R r) -- ^ current weights\n !(R r) -- ^ gradients\n !(R r) -- ^ last update (old momentum)\n | VectorValuesAdam\n !Int -- ^ Step\n !(R r) -- ^ current weights\n !(R r) -- ^ current gradients\n !(R r) -- ^ current m\n !(R r) -- ^ current v\n\ndata VectorInputValuesV\n = VectorValuesSGDV\n !(V.Vector RealNum) -- ^ current weights\n !(V.Vector RealNum) -- ^ current gradients\n !(V.Vector RealNum) -- ^ current m\n | VectorValuesAdamV\n !Int -- ^ Step\n !(V.Vector RealNum) -- ^ current weights\n !(V.Vector RealNum) -- ^ current gradients\n !(V.Vector RealNum) -- ^ current m\n !(V.Vector RealNum) -- ^ current v\n\ndata VectorResult r\n = VectorResultSGD\n { vectorBias :: !(R r) -- ^ new activations (bias)\n , vectorMomentum :: !(R r) -- ^ new momentum\n }\n | VectorResultAdam\n { vectorBias :: !(R r) -- ^ new activations (bias)\n , vectorM :: !(R r) -- ^ new m\n , vectorV :: !(R r) -- ^ new v\n }\n\ndata VectorResultV\n = VectorResultSGDV\n { vectorBiasV :: !(V.Vector RealNum) -- ^ new activations (bias)\n , vectorMV :: !(V.Vector RealNum) -- ^ new m\n }\n | VectorResultAdamV\n { vectorBiasV :: !(V.Vector RealNum) -- ^ new activations (bias)\n , vectorMV :: !(V.Vector RealNum) -- ^ new m\n , vectorVV :: !(V.Vector RealNum) -- ^ new v\n }\n\ndescendMatrix :: (KnownNat rows, KnownNat columns) => Optimizer o -> MatrixInputValues rows columns -> MatrixResult rows columns\ndescendMatrix (OptSGD rate momentum regulariser) (MatrixValuesSGD weights gradient lastUpdate) =\n let (rows, cols) = size weights\n len = rows * cols\n -- Most gradients come in in ColumnMajor,\n -- so we'll transpose here before flattening them\n -- into a vector to prevent a copy.\n --\n -- This gives ~15% speed improvement for LSTMs.\n weights' = flatten . tr . extract $ weights\n gradient' = flatten . tr . extract $ gradient\n lastUpdate' = flatten . tr . extract $ lastUpdate\n (vw, vm) = descendUnsafeSGD len rate momentum regulariser weights' gradient' lastUpdate'\n\n -- Note that it's ColumnMajor, as we did a transpose before\n -- using the internal vectors.\n mw = U.matrixFromVector U.ColumnMajor rows cols vw\n mm = U.matrixFromVector U.ColumnMajor rows cols vm\n in MatrixResultSGD (fromJust . create $ mw) (fromJust . create $ mm)\ndescendMatrix (OptAdam alpha beta1 beta2 epsilon lambda) (MatrixValuesAdam step weights gradient m v) =\n let (rows, cols) = size weights\n len = rows * cols\n -- Most gradients come in in ColumnMajor,\n -- so we'll transpose here before flattening them\n -- into a vector to prevent a copy.\n --\n -- This gives ~15% speed improvement for LSTMs.\n weights' = flatten . tr . extract $ weights\n gradient' = flatten . tr . extract $ gradient\n m' = flatten . tr . extract $ m\n v' = flatten . tr . extract $ v\n (vw, vm, vv) = descendUnsafeAdamGPU len step alpha beta1 beta2 epsilon lambda weights' gradient' m' v'\n\n -- Note that it's ColumnMajor, as we did a transpose before\n -- using the internal vectors.\n mw = U.matrixFromVector U.ColumnMajor rows cols vw\n mm = U.matrixFromVector U.ColumnMajor rows cols vm\n mv = U.matrixFromVector U.ColumnMajor rows cols vv\n in MatrixResultAdam (fromJust . create $ mw) (fromJust . create $ mm) (fromJust . create $ mv)\ndescendMatrix opt _ = error $ \"optimzer does not match to MatrixInputValues in implementation! Optimizer: \" ++ show opt\n\ndescendMatrixV :: Optimizer o -> MatrixInputValuesV -> MatrixResultV\ndescendMatrixV (OptSGD rate momentum regulariser) (MatrixValuesSGDV weights gradient lastUpdate) =\n let len = V.length weights\n (vw, vm) = descendUnsafeSGD len rate momentum regulariser weights gradient lastUpdate\n in MatrixResultSGDV vw vm\ndescendMatrixV (OptAdam alpha beta1 beta2 epsilon lambda) (MatrixValuesAdamV step weights gradient m v) =\n let len = V.length weights\n (vw, vm, vv) = descendUnsafeAdamGPU len step alpha beta1 beta2 epsilon lambda weights gradient m v\n in MatrixResultAdamV vw vm vv\ndescendMatrixV opt _ = error $ \"optimzer does not match to MatrixInputValues in implementation! Optimizer: \" ++ show opt\n\ndescendVector :: (KnownNat r) => Optimizer o -> VectorInputValues r -> VectorResult r\ndescendVector (OptSGD rate momentum regulariser) (VectorValuesSGD weights gradient lastUpdate) =\n let len = size weights\n weights' = extract weights\n gradient' = extract gradient\n lastUpdate' = extract lastUpdate\n (vw, vm) = descendUnsafeSGD len rate momentum regulariser weights' gradient' lastUpdate'\n in VectorResultSGD (fromJust $ create vw) (fromJust $ create vm)\ndescendVector (OptAdam alpha beta1 beta2 epsilon lambda) (VectorValuesAdam step weights gradient m v) =\n let len = size weights\n weights' = extract weights\n gradient' = extract gradient\n m' = extract m\n v' = extract v\n (vw, vm, vv) = descendUnsafeAdamGPU len step alpha beta1 beta2 epsilon lambda weights' gradient' m' v'\n in VectorResultAdam (fromJust $ create vw) (fromJust $ create vm) (fromJust $ create vv)\ndescendVector opt _ = error $ \"optimzer does not match to VectorInputValues in implementation! Optimizer: \" ++ show opt\n\ndescendVectorV :: Optimizer o -> VectorInputValuesV -> VectorResultV\ndescendVectorV (OptSGD rate momentum regulariser) (VectorValuesSGDV weights gradient lastUpdate) =\n let len = V.length weights\n (vw, vm) = descendUnsafeSGD len rate momentum regulariser weights gradient lastUpdate\n in VectorResultSGDV vw vm\ndescendVectorV (OptAdam alpha beta1 beta2 epsilon lambda) (VectorValuesAdamV step weights gradient m v) =\n let len = V.length weights\n (vw, vm, vv) = descendUnsafeAdamGPU len step alpha beta1 beta2 epsilon lambda weights gradient m v\n in VectorResultAdamV vw vm vv\ndescendVectorV opt _ = error $ \"optimzer does not match to VectorInputValues in implementation! Optimizer: \" ++ show opt\n\n\n-- -- | Caching of data\n-- type CacheKey = (LookupType, ProxyType, StateFeatures)\n\n-- cacheMVar :: MVar (M.Map CacheKey [Values])\n-- cacheMVar = unsafePerformIO $ newMVar mempty\n-- {-# NOINLINE cacheMVar #-}\n\n-- emptyCache :: MonadIO m => m ()\n-- emptyCache = liftIO $ modifyMVar_ cacheMVar (const mempty)\n\n-- addCache :: (MonadIO m) => CacheKey -> [Values] -> m ()\n-- addCache k val = liftIO $ modifyMVar_ cacheMVar (return . M.insert k val)\n\n-- lookupCache :: (MonadIO m) => CacheKey -> m (Maybe [Values])\n-- lookupCache k = liftIO $ (M.lookup k =<<) <$> tryReadMVar cacheMVar\n\n\n-- -- | Get output of function f, if possible from cache according to key (st).\n-- cached :: (MonadIO m) => (LookupType, ProxyType, StateFeatures) -> m [Values] -> m [Values]\n-- cached st ~f = do\n-- c <- lookupCache st\n-- case c of\n-- Nothing -> do\n-- res <- f\n-- res `seq` addCache st res\n-- return res\n-- Just res -> return res\n\ndescendUnsafeSGD :: Int -> RealNum -> RealNum -> RealNum -> Vector RealNum -> Vector RealNum -> Vector RealNum -> (Vector RealNum, Vector RealNum)\ndescendUnsafeSGD len rate momentum regulariser weights gradient lastUpdate =\n unsafePerformIO $ do\n\n outWPtr <- mallocForeignPtrArray len\n outMPtr <- mallocForeignPtrArray len\n let (wPtr, _) = U.unsafeToForeignPtr0 weights\n let (gPtr, _) = U.unsafeToForeignPtr0 gradient\n let (lPtr, _) = U.unsafeToForeignPtr0 lastUpdate\n\n withForeignPtr wPtr $ \\wPtr' ->\n withForeignPtr gPtr $ \\gPtr' ->\n withForeignPtr lPtr $ \\lPtr' ->\n withForeignPtr outWPtr $ \\outWPtr' ->\n withForeignPtr outMPtr $ \\outMPtr' ->\n descend_sgd_cpu len rate momentum regulariser wPtr' gPtr' lPtr' outWPtr' outMPtr'\n\n return (U.unsafeFromForeignPtr0 outWPtr len, U.unsafeFromForeignPtr0 outMPtr len)\n{-# NOINLINE descendUnsafeSGD #-}\n\ndescendUnsafeAdam ::\n Int -- Len\n -> Int -- Step\n -> RealNum -- Alpha\n -> RealNum -- Beta1\n -> RealNum -- Beta2\n -> RealNum -- Epsilon\n -> RealNum -- Lambda\n -> Vector RealNum -- Weights\n -> Vector RealNum -- Gradient\n -> Vector RealNum -- M\n -> Vector RealNum -- V\n -> (Vector RealNum, Vector RealNum, Vector RealNum)\ndescendUnsafeAdam len step alpha beta1 beta2 epsilon lambda weights gradient m v =\n unsafePerformIO $ do\n V.unsafeWith weights $ \\wPtr' ->\n V.unsafeWith gradient $ \\gPtr' ->\n V.unsafeWith m $ \\mPtr' ->\n V.unsafeWith v $ \\vPtr' ->\n descend_adam_cpu len step alpha beta1 beta2 epsilon lambda wPtr' gPtr' mPtr' vPtr'\n return (weights, m, v)\n{-# NOINLINE descendUnsafeAdam #-}\n\ndescendUnsafeAdamGPU ::\n Int -- Len\n -> Int -- Step\n -> RealNum -- Alpha\n -> RealNum -- Beta1\n -> RealNum -- Beta2\n -> RealNum -- Epsilon\n -> RealNum -- Lambda\n -> Vector RealNum -- Weights\n -> Vector RealNum -- Gradient\n -> Vector RealNum -- M\n -> Vector RealNum -- V\n -> (Vector RealNum, Vector RealNum, Vector RealNum)\ndescendUnsafeAdamGPU len step alpha beta1 beta2 epsilon lambda weights gradient m v\n -- | useCuda len = -- We need some size, otherwise the overhead is too big and processing using BLAS is faster\n -- fromMaybe\n -- (descendUnsafeAdam len step alpha beta1 beta2 epsilon lambda weights gradient m v)\n -- (cudaDescendUnsafeAdamGPU len step alpha beta1 beta2 epsilon lambda weights gradient m v)\n | otherwise = descendUnsafeAdam len step alpha beta1 beta2 epsilon lambda weights gradient m v\n\n\nforeign import ccall unsafe\n descend_sgd_cpu\n :: Int -> RealNum -> RealNum -> RealNum -> Ptr RealNum -> Ptr RealNum -> Ptr RealNum -> Ptr RealNum -> Ptr RealNum -> IO ()\n\nforeign import ccall unsafe\n descend_adam_cpu\n :: Int -> Int -> RealNum -> RealNum -> RealNum -> RealNum -> RealNum -> Ptr RealNum -> Ptr RealNum -> Ptr RealNum -> Ptr RealNum -> IO ()\n", "meta": {"hexsha": "99290a6b347eabe3a61d19c2d27db60b190bde50", "size": 13039, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/Grenade/Layers/Internal/Update.hs", "max_stars_repo_name": "schnecki/grenade", "max_stars_repo_head_hexsha": "027e9c16899e2ca3685e89338a047488ac834249", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-01-11T15:05:38.000Z", "max_stars_repo_stars_event_max_datetime": "2021-01-11T15:05:38.000Z", "max_issues_repo_path": "src/Grenade/Layers/Internal/Update.hs", "max_issues_repo_name": "schnecki/grenade", "max_issues_repo_head_hexsha": "027e9c16899e2ca3685e89338a047488ac834249", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/Grenade/Layers/Internal/Update.hs", "max_forks_repo_name": "schnecki/grenade", "max_forks_repo_head_hexsha": "027e9c16899e2ca3685e89338a047488ac834249", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2018-07-02T01:04:29.000Z", "max_forks_repo_forks_event_max_datetime": "2021-01-08T13:08:47.000Z", "avg_line_length": 42.0612903226, "max_line_length": 146, "alphanum_fraction": 0.6413835417, "num_tokens": 3418, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6893056040203134, "lm_q2_score": 0.4455295350395727, "lm_q1q2_score": 0.30710600525934206}} {"text": "{-# OPTIONS_GHC -fplugin GHC.TypeLits.KnownNat.Solver #-}\n\n{-# LANGUAGE AllowAmbiguousTypes #-}\n{-# LANGUAGE CPP #-}\n{-# LANGUAGE DataKinds #-}\n{-# LANGUAGE DeriveAnyClass #-}\n{-# LANGUAGE DeriveGeneric #-}\n{-# LANGUAGE FlexibleContexts #-}\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE MultiParamTypeClasses #-}\n{-# LANGUAGE OverloadedStrings #-}\n{-# LANGUAGE ScopedTypeVariables #-}\n{-# LANGUAGE TypeFamilies #-}\n{-# LANGUAGE TypeOperators #-}\n{-# LANGUAGE UndecidableInstances #-}\n{-|\nModule : Grenade.Layers.SamePadPooling\nDescription : Pooling layer that supports SAME_UPPER padding\nMaintainer : Theo Charalambous\nLicense : BSD2\nStability : experimental\n-}\nmodule Grenade.Layers.SamePadPooling (\n -- * Layer Definition\n SamePadPooling (..)\n ) where\n\nimport Control.DeepSeq\nimport Data.Function ((&))\nimport Data.Kind (Type)\nimport Data.Maybe\nimport Data.Proxy\nimport Data.Serialize\nimport Data.Singletons.TypeLits hiding (natVal)\nimport GHC.Generics\nimport GHC.TypeLits\nimport Numeric.LinearAlgebra.Static (create, extract)\n\nimport Grenade.Core\nimport Grenade.Layers.Internal.Pooling\nimport Grenade.Onnx\n\n-- | A pooling layer for a neural network, for when auto_pad is SAME_UPPER or SAME_LOWER\n--\n-- Pads on the X and Y dimension of an image.\ndata SamePadPooling :: Nat -> Nat -> Nat -> Nat -> Nat -> Nat -> Nat -> Nat -> Type where\n SamePadPooling :: SamePadPooling kernelRows kernelColumns strideRows strideColumns padLeft padTop padRight padBottom\n deriving (NFData, Generic)\n\ninstance Show (SamePadPooling kernelRows kernelColumns strideRows strideColumns padLeft padTop padRight padBottom) where\n show SamePadPooling = \"SamePadPooling\"\n\ninstance UpdateLayer (SamePadPooling kernelRows kernelColumns strideRows strideColumns padLeft padTop padRight padBottom) where\n type Gradient (SamePadPooling kernelRows kernelColumns strideRows strideColumns padLeft padTop padRight padBottom) = ()\n runUpdate _ x _ = x\n reduceGradient _ = ()\n\ninstance RandomLayer (SamePadPooling kernelRows kernelColumns strideRows strideColumns padLeft padTop padRight padBottom) where\n createRandomWith _ _ = return SamePadPooling\n\ninstance Serialize (SamePadPooling kernelRows kernelColumns strideRows strideColumns padLeft padTop padRight padBottom) where\n put _ = return ()\n get = return SamePadPooling\n\n-- | A two dimentional image can be padded.\ninstance ( KnownNat padLeft\n , KnownNat padTop\n , KnownNat padRight\n , KnownNat padBottom\n , KnownNat strideRows\n , KnownNat strideColumns\n , KnownNat kernelRows\n , KnownNat kernelColumns\n , KnownNat inputRows\n , KnownNat inputColumns\n , KnownNat outputRows\n , KnownNat outputColumns\n , (padLeft + padRight) ~ ((outputColumns - 1) * strideColumns + kernelColumns - inputColumns)\n , (padTop + padBottom) ~ ((outputRows - 1) * strideRows + kernelRows - inputRows)\n ) => Layer (SamePadPooling kernelRows kernelColumns strideRows strideColumns padLeft padTop padRight padBottom) ('D2 inputRows inputColumns) ('D2 outputRows outputColumns) where\n type Tape (SamePadPooling kernelRows kernelColumns strideRows strideColumns padLeft padTop padRight padBottom) ('D2 inputRows inputColumns) ('D2 outputRows outputColumns) = ()\n runForwards SamePadPooling (S2D input) =\n let padl = fromIntegral $ natVal (Proxy :: Proxy padLeft)\n padt = fromIntegral $ natVal (Proxy :: Proxy padTop)\n padr = fromIntegral $ natVal (Proxy :: Proxy padRight)\n padb = fromIntegral $ natVal (Proxy :: Proxy padBottom)\n kr = fromIntegral $ natVal (Proxy :: Proxy kernelRows)\n kc = fromIntegral $ natVal (Proxy :: Proxy kernelColumns)\n sr = fromIntegral $ natVal (Proxy :: Proxy strideRows)\n sc = fromIntegral $ natVal (Proxy :: Proxy strideColumns)\n h = fromIntegral $ natVal (Proxy :: Proxy inputRows)\n w = fromIntegral $ natVal (Proxy :: Proxy inputColumns)\n\n m = extract input\n\n r = validPadPoolForwards 1 h w kr kc sr sc padl padt padr padb m\n\n in ((), S2D . fromJust . create $ r)\n runBackwards _ _ _ = error \"backward pass for SamePadPooling not implemented\"\n\n-- | A two dimentional image can be padded.\ninstance ( KnownNat padLeft\n , KnownNat padTop\n , KnownNat padRight\n , KnownNat padBottom\n , KnownNat strideRows\n , KnownNat strideColumns\n , KnownNat kernelRows\n , KnownNat kernelColumns\n , KnownNat inputRows\n , KnownNat inputColumns\n , KnownNat outputRows\n , KnownNat outputColumns\n , KnownNat channels\n , KnownNat (inputRows * channels)\n , KnownNat (outputRows * channels)\n , (padLeft + padRight) ~ ((outputColumns - 1) * strideColumns + kernelColumns - inputColumns)\n , (padTop + padBottom) ~ ((outputRows - 1) * strideRows + kernelRows - inputRows)\n ) => Layer (SamePadPooling kernelRows kernelColumns strideRows strideColumns padLeft padTop padRight padBottom) ('D3 inputRows inputColumns channels) ('D3 outputRows outputColumns channels) where\n type Tape (SamePadPooling kernelRows kernelColumns strideRows strideColumns padLeft padTop padRight padBottom) ('D3 inputRows inputColumns channels) ('D3 outputRows outputColumns channels) = ()\n runForwards SamePadPooling (S3D input) =\n let padl = fromIntegral $ natVal (Proxy :: Proxy padLeft)\n padt = fromIntegral $ natVal (Proxy :: Proxy padTop)\n padr = fromIntegral $ natVal (Proxy :: Proxy padRight)\n padb = fromIntegral $ natVal (Proxy :: Proxy padBottom)\n kr = fromIntegral $ natVal (Proxy :: Proxy kernelRows)\n kc = fromIntegral $ natVal (Proxy :: Proxy kernelColumns)\n sr = fromIntegral $ natVal (Proxy :: Proxy strideRows)\n sc = fromIntegral $ natVal (Proxy :: Proxy strideColumns)\n h = fromIntegral $ natVal (Proxy :: Proxy inputRows)\n w = fromIntegral $ natVal (Proxy :: Proxy inputColumns)\n c = fromIntegral $ natVal (Proxy :: Proxy channels)\n\n m = extract input\n\n r = validPadPoolForwards c h w kr kc sr sc padl padt padr padb m\n in ((), S3D . fromJust . create $ r)\n\n runBackwards _ _ _ = error \"backward pass for SamePadPooling not implemented\"\n\ninstance OnnxOperator (SamePadPooling kernelRows kernelColumns strideRows strideColumns padLeft padTop padRight padBottom) where\n onnxOpTypeNames _ = [\"MaxPool\"]\n\ninstance ( KnownNat padLeft\n , KnownNat padTop\n , KnownNat padRight\n , KnownNat padBottom\n , KnownNat strideRows\n , KnownNat strideColumns\n , KnownNat kernelRows\n , KnownNat kernelColumns\n ) => OnnxLoadable (SamePadPooling kernelRows kernelColumns strideRows strideColumns padLeft padTop padRight padBottom) where\n\n loadOnnxNode _ node = do\n node & hasSupportedDilations\n\n (node `hasMatchingShape` \"kernel_shape\") kernelShape\n (node `hasMatchingShape` \"strides\") strideShape\n\n -- todo: check that attribute is one of: SAME_UPPER or SAME_LOWER\n\n return SamePadPooling\n where\n kernelShape = [natVal (Proxy :: Proxy kernelRows), natVal (Proxy :: Proxy kernelColumns)]\n strideShape = [natVal (Proxy :: Proxy strideRows), natVal (Proxy :: Proxy strideColumns)]\n", "meta": {"hexsha": "05dd7811b07ffb07c99efee84a3423fdfd268cda", "size": 7641, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/Grenade/Layers/SamePadPooling.hs", "max_stars_repo_name": "th-char/grenade", "max_stars_repo_head_hexsha": "0be658e7cf07562cd5e4170ed1e8875ccec14cdb", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-06-09T06:06:26.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-09T06:06:26.000Z", "max_issues_repo_path": "src/Grenade/Layers/SamePadPooling.hs", "max_issues_repo_name": "th-char/grenade", "max_issues_repo_head_hexsha": "0be658e7cf07562cd5e4170ed1e8875ccec14cdb", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/Grenade/Layers/SamePadPooling.hs", "max_forks_repo_name": "th-char/grenade", "max_forks_repo_head_hexsha": "0be658e7cf07562cd5e4170ed1e8875ccec14cdb", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 46.0301204819, "max_line_length": 204, "alphanum_fraction": 0.6751734066, "num_tokens": 1815, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO\n\n", "lm_q1_score": 0.7745833945721304, "lm_q2_score": 0.39606816627404173, "lm_q1q2_score": 0.3067878247145062}} {"text": "{-# LANGUAGE OverloadedStrings #-}\n\nmodule Main where\n\nimport qualified Data.Text.IO as T\nimport qualified Data.Text as T\nimport Data.Text (Text)\nimport Data.Text.Encoding (encodeUtf8)\n\nimport qualified Data.ByteString.Lazy as B\nimport Data.ByteString.Lazy (ByteString)\nimport qualified Data.Map as Map\nimport Data.Map (Map)\nimport qualified Data.Vector as V\nimport Data.Vector (Vector)\nimport Data.Csv\nimport Data.Monoid\n\nimport Parser\nimport Type\n\nimport Control.Monad\nimport Control.Monad.Primitive\nimport System.Random.MWC\nimport Statistics.Distribution\nimport Statistics.Distribution.Laplace\n\ntype County a = Map Text a\ntype District a = Map Text (County a)\ntype FlatDistrict a = Map Text a\n\niteration :: Int\niteration = 1000\n\nmain :: IO ()\nmain = do\n raw <- B.readFile \"asset/sim_2.csv\"\n case parse raw of\n Left err -> putStrLn err\n Right rows -> do\n let nation = buildUp rows\n calculateNation nation\n calculateCounty nation\n calculateDistrict nation\n\ncalculateNation :: District (Vector Row) -> IO ()\ncalculateNation nation = do\n putStrLn \"\u5168\u570b\u5e73\u5747\u5c31\u91ab\u8ddd\u96e2\"\n let header = V.fromList [encodeUtf8 \"\u5168\u570b\"] :: Vector Name\n let result = [NationResult (nationAvg nation)]\n B.writeFile \"result/original/nationwide.csv\" (encodeByName header result)\n\n putStrLn \"\u5168\u570b\u5e73\u5747\u5c31\u91ab\u8ddd\u96e2 (added noise)\"\n forM_ [-9 .. 5] $ \\level -> do\n results <- replicateM iteration (nationAddNoise level nation)\n B.writeFile (\"result/pertubated/nationwide/2^\" <> show level <> \".csv\") (encodeByName header results)\n--\ncalculateCounty :: District (Vector Row) -> IO ()\ncalculateCounty nation = do\n putStrLn \"\u5404\u7e23\u5e02\u5e73\u5747\u5c31\u91ab\u8ddd\u96e2\"\n let header = V.fromList (map encodeUtf8 (Map.keys nation)) :: Vector Name\n let avgs = fmap countyAvg nation\n let result = [CountyResult avgs]\n B.writeFile \"result/original/countywide.csv\" (encodeByName header result)\n\n withSystemRandom . asGenIO $ \\gen -> do\n putStrLn \"\u5404\u7e23\u5e02\u5e73\u5747\u5c31\u91ab\u8ddd\u96e2 (added noise)\"\n forM_ [-4 .. 10] $ \\level -> do\n results <- replicateM iteration (countyAddNoise level nation gen)\n B.writeFile (\"result/pertubated/countywide/2^\" <> show level <> \".csv\") (encodeByName header results)\n\ncalculateDistrict :: District (Vector Row) -> IO ()\ncalculateDistrict nation = do\n let flattened = flatten nation\n putStrLn \"\u5404\u9109\u93ae\u5e02\u5340\u7684\u5e73\u5747\u5c31\u91ab\u8ddd\u96e2\"\n let header = V.fromList $ map encodeUtf8 $ Map.keys flattened\n let result = [DistrictResult (flatten $ fmap (fmap districtAvg) nation)]\n B.writeFile \"result/original/districtwide.csv\" (encodeByName header result)\n\n putStrLn \"\u5404\u9109\u93ae\u5e02\u5340\u7684\u5e73\u5747\u5c31\u91ab\u8ddd\u96e2 (added noise)\"\n\n withSystemRandom . asGenIO $ \\gen -> do\n forM_ [5 .. 20] $ \\level -> do\n results <- replicateM iteration (districtAddNoise level flattened gen)\n B.writeFile (\"result/pertubated/districtwide/2^\" <> show level <> \".csv\") (encodeByName header results)\n\n\nnationAddNoise :: Int -> District (Vector Row) -> IO NationResult\nnationAddNoise level nation = do\n let avg = nationAvg nation\n pertubated <- addNoise scale avg\n return (NationResult pertubated)\n where\n size = Map.foldl (\\s elem -> s + (Map.foldl (\\s vec -> s + V.length vec) 0 elem)) 0 nation\n eps = 2.0 ^^ level\n scale = 400000.0 / (fromIntegral size * eps)\n -- pertubated <- addNoise' scale (replicate iteration (nationwideAvg mapping))\n\ncountyAddNoise :: Int -> District (Vector Row) -> Gen (PrimState IO) -> IO CountyResult\ncountyAddNoise level nation gen = do\n pertubated <- mapM (\\county -> do\n let avg = countyAvg county\n noise <- genContVar (laplace 0 (scale county)) gen\n return (avg + noise)) nation\n return (CountyResult pertubated)\n\n where\n countySize = Map.foldl (\\s vec -> s + V.length vec) 0\n eps = 2.0 ^^ level\n scale county = 400000.0 / (fromIntegral (countySize county) * eps)\n\ndistrictAddNoise :: Int -> FlatDistrict (Vector Row) -> Gen (PrimState IO) -> IO DistrictResult\ndistrictAddNoise level flattened gen = do\n pertubated <- mapM (\\district -> do\n let avg = districtAvg district\n noise <- genContVar (laplace 0 (scale district)) gen\n return (avg + noise)) flattened\n return (DistrictResult pertubated)\n\n where\n districtSize = V.length -- Map.foldl (\\s vec -> s + V.length vec) 0\n eps = 2.0 ^^ level\n scale district = 400000.0 / (fromIntegral (districtSize district) * eps)\n\n\n\n\ndata NationResult = NationResult Double deriving (Show)\ndata CountyResult = CountyResult (County Double) deriving (Show)\ndata DistrictResult = DistrictResult (FlatDistrict Double) deriving (Show)\n\ninstance ToNamedRecord NationResult where\n toNamedRecord (NationResult value) = namedRecord\n [ (encodeUtf8 \"\u5168\u570b\") .= value ]\n\ninstance ToNamedRecord CountyResult where\n toNamedRecord (CountyResult value)\n = namedRecord (map (\\(key, val) -> (encodeUtf8 key) .= val) (Map.assocs value))\n\nflatten :: District a -> FlatDistrict a\nflatten = Map.fromList . concat . map fuseName . Map.assocs\n where\n fuseName :: (Text, County a) -> [(Text, a)]\n fuseName (countyName, county) = map (\\(districtName, distrct) -> (countyName <> districtName, distrct)) (Map.assocs county)\n\n\ninstance ToNamedRecord DistrictResult where\n toNamedRecord (DistrictResult nation)\n = namedRecord\n $ Map.elems\n $ Map.mapWithKey (\\name value -> encodeUtf8 name .= value)\n $ nation\n\ndistrictAvg :: Vector Row -> Double\ndistrictAvg = average . V.toList . fmap distance\n\ncountyAvg :: County (Vector Row) -> Double\ncountyAvg = average . concat . Map.elems . fmap (V.toList . fmap distance)\n -- average . Map.elems . fmap districtAvg\n -- Map.foldl (\\ acc distrct -> acc + districtAvg distrct) 0.0\n\nnationAvg :: District (Vector Row) -> Double\nnationAvg = average . concat . Map.elems . fmap (concat . Map.elems . fmap (V.toList . fmap distance))\n\nbuildUp :: Vector Row -> District (Vector Row)\nbuildUp = foldl insertCounty Map.empty\n where\n\n districtSingleton :: Row -> County (Vector Row)\n districtSingleton row = Map.singleton (snd (key row)) (V.singleton row)\n\n insertCounty :: District (Vector Row) -> Row -> District (Vector Row)\n insertCounty m row = Map.insertWith\n (insertDistrict row)\n (fst (key row)) -- key for TierCounty\n (districtSingleton row) -- key for TierCounty (which is TierDistrict)\n m\n\n insertDistrict :: Row -> County (Vector Row) -> County (Vector Row) -> County (Vector Row)\n insertDistrict row _ old = Map.insertWith\n (V.++)\n (snd (key row)) -- key for TierDistrict\n (V.singleton row) -- value for TierDistrict\n old\n\n key :: Row -> (Text, Text)\n key = T.splitAt 3 . townshipName . township . from\n\n townshipName :: Township -> Text\n townshipName (Township name _) = name\n\n\n--------------------------------------------------------------------------------\n-- Queries\n--------------------------------------------------------------------------------\n\naverage :: [Double] -> Double\naverage vec = sum vec / fromIntegral (length vec)\n\ndistance :: Row -> Double\ndistance row = sqrt ((fromX - toX) * (fromX - toX) + (fromY - toY) * (fromY - toY))\n where\n (fromX, fromY) = coord (from row)\n (toX , toY ) = coord (to row)\n\n--------------------------------------------------------------------------------\n-- Noise\n--------------------------------------------------------------------------------\n\nsampleLaplace :: Double -> IO Double\nsampleLaplace scale = withSystemRandom . asGenST $ genContVar (laplace 0 scale)\n\naddNoise :: Double -> Double -> IO Double\naddNoise scale x = do\n noise <- sampleLaplace scale\n return (x + noise)\n\n-- -- \u7814\u7a76\u554f\u984c\n--\n-- -- 1. \u5404\u9109\u93ae\u5e02\u5340\u7684\u5e73\u5747\u5c31\u91ab\u8ddd\u96e2\n-- -- 2. \u5404\u7e23\u5e02\u7684\u5e73\u5747\u5c31\u91ab\u8ddd\u96e2\n-- -- 3. \u5168\u570b\u7684\u5e73\u5747\u5c31\u91ab\u8ddd\u96e2\n--\n-- -- \u8ddd\u96e2\u4e0a\u9650: 400 \u516c\u91cc\n", "meta": {"hexsha": "e868ab7344dba2352daf0c1c5ac321de3a343d0a", "size": 8159, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/Main.hs", "max_stars_repo_name": "banacorn/dp-trial", "max_stars_repo_head_hexsha": "bc4126f19e2aa25cb4d028a2cef3ad524a84c9ca", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2019-11-29T11:05:45.000Z", "max_stars_repo_stars_event_max_datetime": "2019-11-29T11:05:45.000Z", "max_issues_repo_path": "src/Main.hs", "max_issues_repo_name": "banacorn/dp-trial", "max_issues_repo_head_hexsha": "bc4126f19e2aa25cb4d028a2cef3ad524a84c9ca", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/Main.hs", "max_forks_repo_name": "banacorn/dp-trial", "max_forks_repo_head_hexsha": "bc4126f19e2aa25cb4d028a2cef3ad524a84c9ca", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 36.2622222222, "max_line_length": 131, "alphanum_fraction": 0.6179678882, "num_tokens": 2119, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.705785040214066, "lm_q2_score": 0.43398146480389854, "lm_q1q2_score": 0.30629762558877877}} {"text": "{-# LANGUAGE GeneralizedNewtypeDeriving, BangPatterns, NoMonomorphismRestriction, ScopedTypeVariables, CPP #-}\n-- vim: sts=2:sw=2:ai:et\n--module Rolling where\n\nimport Data.Word\nimport Data.Int\nimport Data.Bits\nimport qualified Data.Vector.Unboxed as U\nimport qualified Data.Vector.Unboxed.Mutable as UM\nimport Control.Monad.ST\nimport qualified Data.ByteString as B\nimport qualified Data.ByteString.Unsafe as B\nimport qualified Data.ByteString.Lazy as L\nimport Pipes\nimport Pipes.Lift\nimport qualified Pipes.Prelude as P\nimport Control.Monad.State.Strict\nimport Control.Exception (assert)\nimport qualified Test.QuickCheck as QC\nimport Data.List\nimport qualified Control.Lens as L\nimport Control.Lens.Operators\nimport Control.DeepSeq\nimport Criterion.Main\nimport Statistics.Sample.Histogram\n-- import Debug.Trace\n\nwindow :: Int\nmask :: Word64\n\n#if 0\nwindow = 16\nmask = 0xf\n#else\nwindow = 256\nmask = 0x3fff\n#endif\n\ntestMask :: Word64 -> Bool\ntestMask x = x .&. mask == mask\n{-# INLINE testMask #-}\n\nhash :: Word8 -> Word64\n{-\nhash x = v8\n where v = fromIntegral x\n vv = v `shiftL` 8 .|. v\n vvvv = vv `shiftL` 16 .|. vv\n v8 = vvvv `shiftL` 32 .|. vvvv\n -}\n-- hash x = 31 * fromIntegral x\nhash x = lut `U.unsafeIndex` fromIntegral x\n{-# INLINE hash #-}\n\nrhash :: Word8 -> Word8 -> Word64 -> Word64\nrhash old new h = h `rotateL` 1 `xor` (hash old `rotateL` window) `xor` hash new\n\n(+>) :: Word64 -> Word64 -> Word64\n(+>) !o !n = (o `rotateL` window) `xor` n\n{-# INLINE (+>) #-}\n\nhashCombine :: Word64 -> Word64 -> Word64\nhashCombine !x !y = x `rotateL` 1 `xor` y\n{-# INLINE hashCombine #-}\n\ntype Data = B.ByteString -- S.Vector Word8\n\nroll :: [Word64] -> [Word64]\nroll hashed = tail $ scanl hashCombine h (zipWith (+>) hashed (drop window hashed))\n where h = foldl' hashCombine 0 (take window hashed)\n\nprop_rolls :: QC.Property\nprop_rolls = QC.forAll inputList $ \\a ->\n QC.forAll (QC.suchThat inputList (\\v -> length v > window)) $ \\b ->\n last (roll b) == last (roll (a ++ b))\n\ncontiguous :: Data -> [Data]\ncontiguous xs = zipWith (\\a b -> B.take (b - a) (B.drop a xs)) (0:boundaries) boundaries\n where hashed = map hash (B.unpack xs)\n rolled = roll hashed\n markers = findIndices testMask rolled\n boundaries = (++[B.length xs]) $ map (+(window+1)) markers\n\ncprop_allInputIsOutput :: QC.Property\ncprop_allInputIsOutput = QC.forAll inputData $ \\xs -> B.concat (contiguous xs) == xs\n\ncprop_prefix :: QC.Property\ncprop_prefix = QC.forAll inputData $ \\xs -> QC.forAll inputData $ \\ys ->\n let a = contiguous (xs `B.append` ys); b = contiguous xs in init' b `isPrefixOf` a\n\ncprop_suffix :: QC.Property\ncprop_suffix = QC.forAll inputData $ \\xs -> QC.forAll inputData $ \\ys ->\n let a = contiguous (xs `B.append` ys); c = contiguous ys in tail' c `isSuffixOf` a\n\ncprop_valid :: QC.Property\ncprop_valid = cprop_allInputIsOutput QC..&. cprop_prefix QC..&. cprop_suffix\n\ndata HashState\n = HashState {\n _lastHash :: {-# UNPACK #-} !Word64\n , _lastWindow :: !Data\n }\n\ninitialState :: HashState\ninitialState = HashState 0 B.empty\n\nlastHash :: L.Lens' HashState Word64\nlastHash f (HashState h w) = fmap (\\h' -> HashState h' w) (f h)\n\nlastWindow :: L.Lens' HashState Data\nlastWindow f (HashState h w) = fmap (HashState h) (f w)\n\ndata Output = Partial { getOutput :: Data } | Complete { getOutput :: Data }\n deriving (Show)\n\nisComplete :: Output -> Bool\nisComplete (Partial _) = False\nisComplete (Complete _) = True\n\nrollingBoundaries :: Data -> Data -> Word64 -> (Word64, U.Vector Int)\nrollingBoundaries !old !new !h0 = runST $ do mv <- UM.new (B.length new)\n (h', len) <- runner mv\n v <- U.unsafeFreeze (UM.take len mv)\n return (h', v)\n where\n runner mv = go h0 0 0\n where\n go !h !iOut !iIn | iIn < B.length new =\n do\n let hi = hash (old `B.unsafeIndex` iIn) +> hash (new `B.unsafeIndex` iIn)\n h' = hashCombine h hi\n iOut' <- case testMask h' of\n True -> do UM.unsafeWrite mv iOut (iIn + 1)\n return (iOut + 1)\n False -> return iOut\n go h' iOut' (iIn + 1)\n | otherwise = return (h, iOut)\n\nrollsplitP :: forall m. Monad m => Pipe Data Output (StateT HashState m) ()\nrollsplitP =\n do w <- L.use lastWindow\n if B.length w >= window\n then await >>= warmedUpPhase\n else await >>= initialPhase\n where\n initialPhase !x =\n do\n w <- L.use lastWindow\n assert (B.length w < window) (return ())\n\n let n = window - B.length w\n (xi, xn) = B.splitAt n x\n w' = w `B.append` xi\n lastWindow .= w'\n\n h <- L.use lastHash\n lastHash .= foldl' hashCombine h (map hash (B.unpack $ B.take n x))\n\n yield (Partial xi)\n\n if B.length w' < window\n then await >>= initialPhase\n else warmedUpPhase xn\n\n warmedUpPhase :: Data -> Pipe Data Output (StateT HashState m) ()\n warmedUpPhase !x =\n do\n w <- L.use lastWindow\n assert (B.length w == window) (return ())\n\n w' <- hoist (L.zoom lastHash) $\n do\n let len = B.length x\n chow w (B.take window x)\n when (len > window) $ chow x (B.drop window x)\n return (B.drop len w `B.append` B.drop (len - window) x)\n lastWindow .= w'\n await >>= warmedUpPhase\n\n chow !old !new = assert (B.length old >= B.length new) $\n do\n h <- get\n let (newH, boundaries) = rollingBoundaries old new h\n let sliceAction a b = do\n yield (Complete (B.unsafeTake (b - a) (B.unsafeDrop a new)))\n return b\n n <- U.foldM sliceAction 0 boundaries\n when (n < B.length new) $ yield (Partial (B.drop n new))\n put newH\n {-# INLINE chow #-}\n\nrecombine :: Monad m => Int64 -> Int64 -> Producer Output m a -> Producer L.ByteString m a\nrecombine nmin nmax = loop L.empty\n where\n loop d p =\n case L.length d of\n n | n < nmax ->\n do e <- lift (next p)\n case e of\n Left v -> yield d >> return v\n Right (output, p') -> if isComplete output && L.length d' >= nmin\n then yield d' >> loop L.empty p'\n else loop d' p'\n where d' = d `L.append` L.fromStrict (getOutput output)\n | otherwise ->\n do yield (L.take nmax d)\n loop (L.drop nmax d) p\n\nrollsplit :: Monad m => Int64 -> Int64 -> Producer Data m () -> Producer L.ByteString m ()\nrollsplit nmin nmax p = recombine nmin nmax $ evalStateP initialState $ hoist lift p >-> rollsplitP\n\nrollsplitL :: [Data] -> [L.ByteString]\nrollsplitL = filter (not . L.null) . rollsplitL'\n\nrollsplitL' :: [Data] -> [L.ByteString]\nrollsplitL' xs = P.toList $ rollsplit 0 (maxBound :: Int64) (each xs)\n\ninputList :: QC.Arbitrary a => QC.Gen [a]\ninputList = QC.sized $ \\n -> do\n k <- QC.choose (0,n)\n a <- QC.choose (0,window)\n let len = max 0 $ (k-1)*window+a\n QC.vector len\n\ninputData :: QC.Gen Data\ninputData = fmap B.pack inputList\n\ninit' :: [a] -> [a]\ninit' xs = take (length xs - 1) xs\n\ntail' :: [a] -> [a]\ntail' xs = drop 1 xs\n\nprop_allInputIsOutput :: QC.Property\nprop_allInputIsOutput = QC.forAll (QC.listOf inputData) $ \\xs -> L.concat (rollsplitL xs) == L.fromChunks xs\n\n\nprop_inputSplit :: QC.Property\nprop_inputSplit = QC.forAll (QC.listOf inputData) $ \\xs -> rollsplitL xs == rollsplitL [B.concat xs]\n\nprop_prefix :: QC.Property\nprop_prefix = QC.forAll inputData $ \\xs -> QC.forAll inputData $ \\ys ->\n let a = rollsplitL [xs, ys]; b = rollsplitL [xs] in init' b `isPrefixOf` a\n\nprop_suffix :: QC.Property\nprop_suffix = QC.forAll inputData $ \\xs -> QC.forAll inputData $ \\ys ->\n let a = rollsplitL [xs, ys]; c = rollsplitL [ys] in tail' c `isSuffixOf` a\n\nprop_concat :: QC.Property\nprop_concat = prop_prefix QC..&. prop_suffix\n\nprop_eq :: QC.Property\nprop_eq = QC.forAll inputData $ \\xs -> rollsplitL' [xs] == map L.fromStrict (contiguous xs)\n\nprop_valid :: QC.Property\nprop_valid = prop_allInputIsOutput QC..&. prop_inputSplit QC..&. prop_concat QC..&. prop_eq\n\nqc :: IO ()\nqc = QC.quickCheckWith (QC.stdArgs { QC.maxSuccess = 700 }) (cprop_valid QC..&. prop_valid)\n\ntest :: Int64 -> Int64 -> [Data] -> IO ()\ntest nmin nmax xs = runEffect $ for (rollsplit nmin nmax (each xs)) (lift . print)\n\ntest2 :: [Data] -> IO ()\ntest2 xs = runEffect $ for (evalStateP initialState $ each xs >-> rollsplitP) (lift . print)\n\nlut :: U.Vector Word64\nlut = U.fromList [\n 0xfead5b707dc7705c, 0x377c1e06dc1e45cf, 0x0184179586d5ae76, 0xd23aa044f8193aa6,\n 0xbd8ef5fcde7bd95e, 0x29a822b00a75ea90, 0x5ba03c1b2fdc2f86, 0x4f67d80bad410270,\n 0xfcc4b6b0cb67bb75, 0x8f4359ea8777f5d0, 0x5a110ec6371430f5, 0xe15dae4e9709aa66,\n 0xf8008efefbc29115, 0xd667f1ec0a5bcccf, 0xf56a2815cb29dbf8, 0xfc684381b1846cad,\n 0x15be2b7ed5231683, 0x0c226b1f911732c5, 0xe449b5885fd1d930, 0xf6d86c27a242cf1d,\n 0xc45cd857fdd32ca4, 0x36de9a99be8c3419, 0x8c34f2ee7050433f, 0x9fca9c3c61c05ce8,\n 0xf3727fe070e026f1, 0x019172d2948847be, 0x547bcbfaaef62543, 0x97df2b9f6c70001b,\n 0x2833bcc8513a3ae8, 0x63fb313206823b31, 0xe97ba036be16b286, 0xdde1143e9e8f7684,\n 0xc4e0d8e6e491054c, 0x7c488b71d4cab5fd, 0x2e0986d1f8e2d362, 0x97978ef2435b5cb1,\n 0x5506c42930dfc2a4, 0x3205d4c5886673cf, 0x22d5bfe8ba771cc5, 0x39503d4cb89afd6b,\n 0x9fc1cad11e5b5755, 0xce967aae1fccb3c3, 0x0f164d18916d4043, 0x113893188dd7e602,\n 0xedb9343bcf5f16ef, 0x0ce3b155cfc00cbf, 0x144c6c104492dff7, 0xe1ab67476c3c787f,\n 0x06357095472efed7, 0x29573d1071bb1237, 0xe27e7ce26dcd54c6, 0x03a8623e84a0e89c,\n 0x381194ea8cb4f8fe, 0x53cbe859f67ae71c, 0x85e08cd4432b31f5, 0x21f9758ed837239d,\n 0x835aad64a22264b4, 0xf83ec94f1a0159f3, 0x016a63af376515a4, 0x8af0e82577e30b6e,\n 0x4e3717bd197f8c8d, 0x20193e9699604cea, 0xfa8eb53310f65183, 0xb4980361f9a7e3b3,\n 0xccb9771f04663244, 0xe975bed27cfd7a05, 0x46e9eb7dd3ffd802, 0xbe4b5af269bf4b64,\n 0xf3ff155176f34e7e, 0xfc8e0e5c20814c3f, 0x3910b75cbe6677f5, 0x86fb5f8ef54ad45a,\n 0xad430e08aa6aea72, 0x6a82d96b64a7f48c, 0x8aa8af38d787327e, 0x3a10990b93334a3d,\n 0x010c38275c1fc3ac, 0x03eac81f78d29425, 0x356d5c2052ac066f, 0x9a14a98e51d4eafc,\n 0x9c07059dac0831b5, 0x51c3aa247abb4a6c, 0x7f9d96a58c371a56, 0xe098fe430cedd615,\n 0x960e3a1dbe524565, 0xf0401c427323f9e8, 0x2c22d55a6135331c, 0x8684f0837cb96bc9,\n 0xb7ac495220cc7e9b, 0x4083bd84b86ad15e, 0xd7434c89c5464bfd, 0x6af7d49f8b658a9d,\n 0x1b9878f861dd7d00, 0x6f5b7c3c3baaca36, 0xab6e6179f8b69d37, 0xda4c68dc98bcecd5,\n 0x42cb0a636ba3fa38, 0x04f2814021d2f99a, 0x53a069c086a24b1d, 0xce39ccfebf0fd3cf,\n 0x6da4576c5b938392, 0x73961a564d3684af, 0xe62079e996d934ab, 0x0fe43a5aded65708,\n 0x8ea00b7c1ba4a6b4, 0xb3f325b0d1acc61a, 0xb7d68c724ee32277, 0x8838a5a56df55c2e,\n 0x639e1a16eebc31dc, 0xc824476623ee8713, 0x6cfd35dd41d4a35f, 0xc0cf8dfb2eb67ca4,\n 0x9b2db80c20bf8281, 0x8f43090206cbc3a5, 0xf018850ed3cce401, 0xdd9c873dbc24dacf,\n 0x8c310f7792646b4a, 0xd64514da16af625c, 0x7de1ce3ec600b27d, 0x97742bfa39500785,\n 0x37e57a0934a9e321, 0x0872c00e96058f5f, 0x9a9291f9452ff389, 0x1240421b117dc351,\n 0x179b86fb16a829ed, 0xf773ae083f3cd908, 0xc32304664f8ce10f, 0x3bf48227de1ad114,\n 0x1e051eb805a697ad, 0x70ef7848e5ff8346, 0xe7dc2e245cb0d7f3, 0xf9ccdaee9f48ca62,\n 0x2ef082a2b4419ad3, 0x8a9287ed4ecd5750, 0x9f7b959d7c2ff1ba, 0x1b86fb1047eee0a9,\n 0x342ac90ae166bfb4, 0x9c28c8b1a92ab370, 0x7248bbdc9faaf6c1, 0x1a3b7cdd85269cfa,\n 0xcf3af94626a8c04f, 0x7a4ba5bef4f2856c, 0xa80dd551adc99bb8, 0xd7cef340d2e894ba,\n 0x134c05ffd4928eba, 0x78b5ec19a589ff89, 0xd8d23f88cbd19231, 0xa95a65c91e98558c,\n 0x0a996675f053aa80, 0xf35d31427e2dce98, 0x9985000bf5aefe7b, 0x73ac3f7cc6a7d6e0,\n 0xc48e7406cc446de3, 0xf919aa74e167dbbe, 0x8b09e12fc48dbbcd, 0x33b5f1fbafc21ead,\n 0xfbbf051f129c275d, 0x3239b2a8ee124a62, 0x8984d8d6b4a2ad6a, 0xe2293308df3acd2b,\n 0x2529297459fa7fac, 0x36c72d90491e670f, 0xe7ca9d442ddae3b3, 0x8fa38fa2a012ce0d,\n 0x5caac60bfad2c355, 0xa92158609a2e1285, 0x8a097df8fdb4c6cf, 0x1f1b6f8230e90ff0,\n 0x8369b558bec7e569, 0x2e9d4f7aabcb210d, 0xafb7d767ac296c18, 0x2f5cd5c2515d81c1,\n 0x45934465add6c676, 0xa5a45e774fd55fc3, 0xb4cb7e6e96d2a59d, 0xfdc6635b7ec562b0,\n 0x1bcedbd2ea8b4bf9, 0x0ab5b24bb7ccf99d, 0x31aa59853645b444, 0x9149c77d16594ff5,\n 0x77d9fee30ed21a67, 0x12982d192e88015b, 0xd45d1f788a6a1ef3, 0x332d24e0edf8ca0a,\n 0x88c7695975b9d19b, 0x065f29d44b168060, 0xd2a2a94e28c99de3, 0x8235595da56d3cd7,\n 0x4d58d451daa20b65, 0x36a1edff55e32372, 0xdf5c5c1e6b75c40b, 0x85c8a6bf77ecf2d3,\n 0x7d72ca70ec2882f2, 0xfe286fdc7db952ca, 0x13e308d730603af4, 0x7803625ac832d270,\n 0x920af03f31044bc6, 0x1fe4f2d207fecc03, 0x38537ef4067d59e9, 0x0eca7ef2100d20fc,\n 0x0a6fe0e637366afc, 0x9d52574f1a85c9e5, 0xd0a0fdbd96ed75d2, 0xb6785ac2254c0d92,\n 0x708122c30c97ff1f, 0x3e265597b73bc11e, 0xb3a870c781058225, 0xd93d905b304c4ec6,\n 0x52ff676e213f6ccb, 0xde7503df2ee1aed6, 0xcc95a88b5c5fc05a, 0x351d157d93a36b21,\n 0xf33702abc575fb08, 0xedcec8d4e602f76d, 0x210d869a4002a35a, 0xed6debb5a777ff11,\n 0x4aa4ef159b20a5da, 0x1248e5993f479e53, 0x6afdd7979ed93e76, 0x0048f115bbf8fcc9,\n 0x3c43dcc810f39b4c, 0xd596e217217ba38d, 0xf026411acc2ffc3f, 0xa9bfe1a48496f61c,\n 0x3c5d0feeb403ffe6, 0xf3cc4252ff0a0e4b, 0x9287b23486699a23, 0xfcb9175b7c6ad7f1,\n 0xd28a3ca6572757d0, 0x9679f32c0d2f01f8, 0x9aec761f1611e561, 0x00d429298b4544fc,\n 0x08aa8292dcaff98f, 0x36c88c6cf0188da2, 0x674a34c8653e66b8, 0x0e6316f1731e02b8,\n 0xd049743dfb30601e, 0xe99b74d4efa92d88, 0xa41f9c33729e01ad, 0xe0a2c2031c01b13d,\n 0x04a396e2dfc4f61f, 0xdb2556b846e68964, 0xa5de683723f23704, 0x456f750ec820ea4f,\n 0x47b81bb8dda336aa, 0x7c0b4cab5dffb32e, 0x020a4567a37ada75, 0x66325b8ce0bc3890,\n 0x566e9b6d6a194d5e, 0x53efbb71787c4049, 0xee775a2e794219de, 0xa65c279ca51a6a46,\n 0xaac56091fcec9c38, 0x0b34953b386ed0c4, 0xde46839785d1b945, 0x623a65d725974df2\n ]\n\nstats :: [Int64] -> IO ()\nstats xs = print (minimum xs) >> print (maximum xs) >> print (fromIntegral (sum xs) / fromIntegral (length xs) :: Double) >> print hist\n where\n hist = histogram_ 12 0 32 (U.map (logBase 2 . fromIntegral) $ U.fromList xs :: U.Vector Double) :: U.Vector Int\n\nmain :: IO ()\nmain = do\n benchRawData <- B.readFile \"bench.dat\"\n let benchData bs = force $ map (\\p -> B.take bs (B.drop p benchRawData)) [0,bs..B.length benchRawData-1]\n stats $ map L.length (rollsplitL' $ benchData 4096)\n stats $ map L.length (rollsplitL' $ benchData 65536)\n defaultMain [\n let dat = benchData 4096 in dat `seq` bench \"simple 4096\" $ nf rollsplitL' dat,\n let dat = benchData 65536 in dat `seq` bench \"simple 65536\" $ nf rollsplitL' dat,\n let dat = benchData 1048576 in dat `seq` bench \"simple 1048576\" $ nf rollsplitL' dat,\n let dat = benchData 4096 in dat `seq` bench \"clamped 4096\" $ nf (P.toList . rollsplit 1024 16386 . each) dat,\n let dat = benchData 65536 in dat `seq` bench \"clamped 65536\" $ nf (P.toList . rollsplit 1024 16386 . each) dat\n ]\n", "meta": {"hexsha": "bee7a6d2eeb7fb791e85ba67bdb214803c7921a7", "size": 15348, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "unorganized/Rolling.hs", "max_stars_repo_name": "aristidb/datastorage", "max_stars_repo_head_hexsha": "63f261c3b0e391d480ec3c1ed122f649d4b8c517", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "unorganized/Rolling.hs", "max_issues_repo_name": "aristidb/datastorage", "max_issues_repo_head_hexsha": "63f261c3b0e391d480ec3c1ed122f649d4b8c517", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "unorganized/Rolling.hs", "max_forks_repo_name": "aristidb/datastorage", "max_forks_repo_head_hexsha": "63f261c3b0e391d480ec3c1ed122f649d4b8c517", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 43.4787535411, "max_line_length": 135, "alphanum_fraction": 0.6922726088, "num_tokens": 6267, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6477982043529715, "lm_q2_score": 0.47268347662043286, "lm_q1q2_score": 0.3062035073820362}} {"text": "{-# LANGUAGE FlexibleContexts #-}\n{-# LANGUAGE FlexibleInstances #-}\n{-# LANGUAGE DefaultSignatures #-}\n{-# LANGUAGE FunctionalDependencies #-}\n{-# LANGUAGE GeneralizedNewtypeDeriving #-}\n{-# LANGUAGE MultiParamTypeClasses #-}\n{-# LANGUAGE PatternGuards #-}\n{-# LANGUAGE PatternSynonyms #-}\n{-# LANGUAGE ViewPatterns #-}\n{-# LANGUAGE Rank2Types #-}\n{-# LANGUAGE TypeFamilies #-}\n{-# LANGUAGE UndecidableInstances #-}\n-----------------------------------------------------------------------------\n-- |\n-- Copyright : (c) Edward Kmett 2010-2021\n-- License : BSD3\n-- Maintainer : ekmett@gmail.com\n-- Stability : experimental\n-- Portability : GHC only\n--\n-----------------------------------------------------------------------------\n\nmodule Numeric.AD.Mode\n (\n -- * AD modes\n Mode(..)\n , pattern KnownZero\n , pattern Auto\n ) where\n\nimport Numeric.Natural\nimport Data.Complex\nimport Data.Int\nimport Data.Ratio\nimport Data.Word\n\ninfixr 7 *^\ninfixl 7 ^*\ninfixr 7 ^/\n\nclass (Num t, Num (Scalar t)) => Mode t where\n type Scalar t\n type Scalar t = t\n\n -- | allowed to return False for items with a zero derivative, but we'll give more NaNs than strictly necessary\n isKnownConstant :: t -> Bool\n isKnownConstant _ = False\n\n asKnownConstant :: t -> Maybe (Scalar t)\n asKnownConstant _ = Nothing\n\n -- | allowed to return False for zero, but we give more NaN's than strictly necessary\n isKnownZero :: t -> Bool\n isKnownZero _ = False\n\n -- | Embed a constant\n auto :: Scalar t -> t\n default auto :: (Scalar t ~ t) => Scalar t -> t\n auto = id\n\n -- | Scalar-vector multiplication\n (*^) :: Scalar t -> t -> t\n a *^ b = auto a * b\n\n -- | Vector-scalar multiplication\n (^*) :: t -> Scalar t -> t\n a ^* b = a * auto b\n\n -- | Scalar division\n (^/) :: Fractional (Scalar t) => t -> Scalar t -> t\n a ^/ b = a ^* recip b\n\n -- |\n -- @'zero' = 'lift' 0@\n zero :: t\n zero = auto 0\n\npattern KnownZero :: Mode s => s\npattern KnownZero <- (isKnownZero -> True) where\n KnownZero = zero\n\npattern Auto :: Mode s => Scalar s -> s\npattern Auto n <- (asKnownConstant -> Just n) where\n Auto n = auto n\n\ninstance Mode Double where\n isKnownConstant _ = True\n asKnownConstant = Just\n isKnownZero x = 0 == x\n (^/) = (/)\n\ninstance Mode Float where\n isKnownConstant _ = True\n asKnownConstant = Just\n isKnownZero x = 0 == x\n (^/) = (/)\n\ninstance Mode Int where\n isKnownConstant _ = True\n asKnownConstant = Just\n isKnownZero x = 0 == x\n (^/) = (/)\n\ninstance Mode Integer where\n isKnownConstant _ = True\n asKnownConstant = Just\n isKnownZero x = 0 == x\n (^/) = (/)\n\ninstance Mode Int8 where\n isKnownConstant _ = True\n asKnownConstant = Just\n isKnownZero x = 0 == x\n (^/) = (/)\n\ninstance Mode Int16 where\n isKnownConstant _ = True\n asKnownConstant = Just\n isKnownZero x = 0 == x\n (^/) = (/)\n\ninstance Mode Int32 where\n isKnownConstant _ = True\n asKnownConstant = Just\n isKnownZero x = 0 == x\n (^/) = (/)\n\ninstance Mode Int64 where\n isKnownConstant _ = True\n asKnownConstant = Just\n isKnownZero x = 0 == x\n (^/) = (/)\n\ninstance Mode Natural where\n isKnownConstant _ = True\n asKnownConstant = Just\n isKnownZero x = 0 == x\n (^/) = (/)\n\ninstance Mode Word where\n isKnownConstant _ = True\n asKnownConstant = Just\n isKnownZero x = 0 == x\n (^/) = (/)\n\ninstance Mode Word8 where\n isKnownConstant _ = True\n asKnownConstant = Just\n isKnownZero x = 0 == x\n (^/) = (/)\n\ninstance Mode Word16 where\n isKnownConstant _ = True\n asKnownConstant = Just\n isKnownZero x = 0 == x\n (^/) = (/)\n\ninstance Mode Word32 where\n isKnownConstant _ = True\n asKnownConstant = Just\n isKnownZero x = 0 == x\n (^/) = (/)\n\ninstance Mode Word64 where\n isKnownConstant _ = True\n asKnownConstant = Just\n isKnownZero x = 0 == x\n (^/) = (/)\n\ninstance RealFloat a => Mode (Complex a) where\n isKnownConstant _ = True\n asKnownConstant = Just\n isKnownZero x = 0 == x\n (^/) = (/)\n\ninstance Integral a => Mode (Ratio a) where\n isKnownConstant _ = True\n asKnownConstant = Just\n isKnownZero x = 0 == x\n (^/) = (/)\n", "meta": {"hexsha": "e9cb89693412931873fd4e5f7c741ef425fd5f40", "size": 4030, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/Numeric/AD/Mode.hs", "max_stars_repo_name": "msakai/ad", "max_stars_repo_head_hexsha": "85aee3c6b4b621bab24c4379a88da1b5f0494d97", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 286, "max_stars_repo_stars_event_min_datetime": "2015-01-13T12:54:22.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-01T19:11:54.000Z", "max_issues_repo_path": "src/Numeric/AD/Mode.hs", "max_issues_repo_name": "msakai/ad", "max_issues_repo_head_hexsha": "85aee3c6b4b621bab24c4379a88da1b5f0494d97", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 42, "max_issues_repo_issues_event_min_datetime": "2015-03-15T02:22:40.000Z", "max_issues_repo_issues_event_max_datetime": "2021-07-19T18:26:25.000Z", "max_forks_repo_path": "src/Numeric/AD/Mode.hs", "max_forks_repo_name": "msakai/ad", "max_forks_repo_head_hexsha": "85aee3c6b4b621bab24c4379a88da1b5f0494d97", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 49, "max_forks_repo_forks_event_min_datetime": "2015-01-22T12:26:31.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-21T09:28:35.000Z", "avg_line_length": 22.2651933702, "max_line_length": 113, "alphanum_fraction": 0.6146401985, "num_tokens": 1172, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6113819732941511, "lm_q2_score": 0.5, "lm_q1q2_score": 0.30569098664707556}} {"text": "-- {-# LANGUAGE DuplicateRecordFields #-}\n{-# LANGUAGE FlexibleInstances #-}\n{-# LANGUAGE FlexibleContexts #-}\n-- {-# LANGUAGE TypeSynonymInstances #-} -- needed fo GenIO\n-- {-# LANGUAGE FunctionalDependencies #-}\n{-# LANGUAGE MultiParamTypeClasses #-}\n{-# LANGUAGE TypeFamilies #-}\n{-# LANGUAGE AllowAmbiguousTypes #-} -- MWC.Gen create\n{-# LANGUAGE UndecidableInstances #-} -- for UniformDist\n{-# LANGUAGE TemplateHaskell #-}\n{-# LANGUAGE PolyKinds #-}\n\n{-# OPTIONS_HADDOCK show-extensions #-}\n\n\n-- |\n-- Module : PSO.Random\n-- Description : Uniform interface for \"Control.Random.Mersenne\" and\n-- \"Control.Random.MWC\"\n-- Description : Particle Swarm Optimisation\n-- Copyright : (c) Tom Westerhout, 2017\n-- License : BSD3\n-- Maintainer : t.westerhout@student.ru.nl\n-- Stability : experimental\n\nmodule PSO.Random\n ( Generator(..)\n , Randomisable(..)\n , UniformDist(..)\n , RandomScalable(..)\n , mkMTGen\n , mkMWCGen\n , mkMWCGenST\n , uniformList\n , uniformVector\n , randomSpin\n ) where\n\nimport System.IO.Unsafe\nimport Data.Word(Word8,Word32)\nimport Data.Proxy\nimport Data.Complex(Complex(..))\nimport Control.Monad.Primitive\nimport Control.Monad.ST\nimport Control.Monad.Reader\nimport Data.Vector(singleton)\nimport GHC.Float\nimport qualified Data.Vector.Storable as V\nimport qualified Data.Vector.Generic as GV\nimport Foreign.C.Types(CDouble, CFloat)\nimport qualified Foreign\nimport qualified System.Random.Mersenne as Mersenne\nimport qualified System.Random.MWC as MWC\n\n\nclass (PrimMonad m) => Generator m g where\n create :: Maybe Word32 -> m g\n\ninstance Generator IO Mersenne.MTGen where\n create = Mersenne.newMTGen\n\ninstance Generator IO (MWC.Gen RealWorld) where\n create x = case x of\n (Just n) -> MWC.initialize . singleton $ n\n Nothing -> MWC.createSystemRandom\n\ninstance Generator (ST s) (MWC.Gen s) where\n create x = case x of\n (Just n) -> MWC.initialize . singleton $ n\n Nothing -> MWC.create\n\n\nclass (Monad m) => Randomisable m a where\n random :: m a\n\n\ninstance (Mersenne.MTRandom a)\n => Randomisable (ReaderT Mersenne.MTGen IO) a where\n random = ask >>= lift . Mersenne.random\n\ninstance {-# OVERLAPS #-} Randomisable (ReaderT Mersenne.MTGen IO) Float where\n random = ask >>= lift . liftM double2Float . Mersenne.random\n\ninstance (MWC.Variate a)\n => Randomisable (ReaderT (MWC.Gen RealWorld) IO) a where\n random = ask >>= lift . MWC.uniform\n\ninstance (MWC.Variate a)\n => Randomisable (ReaderT (MWC.Gen s) (ST s)) a where\n random = ask >>= lift . MWC.uniform\n\ninstance {-# OVERLAPS #-} (MWC.Variate a)\n => Randomisable (ReaderT (MWC.Gen RealWorld) IO) (Complex a) where\n random = liftM2 (:+) random random\n\n\nmkMTGen :: Maybe Word32 -> IO Mersenne.MTGen\nmkMTGen = create\n\nmkMWCGen :: Maybe Word32 -> IO MWC.GenIO\nmkMWCGen = create\n\nmkMWCGenST :: Maybe Word32 -> ST s (MWC.GenST s)\nmkMWCGenST = create\n\n\nclass (Monad m) => UniformDist m a where\n uniform :: (a, a) -> m a\n\nclass (Monad m) => RandomScalable m a where\n randScale :: a -> m a\n\n\nuniformFloating :: (RealFloat a, Randomisable m a)\n => (a, a) -> m a\nuniformFloating (low, high) = return (\\x -> low + (high - low) * x) `ap` random\n\nuniformIntegralMWC ::\n (Integral a, MWC.Variate a, PrimMonad m)\n => (a, a) -> ReaderT (MWC.Gen (PrimState m)) m a\nuniformIntegralMWC bounds = ask >>= lift . MWC.uniformR bounds\n\nuniformIntegralMT ::\n (Integral a, Bounded a, Mersenne.MTRandom a)\n => (a, a) -> ReaderT Mersenne.MTGen IO a\nuniformIntegralMT (low, high) = ask >>= lift . Mersenne.random >>= \\x ->\n return $ low + x `mod` (high - low + 1)\n\ninstance (Monad m, Randomisable m Float) => UniformDist m Float where\n uniform = uniformFloating\n\ninstance (Monad m, Randomisable m Double) => UniformDist m Double where\n uniform = uniformFloating\n\ninstance (Monad m, Randomisable m CFloat) => UniformDist m CFloat where\n uniform = uniformFloating\n\ninstance (Monad m, Randomisable m CDouble) => UniformDist m CDouble where\n uniform = uniformFloating\n\ninstance (RealFloat a, UniformDist m a)\n => UniformDist m (Complex a) where\n uniform ((rlow :+ ilow), (rhigh :+ ihigh)) =\n liftM2 (:+) (uniform (rlow, rhigh)) (uniform (ilow, ihigh))\n\ninstance (UniformDist m a) => UniformDist m [a] where\n uniform (low, high) = mapM uniform $ zip low high\n\ninstance (Foreign.Storable a, UniformDist m a)\n => UniformDist m (V.Vector a) where\n uniform (low, high) = V.zipWithM (\\l h -> uniform (l, h)) low high\n\ninstance UniformDist (ReaderT (MWC.Gen RealWorld) IO) Word8 where\n uniform = uniformIntegralMWC\n\ninstance UniformDist (ReaderT (MWC.Gen RealWorld) IO) Int where\n uniform = uniformIntegralMWC\n\ninstance UniformDist (ReaderT Mersenne.MTGen IO) Word8 where\n uniform = uniformIntegralMT\n\ninstance UniformDist (ReaderT Mersenne.MTGen IO) Int where\n uniform = uniformIntegralMT\n\nrandScaleFloating :: (RealFloat a, Randomisable m a) => a -> m a\nrandScaleFloating x = liftM (* x) random\n\ninstance (Monad m, Randomisable m Float) => RandomScalable m Float where\n randScale = randScaleFloating\n\ninstance (Monad m, Randomisable m Double) => RandomScalable m Double where\n randScale = randScaleFloating\n\ninstance (Monad m, Randomisable m CFloat) => RandomScalable m CFloat where\n randScale = randScaleFloating\n\ninstance (Monad m, Randomisable m CDouble) => RandomScalable m CDouble where\n randScale = randScaleFloating\n\ninstance {-# OVERLAPS #-} (RandomScalable m a)\n => RandomScalable m (Complex a) where\n randScale (x :+ y) = return (:+) `ap` (randScale x) `ap` (randScale y)\n\ninstance (Monad m, Foreign.Storable a, RandomScalable m a)\n => RandomScalable m (V.Vector a) where\n randScale = V.mapM randScale\n\n-- instance (RandomScalable m a, GV.Vector v a) => RandomScalable m (v a) where\n-- randScale = GV.mapM randScale\n\nuniformList :: (Monad m, UniformDist m a) => Int -> (a, a) -> m [a]\nuniformList n bounds = replicateM n (uniform bounds)\n\nuniformVector ::\n (Monad m, Foreign.Storable a, UniformDist m a)\n => Int -> (a, a) -> m (V.Vector a)\nuniformVector n = liftM V.fromList . uniformList n\n\nrandomSpin ::\n (Monad m, Foreign.Storable a, Num a, Randomisable m Bool)\n => Int -> m (V.Vector a)\nrandomSpin n =\n let fromBool True = 1\n fromBool False = (-1)\n in V.replicateM n (fromBool <$> random)\n", "meta": {"hexsha": "370a89f63ee36d5b78529d4bcfa2bd73e4728166", "size": 6341, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/PSO/Random.hs", "max_stars_repo_name": "twesterhout/tcm-swarm", "max_stars_repo_head_hexsha": "e632d493a9dc0b78c2634c2ac6311abc5f99168a", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/PSO/Random.hs", "max_issues_repo_name": "twesterhout/tcm-swarm", "max_issues_repo_head_hexsha": "e632d493a9dc0b78c2634c2ac6311abc5f99168a", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/PSO/Random.hs", "max_forks_repo_name": "twesterhout/tcm-swarm", "max_forks_repo_head_hexsha": "e632d493a9dc0b78c2634c2ac6311abc5f99168a", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 30.7815533981, "max_line_length": 79, "alphanum_fraction": 0.6913736004, "num_tokens": 1807, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.611381973294151, "lm_q2_score": 0.5, "lm_q1q2_score": 0.3056909866470755}} {"text": "{-# LANGUAGE GADTs, TypeOperators, ScopedTypeVariables, Rank2Types #-}\nmodule Math.Probably.GibbsUntyped where\n\nimport Math.Probably.Sampler\nimport Math.Probably.StochFun\nimport Numeric.LinearAlgebra hiding (flatten)\nimport Data.Array.ST\nimport Control.Monad.ST\nimport Control.Monad\nimport Data.STRef\nimport Data.Array\nimport GHC.Arr\n\n\ntype V = Vector Double\n\ntype VArr s = STArray s Int V \n\ntype Gibbs s = [VArr s -> Sampler V]\n\nmyG :: Gibbs s\nmyG = [\\_-> return 0.5,\n \\_->return 0.2]\n\n\n{-gibbsSampler :: GTerm a b -> StochFun a b\ngibbsSampler gibbs = SF stochfun\n where stochfun (x0, dbls) = undefined\n\n-}\n\n--there is a serious flaw in this approach. we need to replace items\n--in x0 when running subsequent samplers. this is considerably more\n--difficult.\nrunGibbs :: Gibbs s -> VArr s -> [Double] -> ST s [VArr s]\nrunGibbs gbs x0 dbls = do\n \n--what a nightmare. What about the zipper??\n return []\n \n\n\n\n{-nearlyGibbs :: Gibbs -> StochFun VArr VArr\nnearlyGibbs gbs = SF $ \\(arr, dbls') -> runST $ do\n dbls <- newSTRef dbls'\n melted <- thawSTArray arr\n forM_ (zip gbs [0..]) $ \\(f,idx) -> do\n rnds <- readSTRef dbls\n let (x, rnds) = unSF $ f melted\n ice <- freezeSTArray melted\n newDbls <- readSTRef dbls\n return (ice, newDbls) -}\n\n{-\n (y, dbls') = sf dbls\n next = unSF $ nearlyGibbs g\n (rest, dbls'') = next (x0, dbls')\n in (y :+: rest, dbls'') -}\n--nearlyGibbs GNil = sampler $ return TNil\n \n{-\n\nmyChain = Mrkv (nearlyGibbs myG2) (2:+:2:+:TNil) id\n\ntst = take 20 `fmap` runMarkovIO myChain\n\n\n{-iterateG :: GTerm a b -> a -> b\niterateG (f :%: g) x0 = f x0 :+: iterateG g x0\niterateG GNil _ = TNil\n\nmyXs :: [Double :+: (Double :+: TNil)]\nmyXs = iterate (iterateG myG2) (2 :+: (3 :+: TNil))\n-}\n\ngibbs2 :: (a-> b) -> (b-> a) -> (a,b) -> (a,b)\ngibbs2 f g (x,y) = let y1 = f x\n x1 = g y1 in (x1,y1)\n\ngibbs3 :: ((a, b)->c) -> ((b,c)-> a) -> ((c,a)-> b) -> (a,b,c) -> (a,b,c)\ngibbs3 f g h (x0,y0,z0) = let x1 = g (y0,z0)\n y1 = h (z0, x1)\n z1 = f (x1, y1)\n in (x1,y1,z1)\n\n\nasD :: Double -> Double\nasD = id\n-}", "meta": {"hexsha": "bae249504e01b3031298b2ec9d41866a5b6947bb", "size": 2483, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "Math/Probably/GibbsUntyped.hs", "max_stars_repo_name": "glutamate/probably-base", "max_stars_repo_head_hexsha": "21f93c7391c6ec60795a0d920c1ea16d94a64d2b", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2019-11-28T03:20:01.000Z", "max_stars_repo_stars_event_max_datetime": "2019-11-28T03:20:01.000Z", "max_issues_repo_path": "Math/Probably/GibbsUntyped.hs", "max_issues_repo_name": "glutamate/probably-base", "max_issues_repo_head_hexsha": "21f93c7391c6ec60795a0d920c1ea16d94a64d2b", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Math/Probably/GibbsUntyped.hs", "max_forks_repo_name": "glutamate/probably-base", "max_forks_repo_head_hexsha": "21f93c7391c6ec60795a0d920c1ea16d94a64d2b", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 27.5888888889, "max_line_length": 88, "alphanum_fraction": 0.5094643576, "num_tokens": 775, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6513548646660543, "lm_q2_score": 0.4687906266262437, "lm_q1q2_score": 0.30534905516285177}} {"text": "{-# LANGUAGE DataKinds #-}\n{-# LANGUAGE TypeOperators #-}\n{-# LANGUAGE TypeFamilies #-}\n{-# LANGUAGE MultiParamTypeClasses #-}\n{-|\nModule : Grenade.Layers.Relu\nDescription : Rectifying linear unit layer\nCopyright : (c) Huw Campbell, 2016-2017\nLicense : BSD2\nStability : experimental\n-}\nmodule Grenade.Layers.Relu (\n Relu (..)\n ) where\n\nimport Data.Serialize\n\nimport GHC.TypeLits\nimport Grenade.Core\n\nimport qualified Numeric.LinearAlgebra.Static as LAS\n\n-- | A rectifying linear unit.\n-- A layer which can act between any shape of the same dimension, acting as a\n-- diode on every neuron individually.\ndata Relu = Relu\n deriving Show\n\ninstance UpdateLayer Relu where\n type Gradient Relu = ()\n runUpdate _ _ _ = Relu\n createRandom = return Relu\n\ninstance Serialize Relu where\n put _ = return ()\n get = return Relu\n\ninstance ( KnownNat i) => Layer Relu ('D1 i) ('D1 i) where\n type Tape Relu ('D1 i) ('D1 i) = S ('D1 i)\n\n runForwards _ (S1D y) = (S1D y, S1D (relu y))\n where\n relu = LAS.dvmap (\\a -> if a <= 0 then 0 else a)\n runBackwards _ (S1D y) (S1D dEdy) = ((), S1D (relu' y * dEdy))\n where\n relu' = LAS.dvmap (\\a -> if a <= 0 then 0 else 1)\n\ninstance (KnownNat i, KnownNat j) => Layer Relu ('D2 i j) ('D2 i j) where\n type Tape Relu ('D2 i j) ('D2 i j) = S ('D2 i j)\n\n runForwards _ (S2D y) = (S2D y, S2D (relu y))\n where\n relu = LAS.dmmap (\\a -> if a <= 0 then 0 else a)\n runBackwards _ (S2D y) (S2D dEdy) = ((), S2D (relu' y * dEdy))\n where\n relu' = LAS.dmmap (\\a -> if a <= 0 then 0 else 1)\n\ninstance (KnownNat i, KnownNat j, KnownNat k) => Layer Relu ('D3 i j k) ('D3 i j k) where\n\n type Tape Relu ('D3 i j k) ('D3 i j k) = S ('D3 i j k)\n\n runForwards _ (S3D y) = (S3D y, S3D (relu y))\n where\n relu = LAS.dmmap (\\a -> if a <= 0 then 0 else a)\n runBackwards _ (S3D y) (S3D dEdy) = ((), S3D (relu' y * dEdy))\n where\n relu' = LAS.dmmap (\\a -> if a <= 0 then 0 else 1)\n", "meta": {"hexsha": "3db4670fe4ba86b7f04d4ce4b256e821f0f42b6b", "size": 2014, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/Grenade/Layers/Relu.hs", "max_stars_repo_name": "jrp2014/grenade", "max_stars_repo_head_hexsha": "ccd26792001909d521d41dd9685d85639470bc75", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": 1527, "max_stars_repo_stars_event_min_datetime": "2016-06-23T13:42:34.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-13T05:22:00.000Z", "max_issues_repo_path": "src/Grenade/Layers/Relu.hs", "max_issues_repo_name": "Alien-Inc/grenade", "max_issues_repo_head_hexsha": "14ec0de6bf65d28f981b171ee00f2e0993a369ec", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": 69, "max_issues_repo_issues_event_min_datetime": "2016-06-27T22:16:13.000Z", "max_issues_repo_issues_event_max_datetime": "2020-04-20T17:50:09.000Z", "max_forks_repo_path": "src/Grenade/Layers/Relu.hs", "max_forks_repo_name": "Alien-Inc/grenade", "max_forks_repo_head_hexsha": "14ec0de6bf65d28f981b171ee00f2e0993a369ec", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": 104, "max_forks_repo_forks_event_min_datetime": "2016-06-28T02:24:35.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-20T15:17:29.000Z", "avg_line_length": 29.6176470588, "max_line_length": 89, "alphanum_fraction": 0.5988083416, "num_tokens": 704, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6406358411176238, "lm_q2_score": 0.47657965106367595, "lm_q1q2_score": 0.30531400561872174}} {"text": "module Common where\n\nimport Numeric\nimport Data.Ratio\nimport Data.Complex\nimport Data.Array\nimport Text.ParserCombinators.Parsec hiding (spaces)\nimport Data.IORef\nimport Control.Monad.Except\nimport System.IO\n \ndata LispVal \n = Atom String\n | List [LispVal]\n | DottedList [LispVal] LispVal\n | Number Integer\n | String String\n | Bool Bool\n | Character Char\n | Float Double\n | Ratio Rational\n | Complex (Complex Double)\n | Vector (Array Int LispVal)\n | PrimitiveFunc ([LispVal] -> ThrowsError LispVal)\n | Func {params :: [String], vararg :: (Maybe String),\n body :: [LispVal], closure :: Env}\n | IOFunc ([LispVal] -> IOThrowsError LispVal) \n | Port Handle\n-- Constructors and types have different namespaces, so you can have both a constructor named String and a type named String. Both types and constructor tags always begin with capital letters.\ninstance Eq LispVal where\n (Atom x) == (Atom y) = x == y\n (List xs) == (List ys) = xs == ys\n (DottedList xs x) == (DottedList ys y) = xs == ys && x == y\n (Number x) == (Number y) = x == y\n (String x) == (String y) = x == y\n (Bool x) == (Bool y) = x == y\n (Character x) == (Character y) = x == y\n (Float x) == (Float y) = x == y\n (Ratio x) == (Ratio y) = x == y\n (Complex x) == (Complex y) = x == y\n (Vector xa) == (Vector ya) = xa == ya\n (PrimitiveFunc x) == (PrimitiveFunc y) = False\n (Func {params=paramsx, vararg=varargx, body=bodyx, closure=closurex}) == (Func {params=paramsy, vararg=varargy, body=bodyy, closure=closurey}) = paramsx == paramsy && varargx == varargy && bodyx == bodyy && closurex == closurey\n\n\nunwordsList :: [LispVal] -> String\nunwordsList = unwords . map showVal\n\nshowVal :: LispVal -> String\nshowVal (String contents) = \"\\\"\" ++ contents ++ \"\\\"\"\nshowVal (Atom name) = name\nshowVal (Number contents) = show contents\nshowVal (Bool True) = \"#t\"\nshowVal (Bool False) = \"#f\"\nshowVal (List contents) = \"(\" ++ unwordsList contents ++ \")\"\nshowVal (DottedList head tail) = \"(\" ++ unwordsList head ++ \" . \" ++ showVal tail ++ \")\"\nshowVal (PrimitiveFunc _) = \"\"\nshowVal (Func {params = args, vararg = varargs, body = body, closure = env}) = \n \"(lambda (\" ++ unwords (map show args) ++\n (case varargs of\n Nothing -> \"\"\n Just arg -> \" . \" ++ arg) ++ \") ...)\"\nshowVal (Port _) = \"\"\nshowVal (IOFunc _) = \"\"\n\ninstance Show LispVal where show = showVal\n\ndata LispError = NumArgs Integer [LispVal]\n | TypeMismatch String LispVal\n | Parser ParseError\n | BadSpecialForm String LispVal\n | NotFunction String String\n | UnboundVar String String\n | Default String\n\ntype ThrowsError = Either LispError\ntype Env = IORef [(String, IORef LispVal)]\ntype IOThrowsError = ExceptT LispError IO\n\nshowError :: LispError -> String\nshowError (UnboundVar message varname) = message ++ \": \" ++ varname\nshowError (BadSpecialForm message form) = message ++ \": \" ++ show form\nshowError (NotFunction message func) = message ++ \": \" ++ show func\nshowError (NumArgs expected found) = \"Expected\" ++ show expected ++ \"args: found values \" ++ unwordsList found\nshowError (TypeMismatch expected found) = \"Invalid type: expected \" ++ expected ++ \", found \" ++ show found\nshowError (Parser parseErr) = \"Parse error at \" ++ show parseErr\n\ninstance Show LispError where show = showError\n\n\n", "meta": {"hexsha": "61f414f74c280f5bb5e25f7fd746d669f9e9c200", "size": 3484, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/Common.hs", "max_stars_repo_name": "ShoshinX/SchemeIn48Hrs", "max_stars_repo_head_hexsha": "bdab6c1e37a0e1eb40d805d907a80eefe5af0ca7", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/Common.hs", "max_issues_repo_name": "ShoshinX/SchemeIn48Hrs", "max_issues_repo_head_hexsha": "bdab6c1e37a0e1eb40d805d907a80eefe5af0ca7", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/Common.hs", "max_forks_repo_name": "ShoshinX/SchemeIn48Hrs", "max_forks_repo_head_hexsha": "bdab6c1e37a0e1eb40d805d907a80eefe5af0ca7", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 38.2857142857, "max_line_length": 231, "alphanum_fraction": 0.6297359357, "num_tokens": 960, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.5964331462646255, "lm_q2_score": 0.5117166047041654, "lm_q1q2_score": 0.30520474453955704}} {"text": "{-# LANGUAGE FlexibleContexts #-}\n{-# LANGUAGE DeriveFunctor #-}\n{-# LANGUAGE TypeOperators #-}\n{-# LANGUAGE UndecidableInstances #-}\n{-# LANGUAGE FlexibleInstances #-}\n{-# LANGUAGE TypeFamilyDependencies #-}\n{-# LANGUAGE PolyKinds #-}\n{-# LANGUAGE DataKinds #-}\n{-# LANGUAGE KindSignatures #-}\n{-# LANGUAGE TypeFamilies #-}\n{-# LANGUAGE ScopedTypeVariables #-}\n{-# LANGUAGE MultiParamTypeClasses #-}\n{-# LANGUAGE TypeApplications #-}\n{-# LANGUAGE AllowAmbiguousTypes #-}\n{-# LANGUAGE GADTs #-}\n{-# OPTIONS_GHC -Wwarn #-}\nmodule Language.Test where\n\nimport Control.Arrow\nimport Data.Complex\nimport Data.Proxy\nimport Type.Reflection\n\nimport GHC.TypeLits\n\ndata INat = Z | S INat\n\ndata family Sing :: k -> *\n\ndata instance Sing (n :: INat) where\n SZ :: Sing 'Z\n SS :: Sing n -> Sing ('S n)\n\nclass IsSing a where sing :: Sing a\ninstance IsSing 'Z where sing = SZ\ninstance IsSing n => IsSing ('S n) where sing = SS sing\ntype SINat (n :: INat) = Sing n\n\nnewtype Unit a = MkUnit () deriving Show\n\nunit :: Unit a\nunit = MkUnit ()\n\ntype family Prod (n :: INat) (a :: *) = r | r -> n a where\n Prod 'Z a = Unit a\n Prod ('S n) a = (a, Prod n a)\n\nfmapP' :: SINat n -> (a -> b) -> Prod n a -> Prod n b\nfmapP' SZ _ = const unit\nfmapP' (SS m) f = f{- ALLOCATE HERE -} *** fmapP' m f\n\nfmapPIx :: SINat n -> (Int -> a -> b) -> Int -> Prod n a -> Prod n b\nfmapPIx SZ _ _ = const unit\nfmapPIx (SS m) f k = f k *** fmapPIx m f (k+1)\n\nfmapP :: IsSing n => (a -> b) -> Prod n a -> Prod n b\nfmapP = fmapP' sing\n\ntype family Div2 (n :: INat) where\n Div2 'Z = 'Z\n Div2 ('S 'Z) = 'Z\n Div2 ('S ('S n)) = 'S (Div2 n)\n\ndiv2 :: SINat n -> SINat (Div2 n)\ndiv2 SZ = SZ\ndiv2 (SS SZ) = SZ\ndiv2 (SS (SS n)) = SS (div2 n)\n\nassocL :: (a, (b, c)) -> ((a, b), c)\nassocL (x, (y, z)) = ((x, y), z)\n\nred :: SINat n -> ((a, a) -> a) -> Prod n a -> Prod (Div2 n) a\nred SZ _ = id\nred (SS SZ) _ = snd\nred (SS (SS n)) f = assocL >>> f{- ALLOCATE HERE -} *** red n f\n\nfold :: SINat n -> ((a, a) -> a) -> a -> Prod n a -> a\nfold SZ _ z = const z\nfold (SS SZ) _ _ = fst\nfold n f z = red n f >>> fold (div2 n) f z\n\nreduce :: (IsSing n, Monoid a) => Prod n a -> a\nreduce = fold sing (uncurry mappend) mempty\n\ndata Fin (m :: INat) where\n FZ :: Fin ('S m)\n FS :: Fin m -> Fin ('S m)\n\ndata Le (n :: INat) (m :: INat) where\n LZ :: Le 'Z m\n LS :: Le n m -> Le ('S n) ('S m)\n\nclass (IsSing n, IsSing m) => IsLe (n :: INat) (m :: INat) where\n le :: Sing n -> Le n m\ninstance IsSing n => IsLe 'Z n where\n le SZ = LZ\ninstance IsLe n m => IsLe ('S n) ('S m) where\n le (SS n) = LS (le n)\n\nget' :: Le n m -> Prod ('S m) a -> a\nget' LZ = fst\nget' (LS n) = snd >>> get' n\n\nget :: IsLe n m => SINat n -> Prod ('S m) a -> a\nget n = get' (le n)\n\nzw' :: forall a b c (n :: INat). SINat n -> ((a, b) -> c) -> (Prod n a, Prod n b) -> Prod n c\nzw' SZ _ = const unit\nzw' (SS m) f = swap >>> f *** zw' m f\n\ntoNum :: forall (k :: INat) a. Num a => SINat k -> a\ntoNum SZ = 0\ntoNum (SS sm) = 1 + toNum sm\n\nexpn :: Float -> Float -> Complex Float -> Complex Float\nexpn n k c = cis (-2 * pi * k / n) * c {- multiply exponential -}\n\nadd :: (Complex Float, Complex Float) -> Complex Float\nadd = uncurry (+)\n\nsub :: (Complex Float, Complex Float) -> Complex Float\nsub = uncurry (-)\n\ntype family Add (n :: INat) (m :: INat) where\n Add 'Z n = n\n Add ('S n) m = 'S (Add n m)\n\naddn :: SINat n -> SINat m -> SINat (Add n m)\naddn SZ n = n\naddn (SS n) m = SS (addn n m)\n\ntype family Mul (n :: INat) (m :: INat) where\n Mul 'Z n = 'Z\n Mul ('S n) m = Add m (Mul n m)\n\nmul :: SINat n -> SINat m -> SINat (Mul n m)\nmul SZ _ = SZ\nmul (SS n) m = addn m (mul n m)\n\ntype family Pow2 (n :: INat) where\n Pow2 'Z = 'S 'Z\n Pow2 ('S n) = Add (Pow2 n) (Pow2 n)\n\npow2 :: SINat n -> SINat (Pow2 n)\npow2 SZ = SS SZ\npow2 (SS n) = addn (pow2 n) (pow2 n)\n\n-- Hack: proper way would be to traverse 'n' and 'm', but it is quite inefficient\n\nszr :: SINat n -> Add n 'Z :~: n\nszr SZ = Refl\nszr (SS n) = case szr n of\n Refl -> Refl\n\nssr :: SINat n -> SINat m -> Add n ('S m) :~: 'S (Add n m)\nssr SZ _ = Refl\nssr (SS n) m = case ssr n m of\n Refl -> Refl\n\naddComm :: SINat n -> SINat m -> Add n m :~: Add m n\naddComm SZ m = case szr m of Refl -> Refl -- unsafeCoerce Refl\naddComm (SS n) m = case (addComm n m, ssr m n) of\n (Refl, Refl) -> Refl\n\n--deinterleave\nsplit :: forall a (n :: INat). SINat n -> Prod (Add n n) a -> (Prod n a, Prod n a)\nsplit SZ = id &&& id\nsplit (SS n) =\n case addComm n (SS n) of\n Refl -> assocL >>> id *** split n >>> swap\n\nassocR :: ((a, b), c) -> (a, (b, c))\nassocR ((a, b), c) = (a, (b, c))\n\ncat :: SINat n -> (Prod n a, Prod m a) -> Prod (Add n m) a\ncat SZ = snd\ncat (SS x) = assocR >>> id *** cat x\n\nfromINat :: forall a n. Num a => SINat n -> a\nfromINat SZ = 0\nfromINat (SS x) = 1 + fromINat x\n\nfromTo :: forall a n. Num a => SINat n -> Prod n a\nfromTo = go 0\n\ngo :: forall a n. Num a => a -> SINat n -> Prod n a\ngo _ SZ = unit\ngo n (SS m) = (n, go (1 + n) m)\n\ndft :: SINat n -> Prod (Pow2 n) (Complex Float) -> Prod (Pow2 n) (Complex Float)\ndft SZ = id\ndft (SS x)\n = split p2x >>>\n dft x {-EVENS-} *** dft x {-ODDS-} >>>\n id *** fmapPIx p2x (expn p2sx . fromIntegral) 0 {- Multiply by exponential -} >>>\n zw' p2x add {- Left side -} &&& zw' p2x sub {- right side -} >>>\n cat p2x\n where\n p2x = pow2 x\n p2sx :: Float\n p2sx = fromIntegral $ ((2 ^ (fromINat (SS x) :: Integer)) :: Integer)\n\n--------------------------------------------------------------------------------\n-- FFT BELOW -------------------------------------------------------------------\n\n-- PRIM FUNCTIONS --------------------------------------------------------------\n\n-- baseFFT is one of your PRIM funcs: you can copy from some online FFT implementation: e.g. Rosetta Code\n\nbaseFFT :: RealFloat a => [Complex a] -> [Complex a]\nbaseFFT [] = []\nbaseFFT [x] = [x]\nbaseFFT xs = zipWith (+) ys ts ++ zipWith (-) ys ts\n where n = length xs\n ys = baseFFT evens\n zs = baseFFT odds\n (evens, odds) = splitList xs\n ts = zipWith (\\z k -> (exp' k n) * z) zs [0::Integer ..]\n\nexp' :: (Floating a1, Integral a2, Integral a3) => a2 -> a3 -> Complex a1\nexp' k n = cis $ -2 * pi * (fromIntegral k) / (fromIntegral n)\n\nsplitList :: [a] -> ([a], [a])\nsplitList [] = ([], [])\nsplitList [x] = ([x], [])\nsplitList (x:y:xs) = (x:xt, y:yt) where (xt, yt) = splitList xs\n\naddPadding :: Num a => SINat n -> [a] -> [a]\naddPadding sz l = l ++ replicate (padding $ length l) 0\n where\n padding k = 2 ^ (max ((fromINat sz) :: Integer) (ceiling (logBase 2 $ fromIntegral k :: Double))) - k\n\nconcatenate :: ([a], [a]) -> [a]\nconcatenate = uncurry (++)\n\n{- Below should be your prim functions -}\nmulExp :: (RealFloat a1, Integral a3) =>\n a3 -> Int -> [Complex a1] -> [Complex a1]\nmulExp p2sx i l = zipWith (\\k z -> exp' k (p2sx * fromIntegral len) * z) [i * len ..] l\n where\n len = length l\naddc :: ([Complex Float], [Complex Float]) -> [Complex Float]\naddc = uncurry $ zipWith (+)\nsubc :: ([Complex Float], [Complex Float]) -> [Complex Float]\nsubc = uncurry $ zipWith (-)\n\n-- END PRIM FUNCTIONS ----------------------------------------------------------\n\n-- ARROW DEFINITIONS -----------------------------------------------------------\n--- Should not change, except types\n\ntype family Tree (n :: INat) (a :: *) where\n Tree 'Z a = a\n Tree ('S n) a = (Tree n a, Tree n a)\n\nsplitL :: SINat m -> [Complex Float] -> Tree m [Complex Float]\nsplitL SZ = id\nsplitL (SS n) = splitList >>> splitL n *** splitL n\n\nmerge :: forall (n :: INat). SINat n -> Tree n [Complex Float] -> [Complex Float]\nmerge SZ = id {- same: just concatenate all using a Prim -}\nmerge (SS n) = merge n *** merge n >>> concatenate\n\nfmapTIx :: SINat n -> ((Int, [Complex Float]) -> [Complex Float]) -> Int -> Tree n [Complex Float] -> Tree n [Complex Float]\nfmapTIx SZ f k = (\\v -> f (k, v))\nfmapTIx (SS x) f k = fmapTIx x f k *** fmapTIx x f (k + (2 ^ (fromINat x :: Integer)))\n\nswap :: ((a,b), (c, d)) -> ((a, c), (b, d))\nswap = ((fst >>> fst) &&& (snd >>> fst)) &&&\n ((fst >>> snd) &&& (snd >>> snd))\n\nzwT :: SINat n -> (([Complex Float],[Complex Float]) -> [Complex Float])\n -> (Tree n [Complex Float], Tree n [Complex Float]) -> Tree n [Complex Float]\nzwT SZ f = f\nzwT (SS x) f = swap >>> zwT x f *** zwT x f\n\nfft :: SINat n -> Tree n [Complex Float] -> Tree n [Complex Float]\nfft SZ = baseFFT\nfft (SS x)\n = fft x {-EVENS-} *** fft x {-ODDS-} >>>\n id *** fmapTIx x (uncurry $ mulExp p2sx) 0 {- Multiply by exponential -} >>>\n zwT x addc {- Left side -} &&& zwT x subc {- right side -}\n where\n p2sx :: Integer\n p2sx = 2 ^ (fromINat (SS x) :: Integer)\n\nfastFourierR :: forall (n :: INat). SINat n -> [Complex Float] -> [Complex Float]\nfastFourierR cores = addPadding cores >>> splitL cores >>> fft cores >>> merge cores\n\n---------------------------------------------------------------------------------\n-- UTILITY FUNCTIONS\n\nfastFourier :: forall n. (KnownNat n, IsSing (FromNat n))\n => [Complex Float] -> [Complex Float]\nfastFourier = fastFourierR (sing :: SINat (FromNat n))\n\nfft8core :: [Complex Float] -> [Complex Float]\nfft8core = fastFourier @3\nfft16core :: [Complex Float] -> [Complex Float]\nfft16core = fastFourier @4\n\ntype family ToNat (i :: INat) :: Nat where\n ToNat 'Z = 0\n ToNat ('S n) = 1 + ToNat n\n\ntype family FromNat (i :: Nat) :: INat where\n FromNat 0 = 'Z\n FromNat n = 'S (FromNat (n-1))\n\n\n\nfmapT :: SINat n -> (a -> b) -> Tree n a -> Tree n b\nfmapT SZ f = f\nfmapT (SS x) f = fmapT x f *** fmapT x f\n\n\ndata SDict a where\n SDict :: Show a => SDict a\n\ngetDict :: Show a => SINat n -> Proxy a -> SDict (Tree n a)\ngetDict SZ _ = SDict\ngetDict (SS n) p = case getDict n p of\n SDict -> SDict\n\ntest :: SINat n -> Tree n Int -> String\ntest n = case getDict n (Proxy :: Proxy Int) of\n SDict -> show\n\ntest2 :: Show (Tree n Int) => SINat n -> Tree n Int -> Bool\ntest2 _ _ = False\n\ntest3 :: SINat n -> Tree n Int -> Bool\ntest3 n t = case getDict n (Proxy :: Proxy Int) of\n SDict -> test2 n t\n", "meta": {"hexsha": "899d9d6303908b10dee4286f2afd711bb11f9521", "size": 10077, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/Language/Test.hs", "max_stars_repo_name": "session-arr/session-arr", "max_stars_repo_head_hexsha": "5dbde7e18176c493767f9c84d8d900f7a5637c66", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/Language/Test.hs", "max_issues_repo_name": "session-arr/session-arr", "max_issues_repo_head_hexsha": "5dbde7e18176c493767f9c84d8d900f7a5637c66", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2019-10-07T16:57:27.000Z", "max_issues_repo_issues_event_max_datetime": "2019-10-15T07:58:54.000Z", "max_forks_repo_path": "src/Language/Test.hs", "max_forks_repo_name": "dcastrop/SAlg", "max_forks_repo_head_hexsha": "cfe0fade336b6e34b79eeb5eecc653c9a6926b87", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-03-18T11:16:16.000Z", "max_forks_repo_forks_event_max_datetime": "2021-03-18T11:16:16.000Z", "avg_line_length": 30.0805970149, "max_line_length": 124, "alphanum_fraction": 0.5438126427, "num_tokens": 3442, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6959583376458152, "lm_q2_score": 0.43782349911420193, "lm_q1q2_score": 0.304706914625794}} {"text": "{-# OPTIONS_GHC -Wall #-}\n\n{-# LANGUAGE QuasiQuotes #-}\n{-# LANGUAGE TemplateHaskell #-}\n{-# LANGUAGE MultiWayIf #-}\n{-# LANGUAGE OverloadedStrings #-}\n{-# LANGUAGE ScopedTypeVariables #-}\n\n-----------------------------------------------------------------------------\n-- |\n-- Module : Numeric.Sundials.CVode.ODE\n-- Copyright : Dominic Steinitz 2018,\n-- Novadiscovery 2018\n-- License : BSD\n-- Maintainer : Dominic Steinitz\n-- Stability : provisional\n--\n-- Solution of ordinary differential equation (ODE) initial value problems.\n--\n-- \n--\n-- A simple example:\n--\n-- <>\n--\n-- @\n-- import Numeric.Sundials.CVode.ODE\n-- import Numeric.LinearAlgebra\n--\n-- import Plots as P\n-- import qualified Diagrams.Prelude as D\n-- import Diagrams.Backend.Rasterific\n--\n-- brusselator :: Double -> [Double] -> [Double]\n-- brusselator _t x = [ a - (w + 1) * u + v * u * u\n-- , w * u - v * u * u\n-- , (b - w) / eps - w * u\n-- ]\n-- where\n-- a = 1.0\n-- b = 3.5\n-- eps = 5.0e-6\n-- u = x !! 0\n-- v = x !! 1\n-- w = x !! 2\n--\n-- lSaxis :: [[Double]] -> P.Axis B D.V2 Double\n-- lSaxis xs = P.r2Axis &~ do\n-- let ts = xs!!0\n-- us = xs!!1\n-- vs = xs!!2\n-- ws = xs!!3\n-- P.linePlot' $ zip ts us\n-- P.linePlot' $ zip ts vs\n-- P.linePlot' $ zip ts ws\n--\n-- main = do\n-- let res1 = odeSolve brusselator [1.2, 3.1, 3.0] (fromList [0.0, 0.1 .. 10.0])\n-- renderRasterific \"diagrams/brusselator.png\"\n-- (D.dims2D 500.0 500.0)\n-- (renderAxis $ lSaxis $ [0.0, 0.1 .. 10.0]:(toLists $ tr res1))\n-- @\n--\n-----------------------------------------------------------------------------\nmodule Numeric.Sundials.CVode.ODE ( odeSolve\n , odeSolveV\n , odeSolveVWith\n , odeSolveVWith'\n , odeSolveRootVWith'\n , ODEMethod(..)\n , StepControl(..)\n , SolverResult(..)\n ) where\n\nimport qualified Language.C.Inline as C\nimport qualified Language.C.Inline.Unsafe as CU\n\nimport Data.Monoid ((<>))\nimport Data.Maybe (isJust)\n\nimport Foreign.C.Types (CDouble, CInt, CLong)\nimport Foreign.Ptr (Ptr)\nimport Foreign.Storable (poke)\n\nimport qualified Data.Vector.Storable as V\n\nimport Data.Coerce (coerce)\nimport System.IO.Unsafe (unsafePerformIO)\n\nimport Numeric.LinearAlgebra.Devel (createVector)\n\nimport Numeric.LinearAlgebra.HMatrix (Vector, Matrix, toList, rows,\n cols, toLists, size, reshape)\n\nimport Numeric.Sundials.Arkode (cV_ADAMS, cV_BDF,\n getDataFromContents, putDataInContents,\n vectorToC, cV_SUCCESS, cV_ROOT_RETURN)\nimport qualified Numeric.Sundials.Arkode as T\nimport Numeric.Sundials.ODEOpts (ODEOpts(..), Jacobian, SundialsDiagnostics(..))\n\n\nC.context (C.baseCtx <> C.vecCtx <> C.funCtx <> T.sunCtx)\n\nC.include \"\"\nC.include \"\"\nC.include \"\"\nC.include \"\" -- prototypes for CVODE fcts., consts.\nC.include \"\" -- serial N_Vector types, fcts., macros\nC.include \"\" -- access to dense SUNMatrix\nC.include \"\" -- access to dense SUNLinearSolver\nC.include \"\" -- access to CVDls interface\nC.include \"\" -- definition of type realtype\nC.include \"\"\nC.include \"../../../helpers.h\"\nC.include \"Numeric/Sundials/Arkode_hsc.h\"\n\n\n-- | Stepping functions\ndata ODEMethod = ADAMS\n | BDF\n\ngetMethod :: ODEMethod -> Int\ngetMethod (ADAMS) = cV_ADAMS\ngetMethod (BDF) = cV_BDF\n\ngetJacobian :: ODEMethod -> Maybe Jacobian\ngetJacobian _ = Nothing\n\n-- | A version of 'odeSolveVWith' with reasonable default step control.\nodeSolveV\n :: ODEMethod\n -> Maybe Double -- ^ initial step size - by default, CVode\n -- estimates the initial step size to be the\n -- solution \\(h\\) of the equation\n -- \\(\\|\\frac{h^2\\ddot{y}}{2}\\| = 1\\), where\n -- \\(\\ddot{y}\\) is an estimated value of the\n -- second derivative of the solution at \\(t_0\\)\n -> Double -- ^ absolute tolerance for the state vector\n -> Double -- ^ relative tolerance for the state vector\n -> (Double -> Vector Double -> Vector Double) -- ^ The RHS of the system \\(\\dot{y} = f(t,y)\\)\n -> Vector Double -- ^ initial conditions\n -> Vector Double -- ^ desired solution times\n -> Matrix Double -- ^ solution\nodeSolveV meth hi epsAbs epsRel f y0 ts =\n odeSolveVWith meth (X epsAbs epsRel) hi g y0 ts\n where\n g t x0 = coerce $ f t x0\n\n-- | A version of 'odeSolveV' with reasonable default parameters and\n-- system of equations defined using lists. FIXME: we should say\n-- something about the fact we could use the Jacobian but don't for\n-- compatibility with hmatrix-gsl.\nodeSolve :: (Double -> [Double] -> [Double]) -- ^ The RHS of the system \\(\\dot{y} = f(t,y)\\)\n -> [Double] -- ^ initial conditions\n -> Vector Double -- ^ desired solution times\n -> Matrix Double -- ^ solution\nodeSolve f y0 ts =\n -- FIXME: These tolerances are different from the ones in GSL\n odeSolveVWith BDF (XX' 1.0e-6 1.0e-10 1 1) Nothing g (V.fromList y0) (V.fromList $ toList ts)\n where\n g t x0 = V.fromList $ f t (V.toList x0)\n\nodeSolveVWith ::\n ODEMethod\n -> StepControl\n -> Maybe Double -- ^ initial step size - by default, CVode\n -- estimates the initial step size to be the\n -- solution \\(h\\) of the equation\n -- \\(\\|\\frac{h^2\\ddot{y}}{2}\\| = 1\\), where\n -- \\(\\ddot{y}\\) is an estimated value of the second\n -- derivative of the solution at \\(t_0\\)\n -> (Double -> V.Vector Double -> V.Vector Double) -- ^ The RHS of the system \\(\\dot{y} = f(t,y)\\)\n -> V.Vector Double -- ^ Initial conditions\n -> V.Vector Double -- ^ Desired solution times\n -> Matrix Double -- ^ Error code or solution\nodeSolveVWith method control initStepSize f y0 tt =\n case odeSolveVWith' opts method control initStepSize f y0 tt of\n Left (c, _v) -> error $ show c -- FIXME\n Right (v, _d) -> v\n where\n opts = ODEOpts { maxNumSteps = 10000\n , minStep = 1.0e-12\n , relTol = error \"relTol\"\n , absTols = error \"absTol\"\n , initStep = error \"initStep\"\n , maxFail = 10\n }\n\nodeSolveVWith' ::\n ODEOpts\n -> ODEMethod\n -> StepControl\n -> Maybe Double -- ^ initial step size - by default, CVode\n -- estimates the initial step size to be the\n -- solution \\(h\\) of the equation\n -- \\(\\|\\frac{h^2\\ddot{y}}{2}\\| = 1\\), where\n -- \\(\\ddot{y}\\) is an estimated value of the second\n -- derivative of the solution at \\(t_0\\)\n -> (Double -> V.Vector Double -> V.Vector Double) -- ^ The RHS of the system \\(\\dot{y} = f(t,y)\\)\n -> V.Vector Double -- ^ Initial conditions\n -> V.Vector Double -- ^ Desired solution times\n -> Either (Matrix Double, Int) (Matrix Double, SundialsDiagnostics) -- ^ Error code or solution\nodeSolveVWith' opts method control initStepSize f y0 tt =\n case solveOdeC (fromIntegral $ maxFail opts)\n (fromIntegral $ maxNumSteps opts) (coerce $ minStep opts)\n (fromIntegral $ getMethod method) (coerce initStepSize) jacH (scise control)\n (coerce f) (coerce y0) (coerce tt) of\n Left (v, c) -> Left (reshape l (coerce v), fromIntegral c)\n Right (v, d) -> Right (reshape l (coerce v), d)\n where\n l = size y0\n scise (X aTol rTol) = coerce (V.replicate l aTol, rTol)\n scise (X' aTol rTol) = coerce (V.replicate l aTol, rTol)\n scise (XX' aTol rTol yScale _yDotScale) = coerce (V.replicate l aTol, yScale * rTol)\n -- FIXME; Should we check that the length of ss is correct?\n scise (ScXX' aTol rTol yScale _yDotScale ss) = coerce (V.map (* aTol) ss, yScale * rTol)\n jacH = fmap (\\g t v -> matrixToSunMatrix $ g (coerce t) (coerce v)) $\n getJacobian method\n matrixToSunMatrix m = T.SunMatrix { T.rows = nr, T.cols = nc, T.vals = vs }\n where\n nr = fromIntegral $ rows m\n nc = fromIntegral $ cols m\n -- FIXME: efficiency\n vs = V.fromList $ map coerce $ concat $ toLists m\n\nsolveOdeC ::\n CInt ->\n CLong ->\n CDouble ->\n CInt ->\n Maybe CDouble ->\n (Maybe (CDouble -> V.Vector CDouble -> T.SunMatrix)) ->\n (V.Vector CDouble, CDouble) ->\n (CDouble -> V.Vector CDouble -> V.Vector CDouble) -- ^ The RHS of the system \\(\\dot{y} = f(t,y)\\)\n -> V.Vector CDouble -- ^ Initial conditions\n -> V.Vector CDouble -- ^ Desired solution times\n -> Either (V.Vector CDouble, CInt) (V.Vector CDouble, SundialsDiagnostics) -- ^ Partial solution and error code or\n -- solution and diagnostics\nsolveOdeC maxErrTestFails maxNumSteps_ minStep_ method initStepSize\n jacH (aTols, rTol) fun f0 ts =\n unsafePerformIO $ do\n\n let isInitStepSize :: CInt\n isInitStepSize = fromIntegral $ fromEnum $ isJust initStepSize\n ss :: CDouble\n ss = case initStepSize of\n -- It would be better to put an error message here but\n -- inline-c seems to evaluate this even if it is never\n -- used :(\n Nothing -> 0.0\n Just x -> x\n\n let dim = V.length f0\n nEq :: CLong\n nEq = fromIntegral dim\n nTs :: CInt\n nTs = fromIntegral $ V.length ts\n quasiMatrixRes <- createVector ((fromIntegral dim) * (fromIntegral nTs))\n qMatMut <- V.thaw quasiMatrixRes\n diagnostics :: V.Vector CLong <- createVector 10 -- FIXME\n diagMut <- V.thaw diagnostics\n -- We need the types that sundials expects. These are tied together\n -- in 'CLangToHaskellTypes'. FIXME: The Haskell type is currently empty!\n let funIO :: CDouble -> Ptr T.SunVector -> Ptr T.SunVector -> Ptr () -> IO CInt\n funIO x y f _ptr = do\n -- Convert the pointer we get from C (y) to a vector, and then\n -- apply the user-supplied function.\n fImm <- fun x <$> getDataFromContents dim y\n -- Fill in the provided pointer with the resulting vector.\n putDataInContents fImm dim f\n -- FIXME: I don't understand what this comment means\n -- Unsafe since the function will be called many times.\n [CU.exp| int{ 0 } |]\n let isJac :: CInt\n isJac = fromIntegral $ fromEnum $ isJust jacH\n jacIO :: CDouble -> Ptr T.SunVector -> Ptr T.SunVector -> Ptr T.SunMatrix ->\n Ptr () -> Ptr T.SunVector -> Ptr T.SunVector -> Ptr T.SunVector ->\n IO CInt\n jacIO t y _fy jacS _ptr _tmp1 _tmp2 _tmp3 = do\n case jacH of\n Nothing -> error \"Numeric.Sundials.CVode.ODE: Jacobian not defined\"\n Just jacI -> do j <- jacI t <$> getDataFromContents dim y\n poke jacS j\n -- FIXME: I don't understand what this comment means\n -- Unsafe since the function will be called many times.\n [CU.exp| int{ 0 } |]\n\n res <- [C.block| int {\n /* general problem variables */\n\n int flag; /* reusable error-checking flag */\n int i, j; /* reusable loop indices */\n N_Vector y = NULL; /* empty vector for storing solution */\n N_Vector tv = NULL; /* empty vector for storing absolute tolerances */\n\n SUNMatrix A = NULL; /* empty matrix for linear solver */\n SUNLinearSolver LS = NULL; /* empty linear solver object */\n void *cvode_mem = NULL; /* empty CVODE memory structure */\n realtype t;\n long int nst, nfe, nsetups, nje, nfeLS, nni, ncfn, netf, nge;\n\n /* general problem parameters */\n\n realtype T0 = RCONST(($vec-ptr:(double *ts))[0]); /* initial time */\n sunindextype NEQ = $(sunindextype nEq); /* number of dependent vars. */\n\n /* Initialize data structures */\n\n y = N_VNew_Serial(NEQ); /* Create serial vector for solution */\n if (check_flag((void *)y, \"N_VNew_Serial\", 0)) return 1;\n /* Specify initial condition */\n for (i = 0; i < NEQ; i++) {\n NV_Ith_S(y,i) = ($vec-ptr:(double *f0))[i];\n };\n\n cvode_mem = CVodeCreate($(int method), CV_NEWTON);\n if (check_flag((void *)cvode_mem, \"CVodeCreate\", 0)) return(1);\n\n /* Call CVodeInit to initialize the integrator memory and specify the\n * user's right hand side function in y'=f(t,y), the inital time T0, and\n * the initial dependent variable vector y. */\n flag = CVodeInit(cvode_mem, $fun:(int (* funIO) (double t, SunVector y[], SunVector dydt[], void * params)), T0, y);\n if (check_flag(&flag, \"CVodeInit\", 1)) return(1);\n\n tv = N_VNew_Serial(NEQ); /* Create serial vector for absolute tolerances */\n if (check_flag((void *)tv, \"N_VNew_Serial\", 0)) return 1;\n /* Specify tolerances */\n for (i = 0; i < NEQ; i++) {\n NV_Ith_S(tv,i) = ($vec-ptr:(double *aTols))[i];\n };\n\n flag = CVodeSetMinStep(cvode_mem, $(double minStep_));\n if (check_flag(&flag, \"CVodeSetMinStep\", 1)) return 1;\n flag = CVodeSetMaxNumSteps(cvode_mem, $(long int maxNumSteps_));\n if (check_flag(&flag, \"CVodeSetMaxNumSteps\", 1)) return 1;\n flag = CVodeSetMaxErrTestFails(cvode_mem, $(int maxErrTestFails));\n if (check_flag(&flag, \"CVodeSetMaxErrTestFails\", 1)) return 1;\n\n /* Call CVodeSVtolerances to specify the scalar relative tolerance\n * and vector absolute tolerances */\n flag = CVodeSVtolerances(cvode_mem, $(double rTol), tv);\n if (check_flag(&flag, \"CVodeSVtolerances\", 1)) return(1);\n\n /* Initialize dense matrix data structure and solver */\n A = SUNDenseMatrix(NEQ, NEQ);\n if (check_flag((void *)A, \"SUNDenseMatrix\", 0)) return 1;\n LS = SUNDenseLinearSolver(y, A);\n if (check_flag((void *)LS, \"SUNDenseLinearSolver\", 0)) return 1;\n\n /* Attach matrix and linear solver */\n flag = CVDlsSetLinearSolver(cvode_mem, LS, A);\n if (check_flag(&flag, \"CVDlsSetLinearSolver\", 1)) return 1;\n\n /* Set the initial step size if there is one */\n if ($(int isInitStepSize)) {\n /* FIXME: We could check if the initial step size is 0 */\n /* or even NaN and then throw an error */\n flag = CVodeSetInitStep(cvode_mem, $(double ss));\n if (check_flag(&flag, \"CVodeSetInitStep\", 1)) return 1;\n }\n\n /* Set the Jacobian if there is one */\n if ($(int isJac)) {\n flag = CVDlsSetJacFn(cvode_mem, $fun:(int (* jacIO) (double t, SunVector y[], SunVector fy[], SunMatrix Jac[], void * params, SunVector tmp1[], SunVector tmp2[], SunVector tmp3[])));\n if (check_flag(&flag, \"CVDlsSetJacFn\", 1)) return 1;\n }\n\n /* Store initial conditions */\n for (j = 0; j < NEQ; j++) {\n ($vec-ptr:(double *qMatMut))[0 * $(int nTs) + j] = NV_Ith_S(y,j);\n }\n\n /* Main time-stepping loop: calls CVode to perform the integration */\n /* Stops when the final time has been reached */\n for (i = 1; i < $(int nTs); i++) {\n\n flag = CVode(cvode_mem, ($vec-ptr:(double *ts))[i], y, &t, CV_NORMAL); /* call integrator */\n if (check_flag(&flag, \"CVode solver failure, stopping integration\", 1)) return 1;\n\n /* Store the results for Haskell */\n for (j = 0; j < NEQ; j++) {\n ($vec-ptr:(double *qMatMut))[i * NEQ + j] = NV_Ith_S(y,j);\n }\n }\n\n /* Get some final statistics on how the solve progressed */\n\n flag = CVodeGetNumSteps(cvode_mem, &nst);\n check_flag(&flag, \"CVodeGetNumSteps\", 1);\n ($vec-ptr:(long int *diagMut))[0] = nst;\n\n /* FIXME */\n ($vec-ptr:(long int *diagMut))[1] = 0;\n\n flag = CVodeGetNumRhsEvals(cvode_mem, &nfe);\n check_flag(&flag, \"CVodeGetNumRhsEvals\", 1);\n ($vec-ptr:(long int *diagMut))[2] = nfe;\n /* FIXME */\n ($vec-ptr:(long int *diagMut))[3] = 0;\n\n flag = CVodeGetNumLinSolvSetups(cvode_mem, &nsetups);\n check_flag(&flag, \"CVodeGetNumLinSolvSetups\", 1);\n ($vec-ptr:(long int *diagMut))[4] = nsetups;\n\n flag = CVodeGetNumErrTestFails(cvode_mem, &netf);\n check_flag(&flag, \"CVodeGetNumErrTestFails\", 1);\n ($vec-ptr:(long int *diagMut))[5] = netf;\n\n flag = CVodeGetNumNonlinSolvIters(cvode_mem, &nni);\n check_flag(&flag, \"CVodeGetNumNonlinSolvIters\", 1);\n ($vec-ptr:(long int *diagMut))[6] = nni;\n\n flag = CVodeGetNumNonlinSolvConvFails(cvode_mem, &ncfn);\n check_flag(&flag, \"CVodeGetNumNonlinSolvConvFails\", 1);\n ($vec-ptr:(long int *diagMut))[7] = ncfn;\n\n flag = CVDlsGetNumJacEvals(cvode_mem, &nje);\n check_flag(&flag, \"CVDlsGetNumJacEvals\", 1);\n ($vec-ptr:(long int *diagMut))[8] = ncfn;\n\n flag = CVDlsGetNumRhsEvals(cvode_mem, &nfeLS);\n check_flag(&flag, \"CVDlsGetNumRhsEvals\", 1);\n ($vec-ptr:(long int *diagMut))[9] = ncfn;\n\n /* Clean up and return */\n\n N_VDestroy(y); /* Free y vector */\n N_VDestroy(tv); /* Free tv vector */\n CVodeFree(&cvode_mem); /* Free integrator memory */\n SUNLinSolFree(LS); /* Free linear solver */\n SUNMatDestroy(A); /* Free A matrix */\n\n return flag;\n } |]\n preD <- V.freeze diagMut\n let d = SundialsDiagnostics (fromIntegral $ preD V.!0)\n (fromIntegral $ preD V.!1)\n (fromIntegral $ preD V.!2)\n (fromIntegral $ preD V.!3)\n (fromIntegral $ preD V.!4)\n (fromIntegral $ preD V.!5)\n (fromIntegral $ preD V.!6)\n (fromIntegral $ preD V.!7)\n (fromIntegral $ preD V.!8)\n (fromIntegral $ preD V.!9)\n m <- V.freeze qMatMut\n if res == 0\n then do\n return $ Right (m, d)\n else do\n return $ Left (m, res)\n\nsolveOdeC' ::\n CInt ->\n CLong ->\n CDouble ->\n CInt ->\n Maybe CDouble ->\n (Maybe (CDouble -> V.Vector CDouble -> T.SunMatrix)) ->\n (V.Vector CDouble, CDouble) ->\n (CDouble -> V.Vector CDouble -> V.Vector CDouble) -- ^ The RHS of the system \\(\\dot{y} = f(t,y)\\)\n -> V.Vector CDouble -- ^ Initial conditions\n -> CInt -- ^ FIXME\n -> (CDouble -> V.Vector CDouble -> V.Vector CDouble) -- ^ FIXME\n -> V.Vector CDouble -- ^ Desired solution times\n -> SolverResult V.Vector V.Vector CInt CDouble\nsolveOdeC' maxErrTestFails maxNumSteps_ minStep_ method initStepSize\n jacH (aTols, rTol) fun f0 nr g ts =\n unsafePerformIO $ do\n\n let isInitStepSize :: CInt\n isInitStepSize = fromIntegral $ fromEnum $ isJust initStepSize\n ss :: CDouble\n ss = case initStepSize of\n -- It would be better to put an error message here but\n -- inline-c seems to evaluate this even if it is never\n -- used :(\n Nothing -> 0.0\n Just x -> x\n\n let dim = V.length f0\n nEq :: CLong\n nEq = fromIntegral dim\n nTs :: CInt\n nTs = fromIntegral $ V.length ts\n quasiMatrixRes <- createVector ((fromIntegral dim) * (fromIntegral nTs))\n qMatMut <- V.thaw quasiMatrixRes\n diagnostics :: V.Vector CLong <- createVector 10 -- FIXME\n diagMut <- V.thaw diagnostics\n -- We need the types that sundials expects.\n -- FIXME: The Haskell type is currently empty!\n let funIO :: CDouble -> Ptr T.SunVector -> Ptr T.SunVector -> Ptr () -> IO CInt\n funIO t y f _ptr = do\n -- Convert the pointer we get from C (y) to a vector, and then\n -- apply the user-supplied function.\n fImm <- fun t <$> getDataFromContents dim y\n -- Fill in the provided pointer with the resulting vector.\n putDataInContents fImm dim f\n -- FIXME: I don't understand what this comment means\n -- Unsafe since the function will be called many times.\n [CU.exp| int{ 0 } |]\n\n let nrPre = fromIntegral nr\n gResults :: V.Vector CInt <- createVector nrPre\n gResMut <- V.thaw gResults\n tRoot :: V.Vector CDouble <- createVector 1\n tRootMut <- V.thaw tRoot\n\n let gIO :: CDouble -> Ptr T.SunVector -> Ptr CDouble -> Ptr () -> IO CInt\n gIO x y f _ptr = do\n -- Convert the pointer we get from C (y) to a vector, and then\n -- apply the user-supplied function.\n gImm <- g x <$> getDataFromContents dim y\n -- Fill in the provided pointer with the resulting vector.\n vectorToC gImm nrPre f\n -- FIXME: I don't understand what this comment means\n -- Unsafe since the function will be called many times.\n [CU.exp| int{ 0 } |]\n\n let isJac :: CInt\n isJac = fromIntegral $ fromEnum $ isJust jacH\n jacIO :: CDouble -> Ptr T.SunVector -> Ptr T.SunVector -> Ptr T.SunMatrix ->\n Ptr () -> Ptr T.SunVector -> Ptr T.SunVector -> Ptr T.SunVector ->\n IO CInt\n jacIO t y _fy jacS _ptr _tmp1 _tmp2 _tmp3 = do\n case jacH of\n Nothing -> error \"Numeric.Sundials.CVode.ODE: Jacobian not defined\"\n Just jacI -> do j <- jacI t <$> getDataFromContents dim y\n poke jacS j\n -- FIXME: I don't understand what this comment means\n -- Unsafe since the function will be called many times.\n [CU.exp| int{ 0 } |]\n\n res <- [C.block| int {\n /* general problem variables */\n\n int flag; /* reusable error-checking flag */\n int flagr; /* root finding flag */\n\n int i, j; /* reusable loop indices */\n N_Vector y = NULL; /* empty vector for storing solution */\n N_Vector tv = NULL; /* empty vector for storing absolute tolerances */\n\n SUNMatrix A = NULL; /* empty matrix for linear solver */\n SUNLinearSolver LS = NULL; /* empty linear solver object */\n void *cvode_mem = NULL; /* empty CVODE memory structure */\n realtype t;\n long int nst, nfe, nsetups, nje, nfeLS, nni, ncfn, netf, nge;\n\n realtype tout;\n\n /* general problem parameters */\n\n realtype T0 = RCONST(($vec-ptr:(double *ts))[0]); /* initial time */\n sunindextype NEQ = $(sunindextype nEq); /* number of dependent vars. */\n\n /* Initialize data structures */\n\n y = N_VNew_Serial(NEQ); /* Create serial vector for solution */\n if (check_flag((void *)y, \"N_VNew_Serial\", 0)) return 1;\n /* Specify initial condition */\n for (i = 0; i < NEQ; i++) {\n NV_Ith_S(y,i) = ($vec-ptr:(double *f0))[i];\n };\n\n cvode_mem = CVodeCreate($(int method), CV_NEWTON);\n if (check_flag((void *)cvode_mem, \"CVodeCreate\", 0)) return(1);\n\n /* Call CVodeInit to initialize the integrator memory and specify the\n * user's right hand side function in y'=f(t,y), the inital time T0, and\n * the initial dependent variable vector y. */\n flag = CVodeInit(cvode_mem, $fun:(int (* funIO) (double t, SunVector y[], SunVector dydt[], void * params)), T0, y);\n if (check_flag(&flag, \"CVodeInit\", 1)) return(1);\n\n tv = N_VNew_Serial(NEQ); /* Create serial vector for absolute tolerances */\n if (check_flag((void *)tv, \"N_VNew_Serial\", 0)) return 1;\n /* Specify tolerances */\n for (i = 0; i < NEQ; i++) {\n NV_Ith_S(tv,i) = ($vec-ptr:(double *aTols))[i];\n };\n\n flag = CVodeSetMinStep(cvode_mem, $(double minStep_));\n if (check_flag(&flag, \"CVodeSetMinStep\", 1)) return 1;\n flag = CVodeSetMaxNumSteps(cvode_mem, $(long int maxNumSteps_));\n if (check_flag(&flag, \"CVodeSetMaxNumSteps\", 1)) return 1;\n flag = CVodeSetMaxErrTestFails(cvode_mem, $(int maxErrTestFails));\n if (check_flag(&flag, \"CVodeSetMaxErrTestFails\", 1)) return 1;\n\n /* Call CVodeSVtolerances to specify the scalar relative tolerance\n * and vector absolute tolerances */\n flag = CVodeSVtolerances(cvode_mem, $(double rTol), tv);\n if (check_flag(&flag, \"CVodeSVtolerances\", 1)) return(1);\n\n /* Call CVodeRootInit to specify the root function g with nr components */\n flag = CVodeRootInit(cvode_mem, $(int nr), $fun:(int (* gIO) (double t, SunVector y[], double gout[], void * params)));\n\n if (check_flag(&flag, \"CVodeRootInit\", 1)) return(1);\n\n /* Initialize dense matrix data structure and solver */\n A = SUNDenseMatrix(NEQ, NEQ);\n if (check_flag((void *)A, \"SUNDenseMatrix\", 0)) return 1;\n LS = SUNDenseLinearSolver(y, A);\n if (check_flag((void *)LS, \"SUNDenseLinearSolver\", 0)) return 1;\n\n /* Attach matrix and linear solver */\n flag = CVDlsSetLinearSolver(cvode_mem, LS, A);\n if (check_flag(&flag, \"CVDlsSetLinearSolver\", 1)) return 1;\n\n /* Set the initial step size if there is one */\n if ($(int isInitStepSize)) {\n /* FIXME: We could check if the initial step size is 0 */\n /* or even NaN and then throw an error */\n flag = CVodeSetInitStep(cvode_mem, $(double ss));\n if (check_flag(&flag, \"CVodeSetInitStep\", 1)) return 1;\n }\n\n /* Set the Jacobian if there is one */\n if ($(int isJac)) {\n flag = CVDlsSetJacFn(cvode_mem, $fun:(int (* jacIO) (double t, SunVector y[], SunVector fy[], SunMatrix Jac[], void * params, SunVector tmp1[], SunVector tmp2[], SunVector tmp3[])));\n if (check_flag(&flag, \"CVDlsSetJacFn\", 1)) return 1;\n }\n\n /* Store initial conditions */\n for (j = 0; j < NEQ; j++) {\n ($vec-ptr:(double *qMatMut))[0 * $(int nTs) + j] = NV_Ith_S(y,j);\n }\n\n /* Main time-stepping loop: calls CVode to perform the integration */\n /* Stops when the final time has been reached */\n for (i = 1; i < $(int nTs); i++) {\n\n flag = CVode(cvode_mem, ($vec-ptr:(double *ts))[i], y, &t, CV_NORMAL); /* call integrator */\n if (check_flag(&flag, \"CVode solver failure, stopping integration\", 1)) return 1;\n\n /* Store the results for Haskell */\n for (j = 0; j < NEQ; j++) {\n ($vec-ptr:(double *qMatMut))[i * NEQ + j] = NV_Ith_S(y,j);\n }\n\n if (flag == CV_ROOT_RETURN) {\n flagr = CVodeGetRootInfo(cvode_mem, ($vec-ptr:(int *gResMut)));\n if (check_flag(&flagr, \"CVodeGetRootInfo\", 1)) return(1);\n ($vec-ptr:(double *tRootMut))[0] = t;\n flagr = flag;\n break;\n }\n }\n\n /* Get some final statistics on how the solve progressed */\n\n flag = CVodeGetNumSteps(cvode_mem, &nst);\n check_flag(&flag, \"CVodeGetNumSteps\", 1);\n ($vec-ptr:(long int *diagMut))[0] = nst;\n\n /* FIXME */\n ($vec-ptr:(long int *diagMut))[1] = 0;\n\n flag = CVodeGetNumRhsEvals(cvode_mem, &nfe);\n check_flag(&flag, \"CVodeGetNumRhsEvals\", 1);\n ($vec-ptr:(long int *diagMut))[2] = nfe;\n /* FIXME */\n ($vec-ptr:(long int *diagMut))[3] = 0;\n\n flag = CVodeGetNumLinSolvSetups(cvode_mem, &nsetups);\n check_flag(&flag, \"CVodeGetNumLinSolvSetups\", 1);\n ($vec-ptr:(long int *diagMut))[4] = nsetups;\n\n flag = CVodeGetNumErrTestFails(cvode_mem, &netf);\n check_flag(&flag, \"CVodeGetNumErrTestFails\", 1);\n ($vec-ptr:(long int *diagMut))[5] = netf;\n\n flag = CVodeGetNumNonlinSolvIters(cvode_mem, &nni);\n check_flag(&flag, \"CVodeGetNumNonlinSolvIters\", 1);\n ($vec-ptr:(long int *diagMut))[6] = nni;\n\n flag = CVodeGetNumNonlinSolvConvFails(cvode_mem, &ncfn);\n check_flag(&flag, \"CVodeGetNumNonlinSolvConvFails\", 1);\n ($vec-ptr:(long int *diagMut))[7] = ncfn;\n\n flag = CVDlsGetNumJacEvals(cvode_mem, &nje);\n check_flag(&flag, \"CVDlsGetNumJacEvals\", 1);\n ($vec-ptr:(long int *diagMut))[8] = ncfn;\n\n flag = CVDlsGetNumRhsEvals(cvode_mem, &nfeLS);\n check_flag(&flag, \"CVDlsGetNumRhsEvals\", 1);\n ($vec-ptr:(long int *diagMut))[9] = ncfn;\n\n /* Clean up and return */\n\n N_VDestroy(y); /* Free y vector */\n N_VDestroy(tv); /* Free tv vector */\n CVodeFree(&cvode_mem); /* Free integrator memory */\n SUNLinSolFree(LS); /* Free linear solver */\n SUNMatDestroy(A); /* Free A matrix */\n\n if (flag == CV_SUCCESS && flagr == CV_ROOT_RETURN) {\n return CV_ROOT_RETURN;\n }\n else {\n return flag;\n }\n } |]\n preD <- V.freeze diagMut\n let d = SundialsDiagnostics (fromIntegral $ preD V.!0)\n (fromIntegral $ preD V.!1)\n (fromIntegral $ preD V.!2)\n (fromIntegral $ preD V.!3)\n (fromIntegral $ preD V.!4)\n (fromIntegral $ preD V.!5)\n (fromIntegral $ preD V.!6)\n (fromIntegral $ preD V.!7)\n (fromIntegral $ preD V.!8)\n (fromIntegral $ preD V.!9)\n m <- V.freeze qMatMut\n t <- V.freeze tRootMut\n rs <- V.freeze gResMut\n let f r | r == cV_SUCCESS = SolverSuccess m d\n | r == cV_ROOT_RETURN = SolverRoot (t V.!0) rs m d\n | otherwise = SolverError m res\n return $ f $ fromIntegral res\n\ndata SolverResult f g a b =\n SolverError (f b) a -- ^ Partial results and error code\n | SolverSuccess (f b) SundialsDiagnostics -- ^ Results and diagnostics\n | SolverRoot b (g a) (f b) SundialsDiagnostics -- ^ Time at which the root was found, the root itself and the\n -- results and diagnostics. NB the final result will be at the time\n -- at which the root was found not as specified by the times given\n -- to the solver.\n deriving Show\n\nodeSolveRootVWith' ::\n ODEOpts\n -> ODEMethod\n -> StepControl\n -> Maybe Double -- ^ initial step size - by default, CVode\n -- estimates the initial step size to be the\n -- solution \\(h\\) of the equation\n -- \\(\\|\\frac{h^2\\ddot{y}}{2}\\| = 1\\), where\n -- \\(\\ddot{y}\\) is an estimated value of the second\n -- derivative of the solution at \\(t_0\\)\n -> (Double -> V.Vector Double -> V.Vector Double) -- ^ The RHS of the system \\(\\dot{y} = f(t,y)\\)\n -> V.Vector Double -- ^ Initial conditions\n -> Int -- ^ Dimension of the range of the roots function\n -> (Double -> V.Vector Double -> V.Vector Double) -- ^ Roots function\n -> V.Vector Double -- ^ Desired solution times\n -> SolverResult Matrix Vector Int Double\nodeSolveRootVWith' opts method control initStepSize f y0 is gg tt =\n case solveOdeC' (fromIntegral $ maxFail opts)\n (fromIntegral $ maxNumSteps opts) (coerce $ minStep opts)\n (fromIntegral $ getMethod method) (coerce initStepSize) jacH (scise control)\n (coerce f) (coerce y0) (fromIntegral is) (coerce gg) (coerce tt) of\n SolverError v c -> SolverError (reshape l (coerce v)) (fromIntegral c)\n SolverSuccess v d -> SolverSuccess (reshape l (coerce v)) d\n SolverRoot t rs v d -> SolverRoot (coerce t) (V.map fromIntegral rs) (reshape l (coerce v)) d\n where\n l = size y0\n scise (X aTol rTol) = coerce (V.replicate l aTol, rTol)\n scise (X' aTol rTol) = coerce (V.replicate l aTol, rTol)\n scise (XX' aTol rTol yScale _yDotScale) = coerce (V.replicate l aTol, yScale * rTol)\n -- FIXME; Should we check that the length of ss is correct?\n scise (ScXX' aTol rTol yScale _yDotScale ss) = coerce (V.map (* aTol) ss, yScale * rTol)\n jacH = fmap (\\g t v -> matrixToSunMatrix $ g (coerce t) (coerce v)) $\n getJacobian method\n matrixToSunMatrix m = T.SunMatrix { T.rows = nr, T.cols = nc, T.vals = vs }\n where\n nr = fromIntegral $ rows m\n nc = fromIntegral $ cols m\n -- FIXME: efficiency\n vs = V.fromList $ map coerce $ concat $ toLists m\n\n-- | Adaptive step-size control\n-- functions.\n--\n-- [GSL](https://www.gnu.org/software/gsl/doc/html/ode-initval.html#adaptive-step-size-control)\n-- allows the user to control the step size adjustment using\n-- \\(D_i = \\epsilon^{abs}s_i + \\epsilon^{rel}(a_{y} |y_i| + a_{dy/dt} h |\\dot{y}_i|)\\) where\n-- \\(\\epsilon^{abs}\\) is the required absolute error, \\(\\epsilon^{rel}\\)\n-- is the required relative error, \\(s_i\\) is a vector of scaling\n-- factors, \\(a_{y}\\) is a scaling factor for the solution \\(y\\) and\n-- \\(a_{dydt}\\) is a scaling factor for the derivative of the solution \\(dy/dt\\).\n--\n-- [ARKode](https://computation.llnl.gov/projects/sundials/arkode)\n-- allows the user to control the step size adjustment using\n-- \\(\\eta^{rel}|y_i| + \\eta^{abs}_i\\). For compatibility with\n-- [hmatrix-gsl](https://hackage.haskell.org/package/hmatrix-gsl),\n-- tolerances for \\(y\\) and \\(\\dot{y}\\) can be specified but the latter have no\n-- effect.\ndata StepControl = X Double Double -- ^ absolute and relative tolerance for \\(y\\); in GSL terms, \\(a_{y} = 1\\) and \\(a_{dy/dt} = 0\\); in ARKode terms, the \\(\\eta^{abs}_i\\) are identical\n | X' Double Double -- ^ absolute and relative tolerance for \\(\\dot{y}\\); in GSL terms, \\(a_{y} = 0\\) and \\(a_{dy/dt} = 1\\); in ARKode terms, the latter is treated as the relative tolerance for \\(y\\) so this is the same as specifying 'X' which may be entirely incorrect for the given problem\n | XX' Double Double Double Double -- ^ include both via relative tolerance\n -- scaling factors \\(a_y\\), \\(a_{{dy}/{dt}}\\); in ARKode terms, the latter is ignored and \\(\\eta^{rel} = a_{y}\\epsilon^{rel}\\)\n | ScXX' Double Double Double Double (Vector Double) -- ^ scale absolute tolerance of \\(y_i\\); in ARKode terms, \\(a_{{dy}/{dt}}\\) is ignored, \\(\\eta^{abs}_i = s_i \\epsilon^{abs}\\) and \\(\\eta^{rel} = a_{y}\\epsilon^{rel}\\)\n", "meta": {"hexsha": "5fd306ef5f911b96c6cf05ec323ea2f266e3bbca", "size": 40124, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/Numeric/Sundials/CVode/ODE.hs", "max_stars_repo_name": "steinitznavican/hmatrix-sundials", "max_stars_repo_head_hexsha": "2f2a0722926522861928a5531a88bdac1dfe9c9a", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/Numeric/Sundials/CVode/ODE.hs", "max_issues_repo_name": "steinitznavican/hmatrix-sundials", "max_issues_repo_head_hexsha": "2f2a0722926522861928a5531a88bdac1dfe9c9a", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/Numeric/Sundials/CVode/ODE.hs", "max_forks_repo_name": "steinitznavican/hmatrix-sundials", "max_forks_repo_head_hexsha": "2f2a0722926522861928a5531a88bdac1dfe9c9a", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 50.5977301387, "max_line_length": 310, "alphanum_fraction": 0.5003239956, "num_tokens": 9882, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO\n\n", "lm_q1_score": 0.6113819732941511, "lm_q2_score": 0.4960938294709195, "lm_q1q2_score": 0.3033028244009829}} {"text": "{-# LANGUAGE OverlappingInstances #-}\n{-# LANGUAGE UnicodeSyntax #-}\n\n-- thanks to http://www.muitovar.com/gtk2hs/app1.html\n\n--module Test where\n\nimport Control.Concurrent\nimport Control.Concurrent.MVar\n\nimport Control.Monad.Trans\n\nimport Graphics.UI.Gtk hiding(Circle,Cross)\nimport qualified Graphics.Rendering.Cairo as C\nimport qualified Graphics.Rendering.Pango as P\n\nimport Data.Colour.Names\n\nimport Data.Packed.Vector\n--import Data.Packed.Random\nimport Data.Packed()\n\n--import Prelude.Unicode\n\nimport qualified Data.Array.IArray as A\n\nimport Numeric.LinearAlgebra\n\nimport Numeric.GSL.Statistics\n\nimport Graphics.Rendering.Plot\n\nimport Debug.Trace\n\nln = 25\nts = linspace ln (0,1)\nrs = ln |> take ln [0.306399512330476,-0.4243863460546792,-0.20454667402138094,-0.42873761654774106,1.3054721019673694,0.6474765138733175,1.1942346875362946,-1.7404737823144103,0.2607101951530985,-0.26782584645524893,-0.31403631431884504,3.365508546473985e-2,0.6147856889630383,-1.191723225061435,-1.9933460981205509,0.6015225906539229,0.6394073044477114,-0.6030919788928317,0.1832742199706381,0.35532918011648473,0.1982646055874545,1.7928383756822786,-9.992760294442601e-2,-1.401166614128362,-1.1088031929569364,-0.827319908453775,1.0406363628775428,-0.3070345979284644,0.6781735212645198,-0.8431706723519456,-0.4245730055085966,-0.6503687925251668,-1.4775567962221399,0.5587634921497298,-0.6481020127107823,7.313441602898768e-2,0.573580543636529,-0.9036472376122673,2.650805059813826,9.329324044673039e-2,1.9133487025468563,-1.5366337588254542,-1.0159359710920388,7.95982933517428e-2,0.5813673663649735,-6.93329631989878e-2,1.1024137719307867,-0.6046286796589855,-0.8812842030098401,1.4612246471009083,0.9584060744500491,9.210899579679932e-2,-0.15850413664405813,-0.4754694827227343,0.8669922262489788,0.4593351854708853,-0.2015350278936992,0.8829710664887649,0.7195048491420026]\n\nut = linspace 25 (1::Double,100)\n\nss = sin (15*2*pi*ts)\nds = 0.25*rs + ss\nes = constant (0.25*(stddev rs)) ln\ngs = 0.40*rs - 1\nfs :: Double -> Double\nfs = sin . (15*2*pi*)\n\nms :: Matrix Double\nms = buildMatrix 64 64 (\\(x,y) -> sin (2*2*pi*(fromIntegral x)/64) * cos (5*2*pi*(fromIntegral y)/64))\n\npts = linspace 1000 (0 :: Double,10*pi)\nfx = (\\t -> t * sin t) pts\nfy = (\\t -> t * cos t) pts\n\nhx = fromList [1,3,5,8,11,20,22,26,12,10,4] :: Vector Double\nhy = fromList [10,11,15,17,14,12,9,11,16,4,6] :: Vector Double\nhe = fromList [11,13,16,19,16,14,19,7,10,5,3] :: Vector Double\n\nlx = fromList [1,2,3,4,5,6,7,8,9,10] \u2237 Vector Double\nly = fromList [50000,10000,5000,1000,500,100,50,10,1] \u2237 Vector Double\n\nmx = linspace 100 (1,10) \u2237 Vector Double\nmy = linspace 100 (1,10000) \u2237 Vector Double\n\nrx = scaleRecip 1 mx\n\ncx = fromList [1,2,3,4,5] \u2237 Vector Double\ncyl = fromList [8,10,12,13,8] \u2237 Vector Double\ncyu = fromList [10,12,16,11,10] \u2237 Vector Double\ncel = cyl - 1\nceu = cyu + 1\n\nat = linspace 1000 (0,2*pi) \u2237 Vector Double\nax = sin at\n\n\nfigure = do\n withTextDefaults $ setFontFamily \"OpenSymbol\"\n withTitle $ setText \"Multi-plot test\"\n-- setBackgroundColour yellow\n setPlots 4 2\n\n mapM_ (\\(x,y) -> withPlot (x,y) $ do\n setDataset (ts,[line ds blue])\n-- setPlotBackgroundColour grey\n setPlotPadding 0 0 0 0\n addAxis XAxis (Value 0) $ do\n -- setGridlines Major True\n setTicks Major (TickNumber 5)\n setTicks Minor (TickNumber 41)\n addAxis YAxis (Side Lower) $ do\n setTicks Minor (TickNumber 0)\n setRangeFromData YAxis Lower Linear\n setRangeFromData XAxis Lower Linear) [(x,y)|x <- [1..4],y <- [1..2]]\n\ndisplay :: ((Int,Int) -> C.Render ()) -> IO ()\ndisplay r = do\n initGUI -- is start\n\n window <- windowNew\n set window [ windowTitle := \"Cairo test window\"\n , windowDefaultWidth := 600\n , windowDefaultHeight := 400\n , containerBorderWidth := 1\n ]\n\n-- canvas <- pixbufNew ColorspaceRgb True 8 300 200\n-- containerAdd window canvas\n frame <- frameNew\n containerAdd window frame\n canvas <- drawingAreaNew\n containerAdd frame canvas\n widgetModifyBg canvas StateNormal (Color 65535 65535 65535)\n\n widgetShowAll window \n\n on canvas exposeEvent $ tryEvent $ do \n s <- liftIO $ widgetGetSize canvas\n drw <- liftIO $ widgetGetDrawWindow canvas\n --dat <- liftIO $ takeMVar d\n --liftIO $ renderWithDrawable drw (circle 50 10)\n liftIO $ renderWithDrawable drw (r s)\n\n onDestroy window mainQuit\n mainGUI\n\n \nmain = display $ render figure\n\ntest = writeFigure PDF \"test.pdf\" (400,400) figure", "meta": {"hexsha": "4b9e3380e03c78391e99002e36e10b526f571634", "size": 4761, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "examples/Test3.hs", "max_stars_repo_name": "JackTheEngineer/plot", "max_stars_repo_head_hexsha": "547acf1f348c7aad249d87482becd43bbe37a6ce", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 17, "max_stars_repo_stars_event_min_datetime": "2015-03-03T03:00:01.000Z", "max_stars_repo_stars_event_max_datetime": "2019-10-04T14:10:10.000Z", "max_issues_repo_path": "examples/Test3.hs", "max_issues_repo_name": "strake/plot.hs", "max_issues_repo_head_hexsha": "eacddea5afcf91b0eb7e4c2bccf640b3558daf1b", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 12, "max_issues_repo_issues_event_min_datetime": "2015-01-15T02:11:38.000Z", "max_issues_repo_issues_event_max_datetime": "2020-08-30T07:33:39.000Z", "max_forks_repo_path": "examples/Test3.hs", "max_forks_repo_name": "strake/plot.hs", "max_forks_repo_head_hexsha": "eacddea5afcf91b0eb7e4c2bccf640b3558daf1b", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 7, "max_forks_repo_forks_event_min_datetime": "2015-01-05T02:30:41.000Z", "max_forks_repo_forks_event_max_datetime": "2020-08-23T20:51:16.000Z", "avg_line_length": 36.6230769231, "max_line_length": 1181, "alphanum_fraction": 0.6811594203, "num_tokens": 1607, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6261241772283034, "lm_q2_score": 0.48438008427698437, "lm_q1q2_score": 0.3032820817337031}} {"text": "module CommonTypes \n (LispVal(..), \n LispError(..),\n ThrowsError,\n trapError,\n extractValue,\n Env,\n IOThrowsError,\n nullEnv,\n liftThrows,\n runIOThrows)\n where\n\nimport qualified Data.Vector as V\nimport Data.Ratio\nimport Data.Complex\nimport Control.Monad.Except\nimport Text.ParserCombinators.Parsec\nimport Data.IORef\nimport System.IO\n\ndata LispVal = Atom String\n | List [LispVal]\n | DottedList [LispVal] LispVal\n | Vector (V.Vector LispVal)\n | Number Integer\n | String String\n | Bool Bool\n | Character Char\n | Float Double\n | Ratio Rational\n | Complex (Complex Double)\n | PrimitiveFunc ([LispVal] -> ThrowsError LispVal)\n | Func { params :: [String], vararg :: (Maybe String),\n body :: [LispVal], closure :: Env }\n | IOFunc ([LispVal] -> IOThrowsError LispVal)\n | Port Handle\n\ninstance Show LispVal where show = showVal\n\nshowVal :: LispVal -> String\nshowVal (String string) = \"\\\"\" ++ string ++ \"\\\"\"\nshowVal (Atom name) = name\nshowVal (Number num) = show num\nshowVal (Bool value) = if value then \"#t\" else \"#f\"\nshowVal (List contents) = \"(\" ++ unwordsList contents ++ \")\"\nshowVal (DottedList head tail) = \"(\" ++ unwordsList head ++ \" . \" ++ showVal tail ++ \")\"\nshowVal (Vector vector) = \"#(\" ++ (unwordsList $ V.toList vector) ++ \")\"\nshowVal (Float value) = show value \nshowVal (Ratio value) = show (numerator value) ++ \"/\" ++ show (denominator value)\nshowVal (Complex value) = show (realPart value) ++ \"+\" ++ show (imagPart value) ++ \"i\"\nshowVal (Character char) | char == '\\n' = \"#\\\\newline\"\n | char == ' ' = \"#\\\\space\"\n | otherwise = \"#\\\\\" ++ [char]\nshowVal (PrimitiveFunc _) = \"\"\nshowVal (Func {params = args, vararg = varargs, body = body, closure = env}) =\n \"(lambda (\" ++ unwords (map show args) ++\n (case varargs of\n Nothing -> \"\"\n Just arg -> \" . \" ++ arg) ++ \") ...)\"\nshowVal (Port _) = \"\"\nshowVal (IOFunc _) = \"\"\n\n\nunwordsList = unwords . map showVal\n\n\ndata LispError = NumArgs Integer [LispVal]\n | TypeMismatch String LispVal\n | Parser ParseError\n | BadSpecialForm String LispVal\n | NotFunction String String \n | UnboundVar String String \n | Default String\n\ninstance Show LispError where show = showError\n\ntype ThrowsError = Either LispError\n\nshowError :: LispError -> String\nshowError (UnboundVar message varname) = message ++ \": \" ++ varname\nshowError (BadSpecialForm message form) = message ++ \": \" ++ show form\nshowError (NotFunction message func) = message ++ \": \" ++ show func\nshowError (NumArgs expected found) = \"Expected \" ++ show expected\n ++ \" args; found values \" ++ unwordsList found \nshowError (TypeMismatch expected found) = \"Invalid type: expected \" ++ expected\n ++ \", found \" ++ show found \nshowError (Parser parseErr) = \"Parse error at \" ++ show parseErr\n\ntrapError action = catchError action (return . show)\n\nextractValue :: ThrowsError a -> a\nextractValue (Right val) = val\n\ntype Env = IORef [(String, IORef LispVal)]\ntype IOThrowsError = ExceptT LispError IO\n\nnullEnv :: IO Env\nnullEnv = newIORef []\n\nliftThrows :: ThrowsError a -> IOThrowsError a\nliftThrows (Left err) = throwError err\nliftThrows (Right val) = return val\n\nrunIOThrows :: IOThrowsError String -> IO String\nrunIOThrows action = runExceptT (trapError action) >>= return . extractValue\n\n\n", "meta": {"hexsha": "21565657f06c15a8bddb48c7b46b891cb77b5619", "size": 3737, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/CommonTypes.hs", "max_stars_repo_name": "Xcode23/scheme-interpreter", "max_stars_repo_head_hexsha": "71eaebfe4a26798111a1a1c8aee20d7d3db69c12", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/CommonTypes.hs", "max_issues_repo_name": "Xcode23/scheme-interpreter", "max_issues_repo_head_hexsha": "71eaebfe4a26798111a1a1c8aee20d7d3db69c12", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/CommonTypes.hs", "max_forks_repo_name": "Xcode23/scheme-interpreter", "max_forks_repo_head_hexsha": "71eaebfe4a26798111a1a1c8aee20d7d3db69c12", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 34.2844036697, "max_line_length": 88, "alphanum_fraction": 0.5919186513, "num_tokens": 909, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.5506073655352404, "lm_q2_score": 0.5506073655352404, "lm_q1q2_score": 0.3031684709816578}} {"text": "{-# LANGUAGE ScopedTypeVariables #-}\nmodule Main (main) where\n\nimport Data.Complex (Complex)\nimport Data.Int (Int8, Int16, Int32, Int64)\nimport Data.List.NonEmpty (NonEmpty)\nimport Data.Proxy (Proxy (..))\nimport Data.Typeable (Typeable, typeRep)\nimport Data.Word (Word8, Word16, Word32, Word64)\nimport Numeric.Natural (Natural)\nimport Test.QuickCheck (Arbitrary (..), Property, counterexample, label, (===),\n sized, chooseInt, vectorOf)\nimport Test.QuickCheck.Instances ()\nimport Test.Tasty (defaultMain, testGroup, TestTree)\nimport Test.Tasty.QuickCheck (testProperty)\n\nimport qualified Data.List as L\n\nimport Data.Discrimination\nimport Utils\n\nmain :: IO ()\nmain = defaultMain $ testGroup \"discrimination\"\n [ testGroup \"examples\"\n [ testGroup \"nub\"\n [ testProperty \"List.nub\" $\n let prop :: [Word64] -> Property\n prop xs = L.nub xs === nub xs\n in prop\n\n , testProperty \"ordNub\" $\n let prop :: [Word64] -> Property\n prop xs = ordNub xs === nub xs\n in prop\n\n , testProperty \"hashNub\" $\n let prop :: [Word64] -> Property\n prop xs = hashNub xs === nub xs\n in prop\n ]\n\n , testGroup \"sort\"\n [ testProperty \"List.sort\" $\n let prop :: [Word64] -> Property\n prop xs = L.sort xs === sort xs\n in prop\n\n , testProperty \"introsort\" $\n -- for Word64 unstable sort works too\n let prop :: [Word64] -> Property\n prop xs = introsort xs === sort xs\n in prop\n\n , testProperty \"mergesort\" $\n let prop :: [Word64] -> Property\n prop xs = mergesort xs === sort xs\n in prop\n ]\n ]\n\n , testGroup \"Grouping\"\n [ testGrouping (Proxy :: Proxy ())\n , testGrouping (Proxy :: Proxy Int)\n , testGrouping (Proxy :: Proxy Int8)\n , testGrouping (Proxy :: Proxy Int16)\n , testGrouping (Proxy :: Proxy Int32)\n , testGrouping (Proxy :: Proxy Int64)\n , testGrouping (Proxy :: Proxy Word)\n , testGrouping (Proxy :: Proxy Word8)\n , testGrouping (Proxy :: Proxy Word16)\n , testGrouping (Proxy :: Proxy Word32)\n , testGrouping (Proxy :: Proxy Word64)\n , testGrouping (Proxy :: Proxy Bool)\n , testGrouping (Proxy :: Proxy Ordering)\n , testGrouping (Proxy :: Proxy (Word8,Word8))\n , testGrouping (Proxy :: Proxy (Word8,Word8,Word8))\n , testGrouping (Proxy :: Proxy (Word8,Word8,Word8,Word8))\n , testGrouping (Proxy :: Proxy Rational)\n , testGrouping (Proxy :: Proxy (Complex Word8))\n , testGrouping (Proxy :: Proxy (Maybe Word8))\n , testGrouping (Proxy :: Proxy (Either Word8 Word8))\n , testGrouping (Proxy :: Proxy Char)\n , testGrouping (Proxy :: Proxy String)\n , testGrouping (Proxy :: Proxy (NonEmpty Int))\n , testGrouping (Proxy :: Proxy Natural)\n , testGrouping (Proxy :: Proxy Integer)\n\n , testGrouping' listToNatural\n , testGrouping' listToInteger\n ]\n\n , testGroup \"Sorting\"\n [ testSorting (Proxy :: Proxy ())\n , testSorting (Proxy :: Proxy Int)\n , testSorting (Proxy :: Proxy Int8)\n , testSorting (Proxy :: Proxy Int16)\n , testSorting (Proxy :: Proxy Int32)\n , testSorting (Proxy :: Proxy Int64)\n , testSorting (Proxy :: Proxy Word)\n , testSorting (Proxy :: Proxy Word8)\n , testSorting (Proxy :: Proxy Word16)\n , testSorting (Proxy :: Proxy Word32)\n , testSorting (Proxy :: Proxy Word64)\n , testSorting (Proxy :: Proxy Bool)\n , testSorting (Proxy :: Proxy Ordering)\n , testSorting (Proxy :: Proxy (Word8,Word8))\n , testSorting (Proxy :: Proxy (Word8,Word8,Word8))\n , testSorting (Proxy :: Proxy (Word8,Word8,Word8,Word8))\n , testSorting (Proxy :: Proxy (Maybe Word8))\n , testSorting (Proxy :: Proxy (Either Word8 Word8))\n , testSorting (Proxy :: Proxy Char)\n , testSorting (Proxy :: Proxy String)\n , testSorting (Proxy :: Proxy (NonEmpty Int))\n , testSorting (Proxy :: Proxy Natural)\n , testSorting (Proxy :: Proxy Integer)\n\n , testSorting' listToNatural\n , testSorting' listToInteger\n ]\n ]\n\nlistToNatural :: SmallList Word64 -> Natural\nlistToNatural = L.foldl' (\\x y -> x * 2 ^ (64 :: Int) + fromIntegral y) 0 . getSmallList\n\nlistToInteger :: SmallList Int64 -> Integer\nlistToInteger = L.foldl' (\\x y -> x * 2 ^ (64 :: Int) + fromIntegral y) 0 . getSmallList\n\nnewtype SmallList a = SmallList { getSmallList :: [a] } deriving (Eq, Show)\n\ninstance Arbitrary a => Arbitrary (SmallList a) where\n arbitrary = sized $ \\n -> do\n m <- chooseInt (0, min 10 n)\n SmallList <$> vectorOf m arbitrary\n\n shrink = fmap SmallList . shrink . getSmallList\n\ntestGrouping\n :: forall a. (Grouping a, Typeable a, Arbitrary a, Eq a, Show a)\n => Proxy a\n -> TestTree\ntestGrouping _ = testGrouping' (id :: a -> a)\n\ntestGrouping'\n :: forall a b. (Grouping b, Typeable a, Typeable b, Arbitrary a, Eq b, Show a, Show b)\n => (a -> b)\n -> TestTree\ntestGrouping' f = testGroup name\n [ testProperty \"groupingEq\" prop_eq\n , testProperty \"nub\" prop_nub\n ]\n where\n tra = typeRep (Proxy :: Proxy a)\n trb = typeRep (Proxy :: Proxy b)\n name = if tra == trb then show tra else show trb ++ \" from \" ++ show tra\n\n prop_eq :: a -> a -> Property\n prop_eq x' y' =\n counterexample (show (x,y)) $\n label (show lhs) $\n lhs === groupingEq x y\n where\n x = f x'\n y = f y'\n lhs = x == y\n\n prop_nub :: [a] -> Property\n prop_nub xs' = L.nub xs === nub xs\n where\n xs = take 100 (map f xs')\n\ntestSorting\n :: forall a. (Sorting a, Typeable a, Arbitrary a, Ord a, Show a)\n => Proxy a\n -> TestTree\ntestSorting _ = testSorting' (id :: a -> a)\n\ntestSorting'\n :: forall a b. (Sorting b, Typeable a, Typeable b, Arbitrary a, Ord b, Show a, Show b)\n => (a -> b)\n -> TestTree\ntestSorting' f = testGroup name\n [ testProperty \"sortingCompare\" prop_cmp\n , testProperty \"sort\" prop_sort\n ]\n where\n tra = typeRep (Proxy :: Proxy a)\n trb = typeRep (Proxy :: Proxy b)\n name = if tra == trb then show tra else show trb ++ \" from \" ++ show tra\n\n prop_cmp :: a -> a -> Property\n prop_cmp x' y' =\n counterexample (show (x,y)) $\n label (show lhs) $\n lhs === sortingCompare x y\n where\n x = f x'\n y = f y'\n lhs = compare x y\n\n prop_sort :: [a] -> Property\n prop_sort xs' = L.sort xs === sort xs\n where\n xs = map f xs'\n", "meta": {"hexsha": "daf4bca6776ada7f5d813c6234945e558d02d0c5", "size": 6425, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "test/tests.hs", "max_stars_repo_name": "bacchanalia/discrimination", "max_stars_repo_head_hexsha": "82abd3f173113a85c2187697ff8a8e4cf123b2e3", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": 133, "max_stars_repo_stars_event_min_datetime": "2015-01-16T20:16:01.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-23T05:33:45.000Z", "max_issues_repo_path": "test/tests.hs", "max_issues_repo_name": "bacchanalia/discrimination", "max_issues_repo_head_hexsha": "82abd3f173113a85c2187697ff8a8e4cf123b2e3", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": 23, "max_issues_repo_issues_event_min_datetime": "2015-03-25T08:40:41.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-16T23:17:38.000Z", "max_forks_repo_path": "test/tests.hs", "max_forks_repo_name": "bacchanalia/discrimination", "max_forks_repo_head_hexsha": "82abd3f173113a85c2187697ff8a8e4cf123b2e3", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": 24, "max_forks_repo_forks_event_min_datetime": "2015-02-18T22:19:47.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-17T20:25:28.000Z", "avg_line_length": 31.4950980392, "max_line_length": 88, "alphanum_fraction": 0.6074708171, "num_tokens": 1826, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.542863297964157, "lm_q2_score": 0.5583269943353745, "lm_q1q2_score": 0.3030952334873166}} {"text": "{-# LANGUAGE BangPatterns #-}\n{-# LANGUAGE CPP #-}\n{-# LANGUAGE DataKinds #-}\n{-# LANGUAGE DeriveAnyClass #-}\n{-# LANGUAGE DeriveGeneric #-}\n{-# LANGUAGE FlexibleContexts #-}\n{-# LANGUAGE FlexibleInstances #-}\n{-# LANGUAGE InstanceSigs #-}\n{-# LANGUAGE MultiParamTypeClasses #-}\n{-# LANGUAGE RankNTypes #-}\n{-# LANGUAGE ScopedTypeVariables #-}\n{-# LANGUAGE Strict #-}\n{-# LANGUAGE TypeFamilies #-}\n{-# LANGUAGE TypeOperators #-}\n{-# LANGUAGE UndecidableInstances #-}\n{-# OPTIONS_GHC -Wno-incomplete-uni-patterns #-}\n\nmodule Grenade.Layers.FullyConnected (\n FullyConnected (..)\n , FullyConnected' (..)\n , randomFullyConnected\n , SpecFullyConnected (..)\n , specFullyConnected\n , fullyConnected\n ) where\n\nimport Control.DeepSeq\nimport Control.Monad\nimport Control.Monad.Primitive (PrimBase, PrimState)\nimport Control.Parallel.Strategies\nimport Data.Maybe (fromMaybe)\nimport Data.Reflection (reifyNat)\nimport qualified Data.Vector.Storable as V\nimport GHC.Generics (Generic)\nimport GHC.TypeLits\nimport System.Random.MWC hiding (create)\n#if MIN_VERSION_singletons(2,6,0)\nimport Data.Singletons.TypeLits (SNat (..))\n#endif\nimport Data.List (foldl')\nimport Data.Proxy\nimport Data.Serialize\nimport Data.Singletons\nimport Data.Singletons.Prelude.Num ((%*))\nimport qualified Numeric.LinearAlgebra as LA\nimport Numeric.LinearAlgebra.Static hiding (zipWithVector)\nimport Text.Printf\n\nimport Control.Monad (void)\nimport Foreign.Storable (peekElemOff, pokeElemOff, sizeOf)\nimport System.IO.Unsafe (unsafePerformIO)\n\nimport Grenade.Core\nimport Grenade.Dynamic\nimport Grenade.Dynamic.Internal.Build\nimport Grenade.Layers.Internal.BLAS\nimport Grenade.Layers.Internal.CUDA\nimport Grenade.Layers.Internal.Update\nimport Grenade.Types\nimport Grenade.Utils.Conversion\nimport Grenade.Utils.LinearAlgebra\nimport Grenade.Utils.ListStore\nimport Grenade.Utils.Vector\n\n\nimport Debug.Trace\n\n-- | A basic fully connected (or inner product) neural network layer.\ndata FullyConnected i o = FullyConnected\n !(FullyConnected' i o) -- Neuron weights\n !(ListStore (FullyConnected' i o)) -- momentum store\n deriving (Generic)\n\ninstance NFData (FullyConnected i o) where\n rnf (FullyConnected w store) = rnf w `seq` rnf store\n\ninstance Show (FullyConnected i o) where\n show FullyConnected {} = \"FullyConnected\"\n\n\n-- | How to store the data .\ndata FullyConnected' i o\n = FullyConnectedHMatrix\n !(R o) -- ^ Bias\n !(L o i) -- ^ Activations\n | FullyConnectedBLAS\n !(Int, Int) -- ^ Input, output\n !(V.Vector RealNum) -- ^ Bias, Temporary vector of same size\n !(V.Vector RealNum) -- ^ Activations\n deriving (Generic)\n\ninstance Show (FullyConnected' i o) where\n show FullyConnectedBLAS{} = \"FullyConnectedBLAS\"\n show FullyConnectedHMatrix{} = \"FullyConnectedHMatrix\"\n\ninstance NFData (FullyConnected' i o) where\n rnf (FullyConnectedHMatrix b w) = rnf b `seq` rnf w\n rnf (FullyConnectedBLAS !io !b !w) = rnf io `seq` rnf b `seq` rnf w\n\n\ninstance (KnownNat i, KnownNat o, KnownNat (i * o)) => UpdateLayer (FullyConnected i o) where\n type Gradient (FullyConnected i o) = (FullyConnected' i o)\n type MomentumStore (FullyConnected i o) = ListStore (FullyConnected' i o)\n runUpdate opt@OptSGD {} x@(FullyConnected (FullyConnectedHMatrix oldBias oldActivations) store) (FullyConnectedHMatrix biasGradient activationGradient) =\n let (FullyConnectedHMatrix oldBiasMomentum oldMomentum) = getData opt x store\n VectorResultSGD newBias newBiasMomentum = descendVector opt (VectorValuesSGD oldBias biasGradient oldBiasMomentum)\n MatrixResultSGD newActivations newMomentum = descendMatrix opt (MatrixValuesSGD oldActivations activationGradient oldMomentum)\n newStore = setData opt x store (FullyConnectedHMatrix newBiasMomentum newMomentum)\n in FullyConnected (FullyConnectedHMatrix newBias newActivations) newStore\n runUpdate opt@OptAdam {} x@(FullyConnected (FullyConnectedHMatrix oldBias oldActivations) store) (FullyConnectedHMatrix biasGradient activationGradient) =\n let [FullyConnectedHMatrix oldMBias oldMActivations, FullyConnectedHMatrix oldVBias oldVActivations] = getData opt x store\n VectorResultAdam newBias newMBias newVBias = descendVector opt (VectorValuesAdam (getStep store) oldBias biasGradient oldMBias oldVBias)\n MatrixResultAdam newActivations newMActivations newVActivations =\n descendMatrix opt (MatrixValuesAdam (getStep store) oldActivations activationGradient oldMActivations oldVActivations)\n newStore = setData opt x store [FullyConnectedHMatrix newMBias newMActivations, FullyConnectedHMatrix newVBias newVActivations]\n in FullyConnected (FullyConnectedHMatrix newBias newActivations) newStore\n runUpdate opt@OptSGD {} x@(FullyConnected (FullyConnectedBLAS io@(i,o) oldBiasH oldActivationsH) store) (FullyConnectedBLAS _ biasGradient activationGradient) =\n let oldBias = oldBiasH\n oldActivations = oldActivationsH\n (oldMBias, oldMActivations) = case getData opt x store of -- In the first periods until the store is filled newData is called, which will generate FullyConnectedHMatrix instances!\n FullyConnectedBLAS _ oldMBias' oldMActivations' -> (oldMBias', oldMActivations')\n FullyConnectedHMatrix oldMBias' oldMActivations' -> (extract oldMBias', extractM oldMActivations')\n VectorResultSGDV newBias newMBias = descendVectorV opt (VectorValuesSGDV oldBias biasGradient oldMBias)\n MatrixResultSGDV newActivations newMActivations = descendMatrixV opt (MatrixValuesSGDV oldActivations activationGradient oldMActivations)\n newStore = setData opt x store (FullyConnectedBLAS io newMBias newMActivations)\n in FullyConnected (FullyConnectedBLAS io newBias newActivations) newStore\n where extractM mat = (\\(S2DV vec) -> vec) . fromS2D $ S2D mat\n runUpdate opt@OptAdam {} x@(FullyConnected (FullyConnectedBLAS io@(i,o) oldBiasH oldActivationsH) store) (FullyConnectedBLAS _ biasGradient activationGradient) =\n let oldBias = oldBiasH\n oldActivations = oldActivationsH\n (oldMBias, oldMActivations, oldVBias, oldVActivations) = case getData opt x store of -- In the first periods until the store is filled newData is called, which will generate FullyConnectedHMatrix instances!\n [FullyConnectedBLAS _ oldMBias' oldMActivations', FullyConnectedBLAS _ oldVBias' oldVActivations'] -> (oldMBias', oldMActivations', oldVBias', oldVActivations')\n [FullyConnectedHMatrix oldMBias' oldMActivations', FullyConnectedHMatrix oldVBias' oldVActivations'] -> (extract oldMBias', extractM oldMActivations', extract oldVBias', extractM oldVActivations')\n [FullyConnectedBLAS _ oldMBias' oldMActivations', FullyConnectedHMatrix oldVBias' oldVActivations'] -> (oldMBias', oldMActivations', extract oldVBias', extractM oldVActivations')\n xs -> error $ \"unexpected data in ListStore in FullyConnected BLAS implementation: \" ++ show xs\n VectorResultAdamV newBias newMBias newVBias = descendVectorV opt (VectorValuesAdamV (getStep store) oldBias biasGradient oldMBias oldVBias)\n MatrixResultAdamV newActivations newMActivations newVActivations = descendMatrixV opt (MatrixValuesAdamV (getStep store) oldActivations activationGradient oldMActivations oldVActivations)\n newStore = setData opt x store [FullyConnectedBLAS io newMBias newMActivations, FullyConnectedBLAS io newVBias newVActivations]\n in FullyConnected (FullyConnectedBLAS io newBias newActivations) newStore\n where extractM mat = (\\(S2DV vec) -> vec) . fromS2D $ S2D mat\n runUpdate opt (FullyConnected layer _) _ = error $ \"Unexpected input in runUpdate in FullyConnected layer. Optimizer\" ++ show opt ++ \". Layer: \" ++ show layer\n\ninstance (KnownNat i, KnownNat o, KnownNat (i * o)) => LayerOptimizerData (FullyConnected i o) (Optimizer 'SGD) where\n type MomentumDataType (FullyConnected i o) (Optimizer 'SGD) = FullyConnected' i o\n getData opt x store = head $ getListStore opt x store\n setData opt x store = setListStore opt x store . return\n newData _ _ = FullyConnectedHMatrix (konst 0) (konst 0)\n\ninstance (KnownNat i, KnownNat o, KnownNat (i * o)) => LayerOptimizerData (FullyConnected i o) (Optimizer 'Adam) where\n type MomentumDataType (FullyConnected i o) (Optimizer 'Adam) = FullyConnected' i o\n type MomentumExpOptResult (FullyConnected i o) (Optimizer 'Adam) = [FullyConnected' i o]\n getData = getListStore\n setData = setListStore\n newData _ _ = FullyConnectedHMatrix (konst 0) (konst 0)\n\n\ninstance (KnownNat i, KnownNat o) => FoldableGradient (FullyConnected' i o) where\n mapGradient f (FullyConnectedHMatrix bias activations) = FullyConnectedHMatrix (dvmap f bias) (dmmap f activations)\n mapGradient f (FullyConnectedBLAS io bias activations) = FullyConnectedBLAS io (mapVector f bias) (mapVector f activations)\n squaredSums (FullyConnectedHMatrix bias activations) = [sumV . squareV $ bias, sumM . squareM $ activations]\n squaredSums (FullyConnectedBLAS _ bias activations) = [V.sum . mapVector (^(2::Int)) $ bias, V.sum . mapVector (^(2::Int)) $ activations]\n\n\nrunForward :: forall i o. (KnownNat i, KnownNat o) => FullyConnected i o -> S ('D1 i) -> (Tape (FullyConnected i o) ('D1 i) ('D1 o), S ('D1 o))\nrunForward (FullyConnected (FullyConnectedHMatrix wB wN) _) (S1D v) = (S1D v, S1D (wB + wN #> v))\nrunForward (FullyConnected (FullyConnectedBLAS _ wB wN) _) (S1DV v) =\n let inp = unsafeMemCopyVectorFromTo wB (createVectorUnsafe (V.length wB))\n !out' = unsafePerformIO $ matXVec BlasNoTranspose wN v 1 inp\n in force out' `seq` (S1DV v, S1DV out')\nrunForward lay@(FullyConnected (FullyConnectedHMatrix _ _) _ ) v@S1DV{} = runForward lay (toS1D v)\nrunForward lay@(FullyConnected FullyConnectedBLAS{} _) v@S1D{} = runForward lay (fromS1D v)\n\n\nrunBackward :: forall i o . (KnownNat i, KnownNat o) => FullyConnected i o -> Tape (FullyConnected i o) ('D1 i) ('D1 o) -> S ('D1 o) -> (Gradient (FullyConnected i o), S ('D1 i))\nrunBackward (FullyConnected (FullyConnectedHMatrix _ wN) _) (S1D x) (S1D dEdy) =\n let wB' = dEdy\n mm' = dEdy `outer` x\n -- calcluate derivatives for next step\n dWs = tr wN #> dEdy\n in (FullyConnectedHMatrix wB' mm', S1D dWs)\nrunBackward (FullyConnected (FullyConnectedBLAS io@(i, o) _ wN) _) (S1DV x) (S1DV dEdy) =\n let !mm' = unsafePerformIO $ outerV dEdy x\n dWsInp = createVectorUnsafe i\n !dWs' = unsafePerformIO $ matXVec BlasTranspose wN dEdy 0 dWsInp\n in force mm' `seq` force dWs' `seq` (FullyConnectedBLAS io dEdy mm', S1DV dWs')\nrunBackward l x dEdy = runBackward l x (toLayerShape x dEdy)\n\n\ninstance (KnownNat i, KnownNat o, KnownNat (i * o)) => Layer (FullyConnected i o) ('D1 i) ('D1 o) where\n type Tape (FullyConnected i o) ('D1 i) ('D1 o) = S ('D1 i)\n runForwards = runForward -- Do a matrix vector multiplication and return the result.\n runBackwards = runBackward -- Run a backpropogation step for a full connected layer.\n\n\ninstance (KnownNat i, KnownNat o) => Serialize (FullyConnected i o) where\n put (FullyConnected w ms) = put w >> put ms\n get = FullyConnected <$> get <*> get\n\ninstance (KnownNat i, KnownNat o) => Serialize (FullyConnected' i o) where\n put (FullyConnectedHMatrix b w) = do\n put (0 :: Int)\n putListOf put . LA.toList . extract $ b\n putListOf put . LA.toList . LA.flatten . extract $ w\n put (FullyConnectedBLAS io b w) = do\n put (1 :: Int)\n put io\n putListOf put . V.toList $ b\n putListOf put . V.toList $ w\n get = do\n (nr :: Int) <- get\n case nr of\n 0 -> do\n let f = fromIntegral $ natVal (Proxy :: Proxy i)\n b <- maybe (fail \"Vector of incorrect size\") return . create . LA.fromList =<< getListOf get\n k <- maybe (fail \"Vector of incorrect size\") return . create . LA.reshape f . LA.fromList =<< getListOf get\n return $ FullyConnectedHMatrix b k\n 1 -> do\n io <- get\n b <- V.fromList <$> getListOf get\n w <- V.fromList <$> getListOf get\n return $ FullyConnectedBLAS io b w\n _ -> error $ \"Unexpected nr in get in Serialize of FullyConnected' \" ++ show nr\n\n\ninstance (KnownNat i, KnownNat o, KnownNat (i*o)) => RandomLayer (FullyConnected i o) where\n createRandomWith = randomFullyConnected\n\n\nrandomFullyConnected ::\n forall m i o. (PrimBase m, KnownNat i, KnownNat o, KnownNat (i * o))\n => NetworkInitSettings\n -> Gen (PrimState m)\n -> m (FullyConnected i o)\nrandomFullyConnected (NetworkInitSettings m HMatrix _) gen = do\n wN <- getRandomMatrix i o m gen\n wB <- getRandomVector i o m gen\n return $!! FullyConnected (FullyConnectedHMatrix wB wN) mkListStore\n where i = natVal (Proxy :: Proxy i)\n o = natVal (Proxy :: Proxy o)\nrandomFullyConnected (NetworkInitSettings m BLAS _) gen = do\n\n wB <- getRandomVectorV i o o' m gen\n wN <- getRandomVectorV i o (i' * o') m gen\n return $!! FullyConnected (FullyConnectedBLAS (i', o') wB wN) mkListStore\n where\n i = natVal (Proxy :: Proxy i)\n i' = fromIntegral i\n o = natVal (Proxy :: Proxy o)\n o' = fromIntegral o\n\n-------------------- DynamicNetwork instance --------------------\n\ninstance (KnownNat i, KnownNat o) => FromDynamicLayer (FullyConnected i o) where\n fromDynamicLayer _ _ _ = SpecNetLayer $ SpecFullyConnected (natVal (Proxy :: Proxy i)) (natVal (Proxy :: Proxy o))\n\ninstance ToDynamicLayer SpecFullyConnected where\n toDynamicLayer wInit gen (SpecFullyConnected nrI nrO) =\n reifyNat nrI $ \\(pxInp :: (KnownNat i) => Proxy i) ->\n reifyNat nrO $ \\(pxOut :: (KnownNat o') => Proxy o') ->\n case singByProxy pxInp %* singByProxy pxOut of\n SNat -> do\n (layer :: FullyConnected i o') <- randomFullyConnected wInit gen\n return $ SpecLayer layer (sing :: Sing ('D1 i)) (sing :: Sing ('D1 o'))\n\n-- | Make a specification of a fully connected layer (see Grenade.Dynamic.Build for a user-interface to specifications).\nspecFullyConnected :: Integer -> Integer -> SpecNet\nspecFullyConnected nrI nrO = SpecNetLayer $ SpecFullyConnected nrI nrO\n\n\n-- | A Fully-connected layer with input dimensions as given in last output layer and output dimensions specified. 1D only!\nfullyConnected :: Integer -> BuildM ()\nfullyConnected rows = do\n (inRows, _, _) <- buildRequireLastLayerOut Is1D\n buildAddSpec (SpecNetLayer $ SpecFullyConnected inRows rows)\n buildSetLastLayer (rows, 1, 1)\n\n\n-------------------- GNum instances --------------------\n\ninstance (KnownNat i, KnownNat o) => GNum (FullyConnected i o) where\n s |* FullyConnected w store = FullyConnected (s |* w) (s |* store)\n FullyConnected w1 store1 |+ FullyConnected w2 store2 = FullyConnected (w1 |+ w2) (store1 |+ store2)\n\ninstance (KnownNat i, KnownNat o) => GNum (FullyConnected' i o) where\n s |* FullyConnectedHMatrix b w = FullyConnectedHMatrix (dvmap (fromRational s *) b) (dmmap (fromRational s *) w)\n s |* FullyConnectedBLAS io b w = FullyConnectedBLAS io (mapVector (fromRational s *) b) (mapVector (fromRational s *) w)\n FullyConnectedHMatrix b1 w1 |+ FullyConnectedHMatrix b2 w2 = FullyConnectedHMatrix (b1 + b2) (w1 + w2)\n FullyConnectedBLAS io b1 w1 |+ FullyConnectedBLAS _ b2 w2 = FullyConnectedBLAS io (zipWithVector (+) b2 b1) (zipWithVector (+) w2 w1)\n x |+ y = error $ \"Cannot add different network types in |+ in FullyConnected: \" ++ show (x, y)\n sumG xs@(FullyConnectedBLAS io _ _:_) = FullyConnectedBLAS io bs' ws'\n where\n (bs, ws) = unzip $ map (\\(FullyConnectedBLAS _ b w) -> (b, w)) xs\n bs' = sumVectors bs `using` rparWith rdeepseq\n ws' = sumVectors ws `using` rparWith rdeepseq\n sumG xs = foldl1 (|+) xs\n", "meta": {"hexsha": "12c7038ce7476c243aba5044a61bb0f293df0683", "size": 16306, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/Grenade/Layers/FullyConnected.hs", "max_stars_repo_name": "schnecki/grenade", "max_stars_repo_head_hexsha": "027e9c16899e2ca3685e89338a047488ac834249", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-01-11T15:05:38.000Z", "max_stars_repo_stars_event_max_datetime": "2021-01-11T15:05:38.000Z", "max_issues_repo_path": "src/Grenade/Layers/FullyConnected.hs", "max_issues_repo_name": "schnecki/grenade", "max_issues_repo_head_hexsha": "027e9c16899e2ca3685e89338a047488ac834249", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/Grenade/Layers/FullyConnected.hs", "max_forks_repo_name": "schnecki/grenade", "max_forks_repo_head_hexsha": "027e9c16899e2ca3685e89338a047488ac834249", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2018-07-02T01:04:29.000Z", "max_forks_repo_forks_event_max_datetime": "2021-01-08T13:08:47.000Z", "avg_line_length": 55.0878378378, "max_line_length": 216, "alphanum_fraction": 0.6931190973, "num_tokens": 4374, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.7577943712746406, "lm_q2_score": 0.3998116407397951, "lm_q1q2_score": 0.30297501092269546}} {"text": "module Scheme.Parser (readLisp, readLisps) where\nimport Control.Monad\nimport Control.Monad.Error (throwError)\n\nimport Data.Char\nimport Data.Maybe\nimport Data.Complex\nimport Data.Ratio\nimport Data.Vector as V (fromList)\n\nimport Text.Parsec hiding (spaces)\n\nimport Scheme.Types\n\nreadLisp :: FilePath -> String -> ThrowsErrorIO LispVal\nreadLisp fname inp = case parse (spaces >> lispVal) fname inp of\n Left err -> throwError $ ParserError err\n Right val -> return val\n\nreadLisps :: FilePath -> String -> ThrowsErrorIO [LispVal]\nreadLisps fname inp = case parse lispParser fname inp of\n Left err -> throwError $ ParserError err\n Right val -> return val\n\ntype Parser a = Parsec String () a\n\nlispParser = spaces >> sepEndBy lispVal spaces\n\nlispVal =\n try lispSequence <|> try num <|> try lispChar <|> try bool <|>\n try atom <|> stringLisp <|> quoted\n\ncomment = char ';' >> manyTill anyChar (try (char '\\n' <|> char '\\r'))\n\nignored = void space <|> void comment\n\nspaces = many ignored\n\nspaces1 :: Parser ()\nspaces1 = skipMany1 ignored\n\nsymbol = oneOf \"!$%&|*+-/:<=?>@^_~#\"\n\nbool = char '#' >> (string \"t\" <|> string \"f\")\n >>= (\\s -> return $ case s of \"t\" -> Bool True\n \"f\" -> Bool False)\n\natom = do first <- letter <|> symbol\n rest <- many (letter <|> symbol <|> digit)\n return . Atom $ first:rest\n\nlispChar :: Parser LispVal\nlispChar = do\n string \"#\\\\\"\n special <- optionMaybe $ choice (map (string . fst) specialCharLits)\n maybe (liftM Character anyChar) (\\lit -> return (Character . fromJust $ lookup lit specialCharLits)) special\n where specialCharLits = [(\"newline\", '\\n'), (\"space\", ' '), (\"tab\", '\\t'), (\"return\", '\\r')]\n\nnum = do\n let radices = [('x', 16), ('d', 10), ('o', 8), ('t', 3), ('b', 2)]\n maybeBase <- optionMaybe (try (char '#' >> oneOf (map fst radices)))\n maybeSign <- optionMaybe (char '+' <|> char '-')\n let sign :: Num a => a -> a\n sign = fromMaybe id $ maybeSign >>= \\c -> if c == '-' then Just negate else Nothing\n base = case maybeBase of\n Nothing -> 10\n Just s -> fromMaybe 10 (lookup s radices)\n real <- try (liftM (Double . sign) (parseFloat base))\n <|> try (liftM (Rational . sign) (parseRational base))\n <|> liftM (Int . sign) (parseInteger base)\n maybeImaginary <- optionMaybe (try $ num >>= \\n -> char 'i' >> return n)\n return $ maybe (Num real) (\\(Num imag) ->\n Num $ Complex $ getAsDouble real :+ getAsDouble imag) maybeImaginary\n\ndigitCharacters = ['0'..'9'] ++ ['A'..'Z']\n\ntoDigit :: (Num a, Enum a) => Char -> a\ntoDigit c = case lookup (toUpper c) $ zip digitCharacters [0..] of\n Nothing -> error $ \"character not between 0 and 9 or A and Z: '\" ++ [c] ++ \"'\"\n Just d -> d\n\nparseInteger :: Int -> Parser Integer\nparseInteger base = liftM round $ parseDigits False base\n\nparseFloat :: Int -> Parser Double\nparseFloat base = do big <- parseDigits False base\n char '.'\n small <- parseDigits True base\n return $ big + small\n\nparseRational :: Int -> Parser (Ratio Integer)\nparseRational base = do n <- parseInteger base\n char '/'\n d <- parseInteger base\n return $ n % d\n\nparseDigits :: (Floating a, Enum a) => Bool -> Int -> Parser a\nparseDigits isDecimal base =\n let allowedDigits = take base digitCharacters\n convertStr numAsStr = snd $ foldr\n (\\c (plc, val) -> (plc + 1, val + toDigit c * fromIntegral base ** plc))\n (if isDecimal then (-1) * fromIntegral (length numAsStr) else 0.0, 0.0) numAsStr\n in liftM convertStr $ many1 (satisfy (flip elem allowedDigits . toUpper))\n\nescapables = [('t', '\\t'), ('n', '\\n'), ('r', '\\r'), ('\\\\', '\\\\')]\n\nstringLisp :: Parser LispVal\nstringLisp = do char '\"'\n s <- many (noneOf \"\\\"\\\\\" <|> (try $ do\n char '\\\\'\n esc <- anyChar\n return $ fromMaybe esc $ lookup esc escapables))\n char '\"'\n return $ String s\n\nquoted = do char '\\''\n v <- lispVal\n return $ List [Atom \"quote\", v]\n\nlispSequence = do\n isVector <- (string \"(\" >> return False)\n <|> (string \"#(\" >> return True)\n spaces\n vs <- sepEndBy lispVal spaces1\n maybeDot <- optionMaybe (spaces >> char '.' >> spaces1 >> lispVal)\n spaces\n char ')'\n return $ maybe\n (if isVector then Vector (toVector vs) else List vs)\n (DottedList vs) maybeDot\n\ntoVector = V.fromList\n", "meta": {"hexsha": "ef474a59da9ade9996180e39da3d8468b35d8b1c", "size": 4663, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "Scheme/Parser.hs", "max_stars_repo_name": "oroguh/SCMinHS", "max_stars_repo_head_hexsha": "56332f2021db5b2df58dd17e6033c0dad4ef3484", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Scheme/Parser.hs", "max_issues_repo_name": "oroguh/SCMinHS", "max_issues_repo_head_hexsha": "56332f2021db5b2df58dd17e6033c0dad4ef3484", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Scheme/Parser.hs", "max_forks_repo_name": "oroguh/SCMinHS", "max_forks_repo_head_hexsha": "56332f2021db5b2df58dd17e6033c0dad4ef3484", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 35.0601503759, "max_line_length": 112, "alphanum_fraction": 0.5683036672, "num_tokens": 1256, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.640635854839898, "lm_q2_score": 0.4726834766204329, "lm_q1q2_score": 0.302817983113426}} {"text": "{-# OPTIONS_GHC -fno-warn-unused-binds -fno-warn-unused-matches -fno-warn-name-shadowing -fno-warn-missing-signatures #-}\n{-# LANGUAGE FlexibleInstances, MultiParamTypeClasses, UndecidableInstances, FlexibleContexts, TypeSynonymInstances #-}\n\n\n---------------------------------------------------------------------------------------------------\n---------------------------------------------------------------------------------------------------\n-- | \n-- | Module : Bench mark morris \n-- | Creator: Xiao Ling\n-- | Created: 12/8/2015\n-- | see : https://github.com/snoyberg/conduit\n-- | TODO : move this to benchmark directory\n-- |\n---------------------------------------------------------------------------------------------------\n---------------------------------------------------------------------------------------------------\n\nmodule Bmorris where\n\nimport Data.List\nimport Data.Random\nimport Data.Conduit\nimport Data.List.Split\nimport qualified Data.Conduit.List as Cl\n\nimport Control.Monad.Identity\n\nimport Criterion.Main\n\nimport Core\nimport Statistics\nimport Morris\n\n\n{-----------------------------------------------------------------------------\n Benchmark counter vs counter'\n \n Benchmark results: it's unclear whether counter is faster than counter'\n due to noise: \n\n benchmarking count vs count'/count 500\n time 6.527 s (-1.716 s .. 19.59 s)\n 0.692 R\u00b2 (0.283 R\u00b2 .. 1.000 R\u00b2)\n mean 4.232 s (2.136 s .. 5.686 s)\n std dev 2.186 s (0.0 s .. 2.519 s)\n variance introduced by outliers: 74% (severely inflated)\n\n benchmarking count vs count'/count' 500\n time 3.315 s (-6.152 s .. 16.65 s)\n 0.357 R\u00b2 (0.239 R\u00b2 .. 1.000 R\u00b2)\n mean 5.474 s (2.826 s .. 6.971 s)\n std dev 2.351 s (0.0 s .. 2.592 s)\n variance introduced by outliers: 74% (severely inflated)\n\n The variance actually went up as # of counters increased\n\n------------------------------------------------------------------------------}\n\n\nmain :: IO ()\nmain = defaultMain . return $ bgroup \"flat vs nested morris\" [\n bench \"flat list e=d=0.05\" . nfIO $ morris 0.05 0.05 [1..10000]\n , bench \"nested list e=d=0.05\" . nfIO $ morris' 0.05 0.05 [1..10000]\n ]\n\n_count cs = runRVar (Cl.sourceList [1..1000] $$ count cs) StdRandom\n_count' cs = runRVar (Cl.sourceList [1..1000] $$ count' cs) StdRandom\n\n\n(t1,m1) = (10,3) :: (Int,Int)\n(t2,m2) = (100,3) :: (Int,Int)\n(t3,m3) = (8000,3) :: (Int,Int)\n\ncs' :: Num a => Int -> Int -> [[Counter]]\ncs' t m = replicate m $ replicate t 0 \n\ncs :: Num a => Int -> Int -> [Counter]\ncs t m = replicate (t*m) 0 \n\n-- * conclude: morris 2x faster than morris', not surprisingly\n--main :: IO ()\n--main = defaultMain . return $ bgroup \"morris vs morris'\" [\n-- bench \"morris 10\" . nfIO $ morris 0.5 0.5 [1..10]\n-- , bench \"morris' 10\" . nfIO $ morris' 0.5 0.5 [1..10]\n\n-- , bench \"morris 100\" . nfIO $ morris 0.5 0.5 [1..100]\n-- , bench \"morris' 100\" . nfIO $ morris' 0.5 0.5 [1..100]\n\n-- , bench \"morris 1000\" . nfIO $ morris 0.5 0.5 [1..1000]\n-- , bench \"morris' 1000\" . nfIO $ morris' 0.5 0.5 [1..1000]\n\n-- , bench \"morris 10000\" . nfIO $ morris 0.5 0.5 [1..10000]\n-- , bench \"morris' 10000\" . nfIO $ morris' 0.5 0.5 [1..10000]\n-- ]\n\n\n{-----------------------------------------------------------------------------\n Benchmark t of m vs m of t\n------------------------------------------------------------------------------}\n\n---- * conclusion : counters faster by 1 ms on 0.05 0.05\n--main :: IO ()\n--main = defaultMain . return $ bgroup \"t of m vs m of t tests\" [\n-- bench \"eps = 0.5 d = 0.5 counter \" . nfIO $ incrsIO $ counters 0.5 0.5\n-- , bench \"eps = 0.5 d = 0.5 counter'\" . nfIO $ incrsIO $ counters' 0.5 0.5\n \n-- , bench \"eps = 0.1 d = 0.1 counter\" . nfIO $ incrsIO $ counters 0.1 0.1\n-- , bench \"eps = 0.1 d = 0.1 counter'\" . nfIO $ incrsIO $ counters' 0.1 0.1\n\n-- , bench \"eps = 0.05 d = 0.05 counter\" . nfIO $ incrsIO $ counters 0.05 0.05\n-- , bench \"eps = 0.05 d = 0.05 counter'\" . nfIO $ incrsIO $ counters' 0.05 0.05\n-- ]\n\n\n--incrsIO :: MonadRandom m => [[Counter]] -> m [[Counter]]\n--incrsIO xxs = runRVar (incrs xxs) StdRandom\n\n--counters :: Eps -> Delta -> [[Counter]]\n--counters e d = replicate m $ replicate t 0\n-- where (m,t) = (m' e d, t' e d)\n\n--counters' :: Eps -> Delta -> [[Counter]]\n--counters' e d = replicate t $ replicate m 0\n-- where (m,t) = (m' e d, t' e d)\n\n--t' e d = round $ 1/(e^2*d)\n--m' e d = round . log $ 1/d\n\n\n\n---- * given a list of list of counters toss a coin for each counter and incr\n--incrs :: [[Counter]] -> RVar [[Counter]]\n--incrs = sequence . fmap (sequence . fmap incr)\n\n---- * Increment a counter `x` with probability 1/2^x\n--incr :: Counter -> RVar Counter\n--incr x = do\n-- h <- toss . coin $ 0.5^(round x)\n-- return $ if isHead h then (seq () succ x) else seq () x\n\n\n\n\n{-----------------------------------------------------------------------------\n Benchmark time compleity of mean/median\n see : http://www.serpentine.com/criterion/tutorial.html\n------------------------------------------------------------------------------}\n\n-- * observation: 5% difference in runtime using mean vs not\n-- * 5% difference in runtime using median vs not\n--main :: IO ()\n--main = defaultMain . return $ bgroup \"morris mean vs no median\" [\n-- bench \"morris median 100 items eps = 0.1 delta = 0.1 \" . nfIO $ morris 0.1 0.1 [1..100]\n-- , bench \"morris no median 100 items eps = 0.1 delta = 0.1 \" . nfIO $ morris' 0.1 0.1 [1..100]\n-- , bench \"morris median 100 items eps = 0.05 delta = 0.05\" . nfIO $ morris 0.05 0.05 [1..100]\n-- , bench \"morris no median 100 items eps = 0.05 delta = 0.05\" . nfIO $ morris' 0.05 0.05 [1..100]\n-- ]\n\n{-----------------------------------------------------------------------------\n II. Approximate Mean\n------------------------------------------------------------------------------}\n\n-- * Run Morris alpha on stream inputs `xs`\n--morrisA :: [a] -> IO Counter\n--morrisA xs = flip runRVar StdRandom $ Cl.sourceList xs $$ alpha\n\n---- * Run Morris beta on stream inputs `xs` for `t` independent trials and average\n--morrisB :: Int -> [a] -> IO Counter\n--morrisB t = fmap rmean . replicateM t . morrisA\n\n---- * final morris algorithm\n---- * Run on stream inputs `xs` for t independent trials for `t = 1/eps`, \n---- * and `m` times in parralell, for `m = 1/(e^2 * d)`\n---- * and take the median\n---- * TODO: make this actually parralell\n--morris :: Eps -> Delta -> [a] -> IO Counter\n--morris e d = fmap rmedian . replicateM m . morrisB t \n-- where (t,m) = (round $ 1/(e^2*d), round $ 1/d)\n\n\n------------------------------------------------------------------------------\n-- III. Utils\n-------------------------------------------------------------------------------\n\n---- * Utils * -- \n\n---- * A step in morris Algorithm alpha\n--alpha :: Sink a RVar Counter\n--alpha = (\\x -> 2^(round x) - 1) <$> Cl.foldM (\\x _ -> incr x) 0\n\n\n---- * Increment a counter `x` with probability 1/2^x\n--incr :: Counter -> RVar Counter\n--incr x = do\n-- h <- toss . coin $ 0.5^(round x)\n-- return $ if isHead h then (seq () succ x) else seq () x\n\n\n--rmean, rmedian :: (Floating a, Ord a, RealFrac a) => [a] -> Float\n--rmean = fromIntegral . round . mean\n--rmedian = fromIntegral . round . median\n\n\n\n{-----------------------------------------------------------------------------\n Depricated\n------------------------------------------------------------------------------}\n\n-- * Non fmap f version to test list traversal\n-- * marginal difference due to fmap g where g = mean or median\n--morrisB' :: Int -> [a] -> IO [Counter]\n--morrisB' t = replicateM t . morrisA\n\n--morris' :: Eps -> Delta -> [a] -> IO [Counter]\n--morris' e d = replicateM m . morrisB t \n --where (t,m) = (round $ 1/(e^2*d), round $ 1/d)\n\n\n{-----------------------------------------------------------------------------\n Benchmark median of means\n naive \"imperitive\" solution worse in large n \n------------------------------------------------------------------------------}\n\n--main :: IO ()\n--main = defaultMain . return $ bgroup \"count vs count'\" [\n-- -- bench \"median 1000\" $ whnf (medianOfMeans 10) [1..1000]\n-- --, bench \"median' 1000\" $ whnf (medianOfMeans' 10) [1..1000]\n\n-- --, bench \"median 10000\" $ whnf (medianOfMeans 10) [1..10000]\n-- --, bench \"median' 10000\" $ whnf (medianOfMeans' 10) [1..10000]\n\n-- --, bench \"median 100000\" $ whnf (medianOfMeans 10) [1..100000]\n-- --, bench \"median' 100000\" $ whnf (medianOfMeans' 10) [1..100000]\n\n-- bench \"median 0.1\" $ whnf (medianOfMeans 1000000) [1..5000000]\n-- , bench \"median' 0.1\" $ whnf (medianOfMeans' 1000000) [1..5000000]\n\n-- , bench \"median 0.5\" $ whnf (medianOfMeans 8000) [1..24000]\n-- , bench \"median' 0.5\" $ whnf (medianOfMeans' 8000) [1..24000]\n\n-- ]\n\n---- * this is worse!!\n--medianOfMeans' :: Counter -> [Counter] -> Counter\n--medianOfMeans' t xs = let (ms,_,_) = foldr (tomean t) ([],0,1) xs in median ms\n\n--tomean :: Counter -> Counter -> ([Counter],Counter,Counter) -> ([Counter],Counter,Counter)\n--tomean t x (ms,m,c) | c < t = (ms,m+x,c+1)\n-- | otherwise = ((fromIntegral . round $ (m+x)/t):ms,0,1)\n\n\n--medianOfMeans :: Int -> [Counter] -> Counter\n--medianOfMeans t = median . fmap mean' . (chunksOf t) \n-- fmap median' . \n\n--ms = medianOfMeans 10 [1..100]\n--(ms',_,_) = medianOfMeans' 10 [1..100]\n\n\n\n\n\n\n\n\n\n\n\n\n", "meta": {"hexsha": "62cc04b04a06db74ff59c1626fa442452c406955", "size": 9692, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "test/Bmorris.hs", "max_stars_repo_name": "lingxiao/CIS700", "max_stars_repo_head_hexsha": "0aebe925c4b413a37d75b8c782a3dffd53851f8a", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "test/Bmorris.hs", "max_issues_repo_name": "lingxiao/CIS700", "max_issues_repo_head_hexsha": "0aebe925c4b413a37d75b8c782a3dffd53851f8a", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "test/Bmorris.hs", "max_forks_repo_name": "lingxiao/CIS700", "max_forks_repo_head_hexsha": "0aebe925c4b413a37d75b8c782a3dffd53851f8a", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 36.029739777, "max_line_length": 122, "alphanum_fraction": 0.4899917458, "num_tokens": 2939, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.5698526368038304, "lm_q2_score": 0.5312093733737562, "lm_q1q2_score": 0.3027110621119454}} {"text": "{-# LANGUAGE BangPatterns #-}\n--{-# XRankNTypes #-}\n\nmodule RprGD2 (OptimisationType (Rapid , FromData ,WithDepth)\n , mmlRprGdEvl,mml2DsGD -- ,mmlRprTest\n , mml2DsGen, RprMix2.aBar,mapP -- , stdTest\n --,mmlRprTest\n ) where\n\nimport Numeric.LinearAlgebra\nimport Numeric.GSL.Statistics (stddev,lag1auto)\nimport qualified Data.ByteString.Lazy.Char8 as L (writeFile, pack, unpack, intercalate,appendFile, append,concat)\nimport System.Random\nimport Control.Concurrent\nimport Control.DeepSeq\nimport Foreign.Storable\nimport Control.Parallel (par, pseq)\nimport qualified Control.Parallel.Strategies as St-- (parMap)\nimport System.IO.Unsafe\nimport Data.Maybe (isJust,fromMaybe,maybe,listToMaybe,fromJust)\nimport Data.Time\nimport Data.Char (isDigit)\n--import Text.Printf\nimport Data.Ord (comparing)\nimport Control.Monad (liftM,liftM2)\nimport Data.List (transpose, foldr1, sort, foldl' ,nub, nubBy,sortBy, minimumBy, partition)\nimport qualified Data.Map as M (Map,empty,insertWith' ,mapWithKey,filterWithKey,toList, fromList)\n--import IO\n--------------------------------------------------------------------------------------------\nimport HMDIFPrelude (bsReadChr,bs2Int')\nimport RprMix2 -- (vLength)\nimport LINreg2\nimport ResultTypes\nimport ProcessFile (writeToFile,log2File,writeOrAppend,myTime)\nimport LMisc hiding (force) \nimport ListStats (nCr,normal,binomial ,myTake,-- corr,\n mean, adjustedMatrix,cdf, meanBy, stDivBy, -- stDiv,\n adjustedMatrixN, adjustedMatrixPN,stNorm,mean,stDivM) \n---------------------------------------------------------------------------------------------\n---- optimisation type\ndata OptimisationType = Rapid | FromData | WithDepth Int deriving (Show, Eq)-- | WithNum Int\n---------------------------------------------------------------------------------------------\n---- Paralell definitions\nconcatPMap :: (a -> [b]) -> [a] -> [b]\nconcatPMap f = concat . St.parMap (St.parList St.rseq) f\n\n-- parallel map and parallel concatMap\n--mapP = St.parMap (St.dot St.rseq St.rpar)\n\nmapP' :: (a -> b) -> [a] -> [b]\nmapP' f = foldl' (\\bs a -> let fa = (f a) `St.using` St.rseq in\n fa : bs ) []\n--\nmapP :: (a -> b) -> [a] -> [b]\nmapP f = St.parMap St.rseq f \n\nconcatPMap' f = foldl'Rnf (\\xs x -> xs ++ [St.using (f x) (St.dot St.rseq St.rpar) ] ) []\n\n--- strict fold vector\n-- foldVector :: Storable a => (a -> b -> b) -> b -> Vector a -> b\nfoldVector' :: (NFData b, Storable a) => (b -> a -> b) -> b -> Vector a -> b\nfoldVector' f a vs = foldVector (\\b g x -> g (seqit $ f x b)) id vs a\n where seqit a = rnf a `pseq` a\n--------------------------------------------------------------------------------------------------\nmyMinimum :: (NFData a, Ord a) => [a] -> a\nmyMinimum (x:xs) = foldl'Rnf min x xs\nmyMinimum _ = error \"error: myMinimum empty list\"\n--\n--mmlRprGD :: Vector Double -> Double -> Double -> Matrix Double -> Mmodel -> (Mmodel, Double)\n{-# NOINLINE mmlRprGD #-}\nmmlRprGD g ys n cts nSLP dss (ml, model) = mmlRprGD_aux g ys n cts nSLP dss model\n\nmmlRprGD_aux :: (RandomGen g) => g\n -> Vector Double\n -> Double\n -> [Int] \n -> Maybe Bool\n -> Matrix Double\n -> Mmodel\n -> IO OModel \nmmlRprGD_aux g ys n cts nSLP dss model = do\n return $ Omod (nAbaMod model taU) oldMsgLn\n where\n ------- compute values from the input model, eg the weighs-----------\n nAbaMod (MkModel a b c x _ ) k = (MkModel a b c x k)\n ----\n fL = (+ 1) . fromIntegral . length\n aA' = fL cts\n -------------------------------------------------------\n siG = sigD model \n siGE = sigE model \n taU = tau model \n ---------------------------------------------------------\n xXa = invS nSLP (dss <> (aBar model)) ---\n abar = aBar model\n\n aA = fromIntegral . (\\ a -> if a == 2 then 1 else a `div` 2) $ dim abar\n errFun a b = (r_n model a b) \n rN = zipVectorWith errFun xXa ys -- (r_n model)\n lnR = dim rN -- get the magnitude of rN\n wData :: Matrix Double\n wData = diagRect 0 rN lnR lnR\n wError :: Matrix Double\n wError = diagRect 0 (mapVector (1 -) rN) lnR lnR\n ---\n xtWx = ((trans dss) <> wData) <> dss\n ------------------------------------------------------------\n ---\n nAlpha = foldVector (+) 0 rN \n nAlpA1 = nAlpha - aA - 1 --\n --\n ysSubXa = zipVectorWith (-) ys xXa -- the data minus the predictions\n ySubWySub ww = ysSubXa <.> (ww <> ysSubXa) -- y\n --\n dehAbarSq = (abar <.> abar)\n aBarSqTau1 = dehAbarSq / (2 * taU^2)\n ----------------------------------------------------------------------------------------\n ------------------- calculate the message length of the input model --------------------\n ----------------------------------------------------------------------------------------\n !oldMsgLn = l1 `par` l2 `par` l3 `par` l4 `pseq` (l1 + l2 + l3 + l4)\n ----------------------------------log 0.01 *------------------------------------------------------\n restrPr = ((aA + 1)* log 2)/ 2\n restrPrior = maybe restrPr (\\_ -> restrPr) nSLP\n l1 = (aA + 2.0) * logg taU + aBarSqTau1 - restrPrior + 0.5 * ((n-2) * log (2 * pi))\n ----------------------------------- log 2 * (aA + 1)/2 ---------------------------------\n l2 = nAlpA1 * logg siG + (1/(2 * siG^2)) * (ySubWySub wData)\n l3 = (n - nAlpha) * logg siGE + (1/(2 * siGE^2)) * (ySubWySub wError) + 0.5 * logg (2 * nAlpha)\n mlLogs = 0.5 * log (det xtWx) + 0.5 * logg (2*(n - nAlpha)) + 0.5 * log (pi * (aA + 3)) \n l4 = mlLogs - 1.319\n----------------------------------------------------------------------------------------------------\ndummyMod = Omod (MkModel 0 0 0 (fromList [1]) 0) 100000000\nvunStdNorm' vs = vunStdNorm (vmean vs) (vstDiv vs) vs\n{----------------------------------------------------------------------------------------------------\nmmlRprGdEvl: the mmlRPR evaluation function. Takes:\nn - the range in years of roughness data (which corresponds to the number of data points\n when dealing with simulation data)\nms - the number of chains that are joined together - the maintenance strategy.\n Note that the mml2DS uses the mmlRPR on adjaent sections joined together. Hence this\n parameter says how many sections are to be joined for calls to mmlRprGdEvl. When this\n functions is called outside of the mml2DS, this valus is always 1 (i.e we do not make any\n prior assumptions about maintenances on the chain)\nys - a lsit of the data values for this chain\npp - the interval in years between maintenenace interventions\ngen - a random generator to initialize the process\nnSlopes - determines whether to exclude negative slopes: if true, negative slopes are excluded\n otherwise they are not\nrprOnly - toggles the applicaion of the MMLRPR function only. The likelihood of maintenance\n is not applied to each interventions\n----------------------------------------------------------------------------------------------------}\nmmlRprGdEvl :: (RandomGen g) => Int ->\n Int -> -- error search depth limit\n [Vector Double] -> -- Either (Vector Double) [Double] -> -- the data in standardized for\n Double ->\n g ->\n Maybe Bool -> -- negative slopes (temporarily used for turning on and off the mixture model)\n Int ->\n IO (Maybe ( (OModel,(Vector Double,[Int]) ) , [Double])) --ms\nmmlRprGdEvl n dpt ys pp gen nSlopes mtd = -- mN std\n mmlRprAuxGD n dpt m p (filter ((== mLen) . dim) ys) pp gen nSlopes mtd True -- ms -- mN std\n where\n p = 1 / pp\n --- don need this claculation. we can filter out irelevant values\n m = n `div` mtd\n mLen = maybe 0 (\\_ -> maximum $ map dim ys) (listToMaybe ys)\n ---------------------------------------------------------------------------------------------------\n unStd :: (OModel,(Vector Double,[Int])) -> (OModel,(Vector Double,[Int]))\n unStd (Omod (MkModel c b e ks d) ml,(vs,ys)) = (Omod (MkModel c b e (vunStdNorm' ks) d) ml,(vunStdNorm' vs,ys))\n unSd ms =\n case ms of\n Nothing -> Nothing\n Just (a,b) -> Just (unStd a, b)\n\n------------\nmmlRprAuxGD n _ m p ysv pp gen nSlopes mtd toOpt = do\n return minMod\n where\n minMod = liftM applyMixture $\n maybe Nothing (\\_ -> Just $ minimumBy (comparing (fst . fst)) rprs1) (listToMaybe rprs1)\n --\n result rprss = (snd (minimumBy (comparing (fst . snd)) rprss), map fst rprss) \n f = fromIntegral\n (g1,_) = split gen\n abr' :: Matrix Double -> [(Double, (Vector Double, (Double, Vector Double))) ]\n abr' = (: []) . minimumBy (comparing fst)\n . zipWith (\\f a -> f a) (map (\\ys -> mmlLinearRegLP ys 1 1) setLen)\n . replicate len -- (length ysv)\n where\n len = length ysv\n setLen = replicate len $ join ysv\n ----------------------------------------------------------------------------\n initM b s = initModel gen s b -\n initLz (ml, (prd, (s,ab))) = (ml, (prd , initM ab s))\n --\n mod :: Matrix Double -> [(Double, (Vector Double, Mmodel))]\n mod mxx = map initLz $ abr' mxx \n ----------------------------------------------------------------------------\n nN = f . sum $ map dim ysv -- n\n nNs = map ((\\n -> [1 .. n]) . f . dim) ysv\n fLn = (+ 1) . f . length\n msgLm (Omod _ l) = l\n appMML g1 nM ct mmX (ml,(prd , inMd)) = unsafePerformIO $ mmlRprGD g1 (join ysv) nM ct nSlopes mmX (ml, inMd)\n iTr (mX, cts) = (map (appMML gen nN cts mX) (mod mX), (mX, cts))\n cMML = mapP (getPredictions nSlopes) . mapSnd . iTr\n nps cmm = realignedNpieces cmm mtd\n --------------------------------------------------------------------------------------------\n ----------- applying the mixture model to the discovered intervention, only ----------------\n rprs1 = [ (kx, cm1) | cm1 <- [0 .. m], kx <- ( concatPMap (mapSnd . iTr) . (nps cm1)) nNs ] `St.using` (St.parList St.rseq)\n applyMixture ( (Omod md mln , (mx , cts)), cm) =\n let (!nMd , !mxL) = unsafePerformIO $ nextModelR' gen cts nSlopes mx (join ysv) md\n ncma = n\n nncma = ncma `nCr` cm\n ncr = (binomial n cm p) / f nncma -- else 1\n lncr = log ncr\n newOMod = Omod nMd ((lncr + mln) + mxL)\n prds = getPredictions nSlopes (newOMod, (mx, cts))\n in (prds , [lncr] )\n -------------- end applying the Mixture Model at the end ----------------------------------\n getPredictions nSlp (mm, (xConfig, cts)) = (mm , (invS nSlp prds , cts)) \n where\n prds = xConfig <> (aBar (oMod mm))\n --- retain the domain of the function\n retDom :: (a -> [b]) -> a -> [(a , b)]\n retDom f a = map (\\x -> (a, x)) ( f a)\n ---\n nAbaMod (MkModel a b c _ x) k = (MkModel a b c k x)\n\n{----------------------------------------------------------------------------------------------------\n The mml2DsGD functions applies the MMLRPR to alogorithm to a list of data\n points (i.e. the readings or chainages) and after\n sectioning them off mml2DsGD years distance gen [[Double]]\n--}\n--- returning results\nmml2DsGen :: (RandomGen g) => g -> TdsParms ->\n OptimisationType -> -- the optimisation type (Rapid , FromData ,WithDepth)\n SecOrSchm ->\n IO SecOrSchm\nmml2DsGen g tprms optType ssm =\n case ssm of\n -- analysis results for sections\n Left sect -> do\n let (a, b , c ,d) = (sCondition sect, sScannerCode sect, sScannerSorrg sect, sCWay sect)\n let mkSect = Section a b c d (sChains sect)\n liftM (Left . mkSect . omd2Results) $ mml2DsGD g tprms optType [xs | xs <- sChains sect, length (cData xs) > 1]\n -- results for schemes\n Right schm -> do\n nScmRecs <- mapM (mkSchemeRecRes g tprms optType) (schmRecs schm)\n return $ Right $ Scheme (schemeName schm) (schmCondition schm) nScmRecs\n where\n mkSchemeRecRes :: (RandomGen g) => g ->\n TdsParms ->\n OptimisationType ->\n SchemeRec ->\n IO SchemeRec\n mkSchemeRecRes g tp opT src = liftM (mkSchmRec . omd2Results) $ mml2DsGD g tp opT chn\n where\n mkSchmRec = SchemeRec scd srd srnm srg stc sec chn\n --\n scd = scmScannerCode src\n srd = roadClassCode src\n srnm = roadName src\n srg = scmScannerSorrg src\n --- carriage way\n stc = startChain src\n sec = endChain src\n chn = scmChains src\n\n\n--}\n-- returning a OMod, etc\nmml2DsGD :: (RandomGen g) => g ->\n TdsParms -> -- the parameters for the mmlTds\n OptimisationType -> -- the optimisation type (Rapid , FromData ,WithDepth)\n [Chain] -> --- a list of all the data for each chain in a section or scheme\n IO ([(OModel, ([Double], [Int]))], [Int])\nmml2DsGD gen tdPrs optType chxss = do\n ---------------------------------------------\n scrollLog (\"Identifying candidate groups for section with length: \" ++ show len) -- (max 3 (len `div` 15))\n !mks1 <- (joinPairsV dist optType 2 len 25 xss)\n ------\n let total = length mks1\n let msgP1 = \"Fitting progression rate and identifying outliers for section length: \" ++ show len ++\". \"\n let msgP2 = show total ++\": candidate groups found.\"\n onlycuts <- liftM (maybe 0 (fromJust . bs2Int') . listToMaybe . head) $ bsReadChr ',' \"./mmlTdsFiles/onlycuts.txt\"\n -- print (\"negslopes is : \" ++ show nSlopes)\n if len > 0 then\n if null mks1 then do\n let noGrupMsg = \"NO Groups for section length: \" ++ show len\n logLog (\"-------------------\"++noGrupMsg)\n return dummy\n else if onlycuts == 1 then do\n logLog (\"only first cuts printed\")\n return dummy\n else do\n --\n scrollLog (msgP1 ++ msgP2)\n let mks2 = [(a,b,c) | ((a,b),c) <- zip (zip mks1 (rGens gen)) [1 ..]]\n let applyRpr = mapP (mml2DsGD_aux1 total minTrend scrollLog)\n let appMin = liftM (minimumBy compML'') . sequence . applyRpr -- ($!)\n appMin mks2\n else do\n logLog (\"Empty section list sent to MML2DS: \" ++ show len ++\". limit: \"++ show lenLim)\n return dummy\n where\n ---- projections --\n xss = map cData chxss\n (!dpt, !pp , !dist) = (searchDept tdPrs, rngInYrs tdPrs, rngInDist tdPrs)\n (nSlopes,lim,minAnl) = (negSlopes tdPrs, maxChn2Aln tdPrs, minChn2Aln tdPrs)\n minTrend = minPts2Trd tdPrs\n loggers = logFun tdPrs\n scrollLog = maybe (\\_ -> return ()) (\\_ -> loggers !! 0) (listToMaybe loggers)\n logLog = maybe (\\_ -> return ()) (\\_ -> loggers !! 1) (listToMaybe loggers)\n maxChain = (foldl' (\\n xs -> max (length xs) n) 0 xss)\n lenLim = lim * maxChain \n len = length xss\n minLen = minAnl * maxChain\n -------------------------------- end of projections ------------------\n dummy = ([(dummyMod , ([0] ,[0]))] ,[])\n pm = 1 / dist\n compML'' = comparing (sumBy (oModMl . fst). fst)\n f = fromIntegral\n {--------------------------- logging the output from the meddage lengths --------------------\n printCutsInfo :: OptimisationType -> ([(OModel, ([Double], [Int]))], [Int] ) -> IO ()\n printCutsInfo opTp (ks,cs) = do\n let cutsMsg = \"\\n cuts: \"++ printElm cs\n let mlgMsg = \"; \\t message length: \" ++ (show $ sumBy (oModMl . fst) ks)\n let name = case opTp of\n Rapid -> \"fromData\" -- \"priorOnly\"\n FromData -> \"fromData\"\n WithDepth _ -> \"fixedDepth\"\n let file = \"./SimulationFiles/\"++name++\"groups.txt\"\n -- let header = \"\\n-----------\\t cuts and message lengths ------------\\n\"\n let output = L.pack (cutsMsg ++ mlgMsg)\n writeOrAppend file output\n ---------------------------------------------------------------------------------------}\n mml2DsGD_aux1 :: RandomGen g => Int ->\n Int ->\n (String -> IO()) ->\n ( ([([Vector Double], Int)],[Int]), g, Int) ->\n IO ([(OModel, ([Double], [Int]))], [Int])\n mml2DsGD_aux1 total minToTrend write ((pgroups,pgcuts),gen,num) = do\n write (\"Calculating mmlrpr on group: \"++ show num ++ \" of \" ++ show total)\n let max1 = sumBy snd pgroups -- sum pgcut\n ----\n let calc = [ (result,pgcuts) | \n let !rprsCalcs = unsafePerformIO . sequence $ mapP (calcRpR max1 gen minToTrend) pgroups -- do the mlrpr on each grou\n , all isJust rprsCalcs -- . filter isJust\n , let result = (map fromJust . filter isJust) rprsCalcs]\n if null calc then do\n write (\"Invalid mmlrpr group for group \"++ show num)\n return dummy\n\n else do\n retMinComp calc\n where\n --\n retMinComp = return . minimumBy compML''\n --\n calcRpR :: RandomGen g => Int -> g -> Int ->\n ([Vector Double], Int) -> IO (Maybe (OModel,([Double],[Int]))) -- , [Double]) -\n calcRpR ns g mtd (vys, ms) = do\n !rprs <- mmlRprGdEvl ms dpt vys pp g nSlopes mtd\n case rprs of\n Just ( (Omod r1 r2, prs),nn) -> do\n let smm = ncr' + r2\n let str = (\"\\nncr' is: \"++ show ncr' ++\" mLen is: \"++ show r2 ++\". Their sum is: \" ++ show smm)\n -- L.appendFile \"tempLog1.txt\" (L.pack str)\n return $ Just (Omod r1 smm , (toList (fst prs), snd prs) ) --\n Nothing -> return $ Nothing\n where\n ncr' = (binomial ns ms pm) / f (ns `nCr` ms)\n-----------------------------------------------------------------------------------------------------}\n------------\n--------------------------------------------------------------------------------------------------\nfindGrpsFromData :: Double -> -- the distance of intervention points\n Int -> -- lenght of the input list\n [[Double]] -> -- ^ the data to aling\n IO [([([Vector Double], Int)], [Int])]\nfindGrpsFromData dist inLen =\n return . findCandidateSet . uncurry calculateFixedGroups1 . findInterventions_aux\n where\n findCandidateSet xs\n | length xs > 100 = maintainBy' avgRelCorr (Just 45) xs\n | otherwise = (take 10 . sortBy (comparing avgRelCorr )) xs\n --\n avgRelCorr = (meanBy (relativeCorr . fst)) . fst\n -- find possible interventions from the data\n findInterventions_aux :: [[Double]] -> ([[Double]] , [[Int]])\n findInterventions_aux xys = (xys , (nub . findGrps1 0.7) xys)\n where\n findGrps1 tolerance xs = [ ys | let stDiv = stddev . fromList\n , ys <- findGrps tolerance 38 mmlCorr xs\n ] `St.using` (St.parList St.rseq)\n -- calculate fixed groups\n calculateFixedGroups1 :: [[Double]] -> [[Int]] -> [([([Vector Double], Int)], [Int])]\n calculateFixedGroups1 xys = map (unzip . foldr mkLst [] . filter (not . null . fst) . mkIntervals vs )\n where\n vs = (map fromList xys)\n mkLst (ks,k) ps = ((ks, sumBy dim ks) , k) : ps\n -- relative correlaton between adjacent chains\n relativeCorr :: [Vector Double] -> Double\n relativeCorr xs\n | length xs < 2 = 4 -- bias against groups with only one chian\n | otherwise = mcD xs\n where\n corrDist ps qs = abs (nCorrV ps qs - 1)\n mcD = meanBy (exp . uncurry corrDist) . zipp\n\n----------------------------------------------------------------------------------------------------\n--- an infinite list of random generators\nrGens :: RandomGen g => g -> [g]\nrGens g = g : (g1 : rGens g2)\n where (g1, g2) = split g\n\n------------------------------------------------------------------------------------------------------------------------\njoinPairsV :: Double -> -- the distance of maintenence interventions\n OptimisationType -> -- the optimisation type (Rapid , FromData ,WithDepth)\n Int -> -- ^ the minimum number of chains to aligh\n --Int -> -- ^ maximum\n Int -> -- ^ length of the input list\n Int -> -- ^ the maximum number of chains to align\n [[Double]] -> -- ^ the data to aling\n IO [([([Vector Double], Int)], [Int])]\n --[([(Vector Double, Int, Double )],[Int])]\n -- (joinPairsV pm optType minLen lenLim 3 len lim) xss\njoinPairsV dist optType malg xysLen lim xys -- minL maxL\n | null xys = return []\n | xysLen < 4 = return joinFew -- ' pm --xys\n --- check the length of the combined list\n | lenData < 10 = return joinFew\n | otherwise =\n case optType of\n Rapid -> findGrpsFromData dist xysLen xys\n FromData -> findGrpsFromData dist xysLen xys\n WithDepth d -> calculateFixedGroups vxys [(repeat d)]\n where\n lenData = sumBy length xys\n --\n vxys = map fromList xys\n ------------------\n vs = join vxys\n ms = dim vs\n joinFew = [([([vs],dim vs)],[])]\n\n---------------------------------------------------------------------------------\n\n-- given a list of possible cuts and the list of chains, we generate the a list\n-- of possible maintenance groups defeind by the cuts\ncalculateFixedGroups :: [Vector Double] -> [[Int]] -> IO [([([Vector Double], Int)], [Int])]\ncalculateFixedGroups vs = return . map (unzip . foldr mkLst [] . filter (not . null . fst) . mkIntervals vs)\n where\n mkLst (ks,k) ps = ((ks, sumBy dim ks) , k) : ps\n -- return [ (mkIntervals vs cs , cs) | cs <- ks]\n", "meta": {"hexsha": "37dae6ab3699f6279f9eef0edb90e57e91179377", "size": 23931, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "sourceCode/RprGD2.hs", "max_stars_repo_name": "rawlep/MML", "max_stars_repo_head_hexsha": "a2c05b50adcae345f745fe3e28b4aa0b7c4f17ba", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "sourceCode/RprGD2.hs", "max_issues_repo_name": "rawlep/MML", "max_issues_repo_head_hexsha": "a2c05b50adcae345f745fe3e28b4aa0b7c4f17ba", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "sourceCode/RprGD2.hs", "max_forks_repo_name": "rawlep/MML", "max_forks_repo_head_hexsha": "a2c05b50adcae345f745fe3e28b4aa0b7c4f17ba", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 52.8278145695, "max_line_length": 146, "alphanum_fraction": 0.464543897, "num_tokens": 6404, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO\n\n", "lm_q1_score": 0.7490872019117031, "lm_q2_score": 0.40356685373537454, "lm_q1q2_score": 0.30230676524894123}} {"text": "-- | A tool for measuring cycle time of tasks\n--\n-- Cycle time is the difference between creation date and completion date.\n--\nmodule Main (main) where\n\nimport RIO\n\nimport Asana.Api\nimport Asana.Api.Gid (Gid, gidToText)\nimport Asana.Api.Project (Project(pCreatedAt, pGid, pName), getProjects)\nimport Asana.App\n (AppM, appExt, loadAppWith, parseBugProjectId, parseYear, runApp)\nimport qualified Data.Csv as Csv\nimport Data.Foldable (maximum, minimum)\nimport Data.List (intercalate, nub)\nimport qualified Data.Map.Strict as Map\nimport qualified Data.Vector as V\nimport RIO.ByteString (writeFile)\nimport RIO.ByteString.Lazy (toStrict)\nimport RIO.Text (isPrefixOf, unpack)\nimport RIO.Time (NominalDiffTime, diffUTCTime, toGregorian, utctDay)\nimport Statistics.Quantile (median, medianUnbiased)\nimport Statistics.Sample (kurtosis, mean, skewness, stdDev)\nimport Statistics.Sample.Histogram (histogram)\nimport System.IO.Temp (emptySystemTempFile)\nimport Text.Printf (printf)\n\ndata AppExt = AppExt\n { appYear :: Integer\n , appBugProject :: Gid\n }\n\nmain :: IO ()\nmain = do\n app <- loadAppWith $ AppExt <$> parseYear <*> parseBugProjectId\n runApp app $ do\n logDebug \"Fetch projects\"\n year <- asks $ appYear . appExt\n projects <- filter (approvedProject year) <$> getProjects\n\n taskGids <- fetchRelevantTaskGids projects\n\n tasks <- pooledForConcurrentlyN maxRequests taskGids getTask\n logDebug \"Write task CSV\"\n writeTaskCsv tasks\n\n let\n cycleTimes = zscoreFilter . V.fromList . fmap realToFrac $ mapMaybe\n mayCycleTime\n tasks\n\n when (null cycleTimes) $ logWarn \"No cycle time to compute\"\n\n logDebug \"Write histogram CSV\"\n writeHistogramCsv cycleTimes\n\n logDebug \"Display Cycle Time\"\n let\n fmt = intercalate\n \"\\n\"\n [ \"Cycle Time\"\n , \"- mean: %d days\"\n , \"- mediam: %d days\"\n , \"- skewness: %.3f\"\n , \"- kurtosis: %.3f\"\n , \"- stdDev: %d days\"\n , \"- max: %d days\"\n , \"- min: %d days\"\n ]\n logInfo . fromString $ printf\n fmt\n (toDays $ mean cycleTimes)\n (toDays $ median medianUnbiased cycleTimes)\n (skewness cycleTimes)\n (kurtosis cycleTimes)\n (toDays $ stdDev cycleTimes)\n (toDays $ maximum cycleTimes)\n (toDays $ minimum cycleTimes)\n\nzscoreFilter :: Vector Double -> Vector Double\nzscoreFilter p =\n let\n av = mean p\n sdev = stdDev p\n zs x = (x - av) / sdev\n in V.filter ((<= 3) . zs) p\n\ntoDays :: Double -> Int\ntoDays = floor . (/ 86400)\n\napprovedProject :: Integer -> Project -> Bool\napprovedProject compareYear project = year == compareYear && isPrefixOf\n \"Iteration\"\n (pName project)\n where (year, _, _) = toGregorian $ utctDay (pCreatedAt project)\n\nmayCycleTime :: Task -> Maybe NominalDiffTime\nmayCycleTime task = do\n completedAt <- tCompletedAt task\n -- FIXME: Sometimes this is true\n guard $ completedAt > tCreatedAt task\n Just . diffUTCTime completedAt $ tCreatedAt task\n\nwriteHistogramCsv :: Vector Double -> AppM ext ()\nwriteHistogramCsv cycleTimes = do\n filePath <- liftIO $ emptySystemTempFile \".csv\"\n let histogramCsv = uncurry V.zip $ histogram @_ @_ @Double 100 cycleTimes\n writeFile filePath . toStrict . Csv.encode $ V.toList histogramCsv\n logInfo . fromString $ \"Histogram written to \" <> filePath\n\nwriteTaskCsv :: [Task] -> AppM ext ()\nwriteTaskCsv tasks = do\n filePath <- liftIO $ emptySystemTempFile \".csv\"\n let\n toRecord task = Map.fromList\n [ (\"name\" :: String, unpack $ tName task)\n , (\"task ID\" :: String, unpack $ taskUrl task)\n , ( \"cycle time\"\n , maybe \"\" (show . realToFrac @_ @Double) $ mayCycleTime task\n )\n ]\n writeFile filePath\n . toStrict\n . Csv.encodeByName (V.fromList [\"name\", \"task ID\", \"cycle time\"])\n $ toRecord\n <$> tasks\n logInfo . fromString $ \"Tasks written to \" <> filePath\n\nfetchRelevantTaskGids :: Traversable t => t Project -> AppM AppExt [Gid]\nfetchRelevantTaskGids projects = do\n taskGids <-\n fmap (nub . concat)\n . pooledForConcurrentlyN maxRequests projects\n $ \\project -> do\n logDebug . fromString $ \"Project tasks: \" <> show\n (gidToText $ pGid project)\n fmap nGid <$> getProjectTasks (pGid project) AllTasks\n bugProjectGid <- asks $ appBugProject . appExt\n bugTaskGids <- fmap nGid <$> getProjectTasks bugProjectGid AllTasks\n\n pure $ filter (`notElem` bugTaskGids) taskGids\n", "meta": {"hexsha": "e62d55d79952a1dcb5ceeeae531129d8de1a0c03", "size": 4427, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "cycle-time/Main.hs", "max_stars_repo_name": "freckle/asana", "max_stars_repo_head_hexsha": "91ce6ade118674bb273966943370684eba71f227", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2020-01-10T03:48:58.000Z", "max_stars_repo_stars_event_max_datetime": "2020-11-18T06:37:51.000Z", "max_issues_repo_path": "cycle-time/Main.hs", "max_issues_repo_name": "freckle/asana", "max_issues_repo_head_hexsha": "91ce6ade118674bb273966943370684eba71f227", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 12, "max_issues_repo_issues_event_min_datetime": "2019-08-21T19:19:44.000Z", "max_issues_repo_issues_event_max_datetime": "2021-06-08T13:46:36.000Z", "max_forks_repo_path": "cycle-time/Main.hs", "max_forks_repo_name": "freckle/asana", "max_forks_repo_head_hexsha": "91ce6ade118674bb273966943370684eba71f227", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 30.958041958, "max_line_length": 75, "alphanum_fraction": 0.6760786085, "num_tokens": 1218, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.7090191460821871, "lm_q2_score": 0.42632159254749036, "lm_q1q2_score": 0.3022701715044197}} {"text": "{-# LANGUAGE RecordWildCards, FlexibleContexts #-}\n\nimport Control.Monad.Trans.Except\nimport Data.Complex\nimport Foreign.C.Types\nimport Data.Maybe\nimport Control.Monad\n\nimport Control.Error.Util\nimport Pipes as P\nimport qualified Pipes.Prelude as P\nimport Options.Applicative\nimport Data.Vector.Storable as VS hiding ((++))\nimport Data.Vector.Generic as VG hiding ((++))\nimport Graphics.Rendering.OpenGL\n\nimport Network.Socket (SockAddr(SockAddrInet), PortNumber, HostAddress)\n\nimport SDR.FFT\nimport SDR.Plot\nimport SDR.ArgUtils\nimport SDR.Util\nimport SDR.NetworkStream\nimport Graphics.DynamicGraph.Waterfall\nimport Graphics.DynamicGraph.Util\n\ndata Options = Options {\n fftSize :: Maybe Int,\n windowWidth :: Maybe Int,\n windowHeight :: Maybe Int,\n rows :: Maybe Int,\n colorMap :: Maybe [GLfloat],\n ip :: Maybe HostAddress,\n port :: Maybe PortNumber\n}\n\nparseColorMap :: ReadM [GLfloat]\nparseColorMap = eitherReader func\n where\n func \"jet\" = return jet\n func \"jet_mod\" = return jet_mod\n func \"hot\" = return hot\n func \"bw\" = return bw\n func \"wb\" = return wb\n func arg = Left $ \"Cannot parse colour map: `\" ++ arg ++ \"'\"\n\noptParser :: Parser Options\noptParser = Options \n <$> optional (option (fmap fromIntegral parseSize) (\n long \"size\" \n <> short 's' \n <> metavar \"SIZE\" \n <> help \"FFT bin size. Default is 512.\"\n ))\n <*> optional (option auto (\n long \"width\" \n <> short 'w' \n <> metavar \"WIDTH\" \n <> help \"Window width. Default is 1024.\"\n ))\n <*> optional (option auto (\n long \"height\" \n <> short 'h' \n <> metavar \"HEIGHT\" \n <> help \"Window height. Default is 480.\"\n ))\n <*> optional (option auto (\n long \"rows\" \n <> short 'r' \n <> metavar \"ROWS\" \n <> help \"Number of rows in waterfall. Default is 1000.\"\n ))\n <*> optional (option parseColorMap (\n long \"colorMap\" \n <> short 'm' \n <> metavar \"COLORMAP\" \n <> help \"Waterfall color map. Default is 'jet_mod'.\"\n ))\n <*> optional (option auto (\n long \"ip\"\n <> short 'i'\n <> metavar \"IP\"\n <> help \"IP address to bind to. Default is 0.0.0.0\"\n ))\n <*> optional (option auto (\n long \"port\"\n <> short 'p'\n <> metavar \"PORT\"\n <> help \"UDP port to bind to. Default is 0x1234\"\n ))\n\nopt :: ParserInfo Options\nopt = info (helper <*> optParser) (fullDesc <> progDesc \"Draw a waterall plot of the samples received over Ethernet\" <> header \"Ethernet Waterfall\")\n\n{-# INLINE interleavedIQSigned256ToFloat #-}\ninterleavedIQSigned256ToFloat :: (Num a, Integral a, Num b, Fractional b, VG.Vector v1 a, VG.Vector v2 (Complex b)) => v1 a -> v2 (Complex b)\ninterleavedIQSigned256ToFloat input = VG.generate (VG.length input `quot` 2) convert\n where\n {-# INLINE convert #-}\n convert idx = convert' (input `VG.unsafeIndex` (2 * idx)) :+ convert' (input `VG.unsafeIndex` (2 * idx + 1))\n {-# INLINE convert' #-}\n convert' val = fromIntegral val / 256\n\ndoIt Options{..} = do\n res <- lift setupGLFW\n unless res (throwE \"Unable to initilize GLFW\")\n\n let fftSize' = fromMaybe 512 fftSize\n window = hanning fftSize' :: VS.Vector Double\n rfFFT <- lift $ fftw fftSize'\n rfSpectrum <- plotWaterfall (fromMaybe 1024 windowWidth) (fromMaybe 480 windowHeight) fftSize' (fromMaybe 1000 rows) (fromMaybe jet_mod colorMap)\n\n dev <- lift $ udpRecvSocket $ SockAddrInet (fromMaybe 0x1234 port) (fromMaybe 0 ip)\n\n lift $ runEffect $ udpSource dev (fftSize' * 2)\n >-> P.map (interleavedIQSigned256ToFloat :: VS.Vector CChar -> VS.Vector (Complex Double)) \n >-> P.map (VG.zipWith (flip mult) window . VG.zipWith mult (halfBandUp fftSize')) \n >-> rfFFT \n >-> P.map (VG.map ((* (32 / fromIntegral fftSize')) . realToFrac . magnitude)) \n >-> rfSpectrum \n\nmain = execParser opt >>= exceptT putStrLn return . doIt\n\n", "meta": {"hexsha": "eef6d309670ee1f90bd9c5da4b8d9324d2364341", "size": 4421, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "from-udp/from-udp.hs", "max_stars_repo_name": "adamwalker/sdr-apps", "max_stars_repo_head_hexsha": "b44b9cac4f0ab857d5889141d94ae15aa3025896", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 8, "max_stars_repo_stars_event_min_datetime": "2015-06-04T20:12:32.000Z", "max_stars_repo_stars_event_max_datetime": "2021-08-29T03:45:31.000Z", "max_issues_repo_path": "from-udp/from-udp.hs", "max_issues_repo_name": "adamwalker/sdr-apps", "max_issues_repo_head_hexsha": "b44b9cac4f0ab857d5889141d94ae15aa3025896", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2015-06-04T20:11:41.000Z", "max_issues_repo_issues_event_max_datetime": "2019-03-11T14:58:03.000Z", "max_forks_repo_path": "from-udp/from-udp.hs", "max_forks_repo_name": "adamwalker/sdr-apps", "max_forks_repo_head_hexsha": "b44b9cac4f0ab857d5889141d94ae15aa3025896", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2016-08-05T07:05:34.000Z", "max_forks_repo_forks_event_max_datetime": "2018-10-13T00:56:23.000Z", "avg_line_length": 35.6532258065, "max_line_length": 151, "alphanum_fraction": 0.5661615019, "num_tokens": 1088, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.7154239957834733, "lm_q2_score": 0.42250463481418826, "lm_q1q2_score": 0.30226995407580376}} {"text": "{-# LANGUAGE BangPatterns #-}\n{-# LANGUAGE DataKinds #-}\n{-# LANGUAGE ExplicitNamespaces #-}\n{-# LANGUAGE FlexibleContexts #-}\n{-# LANGUAGE FlexibleInstances #-}\n{-# LANGUAGE IncoherentInstances #-}\n{-# LANGUAGE InstanceSigs #-}\n{-# LANGUAGE OverloadedStrings #-}\n{-# LANGUAGE RankNTypes #-}\n{-# LANGUAGE ScopedTypeVariables #-}\n{-# LANGUAGE Strict #-}\n{-# LANGUAGE TypeFamilies #-}\n{-# LANGUAGE TypeOperators #-}\n{-# LANGUAGE Unsafe #-}\n{-# OPTIONS_GHC -fno-warn-type-defaults #-}\n\nmodule Releaser.Build\n ( buildBORLTable\n , buildBORLGrenade\n , buildSim\n , borlSettings\n , scaleAlg\n , nnConfig\n , netInp\n , modelBuilder\n , actionConfig\n , experimentName\n , load\n , save\n , mInverse\n , databaseSetting\n , expSetting\n , mkMiniPrettyPrintElems\n ) where\n\nimport Control.Arrow (second)\nimport Control.DeepSeq\nimport Control.Lens\nimport Control.Monad\nimport Control.Monad.IO.Class\nimport qualified Data.ByteString as B\nimport Data.Constraint (Dict (..))\nimport Data.Default\nimport Data.Int (Int64)\nimport Data.List (find, genericLength)\nimport qualified Data.Map as M\nimport Data.Maybe (fromMaybe, isJust)\nimport qualified Data.Proxy as Px\nimport Data.Reflection (reifyNat)\nimport Data.Serialize as S\nimport Data.Serialize.Text ()\nimport qualified Data.Text as T\nimport qualified Data.Text as T\nimport qualified Data.Text.Encoding as E\nimport qualified Data.Vector.Storable as V\nimport GHC.Exts (IsList (..))\nimport GHC.TypeLits (KnownNat)\nimport Grenade\nimport Network.HostName\nimport Prelude\nimport Statistics.Distribution\nimport Statistics.Distribution.Uniform\nimport System.Directory\nimport System.Environment (getArgs)\nimport System.IO.Unsafe (unsafePerformIO)\nimport Unsafe.Coerce (unsafeCoerce)\n\n\n-- ANN modules\nimport Grenade\n\nimport Experimenter hiding (sum)\nimport ML.BORL as B hiding (actionFilter,\n featureExtractor)\nimport qualified ML.BORL as B\nimport SimSim hiding (productTypes)\n\nimport Releaser.Costs.Type\nimport Releaser.Decay.Type\nimport Releaser.FeatureExtractor.Type\nimport Releaser.Release.ReleasePlt\nimport Releaser.Routing.Type\nimport Releaser.SettingsAction\nimport Releaser.SettingsActionFilter\nimport Releaser.SettingsConfigParameters\nimport Releaser.SettingsCosts\nimport Releaser.SettingsDecay\nimport Releaser.SettingsDemand\nimport Releaser.SettingsFeatureExtractor\nimport Releaser.SettingsPeriod\nimport Releaser.SettingsReward\nimport Releaser.SettingsRouting\nimport Releaser.Type\nimport Releaser.Util\n\nimport Debug.Trace\n\nbuildSim :: IO SimSim\nbuildSim =\n newSimSimIO\n (configRoutingRoutes routing)\n -- procTimesConst\n (configProcTimes procTimes)\n periodLength\n -- (releaseBIL $ M.fromList [(Product 1, 1), (Product 2, 1)])\n -- (releaseBIL $ M.fromList [(Product 1, 2), (Product 2, 2)])\n -- (releaseBIL $ M.fromList [(Product 1, 3), (Product 2, 3)])\n -- (releaseBIL $ M.fromLisqt [(Product 1, 4), (Product 2, 4), (Product 3, 4), (Product 4, 4), (Product 5, 4), (Product 6, 4)])\n -- (releaseBIL $ M.fromList (map (\\pt -> (pt, 2)) productTypes))\n -- releaseImmediate\n (mkReleasePLT initialPLTS)\n dispatchFirstComeFirstServe\n shipOnDueDate\n\ninitialPLTS :: M.Map ProductType Time\ninitialPLTS = M.fromList $ zip productTypes (replicate len 1)\n where\n len\n | bnNbn = 2\n | otherwise = length productTypes\n\n\n-- testDemand :: IO ()\n-- testDemand = do\n-- let nr = 1000\n-- g <- createSystemRandom\n-- sim <- buildSim\n-- xs <- replicateM nr (generateOrders sim)\n-- let len = fromIntegral $ length (concat xs)\n-- putStr \"Avg order slack time: \"\n-- print $ timeToDouble (sum $ map orderSlackTime (concat xs)) / len\n-- putStr \"Avg order arrival date: \"\n-- print $ timeToDouble (sum $ map arrivalDate (concat xs)) / len\n-- putStr \"Avg number of order per period: \"\n-- print $ fromIntegral (sum (map length xs)) / fromIntegral nr\n-- putStr \"Avg order due date: \"\n-- print $ timeToDouble (sum $ map dueDate (concat xs)) / len\n-- putStr \"Avg number of order per product type\"\n-- print $ map length $ groupBy ((==) `on` productType) $ sortBy (compare `on` productType) (concat xs)\n-- print $ map (productType . head) $ groupBy ((==) `on` productType) $ sortBy (compare `on` productType) (concat xs)\n\n------------------------------------------------------------\n--------------------------- BORL ---------------------------\n------------------------------------------------------------\n\n\ninstance Serialize Release where\n put (Release _ n) = S.put $ T.unpack n\n get = do\n n <- T.pack <$> S.get\n let fun | n == pltReleaseName = mkReleasePLT initialPLTS\n | n == uniqueReleaseName releaseImmediate = releaseImmediate\n | T.isPrefixOf bilName n = releaseBIL $ M.fromList bilArgs\n where ~bilArgs = read (T.unpack $ T.drop (T.length bilName) n)\n ~bilName = T.takeWhile (/= '[') $ uniqueReleaseName (releaseBIL mempty)\n return fun\n\n\ninstance Show St where\n show st = show (extractFeatures False st)\n\n\nnetInp :: St -> V.Vector Double\nnetInp = extractionToList . extractFeatures True\n\nmInverse :: BORL St Act -> NetInputWoAction -> Maybe (Either String St)\nmInverse borl = return . Left . show . fromListToExtraction (borl ^. s) (featureExtractor True)\n\nnetInpTbl :: St -> V.Vector Double\nnetInpTbl st = case extractFeatures False st of\n Extraction plts op que _ fgi shipped _ -> V.fromList $ plts ++ map reduce (concat $ op ++ map (map (fromIntegral . ceiling . (/9))) (concat que) ++ fgi ++ shipped)\n where\n reduce x = 7 * fromIntegral (ceiling (x / 7))\n\nnetInpTblBinary :: St -> [Double]\nnetInpTblBinary st = case extractFeatures False st of\n Extraction plts op que _ fgi shipped _ -> plts ++ map reduce (concat op) ++ map (fromIntegral . ceiling . (/9)) (concat (concat que)) ++ map reduce (concat $ fgi ++ shipped)\n where\n reduce x | x == 0 = x\n | otherwise = 1\n\n\nmodelBuilder :: NrFeatures -> (NrRows, NrCols) -> IO SpecConcreteNetwork\nmodelBuilder nrInp (nrRows, nrCols) =\n buildModelWith (NetworkInitSettings UniformInit BLAS Nothing) (DynamicBuildSetup False) $\n inputLayer1D nrInp >>\n fullyConnected (round $ 1.75*fromIntegral nrInp) >> leakyRelu >>\n fullyConnected (round $ 1.5* fromIntegral nrInp) >> leakyRelu >>\n fullyConnected lenOut >> reshape (nrRows, nrCols, 1) -- >> tanhLayer -- leakyTanhLayer 0.98\n where\n lenOut = nrRows * nrCols\n\n\n-- SpecFullyConnected 180 540 :=> SpecRelu (540,1,1) :=> SpecFullyConnected 540 180 :=> SpecRelu (180,1,1) :=> SpecFullyConnected 180 24 :=> SpecRelu (24,1,1) :=> SpecFullyConnected 24 12 :=> SpecReshape (12,1,1) (6,2,1) :=> SpecLeakyTanh 0.98 (6,2,1) :=> SpecNNil2D 6x2\n\n\n-- *GOOD RESULTS* with DDS=12 and\n-- SpecFullyConnected 45 90 :=> SpecRelu (90,1,1) :=> SpecFullyConnected 90 45 :=> SpecRelu (45,1,1) :=> SpecFullyConnected 45 6 :=> SpecRelu (6,1,1) :=> SpecFullyConnected 6 3 :=> SpecTanh (3,1,1) :=> SpecNNil1D 3\n\n\nmkInitSt :: SimSim -> [Order] -> (AgentType -> IO St, St -> [V.Vector Bool])\nmkInitSt sim startOrds =\n let initSt = St sim startOrds rewardFunction initialPLTS\n actFilter = mkConfig actionFilter actionFilterConfig\n in (return . const initSt, actFilter)\n\n\nbuildBORLTable :: IO (BORL St Act)\nbuildBORLTable = do\n sim <- buildSim\n startOrds <- liftIO $ generateOrders sim\n let (initSt, actFilter) = mkInitSt sim startOrds\n mkUnichainTabular alg initSt netInpTbl -- netInpTblBinary\n action actFilter borlParams (configDecay decay) borlSettings (Just initVals)\n\nbuildBORLGrenade :: IO (BORL St Act)\nbuildBORLGrenade = do\n sim <- buildSim\n startOrds <- liftIO $ generateOrders sim\n let (initSt, actFilter) = mkInitSt sim startOrds\n st <- liftIO $ initSt MainAgent\n flipObjective . setPrettyPrintElems <$>\n mkUnichainGrenadeCombinedNet alg initSt netInp action actFilter borlParams (configDecay decay) modelBuilder nnConfig borlSettings (Just initVals)\n -- flipObjective . setPrettyPrintElems <$> mkUnichainGrenade alg initSt netInp action actFilter borlParams (configDecay decay) (modelBuilder st) nnConfig borlSettings (Just initVals)\n\n\nsetPrettyPrintElems :: BORL St Act -> BORL St Act\nsetPrettyPrintElems borl = setAllProxies (proxyNNConfig . prettyPrintElems) (ppElems borl) borl\n where ppElems borl = mkMiniPrettyPrintElems (borl ^. s)\n\ncopyFiles :: String -> ExperimentNumber -> RepetitionNumber -> Maybe ReplicationNumber -> IO ()\ncopyFiles pre expNr repetNr mRepliNr = do\n let dir = \"results/\" <> T.unpack (T.replace \" \" \"_\" experimentName) <> \"/data/\"\n createDirectoryIfMissing True dir\n mapM_\n (\\fn -> copyIfFileExists fn (dir <> pre <> fn <> \"_exp_\" <> show expNr <> \"_rep_\" <> show repetNr <> maybe \"\" (\\x -> \"_repl_\" <> show x) mRepliNr))\n [\"reward\", \"stateValues\", \"episodeLength\", \"plts\", \"costs\", \"stateVAllStates\", \"stateWAllStates\", \"statePsiVAllStates\", \"statePsiWAllStates\"]\n\ncopyIfFileExists :: FilePath -> FilePath -> IO ()\ncopyIfFileExists fn target = do\n exists <- doesFileExist fn\n when exists $ copyFileWithMetadata fn target\n\n\ndatabaseSetting :: IO DatabaseSetting\ndatabaseSetting = do\n hostName <- getHostName\n args <- getArgs\n let mHostArg = case find ((== \"--host=\") . take 7) args of\n x@Just{} -> drop 7 <$> x\n Nothing -> drop 3 <$> find ((== \"-h=\") . take 3) args\n let getPsqlHost h\n | isJust mHostArg = maybe \"\" (E.encodeUtf8 .T.pack) mHostArg\n | h `elem` [\"schnecki-zenbook\", \"schnecki-laptop\"] = \"192.168.1.110\"\n | otherwise = \"c437-pc147\"\n putStrLn $ \"Using DB-Host: \" <> show (getPsqlHost hostName)\n return $ DatabaseSetting (\"host=\" <> getPsqlHost hostName <> \" dbname=experimenter user=experimenter password=experimenter port=5432\") 10\n\n\nmkMiniPrettyPrintElems :: St -> [V.Vector Double]\nmkMiniPrettyPrintElems st\n | length (head xs) /= length base' = error $ \"wrong length in mkMiniPrettyPrintElems: \" ++\n show (length $ head xs) ++ \" instead of \" ++ show (length base') ++ \". E.g.: \" ++ show (map (unscaleDouble scaleAlg (Just (scaleOrderMin, scaleOrderMax))) base') ++\n \"\\nCurrent state: \" ++ show (extractFeatures True st)\n\n | otherwise = map V.fromList $ concatMap (zipWith (++) plts . replicate (length plts) . map (scaleDouble scaleAlg (Just (scaleOrderMin, scaleOrderMax)))) xs\n where\n len = V.length $ extractionToList $ extractFeatures True st\n base' = drop lenPt (V.toList $ netInp st)\n lenPt | bnNbn = 2\n | otherwise = length productTypes\n\n plts :: [[Double]]\n plts = map (map (scaleDouble scaleAlg (Just (scalePltsMin, scalePltsMax))) . take lenPt) [[1, 3, 1, 1, 3, 1], [3, 5, 3, 3, 5, 3]]\n xs :: [[Double]]\n xs | len - length (head plts) == 22 = [xsSimple, xsSimple2]\n | len - length (head plts) == 21 = map init [xsSimple, xsSimple2]\n | len - length (head plts) == 18 = [xs19, xs19']\n | len - length (head plts) == 35 = [xsFull1, xsFull2]\n | len - length (head plts) == 30 = [xs30', xs30]\n | len - length (head plts) == 29 = [xs29', xs29]\n | len - length (head plts) == 50 = [init xs51]\n | len - length (head plts) == 51 = [xs51]\n | len - length (head plts) == 45 = [xs45]\n | len - length (head plts) == 44 = [xs44, xs44']\n | len - length (head plts) == 106 = [xs106, xs106']\n | len - length (head plts) == 156 = [xs156, xs156']\n | len - length (head plts) == 226 = [xs226]\n | len - length (head plts) == 23 = [xs23]\n | len - length (head plts) == 534 = [xs534]\n | len - length (head plts) == 138 = [xs138]\n | len - length (head plts) == 40 = [xs40]\n | trace (\"len - length (head plts): \" ++ show (len - length (head plts)))len - length (head plts) == 678 = [xs684]\n -- | otherwise = error (\"No mkMiniPrettyPrintElems in Build.hs setup for length: \" ++ show len ++ \"\\nCurrent state: \" ++ show (extractFeatures True st))\n | otherwise = [replicate (len - length (head plts)) 0]\n xsSimple = concat [concat [[ 0, 6, 8, 4, 4, 9, 9]], concat [ concat [[ 2] ]], concat [[ 1]], concat [[ 0, 0, 0, 0, 0, 0]], concat [[ 0, 0, 0, 0, 0, 5, 4]]]\n -- concat [concat [[ 0, 6, 8, 4, 4, 9, 9]], concat [ concat [[ 2], [2],[2] ]], concat [[ 1]], concat [[ 0, 0, 0, 0, 0, 0]], concat [[ 0, 0, 5, 4]]]\n xsSimple2 = concat [concat [[ 0, 0, 7,10,10, 9,14]], concat [ concat [[23] ]], concat [[ 1]], concat [[ 0, 0, 0, 0, 0, 0]], concat [[ 0, 0, 0, 3, 4, 9, 0]]\n -- concat [[ 0, 0, 7,10,10, 9,14]], concat [ concat [[23], [2],[12] ]], concat [[ 1]], concat [[ 0, 0, 0, 0, 0, 0]], concat [[ 0, 0, 9, 0]]\n ]\n xsFull1 = concat [ concat [[ 0, 6, 8, 4, 4, 9, 9]], concat [concat [[ 2, 0, 0, 0, 0, 0, 0, 0]]], concat [[ 1, 0, 0, 0, 0, 0, 0, 0]], concat [[ 2, 0, 0, 0, 0, 0]], concat [[ 0, 0, 0, 0, 5, 4]]]\n xsFull2 = concat [ concat [[ 0, 0, 7, 10, 10, 9, 14]], concat [concat [[ 2, 12, 9, 0, 0, 0, 0, 0]]], concat [[ 1, 0, 0, 0, 0, 0, 0, 0]], concat [[ 0, 0, 0, 0, 0, 0]], concat [[ 0, 0, 3, 4, 9, 0]]]\n xs51 = concat [ concat [[ 0, 0, 0, 0, 0, 0, 0,13]], concat [ concat [[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]],concat [[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], concat [[ 0, 0, 0, 0, 0, 0, 0, 0]],concat [[ 0, 0, 0, 0, 0, 0, 0]]]\n xs45 = concat [ concat [[ 0, 0, 0, 0, 0, 0, 0,15]], concat [ concat [[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]], concat [[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]],concat [[ 0, 0, 0, 0, 0, 0, 0, 0]],concat [[ 0, 0, 0, 0, 0]]]\n xs30 = concat [concat [[ 0, 0, 7,10,10, 9,14]], concat [ concat [[ 0, 0, 0, 0, 0, 4, 6, 0, 0, 0, 0, 0]]], concat [[]], concat [[ 1, 0, 0, 0, 0, 0, 0]], concat [[ 0, 0, 0, 0]]]\n xs30' = concat [concat [[ 0, 0, 7,10,10, 9,14]], concat [ concat [[ 0, 0, 0, 0, 0, 4, 6, 0, 0, 0, 0, 0]]], concat [[]], concat [[ 3, 2, 0, 0, 0, 0, 0]], concat [[ 3, 4, 9, 2]]]\n xs29 = concat [concat [[ 0, 0, 7,10,10, 9,14]], concat [ concat [[ 0, 0, 0, 0, 0, 4, 6, 0, 0, 0, 0, 0]]], concat [[]], concat [[ 1, 0, 0, 0, 0, 0]], concat [[ 0, 0, 0, 0]]]\n xs29' = concat [concat [[ 0, 0, 7,10,10, 9,14]], concat [ concat [[ 0, 0, 0, 0, 0, 4, 6, 0, 0, 0, 0, 0]]], concat [[]], concat [[ 3, 2, 0, 0, 0, 0]], concat [[ 3, 4, 9, 2]]]\n xs19 = concat [concat [[ 0, 0, 7,10,10, 9,14]], concat [ concat [[ 4]]], concat [[]], concat [[ 1, 0, 0, 0, 0, 0]], concat [[ 0, 0, 0, 0]]]\n xs19' = concat [concat [[ 0, 0, 7,10,10, 9,14]], concat [ concat [[ 6 ]]], concat [[]], concat [[ 3, 2, 0, 0, 0, 0]], concat [[ 3, 4, 9, 2]]]\n\n xs44 = concat [ concat [[ 0, 0, 12, 14, 15, 11, 4, 10, 12, 8, 3,13]], concat [ concat [[ 0, 0, 0, 0, 0, 4, 12, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]],[], concat [[ 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], concat [[ 0, 0, 0, 2]]]\n xs44' = concat [ concat [[ 0, 0, 1, 4, 5, 1, 4, 10, 12, 15, 12,13]], concat [ concat [[ 0, 0, 0, 0, 0, 4, 12, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]],[], concat [[ 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], concat [[ 0, 0, 0, 2]]]\n xs156 = concat [ concat [[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7],[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8]],concat [ concat [[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], concat [[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]],concat [[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]],[], concat [[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], concat [[ 0, 0, 0, 0],[ 0, 0, 0, 0]]]\n xs156' = concat [concat [[ 0, 0, 4, 8, 5, 6, 5, 8, 8, 2, 3, 1],[ 0, 0, 0, 0, 0, 0, 0, 4, 7, 3, 5, 2]],concat [ concat [[ 0, 0, 7, 3, 3, 7, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 0, 0, 0, 0, 0]],concat [[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]],concat [[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 7, 3, 3, 6, 5, 3, 2, 0, 0, 0, 0, 0, 0]]],[],concat [[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]],concat [[ 0, 1, 0, 0],[ 0, 0, 0, 5]]]\n\n xs106 = concat [ concat[[ 0, 0, 0, 0, 0, 0, 3],[ 0, 0, 0, 0, 0, 0, 7]],concat [ concat[[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]],concat [[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]],concat [[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]],[],concat [[ 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0]],concat [[ 0, 0, 0, 0],[ 0, 0, 0, 0]]]\n xs106' = concat[ concat [[ 0, 0, 3, 9, 4, 6, 1],[ 0, 0, 0, 0, 0, 0, 2]],concat [ concat [[ 0, 0, 0, 0, 0, 4, 5, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0, 0, 0, 0,11, 2, 0]],concat [[ 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]],concat [[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0]]],[],concat [[ 2, 0, 0, 0, 0, 0],[ 5, 1, 8, 0, 0, 0]],concat [[ 0, 0, 0, 0],[ 0, 0, 0, 0]]]\n\n xs684 :: [Double]\n xs684 = concat [ concat [[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 2],[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 3],[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], concat[ concat [[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]],concat [[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]],concat [[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]],concat [[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]],concat [[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]],concat [[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]],[], concat [[ 0, 0, 0, 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0, 0, 0, 0]],concat [[ 0, 0, 0, 0],[ 0, 0, 0, 0],[ 0, 0, 0, 0],[ 0, 0, 0, 0],[ 0, 0, 0, 0],[ 0, 0, 0, 0]]]\n xs226 :: [Double]\n xs226 = concat [ concat [[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 5],[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 3]], concat [ concat[[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]],concat [[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]],concat [[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]],concat [[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]],concat [[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]],concat [[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]],[],concat [[ 0, 0, 0, 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0, 0, 0, 0]],concat [[ 0, 0, 0, 0],[ 0, 0, 0, 0]]]\n\n xs23 = concat [ concat [[ 0, 0, 0, 0, 0, 0, 6]],concat[concat[[ 0]],concat [[ 0]],concat [[ 0]],concat [[ 0]],concat [[ 0]],concat [[ 0]]],[],concat [[ 0, 0, 0, 0, 0, 0]],concat [[ 0, 0, 0, 0]]]\n xs534 = concat [ concat [[ 0, 0, 0, 0, 0, 0, 1],[ 0, 0, 0, 0, 0, 0, 2],[ 0, 0, 0, 0, 0, 0, 3],[ 0, 0, 0, 0, 0, 0, 1],[ 0, 0, 0, 0, 0, 0, 1],[ 0, 0, 0, 0, 0, 0, 0]], concat [concat [[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]],concat [[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]],concat [[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]],concat [[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]],concat [[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]],concat [[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]],[],concat [[ 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0]],concat [[ 0, 0, 0, 0],[ 0, 0, 0, 0],[ 0, 0, 0, 0],[ 0, 0, 0, 0],[ 0, 0, 0, 0],[ 0, 0, 0, 0]]]\n\n xs138 = concat [concat [[ 0, 0, 0, 2, 3, 1, 1],[ 0, 0, 0, 1, 2, 4, 2],[ 0, 0, 0, 1, 3, 2, 1],[ 0, 0, 0, 0, 1, 3, 3],[ 0, 0, 0, 2, 4, 2, 2],[ 0, 0, 0, 4, 2, 1, 4]],concat [concat [[ 0],[ 0],[ 0],[ 0],[ 0],[ 0]],concat [[ 0],[ 0],[ 0],[ 0],[ 0],[ 0]],concat [[ 0],[ 0],[ 0],[ 0],[ 0],[ 0]],concat [[ 0],[ 0],[ 0],[ 0],[ 0],[ 0]],concat [[ 0],[ 0],[ 0],[ 0],[ 0],[ 0]],concat [[ 0],[ 0],[ 0],[ 0],[ 0],[ 0]]],[],concat [[ 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0]],concat [[ 0, 0, 0, 0],[ 0, 0, 0, 0],[ 0, 0, 0, 0],[ 0, 0, 0, 0],[ 0, 0, 0, 0],[ 0, 0, 0, 0]]]\n\n xs40 = concat [concat [[ 0, 0, 0, 0, 0, 0, 4],[ 0, 0, 0, 0, 0, 0, 7]],concat [ concat [[ 0],[ 0]],concat [[ 0],[ 0]],concat [[ 0],[ 0]]],[],concat [[ 0, 0, 0, 0, 0, 0],[ 0, 0, 0, 0, 0, 0]],concat [[ 0, 0, 0, 0],[ 0, 0, 0, 0]]]\n\n------------------------------------------------------------\n------------------ ExperimentDef instance ------------------\n------------------------------------------------------------\n\nsave :: BORL St Act -> IO ()\nsave borl = do\n res <- toSerialisableWith serializeSt id borl\n B.writeFile \"saved.bin\" (runPut $ put res)\n\nload :: IO (Maybe (BORL St Act))\nload = do\n bs <- liftIO $ B.readFile \"saved.bin\"\n case trace (\"S.runGet\") S.runGet S.get bs of\n Left err -> putStrLn (\"Could not deserialize to Serializable BORL. Error: \" ++ err) >> return Nothing\n Right ser -> trace (\"ser\") $ do\n borl <- buildBORLGrenade\n let (St sim _ _ _) = borl ^. s\n Just <$> fromSerialisableWith (deserializeSt (simRelease sim) (simDispatch sim) (simShipment sim) (simProcessingTimes $ simInternal sim)) id action (borl ^. B.actionFilter) netInp ser\n\n\ninstance ExperimentDef (BORL St Act) where\n type ExpM (BORL St Act) = IO\n type Serializable (BORL St Act) = BORLSerialisable StSerialisable Act\n serialisable = do\n res <- toSerialisableWith serializeSt id\n return res\n deserialisable ser =\n unsafePerformIO $ do\n borl <- buildBORLGrenade\n let (St sim _ _ _) = borl ^. s\n return $\n fromSerialisableWith\n (deserializeSt (simRelease sim) (simDispatch sim) (simShipment sim) (simProcessingTimes $ simInternal sim))\n id\n action\n (borl ^. B.actionFilter)\n netInp\n ser\n type InputValue (BORL St Act) = [Order]\n type InputState (BORL St Act) = ()\n -- ^ Generate some input values and possibly modify state. This function can be used to change the state. It is called\n -- before `runStep` and its output is used to call `runStep`.\n generateInput !_ !borl !_ !_ = do\n let !(St !_ !inc !_ !_) = borl ^. s\n return (inc, ())\n -- ^ Run a step of the environment and return new state and result.\n -- runStep :: (MonadIO m) => a -> InputValue a -> E.Period -> m ([StepResult], a)\n runStep !phase !borl !incOrds !_ = do\n !borl' <- stepM (set (s . nextIncomingOrders) incOrds borl)\n -- helpers\n when (borl ^. t `mod` 10000 == 0) $ liftIO $ prettyBORLMWithStInverse (Just $ mInverse borl) (setStPrettyPrintElems borl) >>= print\n let !simT = timeToDouble $ simCurrentTime $ borl' ^. s . simulation\n let !borlT = borl' ^. t\n -- demand\n let !demand = StepResult \"demand\" (Just simT) (fromIntegral $ length $ borl ^. s . nextIncomingOrders)\n -- cost related measures\n let (StatsOrderCost !earnOld !wipOld !boOld !fgiOld) = simStatsOrderCosts $ simStatistics (borl ^. s . simulation)\n let (StatsOrderCost !earn !wip !bo !fgi) = simStatsOrderCosts $ simStatistics (borl' ^. s . simulation)\n let !cEarn = StepResult \"EARN\" (Just simT) (fromIntegral (earn - earnOld))\n let !cBoc = StepResult \"BOC\" (Just simT) (boCosts costConfig * fromIntegral (bo - boOld))\n let !cWip = StepResult \"WIPC\" (Just simT) (wipCosts costConfig * fromIntegral (wip - wipOld))\n let !cFgi = StepResult \"FGIC\" (Just simT) (fgiCosts costConfig * fromIntegral (fgi - fgiOld))\n let !cSum = StepResult \"SUMC\" (Just simT) (cBoc ^. resultYValue + cWip ^. resultYValue + cFgi ^. resultYValue)\n let !curOp = StepResult \"op\" (Just simT) (fromIntegral $ length $ simOrdersOrderPool $ borl' ^. s . simulation)\n let !curWip = StepResult \"wip\" (Just simT) (fromIntegral $ wip - wipOld)\n let !curBo = StepResult \"bo\" (Just simT) (fromIntegral $ bo - boOld)\n let !curFgi = StepResult \"fgi\" (Just simT) (fromIntegral $ fgi - fgiOld)\n -- time related measures\n let (StatsFlowTime !ftNrFloorAndFgi !(StatsOrderTime !sumTimeFloorAndFgi !stdDevFloorAndFgi !_) !mTardFloorAndFgi) = simStatsShopFloorAndFgi $ simStatistics (borl' ^. s . simulation)\n let !tFtMeanFloorAndFgi = StepResult \"FTMeanFloorAndFgi\" (Just simT) (fromRational sumTimeFloorAndFgi / fromIntegral ftNrFloorAndFgi)\n let !tFtStdDevFloorAndFgi = StepResult \"FTStdDevFloorAndFgi\" (Just simT) (maybe 0 fromRational $ getWelfordStdDev stdDevFloorAndFgi)\n let !tTardPctFloorAndFgi = StepResult \"TARDPctFloorAndFgi\" (Just simT) (maybe 0 (\\(StatsOrderTard nrTard sumTard stdDevTard) -> fromIntegral nrTard / fromIntegral ftNrFloorAndFgi) mTardFloorAndFgi)\n let !tTardMeanFloorAndFgi = StepResult \"TARDMeanFloorAndFGI\" (Just simT) (maybe 0 (\\(StatsOrderTard nrTard sumTard stdDevTard) -> fromRational sumTard / fromIntegral nrTard) mTardFloorAndFgi)\n let !tTardStdDevFloorAndFgi = StepResult \"TARDStdDevFloorAndFGI\" (Just simT) (maybe 0 (\\(StatsOrderTard nrTard sumTard stdDevTard) -> maybe 0 fromRational $ getWelfordStdDev stdDevTard) mTardFloorAndFgi)\n let !(StatsFlowTime !ftNrFloor !(StatsOrderTime !sumTimeFloor !stdDevFloor !_) !mTardFloor) = simStatsShopFloor $ simStatistics (borl' ^. s . simulation)\n let !tFtMeanFloor = StepResult \"FTMeanFloor\" (Just simT) (fromRational sumTimeFloor / fromIntegral ftNrFloor)\n let !tFtStdDevFloor = StepResult \"FTStdDevFloor\" (Just simT) (maybe 0 fromRational $ getWelfordStdDev stdDevFloor)\n let !tTardPctFloor = StepResult \"TARDPctFloor\" (Just simT) (maybe 0 (\\(StatsOrderTard nrTard sumTard stdDevTard) -> fromIntegral nrTard / fromIntegral ftNrFloor) mTardFloor)\n let !tTardMeanFloor = StepResult \"TARDMeanFloor\" (Just simT) (maybe 0 (\\(StatsOrderTard nrTard sumTard stdDevTard) -> fromRational sumTard / fromIntegral nrTard) mTardFloor)\n let !tTardStdDevFloor = StepResult \"TARDStdDevFloor\" (Just simT) (maybe 0 (\\(StatsOrderTard nrTard sumTard stdDevTard) -> maybe 0 fromRational $ getWelfordStdDev stdDevTard) mTardFloor)\n -- BORL' related measures\n let valS !l = realToFrac (borl' ^?! l)\n valV !l = realToFrac $ head $ fromValue (borl' ^?! l)\n valL !l = realToFrac $ V.head $ borl' ^?! l\n let !avgRew = StepResult \"AvgReward\" (Just $ fromIntegral borlT) (valL $ proxies . rho . proxyScalar)\n !expAvgRew = StepResult \"ExpAvgReward\" (Just $ fromIntegral borlT) (valS $ expSmoothedReward)\n !avgRewMin = StepResult \"MinAvgReward\" (Just $ fromIntegral borlT) (valL $ proxies . rhoMinimum . proxyScalar)\n !pltP1 = StepResult \"PLT P1\" (Just $ fromIntegral borlT) (timeToDouble $ M.findWithDefault 0 (Product 1) (borl' ^. s . plannedLeadTimes))\n !pltP2 = StepResult \"PLT P2\" (Just $ fromIntegral borlT) (timeToDouble $ M.findWithDefault 0 (Product 2) (borl' ^. s . plannedLeadTimes))\n !psiRho = StepResult \"PsiRho\" (Just $ fromIntegral borlT) (valV $ psis . _1)\n !psiV = StepResult \"PsiV\" (Just $ fromIntegral borlT) (valV $ psis . _2)\n !psiW = StepResult \"PsiW\" (Just $ fromIntegral borlT) (valV $ psis . _3)\n !vAvg = StepResult \"VAvg\" (Just $ fromIntegral borlT) (avg $ V.toList $ borl' ^. lastRewards)\n !reward = StepResult \"Reward\" (Just $ fromIntegral borlT) (realToFrac $ headWithDefault 0 $ borl' ^. lastRewards)\n avg !xs = realToFrac $ sum xs / fromIntegral (length xs)\n headWithDefault d vec = fromMaybe d $ vec V.!? 0\n return $! force $\n if phase /= EvaluationPhase\n then ([\n -- avgRew\n -- , avgRewMin\n -- , expAvgRew\n -- -- , vAvg\n -- , reward\n\n ], borl')\n\n else\n ( [-- cost related measures\n cSum\n , cEarn\n , cBoc\n , cWip\n , cFgi\n -- floor\n , curOp\n , curWip\n , curBo\n , curFgi\n , demand\n -- time related measures\n , tFtMeanFloorAndFgi\n , tFtStdDevFloorAndFgi\n , tTardPctFloorAndFgi\n , tTardMeanFloorAndFgi\n , tTardStdDevFloorAndFgi\n , tFtMeanFloor\n , tFtStdDevFloor\n , tTardPctFloor\n , tTardMeanFloor\n , tTardStdDevFloor\n -- BORL related measures\n , avgRew\n -- , avgRewMin\n -- , expAvgRew\n -- , pltP1\n -- , pltP2\n -- , psiRho\n -- , psiV\n -- , psiW\n -- , vAvg\n -- , reward\n ]\n , borl')\n -- ^ Provides the parameter setting.\n -- parameters :: a -> [ParameterSetup a]\n parameters borl =\n [ ParameterSetup\n \"Algorithm\"\n (set algorithm)\n (view algorithm)\n (Just $ return .\n const\n [\n AlgDQNAvgRewAdjusted 0.8 1.0 ByStateValues\n , AlgDQNAvgRewAdjusted 0.8 0.99 ByStateValues\n , AlgDQN 0.99 Exact\n ])\n Nothing\n Nothing\n Nothing\n , ParameterSetup\n \"RewardType\"\n (set (s . rewardFunctionOrders))\n (view (s . rewardFunctionOrders))\n (Just $ return .\n const\n [\n -- RewardPeriodEndSimple (ConfigRewardCosts (Just 750))\n RewardPeriodEndSimple (ConfigRewardCosts (Just 200))\n ])\n Nothing\n Nothing\n Nothing\n , ParameterSetup\n \"ReleaseAlgorithm\"\n (\\r -> over (s . simulation) (\\sim -> sim {simRelease = r}))\n (simRelease . view (s . simulation))\n (Just . const . return $\n ([ mkReleasePLT initialPLTS\n -- , releaseImmediate\n -- , releaseBIL (M.fromList [(Product 1, 6), (Product 2, 6)])\n -- , releaseBIL (M.fromList [(Product 1, 5), (Product 2, 5)])\n -- , releaseBIL (M.fromList [(Product 1, 4), (Product 2, 4)])\n -- , releaseBIL (M.fromList [(Product 1, 3), (Product 2, 3)])\n -- , releaseBIL (M.fromList [(Product 1, 2), (Product 2, 2)])\n -- , releaseBIL (M.fromList [(Product 1, 1), (Product 2, 1)])\n ] ++\n map (\\lts -> releaseBIL (M.fromList (map (\\pt -> (pt, lts)) productTypes))) [1..4]\n ))\n Nothing\n (Just (\\x -> uniqueReleaseName x /= pltReleaseName)) -- drop preparation phase for all release algorithms but the BORL releaser\n (Just\n (\\x ->\n if uniqueReleaseName x == pltReleaseName\n then FullFactory\n else SingleInstance -- only evaluate once if ImRe or BIL\n ))\n ] ++\n -- [ ParameterSetup\n -- \"Xi (at period 0)\"\n -- (set (B.parameters . xi))\n -- (^. B.parameters . xi)\n -- (Just $ return . const [5e-3])\n -- Nothing Nothing Nothing\n -- ] ++\n -- [ ParameterSetup\n -- \"Zeta (at period 0)\"\n -- (set (B.parameters . zeta))\n -- (^. B.parameters . zeta)\n -- (Just $ return . const [0.10])\n -- Nothing Nothing Nothing\n -- ] ++\n [ ParameterSetup\n \"Alpha (at period 0)\"\n (set (B.parameters . alpha))\n (^. B.parameters . alpha)\n (Just $ return . const [0.01])\n Nothing Nothing Nothing\n ] ++\n [ ParameterSetup\n \"AlphaRhoMin (at period 0)\"\n (set (B.parameters . alphaRhoMin))\n (^. B.parameters . alphaRhoMin)\n (Just $ return . const [2e-5])\n Nothing Nothing Nothing\n ] ++\n [ ParameterSetup\n \"Delta (at period 0)\"\n (set (B.parameters . delta))\n (^. B.parameters . delta)\n (Just $ return . const [0.005])\n Nothing Nothing Nothing\n ] ++\n [ ParameterSetup\n \"Gamma (at period 0)\"\n (set (B.parameters . gamma))\n (^. B.parameters . gamma)\n (Just $ return . const [0.01])\n Nothing Nothing Nothing\n ] ++\n [ ParameterSetup\n \"Epsilon (at period 0)\"\n (set (B.parameters . epsilon))\n (^. B.parameters . epsilon)\n (Just $ return . const [fromList [0.25, 0.25]])\n Nothing Nothing Nothing\n ] ++\n [ ParameterSetup\n \"Exploration (at period 0)\"\n (set (B.parameters . exploration))\n (^. B.parameters . exploration)\n (Just $ return . const [1.0])\n Nothing Nothing Nothing\n ] ++\n [ ParameterSetup\n \"Learn Random Above (faster converging rho)\"\n (set (B.parameters . learnRandomAbove))\n (^. B.parameters . learnRandomAbove)\n (Just $ return . const [0.5])\n Nothing Nothing Nothing\n ] ++\n [ ParameterSetup\n \"Decay Alpha\"\n (set (B.decaySetting . alpha))\n (^. B.decaySetting . alpha)\n (Just $ return . const [ExponentialDecay (Just 5e-5) 0.25 50000])\n Nothing Nothing Nothing\n ] ++\n [ ParameterSetup\n \"Decay AlphaRhoMin\"\n (set (B.decaySetting . alphaRhoMin))\n (^. B.decaySetting . alphaRhoMin)\n (Just $ return . const [ExponentialDecay (Just 2e-5) 0.25 50000])\n Nothing Nothing Nothing\n ] ++\n [ ParameterSetup\n \"Decay Delta\"\n (set (B.decaySetting . delta))\n (^. B.decaySetting . delta)\n (Just $ return . const [ExponentialDecay (Just 5e-4) 0.25 100000])\n Nothing Nothing Nothing\n ] ++\n [ ParameterSetup\n \"Decay Gamma\"\n (set (B.decaySetting . gamma))\n (^. B.decaySetting . gamma)\n (Just $ return . const [ExponentialDecay (Just 1e-3) 0.25 100000])\n Nothing Nothing Nothing\n ] ++\n [ ParameterSetup\n \"Decay Epsilon\"\n (set (B.decaySetting . epsilon))\n (^. B.decaySetting . epsilon)\n (Just $ return . const [fromList [NoDecay]])\n Nothing Nothing Nothing\n ] ++\n [ ParameterSetup\n \"Decay Exploration\"\n (set (B.decaySetting . exploration))\n (^. B.decaySetting . exploration)\n (Just $ return . const [ExponentialDecay (Just 0.005) 0.25 100000])\n Nothing Nothing Nothing\n ] ++\n -- Cannot be changed here!!!\n -- [ ParameterSetup\n -- \"Replay Memory Size\" Cannot be changed here as initialised!!!\n -- (setAllProxies (proxyNNConfig . replayMemoryMaxSize))\n -- (^?! proxies . v . proxyNNConfig . replayMemoryMaxSize)\n -- (Just $ return . const [10000])\n -- Nothing\n -- Nothing\n -- Nothing\n -- | isNN\n -- ] ++\n -- [ ParameterSetup\n -- \"Replay Memory Strategy\" Cannot be changed here as initialised!!!!!!\n -- (setAllProxies (proxyNNConfig . replayMemoryStrategy))\n -- (^?! proxies . v . proxyNNConfig . replayMemoryStrategy)\n -- (Just $ return . const [ReplayMemoryPerAction])\n -- Nothing\n -- Nothing\n -- Nothing\n -- | isNN\n -- ] ++\n [ ParameterSetup\n \"Training Batch Size\"\n (setAllProxies (proxyNNConfig . trainBatchSize))\n (^?! proxies . v . proxyNNConfig . trainBatchSize)\n (Just $ return . const [4])\n Nothing\n Nothing\n Nothing\n | isNN\n ] ++\n [ ParameterSetup\n \"Training Iterations\"\n (setAllProxies (proxyNNConfig . trainingIterations))\n (^?! proxies . v . proxyNNConfig . trainingIterations)\n (Just $ return . const [1])\n Nothing\n Nothing\n Nothing\n | isNN\n ] ++\n [ ParameterSetup\n \"ANN (Grenade) Learning Rate\"\n (setAllProxies (proxyNNConfig . grenadeLearningParams))\n (^?! proxies . v . proxyNNConfig . grenadeLearningParams)\n (Just $ return . const [OptAdam 0.005 0.9 0.999 1e-8 1e-3 -- , OptAdam 0.0001 0.9 0.999 1e-8 1e-3\n ])\n Nothing\n Nothing\n Nothing\n | isNN\n ] ++\n [ ParameterSetup\n \"ANN Learning Rate Decay\"\n (setAllProxies (proxyNNConfig . learningParamsDecay))\n (^?! proxies . v . proxyNNConfig . learningParamsDecay)\n (Just $ return . const [ ExponentialDecay (Just 5e-6) (configDecayRate decay) (configDecaySteps decay)])\n Nothing\n Nothing\n Nothing\n | isNN\n ] ++\n [ ParameterSetup\n \"Grenade Smooth Target Update\"\n (setAllProxies (proxyNNConfig . grenadeSmoothTargetUpdate))\n (^?! proxies . v . proxyNNConfig . grenadeSmoothTargetUpdate)\n (Just $ return . const [0.01])\n Nothing\n Nothing\n Nothing\n | isNN\n ] ++\n [ ParameterSetup\n \"Grenade Smooth Target Update Period\"\n (setAllProxies (proxyNNConfig . grenadeSmoothTargetUpdatePeriod))\n (^?! proxies . v . proxyNNConfig . grenadeSmoothTargetUpdatePeriod)\n (Just $ return . const [100])\n Nothing\n Nothing\n Nothing\n | isNN\n ] ++\n [ ParameterSetup\n \"ScaleParameters\"\n (setAllProxies (proxyNNConfig . scaleParameters))\n (^?! proxies . v . proxyNNConfig . scaleParameters)\n (Just $ return . const [ScalingNetOutParameters (-800) 800 (-300) 300 (-400) 800 (-400) 800])\n Nothing\n Nothing\n Nothing\n | isNN\n ] ++\n [ ParameterSetup\n \"Scaling Out Setup\"\n (setAllProxies (proxyNNConfig . scaleOutputAlgorithm))\n (^?! proxies . v . proxyNNConfig . scaleOutputAlgorithm)\n (Just $ return . const [ScaleMinMax])\n Nothing\n Nothing\n Nothing\n | isNN\n ] ++\n [ ParameterSetup\n \"Grenade Dropout Layers Flip-Active Periods\"\n (setAllProxies (proxyNNConfig . grenadeDropoutFlipActivePeriod))\n (^?! proxies . v . proxyNNConfig . grenadeDropoutFlipActivePeriod)\n (Just $ return . const [10^5])\n Nothing\n Nothing\n Nothing\n | isNN\n ] ++\n [ ParameterSetup\n \"Grenade Dropout Only-Active After Period\"\n (setAllProxies (proxyNNConfig . grenadeDropoutFlipActivePeriod))\n (^?! proxies . v . proxyNNConfig . grenadeDropoutFlipActivePeriod)\n (Just $ return . const [0])\n Nothing\n Nothing\n Nothing\n | isNN\n ] ++\n [ ParameterSetup\n \"Gradient clipping\"\n (setAllProxies (proxyNNConfig . clipGradients))\n (^?! proxies . v . proxyNNConfig . clipGradients)\n (Just $ return . const [NoClipping])\n Nothing\n Nothing\n Nothing\n | isNN\n ] ++\n [ ParameterSetup\n \"NStep\"\n (set (settings . nStep))\n (^. settings . nStep)\n (Just $ return . const [5])\n Nothing\n Nothing\n Nothing\n | isNN\n ] ++\n [ ParameterSetup\n \"Exploration Strategy\"\n (set (settings . explorationStrategy))\n (^. settings . explorationStrategy)\n (Just $ return . const [EpsilonGreedy])\n Nothing\n Nothing\n Nothing\n | isNN\n ] ++\n [ ParameterSetup\n \"Workers Min Exploration\"\n (set (settings . workersMinExploration))\n (^. settings . workersMinExploration)\n (Just $ return . const [take 8 $ 0.01 : 0.02 : 0.03 : 0.04 : [0.05, 0.10 .. 1.0]])\n Nothing\n Nothing\n Nothing\n | isNN\n ] ++\n [ ParameterSetup\n \"Independent Agents Share Rhos\"\n (set (settings . independentAgentsSharedRho))\n (^. settings . independentAgentsSharedRho)\n (Just $ return . const [True])\n Nothing\n Nothing\n Nothing\n ] ++\n [ ParameterSetup\n \"Overestimate Rho\"\n (set (settings . overEstimateRho))\n (^. settings . overEstimateRho)\n (Just $ return . const [False])\n Nothing\n Nothing\n Nothing\n ] ++\n [ ParameterSetup\n \"Main Agent Selects Greedy Actions\"\n (set (settings . mainAgentSelectsGreedyActions))\n (^. settings . mainAgentSelectsGreedyActions)\n (Just $ return . const [False])\n Nothing\n Nothing\n Nothing\n ]\n where\n isNN = isNeuralNetwork (borl ^. proxies . v)\n -- HOOKS\n -- beforePreparationHook _ _ g borl =\n -- liftIO $ do\n -- let dir = \"results/\" <> T.unpack (T.replace \" \" \"_\" experimentName) <> \"/data/\"\n -- createDirectoryIfMissing True dir\n -- writeFile (dir ++ \"plot.sh\") gnuplot\n -- mapMOf (s . simulation) (setSimulationRandomGen g) borl\n beforeWarmUpHook _ _ _ g borl = liftIO $ mapMOf (s . simulation) (fmap resetStatistics . setSimulationRandomGen g) $ set (B.parameters . exploration) 0.00 $ set (B.settings . disableAllLearning) True borl\n beforeEvaluationHook _ _ _ g borl = liftIO $\n\n mapMOf (s . simulation) (fmap resetStatistics . setSimulationRandomGen g) $ set (B.parameters . exploration) 0.00 $ set (B.settings . disableAllLearning) True borl\n -- afterPreparationHook _ expNr repetNr = liftIO $ copyFiles \"prep_\" expNr repetNr Nothing\n -- afterWarmUpHook _ expNr repetNr repliNr = liftIO $ copyFiles \"warmup_\" expNr repetNr (Just repliNr)\n -- afterEvaluationHook _ expNr repetNr repliNr = liftIO $ copyFiles \"eval_\" expNr repetNr (Just repliNr)\n\nsetStPrettyPrintElems :: BORL St Act -> BORL St Act\nsetStPrettyPrintElems borl = setAllProxies (proxyNNConfig . prettyPrintElems) [netInp $ borl ^. s] borl\n\nexpSetting :: BORL St Act -> ExperimentSetting\nexpSetting borl =\n ExperimentSetting\n { _experimentBaseName = experimentName\n , _experimentInfoParameters = [actBounds, pltBounds, csts, dem, ftExtr, rout, procT, isNN] ++ concat [[repMemSize, repMemStrat, nnSetup] | isNNFlag]\n , _experimentRepetitions = 1\n , _preparationSteps = 300000\n , _evaluationWarmUpSteps = 1000\n , _evaluationSteps = 7000\n , _evaluationReplications = 30\n , _evaluationMaxStepsBetweenSaves = Just 6000\n }\n where\n isNNFlag = isNeuralNetwork (borl ^. proxies . v)\n isNN = ExperimentInfoParameter \"Is Neural Network\" isNNFlag\n -- dec = ExperimentInfoParameter \"Decay\" (configDecayName decay) -- decay is not used in experiment\n actBounds = ExperimentInfoParameter \"Action Bounds\" (configActLower actionConfig, configActUpper actionConfig)\n pltBounds = ExperimentInfoParameter \"Action Filter (Min/Max PLT)\" (configActFilterMin actionFilterConfig, configActFilterMax actionFilterConfig)\n csts = ExperimentInfoParameter \"Costs\" costConfig\n dem = ExperimentInfoParameter \"Demand\" (configDemandName demand)\n ftExtr = ExperimentInfoParameter \"Feature Extractor (State Representation)\" (configFeatureExtractorName $ featureExtractor True)\n rout = ExperimentInfoParameter \"Routing (Simulation Setup)\" (configRoutingName routing)\n procT = ExperimentInfoParameter \"Processing Time (Simulation Setup)\" (configProcTimesName procTimes)\n repMemSize = ExperimentInfoParameter \"Replay Memory Size\" (borl ^?! proxies . v . proxyNNConfig . replayMemoryMaxSize)\n repMemStrat = ExperimentInfoParameter \"Replay Memory Strategy\" (borl ^?! proxies . v . proxyNNConfig . replayMemoryStrategy)\n nnSetup = ExperimentInfoParameter \"ANN Architecture\" (netSpec $ borl ^?! proxies . v)\n netSpec px = case px of\n Grenade t _ _ _ _ _ -> T.replace \"Spec\" \"\" $ T.replace \",1,1)\" \")\" $ T.replace \"SpecRelu \" \"Relu\" $ T.replace \"SpecFullyConnected\" \"FC\" $ tshow (networkToSpecification t)\n CombinedProxy s _ _ -> netSpec s\n _ -> (\"\" :: T.Text)\n", "meta": {"hexsha": "5f7763c3b1fafdfece44a37055405d5bb08c3c0b", "size": 46281, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/Releaser/Build.hs", "max_stars_repo_name": "schnecki/borl-releaser", "max_stars_repo_head_hexsha": "8ab5c4d73456daa3f26628315ad7a562b25e42d8", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/Releaser/Build.hs", "max_issues_repo_name": "schnecki/borl-releaser", "max_issues_repo_head_hexsha": "8ab5c4d73456daa3f26628315ad7a562b25e42d8", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/Releaser/Build.hs", "max_forks_repo_name": "schnecki/borl-releaser", "max_forks_repo_head_hexsha": "8ab5c4d73456daa3f26628315ad7a562b25e42d8", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 52.8925714286, "max_line_length": 2258, "alphanum_fraction": 0.5566215077, "num_tokens": 18544, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.7025300573952054, "lm_q2_score": 0.4301473485858429, "lm_q1q2_score": 0.3021914414904076}} {"text": "{-# LANGUAGE DataKinds #-}\nmodule CannyEdgeIllusoryContour where\n\nimport Control.Monad as M\nimport Control.Monad.IO.Class\nimport Data.Array.Repa as R\nimport Data.Array.Unboxed as AU\nimport Data.Binary\nimport Data.ByteString as BS\nimport Data.Complex\nimport Data.List as L\nimport DFT.Plan\nimport FokkerPlanck.DomainChange\nimport FokkerPlanck.MonteCarlo\nimport FokkerPlanck.Pinwheel\nimport GHC.Word\nimport Image.IO\nimport Image.Transform\nimport Linear.V2\nimport OpenCV as CV hiding (Z)\nimport STC\nimport System.Directory\nimport System.Environment\nimport System.FilePath\nimport Text.Printf\nimport Types\nimport Utils.Array\nimport Utils.Parallel hiding ((.|))\nimport Utils.Time\n\n\nmain = do\n args <- getArgs\n let (numPointStr:numOrientationStr:numScaleStr:thetaSigmaStr:scaleSigmaStr:maxScaleStr:taoStr:numTrailStr:maxTrailStr:theta0FreqsStr:thetaFreqsStr:scale0FreqsStr:scaleFreqsStr:histFileName:histFileNameEndPoint:numIterationStr:numIterationEndPointStr:writeSourceFlagStr:cutoffRadiusEndPointStr:cutoffRadiusStr:reversalFactorStr:inputImgPath:threshold1Str:threshold2Str:writeSegmentsFlagStr:writeEndPointFlagStr:minSegLenStr:useFFTWWisdomFlagStr:fftwWisdomFileName:numThreadStr:_) =\n args\n numPoint = read numPointStr :: Int\n numOrientation = read numOrientationStr :: Int\n numScale = read numScaleStr :: Int\n thetaSigma = read thetaSigmaStr :: Double\n scaleSigma = read scaleSigmaStr :: Double\n maxScale = read maxScaleStr :: Double\n tao = read taoStr :: Double\n numTrail = read numTrailStr :: Int\n maxTrail = read maxTrailStr :: Int\n theta0Freq = read theta0FreqsStr :: Double\n theta0Freqs = [-theta0Freq .. theta0Freq]\n thetaFreq = read thetaFreqsStr :: Double\n thetaFreqs = [-thetaFreq .. thetaFreq]\n scale0Freq = read scale0FreqsStr :: Double\n scaleFreq = read scaleFreqsStr :: Double\n scale0Freqs = [-scale0Freq .. scale0Freq]\n scaleFreqs = [-scaleFreq .. scaleFreq]\n numIteration = read numIterationStr :: Int\n numIterationEndPoint = read numIterationEndPointStr :: Int\n writeSourceFlag = read writeSourceFlagStr :: Bool\n cutoffRadiusEndPoint = read cutoffRadiusEndPointStr :: Int\n cutoffRadius = read cutoffRadiusStr :: Int\n reversalFactor = read reversalFactorStr :: Double\n threshold1 = read threshold1Str :: Double\n threshold2 = read threshold2Str :: Double\n minSegLen = read minSegLenStr :: Int\n writeSegmentsFlag = read writeSegmentsFlagStr :: Bool\n writeEndPointFlag = read writeEndPointFlagStr :: Bool\n minimumPixelDist = 1 :: Int\n useFFTWWisdomFlag = read useFFTWWisdomFlagStr :: Bool\n numThread = read numThreadStr :: Int\n folderPath = \"output/test/CannyEdgeIllusoryContour\"\n histFilePath = folderPath histFileName\n histFilePathEndPoint = folderPath histFileNameEndPoint\n edgeFilePath = folderPath (takeBaseName inputImgPath L.++ \"_edge.png\")\n segmentsFilePath =\n folderPath (takeBaseName inputImgPath L.++ \"_segments.dat\")\n endPointFilePath =\n folderPath \n (printf\n \"%s_EndPoint_%d_%d_%d_%d_%.2f_%f.dat\"\n (takeBaseName inputImgPath)\n (numPoint * minimumPixelDist)\n (round thetaFreq :: Int)\n (round tao :: Int)\n cutoffRadiusEndPoint\n thetaSigma\n reversalFactor)\n fftwWisdomFilePath = folderPath fftwWisdomFileName\n createDirectoryIfMissing True folderPath\n copyFile inputImgPath (folderPath takeFileName inputImgPath)\n -- Find edges using Canny dege detector (Opencv)\n img <-\n (exceptError . coerceMat . imdecode ImreadUnchanged) <$>\n BS.readFile inputImgPath :: IO (Mat ('S '[ 'D, 'D]) 'D ('S GHC.Word.Word8))\n let [cols, rows] = miShape . matInfo $ img\n n = numPoint - cutoffRadiusEndPoint - 1 -- make sure that there is a zero wrap\n (w, h) =\n if rows > cols\n then ( n\n , round $ fromIntegral cols * fromIntegral n / fromIntegral rows)\n else ( round $ fromIntegral rows * fromIntegral n / fromIntegral cols\n , n)\n resizedImg =\n exceptError .\n resize\n (ResizeAbs . toSize $ V2 (fromIntegral w) (fromIntegral h))\n InterCubic $\n img\n edge =\n exceptError . canny threshold1 threshold2 (Just 3) CannyNormL2 $\n resizedImg\n edgeRepa =\n pad [numPoint, numPoint, 1] 0 .\n normalizeValueRange (0, 1) . R.map fromIntegral . toRepa $\n edge\n plotImageRepa edgeFilePath . ImageRepa 8 . computeS $ edgeRepa\n edgeRepa <- (\\(ImageRepa _ img) -> img) <$> readImageRepa edgeFilePath False\n doesEndPointFileExist <- doesFileExist endPointFilePath\n endPointArray <-\n if doesEndPointFileExist && (not writeEndPointFlag)\n then do\n printCurrentTime \"Read endpoint from file.\"\n readRepaArray endPointFilePath\n else do\n printCurrentTime \"Start computing endpoint...\"\n -- find segments for normalization:\n -- two adjacent non-zero-valued points are connected\n patchNormMethod <-\n if writeSegmentsFlag\n then do\n printCurrentTime \"Start computing segments...\"\n let nonzerorPoints =\n createIndex2D .\n L.map fst . L.filter (\\(_, v) -> v /= 0) . AU.assocs $\n (AU.listArray ((0, 0), (numPoint - 1, numPoint - 1)) .\n R.toList $\n edgeRepa :: AU.Array (Int, Int) Double)\n segments =\n L.map\n (L.map\n (\\(a, b) ->\n (a * minimumPixelDist, b * minimumPixelDist))) .\n L.filter (\\xs -> L.length xs >= minSegLen) .\n pointCluster\n (connectionMatrixP\n (ParallelParams numThread 1)\n 1\n nonzerorPoints) $\n nonzerorPoints\n encodeFile segmentsFilePath segments\n removePathForcibly (folderPath \"segments\")\n createDirectoryIfMissing True (folderPath \"segments\")\n M.zipWithM_\n (\\i ->\n plotImageRepa\n (folderPath \"segments\" (printf \"Cluster%03d.png\" i)) .\n ImageRepa 8)\n [1 :: Int ..] .\n cluster2Array\n (numPoint * minimumPixelDist)\n (numPoint * minimumPixelDist) $\n segments\n printCurrentTime \"Done computing segments.\"\n return . PowerMethodConnection $ segments\n else do\n printCurrentTime \"Read segments from files.\"\n PowerMethodConnection <$> decodeFile segmentsFilePath\n -- Compute the Green's function\n let numPointEndPoint = minimumPixelDist * numPoint\n maxScaleEndPoint = 1.00000000001\n flag <- doesFileExist histFilePathEndPoint\n radialArr <-\n if flag\n then do\n printCurrentTime \"Read endpoint filter histogram from files.\"\n R.map magnitude . getNormalizedHistogramArr <$>\n decodeFile histFilePathEndPoint\n else do\n printCurrentTime\n \"Couldn't find a Green's function data. Start simulation...\"\n solveMonteCarloR2Z2T0S0Radial\n numThread\n numTrail\n maxTrail\n numPointEndPoint\n numPointEndPoint\n thetaSigma\n 0.0\n maxScaleEndPoint\n tao\n theta0Freqs\n thetaFreqs\n [0]\n [0]\n histFilePathEndPoint\n (emptyHistogram\n [ (round . sqrt . fromIntegral $\n 2 * (div numPointEndPoint 2) ^ 2)\n , 1\n , L.length theta0Freqs\n , 1\n , L.length thetaFreqs\n ]\n 0)\n arrR2Z2T0S0 <-\n computeUnboxedP $\n computeR2Z2T0S0ArrayRadial\n (pinwheelHollowNonzeronCenter 12)\n (cutoff cutoffRadiusEndPoint radialArr)\n numPointEndPoint\n numPointEndPoint\n 1\n maxScaleEndPoint\n thetaFreqs\n [0]\n theta0Freqs\n [0]\n plan <-\n makeR2Z2T0S0Plan\n emptyPlan\n useFFTWWisdomFlag\n fftwWisdomFilePath\n arrR2Z2T0S0\n -- Compute initial eigenvector and bias\n -- increase the distance between pixels to aovid aliasing\n let resizedEdgeRepa =\n R.traverse\n edgeRepa\n (const (Z :. numPointEndPoint :. numPointEndPoint)) $ \\f (Z :. i :. j) ->\n if mod i minimumPixelDist == 0 && mod j minimumPixelDist == 0\n then f (Z :. (0 :: Int) :. (div i minimumPixelDist) :.\n (div j minimumPixelDist))\n else 0\n bias =\n computeBiasR2T0S0FromRepa\n numPointEndPoint\n numPointEndPoint\n (L.length theta0Freqs)\n 1\n resizedEdgeRepa\n eigenVec =\n computeInitialEigenVectorR2T0S0FromRepa\n numPointEndPoint\n numPointEndPoint\n (L.length theta0Freqs)\n 1\n (L.length thetaFreqs)\n 1\n resizedEdgeRepa\n plotImageRepa\n (folderPath takeBaseName inputImgPath L.++ \"_resizedEdge.png\") .\n ImageRepa 8 . computeS . extend (Z :. (1 :: Int) :. All :. All) $\n resizedEdgeRepa\n endPointSource <-\n computeS . R.zipWith (*) bias <$>\n powerMethodR2Z2T0S0Reversal\n plan\n folderPath\n numPointEndPoint\n numPointEndPoint\n numOrientation\n thetaFreqs\n theta0Freqs\n 1\n [0]\n [0]\n 0\n arrR2Z2T0S0\n patchNormMethod\n numIterationEndPoint\n writeSourceFlag\n (printf\n \"_%d_%d_%d_%d_%.2f_%f_%s_EndPoint\"\n (numPoint * minimumPixelDist)\n (round thetaFreq :: Int)\n (round tao :: Int)\n cutoffRadiusEndPoint\n thetaSigma\n reversalFactor\n (takeBaseName inputImgPath))\n 0.5\n reversalFactor\n bias\n eigenVec\n writeRepaArray endPointFilePath endPointSource\n return endPointSource\n print \"done\"\n\n", "meta": {"hexsha": "318aaae84c5b0b3907ad86ade96b626727cef255", "size": 11206, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "test/CannyEdgeIllusoryContour/CannyEdgeIllusoryContour.hs", "max_stars_repo_name": "XinhuaZhang/Stochastic-Completion-Field", "max_stars_repo_head_hexsha": "494a49356e17288ce09864c64ba09d11a3e9e0a8", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "test/CannyEdgeIllusoryContour/CannyEdgeIllusoryContour.hs", "max_issues_repo_name": "XinhuaZhang/Stochastic-Completion-Field", "max_issues_repo_head_hexsha": "494a49356e17288ce09864c64ba09d11a3e9e0a8", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 4, "max_issues_repo_issues_event_min_datetime": "2019-07-25T20:48:32.000Z", "max_issues_repo_issues_event_max_datetime": "2019-09-04T20:46:48.000Z", "max_forks_repo_path": "test/CannyEdgeIllusoryContour/CannyEdgeIllusoryContour.hs", "max_forks_repo_name": "XinhuaZhang/Stochastic-Completion-Field", "max_forks_repo_head_hexsha": "494a49356e17288ce09864c64ba09d11a3e9e0a8", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2019-07-29T15:55:46.000Z", "max_forks_repo_forks_event_max_datetime": "2019-07-29T15:55:46.000Z", "avg_line_length": 39.3192982456, "max_line_length": 482, "alphanum_fraction": 0.5592539711, "num_tokens": 2579, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6825737214979745, "lm_q2_score": 0.44167300566462553, "lm_q1q2_score": 0.3014743871616994}} {"text": "{-# LANGUAGE CPP #-}\n{-# LANGUAGE DataKinds #-}\n{-# LANGUAGE DeriveGeneric #-}\n{-# language FlexibleInstances #-}\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE GeneralizedNewtypeDeriving #-}\n{-# LANGUAGE OverloadedStrings #-}\n{-# LANGUAGE ScopedTypeVariables #-}\n{-# LANGUAGE UndecidableInstances #-}\n{-# LANGUAGE StandaloneDeriving #-}\n{-# language QuasiQuotes #-}\n{-# LANGUAGE TemplateHaskell #-}\n{-# language TypeFamilies #-}\n\nmodule Model (\n Val(..),\n ToVal(..),\n FromVal(..),\n Expr(..),\n ModelImage(..),\n Prim1(..),\n Prim2(..),\n Type(..),\n WorkerProfile(..),\n WorkerProfileMap,\n WorkerName(..),\n WorkerProfileId,\n module Type\n) where\n\nimport Codec.Picture\nimport Control.Applicative ((<|>))\nimport Control.DeepSeq\nimport Control.Monad (mzero)\nimport Data.ByteString\nimport Data.Aeson ((.=),(.:))\nimport qualified Data.ByteString.Char8 as BS\nimport qualified Data.ByteString.Lazy.Char8 as BL\nimport qualified Data.ByteString.Base64 as B64\nimport Data.Complex\nimport Data.Monoid ((<>))\nimport Data.Text\nimport qualified Data.Text as T\nimport qualified Data.Text.Lazy as TL\nimport Data.Text.Encoding\nimport qualified Data.Aeson as A\nimport qualified Data.Vector as V\n#ifndef __GHCJS__\nimport Database.Groundhog\n#endif\nimport Database.Groundhog.TH hiding (defaultCodegenConfig)\nimport Generics.SOP\nimport GHC.Generics\nimport GHC.TypeLits\nimport Text.Read\nimport Text.ParserCombinators.ReadPrec\nimport qualified Text.PrettyPrint.HughesPJClass as P\nimport URI.ByteString\nimport Web.HttpApiData\n\nimport EntityID\nimport Type\nimport Utils\n\nclass ToVal a where\n toVal :: a -> Val\n\nclass FromVal a where\n fromVal :: Val -> a\n\ndata WorkerName = WorkerName { unWorkerName :: Text }\n deriving (Eq, Ord, Show, Read, GHC.Generics.Generic)\n\ninstance NFData WorkerName\n\ndata WorkerProfile = WorkerProfile\n { wpName :: WorkerName\n , wpFunction :: (Text, Type)\n } deriving (Eq, Ord, Show, Read, GHC.Generics.Generic)\n\ninstance NFData WorkerProfile\n\n\ntype WorkerProfileMap = EntityMap WorkerProfile\ntype WorkerProfileId = EntityID WorkerProfile\n\n\ndata Expr a = ELit a Val\n | EVar a Text\n | ELambda a Text (Expr a)\n | ERemote a (WorkerProfileId, WorkerProfile, Text)\n | EApp a (Expr a) (Expr a)\n | EPrim1 a Prim1 (Expr a)\n | EPrim2 a Prim2 (Expr a) (Expr a)\n deriving (Eq, Ord, Show, Read, GHC.Generics.Generic)\n\ninstance Functor Expr where\n fmap f (ELit a v) = ELit (f a) v\n fmap f (EVar a n) = EVar (f a) n\n fmap f (ELambda a n b) = ELambda (f a) n (fmap f b)\n fmap f (ERemote a r) = ERemote (f a) r\n fmap f (EApp a eA eB) = EApp (f a) (fmap f eA) (fmap f eB)\n fmap f (EPrim1 a p e) = EPrim1 (f a) p (fmap f e)\n fmap f (EPrim2 a p eA eB) = EPrim2 (f a) p (fmap f eA) (fmap f eB)\n\ninstance A.ToJSON a => A.ToJSON (Expr a)\ninstance A.FromJSON a => A.FromJSON (Expr a)\n\ninstance NFData a => NFData (Expr a)\n\n\ninstance NFData Type\n\n\ndata Prim1 = P1Negate | P1Not\n deriving (Eq, Ord, Show, Read, GHC.Generics.Generic)\n\ninstance A.ToJSON Prim1\ninstance A.FromJSON Prim1\ninstance NFData Prim1\n\ndata Prim2 = P2And | P2Or | P2Sum | P2Map | P2Prod\n deriving (Eq, Ord, Show, Read, GHC.Generics.Generic)\n\ninstance A.ToJSON Prim2\ninstance A.FromJSON Prim2\ninstance NFData Prim2\n\ninstance A.ToJSON Type\n\ninstance A.FromJSON Type\n\ndata Val = VDouble Double\n | VComplex PrimComplex\n | VText Text\n | VImage ModelImage\n | VLabelProbs [(Text, Double)]\n -- TODO: I'm having trouble getting the recursive values into groundhog\n | VList [Val]\n | VProbabilityDistribution [(Val,Double)]\n | VVec1 (V.Vector Val)\n | VVec2 (V.Vector (Val, Val))\n | VVec3 (V.Vector (Val, Val, Val))\n | VMat2 (V.Vector (V.Vector Val))\n | VMat2C (V.Vector (V.Vector Val),\n V.Vector (V.Vector Val),\n V.Vector (V.Vector Val))\n | VClosure [(Text,Expr Type)] (Expr Type)\n deriving (Eq, Ord, Show, Read, GHC.Generics.Generic)\n\n\ninstance Generics.SOP.Generic Val\n\nnewtype PrimComplex = PComplex { getComplex :: Complex Double }\n deriving (Eq, Show, Read, GHC.Generics.Generic, NFData)\n\ninstance Ord PrimComplex where\n compare (PComplex p) (PComplex p')\n | realPart p > realPart p' = GT\n | realPart p < realPart p' = LT\n | otherwise = compare (imagPart p) (imagPart p')\n\ninstance A.ToJSON PrimComplex where\n toJSON (PComplex c) = A.object [\"real\" A..= realPart c\n ,\"imag\" A..= imagPart c]\n\ninstance A.FromJSON PrimComplex where\n parseJSON (A.Object o) = do\n r <- o A..: \"real\"\n i <- o A..: \"imag\"\n return (PComplex (r :+ i))\n parseJSON _ = mzero\n\n-- From basic-sop (not compiling under ghc8)\n-- instance NFData Val where\n-- rnf = grnf\ninstance NFData Val\n\n\ninstance A.ToJSON Val\ninstance A.FromJSON Val\n\n-- | @ModelImage@ is always a base64 encoded tiff with RGBA8 pixels\nnewtype ModelImage = ModelImage (Image PixelRGBA8)\n\nimageToBytes :: ModelImage -> BS.ByteString\nimageToBytes (ModelImage i) = B64.encode . BL.toStrict . encodeTiff $ i\n\nimageFromBytes :: BS.ByteString -> Either String ModelImage\nimageFromBytes bs = fmap (ModelImage . convertRGBA8) $ decodeTiff =<< B64.decode bs\n\ninstance Show ModelImage where\n show = BS.unpack . imageToBytes\n\ninstance Read ModelImage where\n readsPrec _ = readModelImage\n\n\nreadModelImage :: ReadS ModelImage\nreadModelImage s = case imageFromBytes (BS.pack $ Prelude.dropWhile (== ' ') s) of\n Right m -> [(m,\"\")]\n Left e -> error e\n\ninstance Eq ModelImage where\n a == b =\n A.toJSON a == A.toJSON b\n\ninstance Ord ModelImage where\n compare a b = compare (A.encode a) (A.encode b)\n\ninstance NFData ModelImage where\n rnf (ModelImage img) = rnf img\n\ninstance A.ToJSON ModelImage where\n toJSON (ModelImage img) =\n A.object [\"tag\" A..= (\"ModelImage\" :: String)\n ,\"contents\" A..= imgString]\n where imgString = A.String . decodeUtf8\n . B64.encode . BL.toStrict\n . encodeTiff $ img\n\ninstance A.FromJSON ModelImage where\n parseJSON (A.Object o) = do\n t <- o A..: \"tag\"\n c <- o A..: \"contents\"\n case (t,c) of\n (\"ModelImage\" :: String, imgString) ->\n let d = decodeImage =<< B64.decode (encodeUtf8 imgString)\n in case d of\n Right di -> return $ ModelImage (convertRGBA8 di)\n Left e -> error $ \"DECODING FAILURE: \" ++ e -- mzero\n _ -> mzero\n\n\ndata Tensor = Tensor\n { tDoubleShape :: [Int]\n , tDoubleElems :: V.Vector Double\n }\n\n\ninstance Model.ToVal Int where\n toVal i = Model.VDouble (realToFrac i)\n\ninstance Model.ToVal Double where\n toVal = VDouble\n\ninstance Model.ToVal Text where\n toVal = VText\n\n\ninstance Model.FromVal Double where\n fromVal (VDouble t) = t\n fromVal e = error $ \"Couldn't cast to double: \" ++ show e\n\ninstance Model.FromVal Text where\n fromVal (VText t) = t\n fromVal e = error $ \"Couldn't cast to text: \" ++ show e\n\ninstance Model.FromVal (Image PixelRGBA8) where\n fromVal (Model.VImage (Model.ModelImage i)) = i\n fromVal x = error $ \"Couldn't cast to image: \" ++ show x\n\n#ifndef __GHCJS__\nmkPersist ghCodeGen [groundhog|\n - primitive: Val\n converter: showReadConverter\n|]\n#endif\n\n\n\ninstance A.ToJSON WorkerProfile where\n toJSON (WorkerProfile (WorkerName n) (f,t)) =\n A.object [\"name\" .= n\n ,\"function\" .= f\n ,\"type\" .= t\n ]\n\ninstance A.FromJSON WorkerProfile where\n parseJSON (A.Object o) = do\n n <- o .: \"name\"\n f <- o .: \"function\"\n t <- o .: \"type\"\n return $ WorkerProfile n (f,t)\n\ninstance FromHttpApiData WorkerName where\n parseUrlPiece = Right . WorkerName\n\ninstance A.ToJSON WorkerName where\n toJSON (WorkerName n) = A.String n\n\ninstance A.FromJSON WorkerName where\n parseJSON (A.String n) = return $ WorkerName n\n parseJSON _ = mzero\n\n\nparseWorkerProfile :: Query -> Either String WorkerProfile\nparseWorkerProfile q = do\n nm <- note \"No WorkerProfile name\" (lookup \"name\" ps)\n fn <- note \"No WorkerProfile function\" (lookup \"function\" ps)\n fty <- note \"No WorkerProfile type\" (lookup \"type\" ps) >>= (note \"No parse\" . readMaybe . BS.unpack)\n return $ WorkerProfile (WorkerName $ decodeUtf8 nm) (decodeUtf8 fn, fty)\n where ps = queryPairs q\n\n#ifndef __GHCJS__\n-- TODO custom WorkerName instance to avoid showing/reading constructors\nmkPersist ghCodeGen [groundhog|\n - primitive: WorkerName\n converter: showReadConverter\n - entity: WorkerProfile\n|]\n#endif\n", "meta": {"hexsha": "1942a2cd124ed9b2c80a7d64ad33dd1efc246717", "size": 8649, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "cbaas-lib/src/Model.hs", "max_stars_repo_name": "CBMM/CBaaS", "max_stars_repo_head_hexsha": "3f34ddefcd37d443833b002e53f60ca4cd5ff610", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 7, "max_stars_repo_stars_event_min_datetime": "2016-03-31T03:33:55.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-25T01:18:29.000Z", "max_issues_repo_path": "cbaas-lib/src/Model.hs", "max_issues_repo_name": "CBMM/CBaaS", "max_issues_repo_head_hexsha": "3f34ddefcd37d443833b002e53f60ca4cd5ff610", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 5, "max_issues_repo_issues_event_min_datetime": "2016-01-26T20:48:40.000Z", "max_issues_repo_issues_event_max_datetime": "2016-09-09T16:47:12.000Z", "max_forks_repo_path": "cbaas-lib/src/Model.hs", "max_forks_repo_name": "CBMM/CBaaS", "max_forks_repo_head_hexsha": "3f34ddefcd37d443833b002e53f60ca4cd5ff610", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2016-11-16T00:15:22.000Z", "max_forks_repo_forks_event_max_datetime": "2017-04-12T17:41:28.000Z", "avg_line_length": 27.6325878594, "max_line_length": 102, "alphanum_fraction": 0.6554514973, "num_tokens": 2405, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6477982179521103, "lm_q2_score": 0.46490157137338844, "lm_q1q2_score": 0.3011624094588169}} {"text": "{-# LANGUAGE BangPatterns #-}\n{-# LANGUAGE FlexibleContexts #-}\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE RecordWildCards #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Taiji.View.Commands.Rank\n ( plotRankParser\n , viewRanks\n ) where\n\nimport Bio.Utils.Functions (scale)\nimport qualified Data.Text as T\nimport qualified Data.Text.IO as T\nimport qualified Data.HashSet as S\nimport Data.Function (on)\nimport AI.Clustering.Hierarchical hiding (normalize)\nimport Control.Arrow (first)\nimport Data.Colour (blend)\nimport Options.Applicative\nimport qualified Data.Matrix as M\nimport qualified Data.Vector as V\nimport Diagrams.Backend.Cairo (B)\nimport Diagrams.Backend.Cairo (renderCairo)\nimport Diagrams.Prelude hiding (option, scale, value, normalize)\nimport Graphics.SVGFonts (textSVG)\nimport Data.Colour.Palette.BrewerSet\nimport Statistics.Sample\nimport Statistics.Correlation (spearman)\nimport Text.Printf\n\nimport Taiji.View.Types\nimport Taiji.View.Utils hiding (zip, unzip)\nimport qualified Taiji.View.Utils as U\n\nplotRankParser :: Parser Command\nplotRankParser = ViewRanks\n <$> strArgument\n ( metavar \"INPUT\"\n <> help \"rank file\" )\n <*> strArgument\n ( metavar \"OUTPUT\"\n <> help \"output file\" )\n <*> (optional . strOption)\n ( long \"expression\" )\n <*> option auto\n ( long \"cv\"\n <> value 0.5\n <> help \"TFs with coefficient of variance less than the specified value will be removed. (default: 1)\"\n )\n <*> option auto\n ( long \"min\"\n <> value 1e-4\n <> help \"lowerBound of TF rank.\" )\n <*> (optional . strOption) ( long \"rowNamesFilter\" )\n <*> (optional . strOption) ( long \"output-values\" )\n <*> (optional . option (maybeReader f)) ( long \"rank-range\" )\n <*> (optional . strOption) ( long \"groups\" )\n where\n f x = let [a,b] = T.splitOn \",\" $ T.pack x\n in Just (read $ T.unpack a, read $ T.unpack b)\n\nviewRanks :: Command -> IO ()\nviewRanks ViewRanks{..} = do\n grp <- case colGroup of\n Nothing -> return Nothing\n Just fl -> fmap (Just . map (T.splitOn \",\") . T.lines) $ T.readFile fl\n\n rowFilt <- case rowNamesFilter of\n Nothing -> return $ const True\n Just fl -> do\n names <- T.lines <$> T.readFile fl\n return (`elem` names)\n\n df <- case exprFile of\n Just fl -> do\n mat <- cbind .\n map (reorderColumns (orderByCluster fst)) .\n groupDataFrame grp .\n reorderRows (orderByCluster fst) .\n uncurry U.zip . first normalize . U.unzip .\n filterRows (const $ filtCV cv . fst . V.unzip) .\n filterRows (const $ V.any ((>=minRank) . fst)) .\n filterRows (flip $ const rowFilt) <$> readData rankFile fl\n case outputValues of\n Nothing -> return ()\n Just x -> writeTable x (T.pack . show . fst) mat\n return $ Left mat\n Nothing -> do\n mat <- cbind .\n map (reorderColumns (orderByCluster id)) .\n groupDataFrame grp .\n reorderRows (orderByCluster id) .\n normalize .\n filterRows (const $ filtCV cv) .\n filterRows (const $ V.any (>=minRank)) .\n filterRows (flip $ const rowFilt) <$> readTable rankFile\n case outputValues of\n Nothing -> return ()\n Just x -> writeTable x (T.pack . show) mat\n return $ Right mat\n\n let w = width dia\n h = height dia\n n = fromIntegral (either (M.cols . _dataframe_data)\n (M.cols . _dataframe_data) df) * 50\n dia = bubblePlot df $ BubblePlotOpts 15 reds rankRange\n renderCairo output (dims2D n (n*(h/w))) dia\n\n\ngroupDataFrame :: Maybe [[T.Text]] -> DataFrame a -> [DataFrame a]\ngroupDataFrame Nothing df = [df]\ngroupDataFrame (Just grp) df = map (df `csub`) $ grp ++ [others]\n where\n others = S.toList $\n S.fromList (colNames df) `S.difference` S.fromList (concat grp)\n\norderByCluster :: (a -> Double) -> ReodrderFn a \norderByCluster f xs = flatten $ hclust Ward (V.fromList xs) dist\n where\n dist = euclidean `on` V.map f . snd\n\ndata BubblePlotOpts = BubblePlotOpts\n { _radius :: Double -- ^ The size of bubble\n , _colours :: V.Vector (Colour Double) -- ^ Color scheme\n , _rank_range :: Maybe (Double, Double) -- ^ The range of ranks\n }\n\nbubblePlot :: Either (DataFrame (Double, Double)) (DataFrame Double)\n -> BubblePlotOpts -> Diagram B\nbubblePlot (Left df) opts@BubblePlotOpts{..}\n | null (rowNames df) = error \"Nothing to plot\"\n | otherwise = center bubbles === strutY 30 === center legend\n where\n bubbles = drawBubbles df{_dataframe_data = M.zip ranks' expr'} opts\n legend = mkLegend opts\n (V.minimum $ M.flatten expr, V.maximum $ M.flatten expr)\n (case _rank_range of\n Nothing -> (V.minimum $ M.flatten ranks, V.maximum $ M.flatten ranks)\n Just r -> r )\n expr' = M.fromVector (M.dim expr) $ linearMap (4, _radius) $ M.flatten expr\n ranks' = M.fromVector (M.dim ranks) $ case _rank_range of\n Nothing -> linearMap (0, 1) $ M.flatten ranks\n Just rng -> linearMapBounded rng (0, 1) $ M.flatten ranks\n (ranks, expr) = M.unzip $ _dataframe_data df\nbubblePlot (Right df) opts@BubblePlotOpts{..}\n | null (rowNames df) = error \"Nothing to plot\"\n | otherwise = center bubbles === strutY 30 === center legend\n where\n bubbles = drawBubbles df{_dataframe_data = M.zip expr' ranks'} opts\n expr' = M.fromVector (M.dim ranks) $ V.replicate (uncurry (*) $ M.dim ranks) 0.7\n ranks' = M.fromVector (M.dim ranks) $ linearMap (4, _radius) $ M.flatten ranks\n ranks = _dataframe_data df\n legend = mkCircleLegend \"normalized rank score\"\n ( V.minimum $ M.flatten $ _dataframe_data df\n , V.maximum $ M.flatten $ _dataframe_data df) _radius\n\ndrawBubbles :: DataFrame (Double, Double)\n -> BubblePlotOpts \n -> Diagram B\ndrawBubbles df BubblePlotOpts{..} = vsep 1 $ (colnames:) $\n zipWith drawBubble (rowNames df) $ M.toLists $ M.zip ranks' expr'\n where\n drawBubble lab xs = alignR $ textBounded lab ||| strutX 5 ||| bb ||| cor\n where\n bb = hsep 1 $ flip map xs $ \\(x,y) -> withEnvelope unitEnvelope $\n circle y # lw 0 # fc (colorMapSmooth x _colours)\n cor = let r = spearman $ V.fromList xs\n in withEnvelope unitEnvelope $\n square _radius # lw 0 # fc (colorMapSmooth ((r+1)/2) buYlRd)\n colnames = alignR $ hsep 1 $ map\n (\\x -> (alignB $ textBounded x # rotate (90 @@ deg)) <> unitEnvelope) $\n colNames df ++ [\"\"]\n (ranks', expr') = M.unzip $ _dataframe_data df\n unitEnvelope = circle _radius # lw 0\n\nmkLegend :: BubblePlotOpts -> (Double, Double) -> (Double, Double) -> Diagram B\nmkLegend BubblePlotOpts{..} (min_expr, max_expr) (min_rank, max_rank) =\n hsep 50 [rank_legend, expr_legend, cor_legend]\n where\n expr_legend = mkCircleLegend \"inverse hyperbolic sine of expression level\"\n (min_expr, max_expr) _radius\n rank_legend = mkColorLegend \"normalized rank score\" (min_rank, max_rank) _colours\n cor_legend = vsep 2\n [ rect 100 25 # lw 0 # fillTexture (mkGradient buYlRd)\n , center $ position $ zip [0^&0, 50^&0, 100^&0] $ map textBounded [\"-1\", \"0\", \"1\"]\n , textBounded \"Spearman's correlation\" ]\n{-# INLINE mkLegend #-}\n\nmkColorLegend :: T.Text -- ^ Title\n -> (Double, Double) -- ^ lower and upper bound\n -> V.Vector (Colour Double) -- ^ color scheme\n -> Diagram B\nmkColorLegend title (lo, hi) colors = vsep 2 $\n [ rect 100 25 # lw 0 # fillTexture (mkGradient colors)\n , center $ position $ zip [0^&0, 50^&0, 100^&0] $\n map (textBounded . T.pack . printf \"%.2f\") values\n , textBounded title ]\n where\n values = [lo, lo + (hi - lo) / 2, hi]\n\nmkCircleLegend :: T.Text -- ^ Title\n -> (Double, Double) -- ^ Lower and upper bound\n -> Double -- ^ radius\n -> Diagram B\nmkCircleLegend title (lo, hi) r = center\n ( hsep 1 $ map (\\(x,s) -> withEnvelope unitEnvelope\n (circle s # lw 0 # fc black) === strutY 2 === textBounded (T.pack $ printf \"%.2f\" x)) $\n zip values $ V.toList $ linearMap (4, r) $ V.fromList values ) ===\n strutY 2 === textBounded title\n where\n values = [lo, lo + (hi - lo) / 3 .. hi]\n unitEnvelope = circle r # lw 0 :: Diagram B\n\nmkGradient :: V.Vector (Colour Double) -> Texture Double\nmkGradient cs = mkLinearGradient stops ((-50) ^& 0) (50 ^& 0) GradPad\n where\n stops = mkStops $ zipWith (\\c x -> (c, x, 1)) (V.toList cs) [0, 1/(n-1) .. 1]\n n = fromIntegral $ V.length cs\n{-# INLINE mkGradient #-}\n\n-- | Map numbers to colors\ncolorMapSmooth :: Double -- a value from 0 to 1\n -> V.Vector (Colour Double) -> Colour Double\ncolorMapSmooth x colors\n | isNaN x = black\n | x <0 || x > 1 = error \"input value is out of range.\"\n | x == 1 = V.last colors\n | n == 2 = blend (1-p) (V.head colors) $ V.last colors\n | otherwise = blend (1 - p) (colors V.! i) $ colors V.! (i+1)\n where\n (i,p) = properFraction $ x * fromIntegral (n - 1)\n n = V.length colors\n{-# INLINE colorMapSmooth #-}\n\ntextBounded :: T.Text -> Diagram B\ntextBounded x = stroke (textSVG (T.unpack x) 15) # lw 0 # fc black\n{-# INLINE textBounded #-}\n\nlinearMap :: (Double, Double) -> V.Vector Double -> V.Vector Double\nlinearMap (lo, hi) xs = V.map f xs\n where\n f x = lo + (x - min') / (max' - min') * (hi - lo)\n min' = V.minimum xs\n max' = V.maximum xs\n{-# INLINE linearMap #-}\n\nlinearMapBounded :: (Double, Double) -- ^ Range of input data\n -> (Double, Double) -- ^ Range of output\n -> V.Vector Double\n -> V.Vector Double\nlinearMapBounded (min', max') (lo, hi) xs = V.map f xs\n where\n f x | x <= min' = lo\n | x >= max' = hi\n | otherwise = lo + (x - min') / (max' - min') * (hi - lo)\n{-# INLINE linearMapBounded #-}\n\n-------------------------------------------------------------------------------\n-- Colours\n-------------------------------------------------------------------------------\n\nbuYlRd :: V.Vector (Colour Double)\nbuYlRd = V.fromList $ reverse $ brewerSet RdYlBu 9\n\nreds :: V.Vector (Colour Double)\nreds = V.fromList [white, red]\n\n-- | Normalize the data frame.\nnormalize :: DataFrame Double -> DataFrame Double\nnormalize = mapRows f\n where\n f xs | V.length xs <= 2 = V.map (logBase 2 . (/ V.head xs)) xs\n | otherwise = scale xs\n\n-- | Determine whether the input pass the CV cutoff\nfiltCV :: Double -> V.Vector Double -> Bool\nfiltCV cutoff xs = sqrt v / m >= cutoff\n where\n (m, v) = meanVarianceUnb xs\n\n-- | Determine whether the input pass the fold-change cutoff\nfiltFC :: Double -> V.Vector Double -> Bool\nfiltFC cutoff xs = V.maximum xs / V.minimum xs >= cutoff\n", "meta": {"hexsha": "252ba454a66d1f11d3dca390b3de49995d387251", "size": 11141, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "app/Taiji/View/Commands/Rank.hs", "max_stars_repo_name": "Taiji-pipeline/Taiji-view", "max_stars_repo_head_hexsha": "c56deb49b713ad62bc4151b585ff8fe6ded0fb8b", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2018-05-31T07:38:31.000Z", "max_stars_repo_stars_event_max_datetime": "2019-01-23T20:12:59.000Z", "max_issues_repo_path": "app/Taiji/View/Commands/Rank.hs", "max_issues_repo_name": "Taiji-pipeline/Taiji-view", "max_issues_repo_head_hexsha": "c56deb49b713ad62bc4151b585ff8fe6ded0fb8b", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2019-07-05T06:39:34.000Z", "max_issues_repo_issues_event_max_datetime": "2019-07-05T21:15:05.000Z", "max_forks_repo_path": "app/Taiji/View/Commands/Rank.hs", "max_forks_repo_name": "Taiji-pipeline/Taiji-view", "max_forks_repo_head_hexsha": "c56deb49b713ad62bc4151b585ff8fe6ded0fb8b", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 39.0912280702, "max_line_length": 107, "alphanum_fraction": 0.5850462257, "num_tokens": 3038, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6757646140788307, "lm_q2_score": 0.4455295350395727, "lm_q1q2_score": 0.30107309430673773}} {"text": "{-# LANGUAGE NamedFieldPuns #-}\n\nmodule School.FileIO.FileHeader\n( FileHeader(..)\n, compatibleHeaders\n, headerBuilder\n, parseHeader\n) where\n\nimport Control.Applicative ((<|>))\nimport Control.Monad (replicateM)\nimport Data.Attoparsec.ByteString (Parser, anyWord8, parseOnly, take, word8)\nimport Data.Attoparsec.ByteString.Char8 (char)\nimport qualified Data.ByteString as B\nimport Data.ByteString.Conversion (FromByteString(..), ToByteString(..), toByteString')\nimport Data.Default.Class (Default(..))\nimport Data.Monoid ((<>))\nimport Numeric.LinearAlgebra (I)\nimport Prelude hiding (take)\nimport School.FileIO.FileType (FileType(..))\nimport School.Types.DataType (DataType(..), fromIdxIndicator, toIdxIndicator)\nimport School.Types.Decoding (binToInt)\nimport School.Types.Encoding (intToBin)\nimport School.Types.Error (Error)\nimport School.Types.LiftResult (liftResult)\nimport School.Utils.Constants (separator)\n\ndata FileHeader = FileHeader\n { dataType :: DataType\n , rows :: Int\n , cols :: Int\n } deriving (Eq, Show)\n\ninstance Default FileHeader where\n def = FileHeader { dataType = DBL64B\n , cols = 1\n , rows = 1\n }\n\ncompatibleHeaders :: FileHeader\n -> FileHeader\n -> Bool\ncompatibleHeaders\n FileHeader { dataType = type1, rows = rows1, cols = cols1 }\n FileHeader { dataType = type2, rows = rows2, cols = cols2 }\n = type1 == type2\n && cols1 == cols2\n && rows2 `mod` rows1 == 0\n\ninstance ToByteString FileHeader where\n builder header = sep <> t <> r <> c <> sep where\n sep = builder separator\n t = (builder . dataType) header\n r = builder 'r' <> (builder . rows) header\n c = builder 'c' <> (builder . cols) header\n\nintGetter :: Parser I\nintGetter = take 4 >>= liftResult . binToInt\n\nparseIdxHeader :: Parser FileHeader\nparseIdxHeader = do\n _ <- word8 0\n _ <- word8 0\n t <- fromEnum <$> anyWord8\n dataType <- liftResult $ fromIdxIndicator t\n d <- fromEnum <$> anyWord8\n dims <- (fromIntegral <$>) <$> replicateM d intGetter\n let rows = head dims\n let cols = product . tail $ dims\n return FileHeader { dataType, cols, rows }\n\nparseSmHeader :: Parser FileHeader\nparseSmHeader = do\n _ <- char separator\n typeName <- parser\n _ <- char 'r'\n r <- parser\n _ <- char 'c'\n c <- parser\n _ <- char separator\n return $ FileHeader typeName r c\n\nparseHeader :: B.ByteString -> Either Error FileHeader\nparseHeader = parseOnly $ parseSmHeader <|> parseIdxHeader\n\ninstance FromByteString FileHeader where\n parser = parseSmHeader <|> parseIdxHeader\n\nheaderBuilder :: FileType\n -> FileHeader\n -> B.ByteString\nheaderBuilder SM header = toByteString' header\nheaderBuilder IDX FileHeader { cols, dataType, rows } =\n let i = toIdxIndicator dataType\n in B.pack (toEnum <$> [0, 0, i, 2])\n <> (intToBin . fromIntegral $ rows)\n <> (intToBin . fromIntegral $ cols)\nheaderBuilder _ _ = undefined\n", "meta": {"hexsha": "11357b53e132f4878cc4fc852566488cfdc997cb", "size": 2930, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/School/FileIO/FileHeader.hs", "max_stars_repo_name": "jfulseca/School", "max_stars_repo_head_hexsha": "cdc66fc21fc5342596ac37d920d810879bb09c3d", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/School/FileIO/FileHeader.hs", "max_issues_repo_name": "jfulseca/School", "max_issues_repo_head_hexsha": "cdc66fc21fc5342596ac37d920d810879bb09c3d", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/School/FileIO/FileHeader.hs", "max_forks_repo_name": "jfulseca/School", "max_forks_repo_head_hexsha": "cdc66fc21fc5342596ac37d920d810879bb09c3d", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 29.595959596, "max_line_length": 87, "alphanum_fraction": 0.6819112628, "num_tokens": 762, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.5467381519846138, "lm_q2_score": 0.5506073655352403, "lm_q1q2_score": 0.30103805350185403}} {"text": "{-# OPTIONS -Wall #-}\n\nmodule Types where\n\nimport Control.Monad.Except\nimport Data.Array (Array)\nimport Data.Complex\nimport Data.Foldable\nimport Data.IORef\nimport Text.ParserCombinators.Parsec\nimport System.IO (Handle)\n\ndata LispVal\n = Atom String\n | List [LispVal]\n | DottedList [LispVal] LispVal\n | Number Integer\n | String String\n | Bool Bool\n | Character Char\n | Float Double\n | Ratio Rational\n | Complex (Complex Double)\n | Vector (Array Int LispVal)\n | PrimitiveFunc ([LispVal] -> ThrowsError LispVal)\n | Func\n { params :: [String]\n , vararg :: Maybe String\n , body :: [LispVal]\n , closure :: Env\n }\n | IOFunc ([LispVal] -> IOThrowsError LispVal)\n | Port Handle\n\ninstance Show LispVal where\n show = showVal\n\nshowVal :: LispVal -> String\nshowVal (Atom x) = x\nshowVal (List xs) = \"(\" ++ unwords (map showVal xs) ++ \")\"\nshowVal (DottedList xs y) = \"(\" ++ unwords (map showVal xs) ++ \" . \" ++ showVal y ++ \")\"\nshowVal (Number x) = show x\nshowVal (String x) = x\nshowVal (Bool True) = \"#t\"\nshowVal (Bool False) = \"#f\"\nshowVal (Character c) = [c]\nshowVal (Float x) = show x\nshowVal (Ratio x) = show x\nshowVal (Complex x) = show x\nshowVal (Vector xs) = \"#(\" ++ unwords (map showVal (toList xs)) ++ \")\"\nshowVal (PrimitiveFunc _) = \"\"\nshowVal Func {params = args, vararg = varargs} =\n \"(lambda (\" ++\n unwords (map show args) ++\n (case varargs of\n Nothing -> \"\"\n Just arg -> \" . \" ++ arg) ++\n \") ...)\"\nshowVal (Port _) = \"\"\nshowVal (IOFunc _) = \"\"\n\ndata LispError\n = NumArgs Integer [LispVal]\n | TypeMismatch String LispVal\n | Parser ParseError\n | BadSpecialForm String LispVal\n | NotFunction String String\n | UnboundVar String String\n | Default String\n\ninstance Show LispError where\n show = showError\n\nshowError :: LispError -> String\nshowError (UnboundVar message varname) = message ++ \": \" ++ varname\nshowError (BadSpecialForm message form) = message ++ \": \" ++ show form\nshowError (NotFunction message func) = message ++ \": \" ++ show func\nshowError (NumArgs expected found) = \"Expected \" ++ show expected ++ \" args: found values \" ++ unwords (map show found)\nshowError (TypeMismatch expected found) = \"Invalid type: expected \" ++ expected ++ \", found \" ++ show found\nshowError (Parser parseErr) = \"Parse error at \" ++ show parseErr\nshowError (Default s) = s\n\ntype IOThrowsError = ExceptT LispError IO\n\ntype ThrowsError = Either LispError\n\ntype Env = IORef [(String, IORef LispVal)]", "meta": {"hexsha": "731f133c1b4f8fe888ccdb99b90cc7e281397f61", "size": 2475, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/Types.hs", "max_stars_repo_name": "willGuimont/write-yourself-a-scheme", "max_stars_repo_head_hexsha": "14cc546992472ee45ecc62ba5ce2049421750b45", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/Types.hs", "max_issues_repo_name": "willGuimont/write-yourself-a-scheme", "max_issues_repo_head_hexsha": "14cc546992472ee45ecc62ba5ce2049421750b45", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/Types.hs", "max_forks_repo_name": "willGuimont/write-yourself-a-scheme", "max_forks_repo_head_hexsha": "14cc546992472ee45ecc62ba5ce2049421750b45", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 28.4482758621, "max_line_length": 119, "alphanum_fraction": 0.6658585859, "num_tokens": 710, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.5544704649604273, "lm_q2_score": 0.5428632831725052, "lm_q1q2_score": 0.30100165703060305}} {"text": "module HVX.DcpTests.NoAffineNonmonConvexNondec where\n\nimport Numeric.LinearAlgebra\n\nimport HVX\n\nmain :: IO ()\nmain = do\n let x = EVar \"x\"\n _ = (EConst $ (1><2) [1,2]) *~ hexp x\n return ()\n", "meta": {"hexsha": "cfd316877840e3ce66fded250138bfbf4a0a3ba7", "size": 195, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "test/DcpTests/NoAffineNonmonConvexNondec.hs", "max_stars_repo_name": "wellposed/hvx", "max_stars_repo_head_hexsha": "4cc39c1ff940960e8ff7d50e368c76031786befe", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 16, "max_stars_repo_stars_event_min_datetime": "2015-02-06T21:10:51.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-02T06:40:50.000Z", "max_issues_repo_path": "test/DcpTests/NoAffineNonmonConvexNondec.hs", "max_issues_repo_name": "wellposed/hvx", "max_issues_repo_head_hexsha": "4cc39c1ff940960e8ff7d50e368c76031786befe", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 10, "max_issues_repo_issues_event_min_datetime": "2017-08-01T05:22:09.000Z", "max_issues_repo_issues_event_max_datetime": "2020-07-09T17:07:19.000Z", "max_forks_repo_path": "test/DcpTests/NoAffineNonmonConvexNondec.hs", "max_forks_repo_name": "chrisnc/hvx", "max_forks_repo_head_hexsha": "4256e83d265c7b6bf9336533c15eae9fecce9a6d", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 5, "max_forks_repo_forks_event_min_datetime": "2017-07-31T09:08:48.000Z", "max_forks_repo_forks_event_max_datetime": "2018-11-07T15:50:42.000Z", "avg_line_length": 16.25, "max_line_length": 52, "alphanum_fraction": 0.6461538462, "num_tokens": 70, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO\n\n", "lm_q1_score": 0.7122321842389469, "lm_q2_score": 0.42250463481418826, "lm_q1q2_score": 0.3009213989047879}} {"text": "{-# LANGUAGE BangPatterns, CPP, DefaultSignatures, DerivingVia, LambdaCase #-}\n{-# LANGUAGE OverloadedStrings, QuantifiedConstraints, StandaloneDeriving #-}\n{-# LANGUAGE TemplateHaskell, TypeOperators #-}\n{-# OPTIONS_GHC -Wno-orphans #-}\nmodule Control.Subcategory.Foldable\n ( CFoldable(..),\n ctoList,\n CTraversable(..),\n CFreeMonoid(..),\n cfromList,\n cfolded, cfolding,\n cctraverseFreeMonoid,\n cctraverseZipFreeMonoid\n ) where\nimport Control.Applicative (ZipList, getZipList)\nimport Control.Arrow (first, second, (***))\nimport qualified Control.Foldl as L\nimport Control.Monad (forM)\nimport Control.Subcategory.Applicative\nimport Control.Subcategory.Functor\nimport Control.Subcategory.Pointed\nimport Control.Subcategory.Wrapper.Internal\nimport Control.Subcategory.Zip\nimport Data.Coerce\nimport Data.Complex (Complex)\nimport Data.Foldable\nimport Data.Functor.Const (Const)\nimport Data.Functor.Contravariant (Contravariant, contramap,\n phantom)\nimport Data.Functor.Identity (Identity)\nimport qualified Data.Functor.Product as SOP\nimport qualified Data.Functor.Sum as SOP\nimport qualified Data.HashMap.Strict as HM\nimport qualified Data.HashSet as HS\nimport qualified Data.IntMap.Strict as IM\nimport qualified Data.IntSet as IS\nimport Data.Kind (Type)\nimport Data.List (uncons)\nimport Data.List (intersperse)\nimport Data.List (nub)\nimport qualified Data.List as List\nimport Data.List.NonEmpty (NonEmpty)\nimport qualified Data.List.NonEmpty as NE\nimport qualified Data.Map as M\nimport Data.Maybe\nimport Data.Monoid\nimport qualified Data.Monoid as Mon\nimport Data.MonoTraversable hiding (WrappedMono,\n unwrapMono)\nimport Data.Ord (Down)\nimport qualified Data.Primitive.Array as A\nimport qualified Data.Primitive.PrimArray as PA\nimport qualified Data.Primitive.SmallArray as SA\nimport Data.Proxy (Proxy)\nimport Data.Semigroup (Arg, Max (..), Min (..),\n Option)\nimport qualified Data.Semigroup as Sem\nimport qualified Data.Sequence as Seq\nimport Data.Sequences (IsSequence (indexEx))\nimport qualified Data.Sequences as MT\nimport qualified Data.Set as Set\nimport qualified Data.Text as T\nimport qualified Data.Vector as V\nimport qualified Data.Vector.Algorithms.Intro as AI\nimport qualified Data.Vector.Primitive as P\nimport qualified Data.Vector.Storable as S\nimport qualified Data.Vector.Unboxed as U\nimport Foreign.Ptr (Ptr)\nimport qualified GHC.Exts as GHC\nimport GHC.Generics\nimport Language.Haskell.TH hiding (Type)\nimport Language.Haskell.TH.Syntax hiding (Type)\nimport qualified VectorBuilder.Builder as VB\nimport qualified VectorBuilder.Vector as VB\n\n-- See Note [Function coercion]\n(#.) :: Coercible b c => (b -> c) -> (a -> b) -> (a -> c)\n(#.) _f = coerce\n{-# INLINE (#.) #-}\n\nctoList :: (CFoldable f, Dom f a) => f a -> [a]\n{-# INLINE [1] ctoList #-}\nctoList = cbasicToList\n\ncfromList :: (CFreeMonoid f, Dom f a) => [a] -> f a\n{-# INLINE [1] cfromList #-}\ncfromList = cbasicFromList\n\n\n-- | Fold-optic for 'CFoldable' instances.\n-- In the terminology of lens, cfolded is a constrained\n-- variant of @folded@ optic.\n--\n-- @\n-- cfolded :: (CFoldable t, Dom t a) => Fold (t a) a\n-- @\ncfolded\n :: (CFoldable t, Dom t a)\n => forall f. (Contravariant f, Applicative f) => (a -> f a) -> t a -> f (t a)\n{-# INLINE cfolded #-}\ncfolded = (contramap (const ()) .) . ctraverse_\n\nclass Constrained f => CFoldable f where\n {-# MINIMAL cfoldMap | cfoldr #-}\n cfoldMap :: (Dom f a, Monoid w) => (a -> w) -> f a -> w\n {-# INLINE [1] cfoldMap #-}\n cfoldMap f = cfoldr (mappend . f) mempty\n\n cfoldMap' :: (Dom f a, Monoid m) => (a -> m) -> f a -> m\n {-# INLINE [1] cfoldMap' #-}\n cfoldMap' f = cfoldl' (\\ acc a -> acc <> f a) mempty\n\n cfold :: (Dom f w, Monoid w) => f w -> w\n cfold = cfoldMap id\n\n {-# INLINE [1] cfold #-}\n cfoldr :: (Dom f a) => (a -> b -> b) -> b -> f a -> b\n {-# INLINE [1] cfoldr #-}\n cfoldr f z t = appEndo (cfoldMap (Endo #. f) t) z\n\n cfoldlM\n :: (Monad m, Dom f b)\n => (a -> b -> m a) -> a -> f b -> m a\n {-# INLINE [1] cfoldlM #-}\n cfoldlM f z0 xs = cfoldr f' return xs z0\n where f' x k z = f z x >>= k\n\n cfoldlM'\n :: (Monad m, Dom f b)\n => (a -> b -> m a) -> a -> f b -> m a\n {-# INLINE [1] cfoldlM' #-}\n cfoldlM' f z0 xs = cfoldr' f' return xs z0\n where f' !x k z = do\n !i <- f z x\n k i\n\n cfoldrM\n :: (Monad m, Dom f a)\n => (a -> b -> m b) -> b -> f a -> m b\n {-# INLINE [1] cfoldrM #-}\n cfoldrM f z0 xs = cfoldl c return xs z0\n where c k x z = f x z >>= k\n\n cfoldrM'\n :: (Monad m, Dom f a)\n => (a -> b -> m b) -> b -> f a -> m b\n {-# INLINE [1] cfoldrM' #-}\n cfoldrM' f z0 xs = cfoldl' c return xs z0\n where c k !x z = do\n !i <- f x z\n k i\n cfoldl\n :: (Dom f a)\n => (b -> a -> b) -> b -> f a -> b\n {-# INLINE [1] cfoldl #-}\n cfoldl f z t = appEndo (getDual (cfoldMap (Dual . Endo . flip f) t)) z\n\n cfoldr' :: (Dom f a) => (a -> b -> b) -> b -> f a -> b\n {-# INLINE [1] cfoldr' #-}\n cfoldr' f z0 xs = cfoldl f' id xs z0\n where f' k x z = k $! f x z\n\n cfoldl' :: Dom f a => (b -> a -> b) -> b -> f a -> b\n {-# INLINE [1] cfoldl' #-}\n cfoldl' f z0 xs = cfoldr f' id xs z0\n where f' x k z = k $! f z x\n\n cbasicToList :: Dom f a => f a -> [a]\n {-# INLINE cbasicToList #-}\n cbasicToList = cfoldr (:) []\n\n cfoldr1 :: Dom f a => (a -> a -> a) -> f a -> a\n {-# INLINE [1] cfoldr1 #-}\n cfoldr1 f xs = fromMaybe (errorWithoutStackTrace \"cfoldr1: empty structure\")\n (cfoldr mf Nothing xs)\n where\n mf x m = Just $\n case m of\n Nothing -> x\n Just y -> f x y\n\n\n\n cfoldl1 :: Dom f a => (a -> a -> a) -> f a -> a\n {-# INLINE [1] cfoldl1 #-}\n cfoldl1 f xs = fromMaybe (errorWithoutStackTrace \"cfoldl1: empty structure\")\n (cfoldl mf Nothing xs)\n where\n mf m y = Just $\n case m of\n Nothing -> y\n Just x -> f x y\n\n cindex :: Dom f a => f a -> Int -> a\n cindex xs n = case cfoldl' go (Left' 0) xs of\n Right' x -> x\n Left'{} -> errorWithoutStackTrace $ \"cindex: index out of bound \" ++ show n\n where\n go (Left' i) x\n | i == n = Right' x\n | otherwise = Left' (i + 1)\n go r@Right'{} _ = r\n\n cnull :: Dom f a => f a -> Bool\n cnull = cfoldr (const $ const False) True\n\n clength :: Dom f a => f a -> Int\n {-# INLINE [1] clength #-}\n clength = cfoldl' (\\c _ -> c + 1) 0\n\n cany :: Dom f a => (a -> Bool) -> f a -> Bool\n {-# INLINE [1] cany #-}\n cany p = cfoldl' (\\b -> (||) b . p) False\n\n call :: Dom f a => (a -> Bool) -> f a -> Bool\n {-# INLINE [1] call #-}\n call p = cfoldl' (\\b -> (&&) b . p) True\n\n celem :: (Eq a, Dom f a) => a -> f a -> Bool\n {-# INLINE [1] celem #-}\n celem = cany . (==)\n\n cnotElem :: (Eq a, Dom f a) => a -> f a -> Bool\n {-# INLINE [1] cnotElem #-}\n cnotElem = call . (/=)\n\n cminimum :: (Ord a, Dom f a) => f a -> a\n {-# INLINE [1] cminimum #-}\n cminimum =\n getMin\n . fromMaybe (errorWithoutStackTrace \"minimum: empty structure\")\n . cfoldMap (Just . Min)\n\n cmaximum :: (Ord a, Dom f a) => f a -> a\n {-# INLINE [1] cmaximum #-}\n cmaximum =\n getMax\n . fromMaybe (errorWithoutStackTrace \"cmaximum: empty structure\")\n . cfoldMap (Just . Max)\n\n csum :: (Num a, Dom f a) => f a -> a\n {-# INLINE [1] csum #-}\n csum = getSum #. cfoldMap Sum\n\n cproduct :: (Num a, Dom f a) => f a -> a\n {-# INLINE [1] cproduct #-}\n cproduct = getProduct #. cfoldMap Product\n\n cctraverse_\n :: (CApplicative g, CPointed g, Dom g (), Dom f a, Dom g b)\n => (a -> g b)\n -> f a -> g ()\n {-# INLINE [1] cctraverse_ #-}\n cctraverse_ f = cfoldr c (cpure ())\n where\n {-# INLINE c #-}\n c x k = f x .> k\n\n ctraverse_\n :: (Applicative g, Dom f a)\n => (a -> g b)\n -> f a -> g ()\n {-# INLINE [1] ctraverse_ #-}\n ctraverse_ f = cfoldr c (pure ())\n where\n {-# INLINE c #-}\n c x k = f x *> k\n\n clast :: Dom f a => f a -> a\n {-# INLINE [1] clast #-}\n clast = fromJust . L.foldOver cfolded L.last\n\n chead :: Dom f a => f a -> a\n {-# INLINE [1] chead #-}\n chead = fromJust . L.foldOver cfolded L.head\n\n cfind :: Dom f a => (a -> Bool) -> f a -> Maybe a\n {-# INLINE [1] cfind #-}\n cfind = \\p -> getFirst . cfoldMap (\\x -> First $ if p x then Just x else Nothing)\n\n cfindIndex :: Dom f a => (a -> Bool) -> f a -> Maybe Int\n {-# INLINE [1] cfindIndex #-}\n cfindIndex = \\p -> L.foldOver cfolded (L.findIndex p)\n\n cfindIndices :: Dom f a => (a -> Bool) -> f a -> [Int]\n {-# INLINE [1] cfindIndices #-}\n cfindIndices = \\p -> List.findIndices p . ctoList\n\n celemIndex :: (Dom f a, Eq a) => a -> f a -> Maybe Int\n {-# INLINE [0] celemIndex #-}\n celemIndex = cfindIndex . (==)\n\n celemIndices :: (Dom f a, Eq a) => a -> f a -> [Int]\n {-# INLINE [0] celemIndices #-}\n celemIndices = cfindIndices . (==)\n\ndata Eith' a b = Left' !a | Right' !b\n\ninstance Traversable f => CTraversable (WrapFunctor f) where\n ctraverse = traverse\n {-# INLINE [1] ctraverse #-}\n\ninstance Foldable f => CFoldable (WrapFunctor f) where\n cfoldMap = foldMap\n {-# INLINE [1] cfoldMap #-}\n#if MIN_VERSION_base(4,13,0)\n cfoldMap' = foldMap'\n {-# INLINE [1] cfoldMap' #-}\n#endif\n cfold = fold\n {-# INLINE [1] cfold #-}\n cfoldr = foldr\n {-# INLINE [1] cfoldr #-}\n cfoldr' = foldr'\n {-# INLINE [1] cfoldr' #-}\n cfoldl = foldl\n {-# INLINE [1] cfoldl #-}\n cfoldl' = foldl'\n {-# INLINE [1] cfoldl' #-}\n cbasicToList = toList\n {-# INLINE [1] cbasicToList #-}\n cfoldr1 = foldr1\n {-# INLINE [1] cfoldr1 #-}\n cfoldl1 = foldl1\n {-# INLINE [1] cfoldl1 #-}\n cfoldlM = foldlM\n {-# INLINE [1] cfoldlM #-}\n cfoldrM = foldrM\n {-# INLINE [1] cfoldrM #-}\n cnull = null\n {-# INLINE [1] cnull #-}\n clength = length\n {-# INLINE [1] clength #-}\n cany = any\n {-# INLINE [1] cany #-}\n call = all\n {-# INLINE [1] call #-}\n celem = elem\n {-# INLINE [1] celem #-}\n cnotElem = notElem\n {-# INLINE [1] cnotElem #-}\n cminimum = minimum\n {-# INLINE [1] cminimum #-}\n cmaximum = maximum\n {-# INLINE [1] cmaximum #-}\n csum = sum\n {-# INLINE [1] csum #-}\n cproduct = product\n {-# INLINE [1] cproduct #-}\n ctraverse_ = traverse_\n {-# INLINE [1] ctraverse_ #-}\n cfind = find\n {-# INLINE [1] cfind #-}\n cfindIndex = L.fold . L.findIndex\n {-# INLINE [1] cfindIndex #-}\n celemIndex = L.fold . L.elemIndex\n {-# INLINE [1] celemIndex #-}\n\n{-# RULES\n\"cfind/List\"\n cfind = find @[]\n\n\"cfindIndex/List\"\n cfindIndex = List.findIndex\n\n\"cfindIndices/List\"\n cfindIndices = List.findIndices\n\n\"celemIndex/List\"\n celemIndex = List.elemIndex\n\n\"celemIndices/List\"\n celemIndices = List.elemIndices\n\n\"cfindIndex/List\"\n cfindIndex = Seq.findIndexL\n\n\"cfindIndices/Seq\"\n cfindIndices = Seq.findIndicesL\n\n\"celemIndex/Seq\"\n celemIndex = Seq.elemIndexL\n\n\"celemIndices/Seq\"\n celemIndices = Seq.elemIndicesL\n\n #-}\n\n{-# RULES\n\"cctraverse_/traverse_\"\n forall (f :: Applicative f => a -> f b) (tx :: Foldable t => t a).\n cctraverse_ f tx = traverse_ f tx\n #-}\n\n{-# RULES\n\"cindex/List\"\n cindex = (!!)\n #-}\n\nclass (CFunctor f, CFoldable f) => CTraversable f where\n -- | __N.B.__ If we require @g@ to be 'CApplicative'\n -- we cannot directly lift plain 'Traversable' to 'CTraversable'.\n -- This is rather annoying, so we require the strongest possible\n -- constraint to @g@ here.\n ctraverse\n :: (Dom f a, Dom f b, Applicative g)\n => (a -> g b) -> f a -> g (f b)\n\nderiving via WrapFunctor []\n instance CFoldable []\n{-# RULES\n\"ctoList/List\"\n ctoList = id\n\"cfromList/List\"\n cbasicFromList = id\n\"clast/List\"\n clast = last\n\"chead/List\"\n chead = head\n #-}\n\ninstance CTraversable [] where\n ctraverse = traverse\n {-# INLINE [1] ctraverse #-}\nderiving via WrapFunctor Maybe\n instance CFoldable Maybe\ninstance CTraversable Maybe where\n ctraverse = traverse\nderiving via WrapFunctor (Either e)\n instance CFoldable (Either e)\ninstance CTraversable (Either e) where\n ctraverse = traverse\n {-# INLINE [1] ctraverse #-}\nderiving via WrapFunctor IM.IntMap\n instance CFoldable IM.IntMap\ninstance CTraversable IM.IntMap where\n ctraverse = traverse\n {-# INLINE [1] ctraverse #-}\nderiving via WrapFunctor (M.Map k)\n instance CFoldable (M.Map k)\ninstance Ord k => CTraversable (M.Map k) where\n ctraverse = traverse\n {-# INLINE [1] ctraverse #-}\nderiving via WrapFunctor (HM.HashMap k)\n instance CFoldable (HM.HashMap k)\ninstance CTraversable (HM.HashMap k) where\n ctraverse = traverse\n {-# INLINE [1] ctraverse #-}\nderiving via WrapFunctor Seq.Seq\n instance CFoldable Seq.Seq\ninstance CTraversable Seq.Seq where\n ctraverse = traverse\n {-# INLINE [1] ctraverse #-}\n{-# RULES\n\"cindex/Seq\"\n cindex = Seq.index\n #-}\n\nderiving via WrapFunctor Par1\n instance CFoldable Par1\ninstance CTraversable Par1 where\n ctraverse = traverse\n {-# INLINE [1] ctraverse #-}\nderiving via WrapFunctor NonEmpty\n instance CFoldable NonEmpty\ninstance CTraversable NonEmpty where\n ctraverse = traverse\n {-# INLINE [1] ctraverse #-}\n{-# RULES\n\"cindex/NonEmpty\"\n cindex = (NE.!!)\n #-}\n\nderiving via WrapFunctor Down\n instance CFoldable Down\ninstance CTraversable Down where\n ctraverse = traverse\n {-# INLINE [1] ctraverse #-}\nderiving via WrapFunctor Mon.Last\n instance CFoldable Mon.Last\ninstance CTraversable Mon.Last where\n ctraverse = traverse\n {-# INLINE [1] ctraverse #-}\nderiving via WrapFunctor Mon.First\n instance CFoldable Mon.First\ninstance CTraversable Mon.First where\n ctraverse = traverse\n {-# INLINE [1] ctraverse #-}\nderiving via WrapFunctor Sem.Last\n instance CFoldable Sem.Last\ninstance CTraversable Sem.Last where\n ctraverse = traverse\n {-# INLINE [1] ctraverse #-}\nderiving via WrapFunctor Sem.First\n instance CFoldable Sem.First\ninstance CTraversable Sem.First where\n ctraverse = traverse\n {-# INLINE [1] ctraverse #-}\nderiving via WrapFunctor Identity\n instance CFoldable Identity\ninstance CTraversable Identity where\n ctraverse = traverse\n {-# INLINE [1] ctraverse #-}\nderiving via WrapFunctor ZipList\n instance CFoldable ZipList\ninstance CTraversable ZipList where\n ctraverse = traverse\n {-# INLINE [1] ctraverse #-}\n{-# RULES\n\"cindex/ZipList\"\n cindex = (!!) . getZipList\n #-}\n\nderiving via WrapFunctor Option\n instance CFoldable Option\ninstance CTraversable Option where\n ctraverse = traverse\n {-# INLINE [1] ctraverse #-}\nderiving via WrapFunctor Min\n instance CFoldable Min\ninstance CTraversable Min where\n ctraverse = traverse\n {-# INLINE [1] ctraverse #-}\nderiving via WrapFunctor Max\n instance CFoldable Max\ninstance CTraversable Max where\n ctraverse = traverse\n {-# INLINE [1] ctraverse #-}\nderiving via WrapFunctor Complex\n instance CFoldable Complex\ninstance CTraversable Complex where\n ctraverse = traverse\n {-# INLINE [1] ctraverse #-}\nderiving via WrapFunctor (V1 :: Type -> Type)\n instance CFoldable (V1 :: Type -> Type)\ninstance CTraversable (V1 :: Type -> Type) where\n ctraverse = traverse\n {-# INLINE [1] ctraverse #-}\nderiving via WrapFunctor (U1 :: Type -> Type)\n instance CFoldable (U1 :: Type -> Type)\ninstance CTraversable (U1 :: Type -> Type) where\n ctraverse = traverse\n {-# INLINE [1] ctraverse #-}\nderiving via WrapFunctor ((,) a)\n instance CFoldable ((,) a)\ninstance CTraversable ((,) a) where\n ctraverse = traverse\n {-# INLINE [1] ctraverse #-}\nderiving via WrapFunctor (Proxy :: Type -> Type)\n instance CFoldable (Proxy :: Type -> Type)\ninstance CTraversable (Proxy :: Type -> Type) where\n ctraverse = traverse\n {-# INLINE [1] ctraverse #-}\nderiving via WrapFunctor (Arg a)\n instance CFoldable (Arg a)\ninstance CTraversable (Arg a) where\n ctraverse = traverse\n {-# INLINE [1] ctraverse #-}\nderiving via WrapFunctor (Rec1 (f :: Type -> Type))\n instance Foldable f => CFoldable (Rec1 (f :: Type -> Type))\nderiving via WrapFunctor (URec Char :: Type -> Type)\n instance CFoldable (URec Char :: Type -> Type)\ninstance CTraversable (URec Char :: Type -> Type) where\n ctraverse = traverse\n {-# INLINE [1] ctraverse #-}\nderiving via WrapFunctor (URec Double :: Type -> Type)\n instance CFoldable (URec Double :: Type -> Type)\ninstance CTraversable (URec Double :: Type -> Type) where\n ctraverse = traverse\n {-# INLINE [1] ctraverse #-}\nderiving via WrapFunctor (URec Float :: Type -> Type)\n instance CFoldable (URec Float :: Type -> Type)\ninstance CTraversable (URec Float :: Type -> Type) where\n ctraverse = traverse\n {-# INLINE [1] ctraverse #-}\nderiving via WrapFunctor (URec Int :: Type -> Type)\n instance CFoldable (URec Int :: Type -> Type)\ninstance CTraversable (URec Int :: Type -> Type) where\n ctraverse = traverse\n {-# INLINE [1] ctraverse #-}\nderiving via WrapFunctor (URec Word :: Type -> Type)\n instance CFoldable (URec Word :: Type -> Type)\ninstance CTraversable (URec Word :: Type -> Type) where\n ctraverse = traverse\n {-# INLINE [1] ctraverse #-}\nderiving via WrapFunctor (URec (Ptr ()) :: Type -> Type)\n instance CFoldable (URec (Ptr ()) :: Type -> Type)\ninstance CTraversable (URec (Ptr ()) :: Type -> Type) where\n ctraverse = traverse\n {-# INLINE [1] ctraverse #-}\nderiving newtype\n instance CFoldable f => CFoldable (Alt f)\nderiving newtype\n instance CFoldable f => CFoldable (Ap f)\nderiving via WrapFunctor (Const m :: Type -> Type)\n instance CFoldable (Const m :: Type -> Type)\ninstance CTraversable (Const m :: Type -> Type) where\n ctraverse = traverse\n {-# INLINE [1] ctraverse #-}\nderiving via WrapFunctor (K1 i c :: Type -> Type)\n instance CFoldable (K1 i c :: Type -> Type)\ninstance CTraversable (K1 i c :: Type -> Type) where\n ctraverse = traverse\n {-# INLINE [1] ctraverse #-}\n\ninstance (CFoldable f, CFoldable g) => CFoldable (f :+: g) where\n {-# INLINE [1] cfoldMap #-}\n cfoldMap f = \\case\n L1 x -> cfoldMap f x\n R1 x -> cfoldMap f x\n\n {-# INLINE [1] cfoldr #-}\n cfoldr f z = \\case\n L1 x -> cfoldr f z x\n R1 x -> cfoldr f z x\n\n cfoldMap' = \\f -> \\case\n L1 x -> cfoldMap' f x\n R1 x -> cfoldMap' f x\n {-# INLINE [1] cfoldMap' #-}\n cfold = \\case\n L1 x -> cfold x\n R1 x -> cfold x\n {-# INLINE [1] cfold #-}\n cfoldr' = \\f z -> \\case\n L1 x -> cfoldr' f z x\n R1 x -> cfoldr' f z x\n {-# INLINE [1] cfoldr' #-}\n cfoldl = \\f z -> \\case\n L1 x -> cfoldl f z x\n R1 x -> cfoldl f z x\n {-# INLINE [1] cfoldl #-}\n cfoldl' = \\f z -> \\case\n L1 x -> cfoldl' f z x\n R1 x -> cfoldl' f z x\n {-# INLINE [1] cfoldl' #-}\n cbasicToList = \\case\n L1 x -> ctoList x\n R1 x -> ctoList x\n {-# INLINE cbasicToList #-}\n cfoldr1 = \\f -> \\case\n L1 x -> cfoldr1 f x\n R1 x -> cfoldr1 f x\n {-# INLINE [1] cfoldr1 #-}\n cfoldl1 = \\f -> \\case\n L1 x -> cfoldl1 f x\n R1 x -> cfoldl1 f x\n {-# INLINE [1] cfoldl1 #-}\n cnull = \\case\n L1 x -> cnull x\n R1 x -> cnull x\n {-# INLINE [1] cnull #-}\n clength = \\case\n L1 x -> clength x\n R1 x -> clength x\n {-# INLINE [1] clength #-}\n cany = \\f -> \\case\n L1 x -> cany f x\n R1 x -> cany f x\n {-# INLINE [1] cany #-}\n call = \\f -> \\case\n L1 x -> call f x\n R1 x -> call f x\n {-# INLINE [1] call #-}\n celem = \\x -> \\case\n L1 xs -> celem x xs\n R1 xs -> celem x xs\n {-# INLINE [1] celem #-}\n cminimum = \\case\n L1 xs -> cminimum xs\n R1 xs -> cminimum xs\n {-# INLINE [1] cminimum #-}\n cmaximum = \\case\n L1 xs -> cmaximum xs\n R1 xs -> cmaximum xs\n {-# INLINE [1] cmaximum #-}\n csum = \\case\n L1 xs -> csum xs\n R1 xs -> csum xs\n {-# INLINE [1] csum #-}\n cproduct = \\case\n L1 xs -> cproduct xs\n R1 xs -> cproduct xs\n {-# INLINE [1] cproduct #-}\n ctraverse_ f = \\case\n L1 xs -> ctraverse_ f xs\n R1 xs -> ctraverse_ f xs\n {-# INLINE [1] ctraverse_ #-}\n\ninstance (CTraversable f, CTraversable g) => CTraversable (f :+: g) where\n ctraverse f = \\case\n L1 xs -> L1 <$> ctraverse f xs\n R1 xs -> R1 <$> ctraverse f xs\n {-# INLINE [1] ctraverse #-}\n\ninstance (CFoldable f, CFoldable g) => CFoldable (f :*: g) where\n {-# INLINE [1] cfoldMap #-}\n cfoldMap f (l :*: r) = cfoldMap f l <> cfoldMap f r\n\n cfoldMap' f (l :*: r) = cfoldMap' f l <> cfoldMap' f r\n {-# INLINE [1] cfoldMap' #-}\n cfold (l :*: r) = cfold l <> cfold r\n {-# INLINE [1] cfold #-}\n cnull (l :*: r) = cnull l && cnull r\n {-# INLINE [1] cnull #-}\n clength (l :*: r) = clength l + clength r\n {-# INLINE [1] clength #-}\n cany f (l :*: r) = cany f l || cany f r\n {-# INLINE [1] cany #-}\n call f (l :*: r) = call f l && call f r\n {-# INLINE [1] call #-}\n celem x (l :*: r) = celem x l || celem x r\n {-# INLINE [1] celem #-}\n csum (l :*: r) = csum l + csum r\n {-# INLINE [1] csum #-}\n cproduct (l :*: r) = cproduct l * cproduct r\n {-# INLINE [1] cproduct #-}\n ctraverse_ f (l :*: r) = ctraverse_ f l *> ctraverse_ f r\n {-# INLINE [1] ctraverse_ #-}\n\ninstance (CTraversable f, CTraversable g) => CTraversable (f :*: g) where\n ctraverse f (l :*: r) =\n (:*:) <$> ctraverse f l <*> ctraverse f r\n\ninstance (CFoldable f, CFoldable g) => CFoldable (SOP.Sum f g) where\n {-# INLINE [1] cfoldMap #-}\n cfoldMap f = \\case\n SOP.InL x -> cfoldMap f x\n SOP.InR x -> cfoldMap f x\n\n {-# INLINE [1] cfoldr #-}\n cfoldr f z = \\case\n SOP.InL x -> cfoldr f z x\n SOP.InR x -> cfoldr f z x\n\n cfoldMap' = \\f -> \\case\n SOP.InL x -> cfoldMap' f x\n SOP.InR x -> cfoldMap' f x\n {-# INLINE [1] cfoldMap' #-}\n cfold = \\case\n SOP.InL x -> cfold x\n SOP.InR x -> cfold x\n {-# INLINE [1] cfold #-}\n cfoldr' = \\f z -> \\case\n SOP.InL x -> cfoldr' f z x\n SOP.InR x -> cfoldr' f z x\n {-# INLINE [1] cfoldr' #-}\n cfoldl = \\f z -> \\case\n SOP.InL x -> cfoldl f z x\n SOP.InR x -> cfoldl f z x\n {-# INLINE [1] cfoldl #-}\n cfoldl' = \\f z -> \\case\n SOP.InL x -> cfoldl' f z x\n SOP.InR x -> cfoldl' f z x\n {-# INLINE [1] cfoldl' #-}\n cbasicToList = \\case\n SOP.InL x -> ctoList x\n SOP.InR x -> ctoList x\n {-# INLINE cbasicToList #-}\n cfoldr1 = \\f -> \\case\n SOP.InL x -> cfoldr1 f x\n SOP.InR x -> cfoldr1 f x\n {-# INLINE [1] cfoldr1 #-}\n cfoldl1 = \\f -> \\case\n SOP.InL x -> cfoldl1 f x\n SOP.InR x -> cfoldl1 f x\n {-# INLINE [1] cfoldl1 #-}\n cnull = \\case\n SOP.InL x -> cnull x\n SOP.InR x -> cnull x\n {-# INLINE [1] cnull #-}\n clength = \\case\n SOP.InL x -> clength x\n SOP.InR x -> clength x\n {-# INLINE [1] clength #-}\n cany = \\f -> \\case\n SOP.InL x -> cany f x\n SOP.InR x -> cany f x\n {-# INLINE [1] cany #-}\n call = \\f -> \\case\n SOP.InL x -> call f x\n SOP.InR x -> call f x\n {-# INLINE [1] call #-}\n celem = \\x -> \\case\n SOP.InL xs -> celem x xs\n SOP.InR xs -> celem x xs\n {-# INLINE [1] celem #-}\n cminimum = \\case\n SOP.InL xs -> cminimum xs\n SOP.InR xs -> cminimum xs\n {-# INLINE [1] cminimum #-}\n cmaximum = \\case\n SOP.InL xs -> cmaximum xs\n SOP.InR xs -> cmaximum xs\n {-# INLINE [1] cmaximum #-}\n csum = \\case\n SOP.InL xs -> csum xs\n SOP.InR xs -> csum xs\n {-# INLINE [1] csum #-}\n cproduct = \\case\n SOP.InL xs -> cproduct xs\n SOP.InR xs -> cproduct xs\n {-# INLINE [1] cproduct #-}\n ctraverse_ f = \\case\n SOP.InL xs -> ctraverse_ f xs\n SOP.InR xs -> ctraverse_ f xs\n {-# INLINE [1] ctraverse_ #-}\n\ninstance (CTraversable f, CTraversable g) => CTraversable (SOP.Sum f g) where\n ctraverse f = \\case\n SOP.InL xs -> SOP.InL <$> ctraverse f xs\n SOP.InR xs -> SOP.InR <$> ctraverse f xs\n {-# INLINE [1] ctraverse #-}\n\ninstance (CFoldable f, CFoldable g) => CFoldable (SOP.Product f g) where\n {-# INLINE [1] cfoldMap #-}\n cfoldMap f (SOP.Pair l r) = cfoldMap f l <> cfoldMap f r\n\n cfoldMap' f (SOP.Pair l r) = cfoldMap' f l <> cfoldMap' f r\n {-# INLINE [1] cfoldMap' #-}\n cfold (SOP.Pair l r) = cfold l <> cfold r\n {-# INLINE [1] cfold #-}\n cnull (SOP.Pair l r) = cnull l && cnull r\n {-# INLINE [1] cnull #-}\n clength (SOP.Pair l r) = clength l + clength r\n {-# INLINE [1] clength #-}\n cany f (SOP.Pair l r) = cany f l || cany f r\n {-# INLINE [1] cany #-}\n call f (SOP.Pair l r) = call f l && call f r\n {-# INLINE [1] call #-}\n celem x (SOP.Pair l r) = celem x l || celem x r\n {-# INLINE [1] celem #-}\n csum (SOP.Pair l r) = csum l + csum r\n {-# INLINE [1] csum #-}\n cproduct (SOP.Pair l r) = cproduct l * cproduct r\n {-# INLINE [1] cproduct #-}\n ctraverse_ f (SOP.Pair l r) =\n ctraverse_ f l *> ctraverse_ f r\n {-# INLINE ctraverse_ #-}\n\nderiving via WrapFunctor SA.SmallArray instance CFoldable SA.SmallArray\nderiving via WrapFunctor A.Array instance CFoldable A.Array\n\ninstance CFoldable PA.PrimArray where\n cfoldr = PA.foldrPrimArray\n {-# INLINE [1] cfoldr #-}\n cfoldl' = PA.foldlPrimArray'\n {-# INLINE [1] cfoldl' #-}\n cfoldlM' = PA.foldlPrimArrayM'\n {-# INLINE [1] cfoldlM' #-}\n cfoldl = PA.foldlPrimArray\n {-# INLINE [1] cfoldl #-}\n clength = PA.sizeofPrimArray\n {-# INLINE [1] clength #-}\n csum = PA.foldlPrimArray' (+) 0\n {-# INLINE [1] csum #-}\n cproduct = PA.foldlPrimArray' (*) 1\n {-# INLINE [1] cproduct #-}\n ctraverse_ = PA.traversePrimArray_\n {-# INLINE [1] ctraverse_ #-}\n\ninstance CTraversable PA.PrimArray where\n ctraverse = PA.traversePrimArray\n {-# INLINE [1] ctraverse #-}\n\ninstance CTraversable SA.SmallArray where\n ctraverse = traverse\n {-# INLINE [1] ctraverse #-}\n\ninstance CTraversable A.Array where\n ctraverse = traverse\n {-# INLINE [1] ctraverse #-}\n\ninstance (CTraversable f, CTraversable g) => CTraversable (SOP.Product f g) where\n {-# INLINE [1] ctraverse #-}\n ctraverse f (SOP.Pair l r) =\n SOP.Pair <$> ctraverse f l <*> ctraverse f r\n\ninstance CFoldable Set.Set where\n cfoldMap = ofoldMap\n {-# INLINE [1] cfoldMap #-}\n cfoldr = Set.foldr\n {-# INLINE [1] cfoldr #-}\n cfoldl = Set.foldl\n {-# INLINE [1] cfoldl #-}\n cfoldr' = Set.foldr'\n {-# INLINE [1] cfoldr' #-}\n cfoldl' = Set.foldl'\n {-# INLINE [1] cfoldl' #-}\n cminimum = Set.findMin\n {-# INLINE [1] cminimum #-}\n cmaximum = Set.findMax\n {-# INLINE [1] cmaximum #-}\n celem = Set.member\n {-# INLINE [1] celem #-}\n cnotElem = Set.notMember\n {-# INLINE [1] cnotElem #-}\n cbasicToList = Set.toList\n {-# INLINE cbasicToList #-}\n celemIndex = Set.lookupIndex\n {-# INLINE [1] celemIndex #-}\n cindex = flip Set.elemAt\n {-# INLINE [1] cindex #-}\n\ninstance CTraversable Set.Set where\n -- TODO: more efficient implementation\n ctraverse f =\n fmap Set.fromList\n . traverse f\n . Set.toList\n {-# INLINE [1] ctraverse #-}\n\ninstance CFoldable HS.HashSet where\n cfoldMap = ofoldMap\n {-# INLINE [1] cfoldMap #-}\n cfoldr = HS.foldr\n {-# INLINE [1] cfoldr #-}\n cfoldl' = HS.foldl'\n {-# INLINE [1] cfoldl' #-}\n celem = HS.member\n {-# INLINE [1] celem #-}\n cbasicToList = HS.toList\n {-# INLINE cbasicToList #-}\n\ninstance CTraversable HS.HashSet where\n -- TODO: more efficient implementation\n ctraverse f =\n fmap HS.fromList\n . traverse f\n . HS.toList\n {-# INLINE [1] ctraverse #-}\n\n{-# RULES\n\"celem/IntSet\"\n celem = coerce\n @(Int -> IS.IntSet -> Bool)\n @(Int -> WrapMono IS.IntSet Int -> Bool)\n IS.member\n\"cnotElem/IntSet\"\n cnotElem = coerce\n @(Int -> IS.IntSet -> Bool)\n @(Int -> WrapMono IS.IntSet Int -> Bool)\n IS.notMember\n\"cmaximum/IntSet\"\n cmaximum = coerce @_ @(WrapMono IS.IntSet Int -> Int)\n IS.findMax\n\"cminimum/IntSet\"\n cminimum = coerce @(IS.IntSet -> Int) @(WrapMono IS.IntSet Int -> Int)\n IS.findMin\n #-}\n\ninstance MonoFoldable mono => CFoldable (WrapMono mono) where\n cfoldMap = ofoldMap\n {-# INLINE [1] cfoldMap #-}\n cfold = ofold\n {-# INLINE [1] cfold #-}\n cfoldr = ofoldr\n {-# INLINE [1] cfoldr #-}\n cfoldl' = ofoldl'\n {-# INLINE [1] cfoldl' #-}\n cfoldlM = ofoldlM\n {-# INLINE [1] cfoldlM #-}\n cbasicToList = otoList\n {-# INLINE cbasicToList #-}\n cfoldr1 = ofoldr1Ex\n {-# INLINE [1] cfoldr1 #-}\n cnull = onull\n {-# INLINE [1] cnull #-}\n clength = olength\n {-# INLINE [1] clength #-}\n cany = oany\n {-# INLINE [1] cany #-}\n call = oall\n {-# INLINE [1] call #-}\n celem = oelem\n {-# INLINE [1] celem #-}\n cnotElem = onotElem\n {-# INLINE [1] cnotElem #-}\n cminimum = minimumEx\n {-# INLINE [1] cminimum #-}\n cmaximum = maximumEx\n {-# INLINE [1] cmaximum #-}\n csum = osum\n {-# INLINE [1] csum #-}\n cproduct = oproduct\n {-# INLINE [1] cproduct #-}\n ctraverse_ = otraverse_\n {-# INLINE [1] ctraverse_ #-}\n\ninstance MonoTraversable mono => CTraversable (WrapMono mono) where\n ctraverse = \\f -> fmap WrapMono . otraverse f . unwrapMono\n\ninstance CFoldable V.Vector where\n {-# INLINE [1] cfoldMap #-}\n cfoldMap = foldMap\n {-# INLINE [1] cfoldr #-}\n cfoldr = V.foldr\n {-# INLINE [1] cfoldr' #-}\n cfoldr' = V.foldr'\n {-# INLINE [1] cfoldl #-}\n cfoldl = V.foldl\n {-# INLINE [1] cfoldl' #-}\n cfoldl' = V.foldl'\n {-# INLINE cfoldlM #-}\n cfoldlM = V.foldM\n {-# INLINE cfoldlM' #-}\n cfoldlM' = V.foldM'\n {-# INLINE [1] cindex #-}\n cindex = (V.!)\n {-# INLINE [1] celem #-}\n celem = V.elem\n {-# INLINE [1] cnotElem #-}\n cnotElem = V.notElem\n {-# INLINE [1] cany #-}\n cany = V.any\n {-# INLINE [1] call #-}\n call = V.all\n {-# INLINE [1] cfoldl1 #-}\n cfoldl1 = V.foldl1\n {-# INLINE [1] cfoldr1 #-}\n cfoldr1 = V.foldr1\n {-# INLINE [1] csum #-}\n csum = V.sum\n {-# INLINE [1] cproduct #-}\n cproduct = V.product\n {-# INLINE [1] cmaximum #-}\n cmaximum = V.maximum\n {-# INLINE [1] cminimum #-}\n cminimum = V.minimum\n {-# INLINE cbasicToList #-}\n cbasicToList = V.toList\n {-# INLINE [1] clast #-}\n clast = V.last\n {-# INLINE [1] chead #-}\n chead = V.head\n {-# INLINE [1] cfind #-}\n cfind = V.find\n {-# INLINE [1] cfindIndex #-}\n cfindIndex = V.findIndex\n {-# INLINE [1] cfindIndices #-}\n cfindIndices = fmap V.toList . V.findIndices\n {-# INLINE [1] celemIndex #-}\n celemIndex = V.elemIndex\n {-# INLINE [1] celemIndices #-}\n celemIndices = fmap V.toList . V.elemIndices\n\ninstance CFoldable U.Vector where\n {-# INLINE [1] cfoldMap #-}\n cfoldMap = ofoldMap\n {-# INLINE [1] cfoldr #-}\n cfoldr = U.foldr\n {-# INLINE [1] cfoldr' #-}\n cfoldr' = U.foldr'\n {-# INLINE [1] cfoldl #-}\n cfoldl = U.foldl\n {-# INLINE [1] cfoldl' #-}\n cfoldl' = U.foldl'\n {-# INLINE cfoldlM #-}\n cfoldlM = U.foldM\n {-# INLINE cfoldlM' #-}\n cfoldlM' = U.foldM'\n {-# INLINE [1] cindex #-}\n cindex = (U.!)\n {-# INLINE [1] celem #-}\n celem = U.elem\n {-# INLINE [1] cnotElem #-}\n cnotElem = U.notElem\n {-# INLINE [1] cany #-}\n cany = U.any\n {-# INLINE [1] call #-}\n call = U.all\n {-# INLINE [1] cfoldl1 #-}\n cfoldl1 = U.foldl1\n {-# INLINE [1] cfoldr1 #-}\n cfoldr1 = U.foldr1\n {-# INLINE [1] csum #-}\n csum = U.sum\n {-# INLINE [1] cproduct #-}\n cproduct = U.product\n {-# INLINE [1] cmaximum #-}\n cmaximum = U.maximum\n {-# INLINE [1] cminimum #-}\n cminimum = U.minimum\n {-# INLINE cbasicToList #-}\n cbasicToList = U.toList\n {-# INLINE [1] clast #-}\n clast = U.last\n {-# INLINE [1] chead #-}\n chead = U.head\n {-# INLINE [1] cfind #-}\n cfind = U.find\n {-# INLINE [1] cfindIndex #-}\n cfindIndex = U.findIndex\n {-# INLINE [1] cfindIndices #-}\n cfindIndices = fmap U.toList . U.findIndices\n {-# INLINE [1] celemIndex #-}\n celemIndex = U.elemIndex\n {-# INLINE [1] celemIndices #-}\n celemIndices = fmap U.toList . U.elemIndices\n\ninstance CFoldable S.Vector where\n {-# INLINE [1] cfoldr #-}\n cfoldr = S.foldr\n {-# INLINE [1] cfoldr' #-}\n cfoldr' = S.foldr'\n {-# INLINE [1] cfoldl #-}\n cfoldl = S.foldl\n {-# INLINE [1] cfoldl' #-}\n cfoldl' = S.foldl'\n {-# INLINE cfoldlM #-}\n cfoldlM = S.foldM\n {-# INLINE cfoldlM' #-}\n cfoldlM' = S.foldM'\n {-# INLINE [1] cindex #-}\n cindex = (S.!)\n {-# INLINE [1] celem #-}\n celem = S.elem\n {-# INLINE [1] cnotElem #-}\n cnotElem = S.notElem\n {-# INLINE [1] cany #-}\n cany = S.any\n {-# INLINE [1] call #-}\n call = S.all\n {-# INLINE [1] cfoldl1 #-}\n cfoldl1 = S.foldl1\n {-# INLINE [1] cfoldr1 #-}\n cfoldr1 = S.foldr1\n {-# INLINE [1] csum #-}\n csum = S.sum\n {-# INLINE [1] cproduct #-}\n cproduct = S.product\n {-# INLINE [1] cmaximum #-}\n cmaximum = S.maximum\n {-# INLINE [1] cminimum #-}\n cminimum = S.minimum\n {-# INLINE cbasicToList #-}\n cbasicToList = S.toList\n {-# INLINE [1] clast #-}\n clast = S.last\n {-# INLINE [1] chead #-}\n chead = S.head\n {-# INLINE [1] cfind #-}\n cfind = S.find\n {-# INLINE [1] cfindIndex #-}\n cfindIndex = S.findIndex\n {-# INLINE [1] cfindIndices #-}\n cfindIndices = fmap S.toList . S.findIndices\n {-# INLINE [1] celemIndex #-}\n celemIndex = S.elemIndex\n {-# INLINE [1] celemIndices #-}\n celemIndices = fmap S.toList . S.elemIndices\n\ninstance CFoldable P.Vector where\n {-# INLINE [1] cfoldr #-}\n cfoldr = P.foldr\n {-# INLINE [1] cfoldr' #-}\n cfoldr' = P.foldr'\n {-# INLINE [1] cfoldl #-}\n cfoldl = P.foldl\n {-# INLINE [1] cfoldl' #-}\n cfoldl' = P.foldl'\n {-# INLINE cfoldlM #-}\n cfoldlM = P.foldM\n {-# INLINE cfoldlM' #-}\n cfoldlM' = P.foldM'\n {-# INLINE [1] cindex #-}\n cindex = (P.!)\n {-# INLINE [1] celem #-}\n celem = P.elem\n {-# INLINE [1] cnotElem #-}\n cnotElem = P.notElem\n {-# INLINE [1] cany #-}\n cany = P.any\n {-# INLINE [1] call #-}\n call = P.all\n {-# INLINE [1] cfoldl1 #-}\n cfoldl1 = P.foldl1\n {-# INLINE [1] cfoldr1 #-}\n cfoldr1 = P.foldr1\n {-# INLINE [1] csum #-}\n csum = P.sum\n {-# INLINE [1] cproduct #-}\n cproduct = P.product\n {-# INLINE [1] cmaximum #-}\n cmaximum = P.maximum\n {-# INLINE [1] cminimum #-}\n cminimum = P.minimum\n {-# INLINE cbasicToList #-}\n cbasicToList = P.toList\n {-# INLINE [1] clast #-}\n clast = P.last\n {-# INLINE [1] chead #-}\n chead = P.head\n {-# INLINE [1] cfind #-}\n cfind = P.find\n {-# INLINE [1] cfindIndex #-}\n cfindIndex = P.findIndex\n {-# INLINE [1] cfindIndices #-}\n cfindIndices = fmap P.toList . P.findIndices\n {-# INLINE [1] celemIndex #-}\n celemIndex = P.elemIndex\n {-# INLINE [1] celemIndices #-}\n celemIndices = fmap P.toList . P.elemIndices\n\ninstance CTraversable V.Vector where\n ctraverse = traverse\n {-# INLINE [1] ctraverse #-}\n\ninstance CTraversable U.Vector where\n ctraverse = \\f -> fmap S.convert . traverse f . U.convert @_ @_ @V.Vector\n {-# INLINE [1] ctraverse #-}\n\ninstance CTraversable S.Vector where\n ctraverse = \\f -> fmap S.convert . traverse f . U.convert @_ @_ @V.Vector\n {-# INLINE [1] ctraverse #-}\n\ninstance CTraversable P.Vector where\n ctraverse = \\f -> fmap P.convert . traverse f . U.convert @_ @_ @V.Vector\n {-# INLINE [1] ctraverse #-}\n\n{-# RULES\n\"cindex/IsSequence\" forall (xs :: (MT.Index mono ~ Int, IsSequence mono) => WrapMono mono b).\n cindex xs = withMonoCoercible (coerce @(mono -> Int -> Element mono) indexEx xs)\n #-}\n\n{-# RULES\n\"cfromList/ctoList\" [~1]\n cfromList . ctoList = id\n\"cfromList/ctoList\" [~1] forall xs.\n cfromList (ctoList xs) = xs\n #-}\n\n{-# RULES\n\"ctoList/cfromList\" [~1]\n ctoList . cfromList = id\n\"ctoList/cfromList\" forall xs.\n ctoList (cfromList xs) = xs\n #-}\n-- | Free monoid functor from fullsubcategory.\n-- It must be a pointed foldable functor with the property\n-- that for any 'Monoid' @w@ and @f :: a -> w@,\n-- @'cfoldMap' f@ must be a monoid homomorphism and the following\n-- must be hold:\n--\n-- @\n-- 'cfoldMap' f . 'cpure' == f\n-- @\n--\n-- Hence, @'Set's@ cannot be a free monoid functor;\nclass (CFunctor f, forall x. Dom f x => Monoid (f x), CPointed f, CFoldable f)\n => CFreeMonoid f where\n cbasicFromList :: Dom f a => [a] -> f a\n cbasicFromList = foldr ((<>) . cpure) mempty\n {-# INLINE cbasicFromList #-}\n\n ccons :: Dom f a => a -> f a -> f a\n {-# INLINE [1] ccons #-}\n ccons = (<>) . cpure\n\n csnoc :: Dom f a => f a -> a -> f a\n {-# INLINE [1] csnoc #-}\n csnoc = (. cpure) . (<>)\n\n {- |\n The 'cfromListN' function takes the input list's length as a hint. Its behaviour should be equivalent to 'cfromList'. The hint can be used to construct the structure l more efficiently compared to 'cfromList'.\n If the given hint does not equal to the input list's length the behaviour of fromListN is not specified.\n -}\n cfromListN :: Dom f a => Int -> [a] -> f a\n cfromListN = const cfromList\n {-# INLINE [1] cfromListN #-}\n\n ctake :: Dom f a => Int -> f a -> f a\n {-# INLINE [1] ctake #-}\n ctake n = cfromList . take n . ctoList\n\n cdrop :: Dom f a => Int -> f a -> f a\n {-# INLINE [1] cdrop #-}\n cdrop n = cfromList . drop n . ctoList\n\n cinit :: Dom f a => f a -> f a\n {-# INLINE [1] cinit #-}\n cinit = cfromList . init . ctoList\n\n ctail :: Dom f a => f a -> f a\n ctail = cfromList . tail . ctoList\n\n csplitAt :: Dom f a => Int -> f a -> (f a, f a)\n {-# INLINE [1] csplitAt #-}\n csplitAt n = (\\(a, b) -> (cfromList a, cfromList b)) . splitAt n . ctoList\n\n creplicate :: Dom f a => Int -> a -> f a\n {-# INLINE [1] creplicate #-}\n creplicate n = cfromList . replicate n\n\n cgenerate :: Dom f a => Int -> (Int -> a) -> f a\n {-# INLINE [1] cgenerate #-}\n cgenerate = \\n f ->\n cfromList [f i | i <- [0.. n - 1]]\n\n cgenerateM :: (Dom f a, Monad m) => Int -> (Int -> m a) -> m (f a)\n {-# INLINE [1] cgenerateM #-}\n cgenerateM = \\n f ->\n cfromList <$> mapM f [0..n-1]\n\n cgenerateA :: (Dom f a, Applicative g) => Int -> (Int -> g a) -> g (f a)\n {-# INLINE [1] cgenerateA #-}\n cgenerateA = \\n f ->\n cfromList <$> traverse f [0..n-1]\n\n cuncons :: Dom f a => f a -> Maybe (a, f a)\n {-# INLINE [1] cuncons #-}\n cuncons = fmap (second cfromList) . uncons . ctoList\n\n cunsnoc :: Dom f a => f a -> Maybe (f a, a)\n {-# INLINE [1] cunsnoc #-}\n cunsnoc = fmap (first cfromList) . MT.unsnoc . ctoList\n\n creverse :: Dom f a => f a -> f a\n {-# INLINE [1] creverse #-}\n creverse = cfromList . reverse . ctoList\n\n cintersperse :: Dom f a => a -> f a -> f a\n cintersperse = \\a -> cfromList . intersperse a . ctoList\n\n cnub :: (Dom f a, Eq a) => f a -> f a\n {-# INLINE [1] cnub #-}\n cnub = cfromList . nub . ctoList\n\n cnubOrd :: (Dom f a, Ord a) => f a -> f a\n {-# INLINE [1] cnubOrd #-}\n cnubOrd = cfromList . L.foldOver cfolded L.nub\n\n csort :: (Dom f a, Ord a) => f a -> f a\n {-# INLINE [1] csort #-}\n csort = cfromList . List.sort . ctoList\n\n csortBy :: (Dom f a) => (a -> a -> Ordering) -> f a -> f a\n {-# INLINE [1] csortBy #-}\n csortBy = \\f -> cfromList . List.sortBy f . ctoList\n\n cinsert :: (Dom f a, Ord a) => a -> f a -> f a\n {-# INLINE [1] cinsert #-}\n cinsert = \\a -> cfromList . List.insert a . ctoList\n\n cinsertBy :: (Dom f a) => (a -> a -> Ordering) -> a -> f a -> f a\n {-# INLINE [1] cinsertBy #-}\n cinsertBy = \\f a -> cfromList . List.insertBy f a . ctoList\n\n ctakeWhile :: Dom f a => (a -> Bool) -> f a -> f a\n {-# INLINE [1] ctakeWhile #-}\n ctakeWhile = \\f -> cfromList . takeWhile f . ctoList\n\n cdropWhile :: Dom f a => (a -> Bool) -> f a -> f a\n {-# INLINE [1] cdropWhile #-}\n cdropWhile = \\f -> cfromList . dropWhile f . ctoList\n\n cspan :: Dom f a => (a -> Bool) -> f a -> (f a, f a)\n {-# INLINE [1] cspan #-}\n cspan = \\f -> (cfromList *** cfromList) . span f . ctoList\n\n cbreak :: Dom f a => (a -> Bool) -> f a -> (f a, f a)\n {-# INLINE [1] cbreak #-}\n cbreak = \\f -> (cfromList *** cfromList) . break f . ctoList\n\n cfilter :: Dom f a => (a -> Bool) -> f a -> f a\n {-# INLINE [1] cfilter #-}\n cfilter = \\f -> cfromList . filter f . ctoList\n\n cpartition :: Dom f a => (a -> Bool) -> f a -> (f a, f a)\n {-# INLINE [1] cpartition #-}\n cpartition = \\f -> (cfromList *** cfromList) . List.partition f . ctoList\n\n -- TODO: more ListLike equivalent functions here\n\ninstance CFreeMonoid [] where\n cbasicFromList = id\n {-# INLINE cbasicFromList #-}\n cfromListN = take\n {-# INLINE [1] cfromListN #-}\n ccons = (:)\n {-# INLINE [1] ccons #-}\n csnoc = \\xs x -> xs ++ [x]\n {-# INLINE [1] csnoc #-}\n ctake = take\n {-# INLINE [1] ctake #-}\n cdrop = drop\n {-# INLINE [1] cdrop #-}\n cinit = init\n {-# INLINE [1] cinit #-}\n ctail = tail\n {-# INLINE [1] ctail #-}\n csplitAt = splitAt\n {-# INLINE [1] csplitAt #-}\n creplicate = replicate\n {-# INLINE [1] creplicate #-}\n cgenerateM = \\n f -> mapM f [0..n-1]\n {-# INLINE [1] cgenerateM #-}\n cgenerateA = \\n f -> traverse f [0..n-1]\n {-# INLINE [1] cgenerateA #-}\n cuncons = uncons\n {-# INLINE [1] cuncons #-}\n cunsnoc = MT.unsnoc\n {-# INLINE [1] cunsnoc #-}\n creverse = reverse\n {-# INLINE [1] creverse #-}\n cintersperse = intersperse\n {-# INLINE [1] cintersperse #-}\n cnub = cnub\n {-# INLINE [1] cnub #-}\n csort = List.sort\n {-# INLINE [1] csort #-}\n csortBy = List.sortBy\n {-# INLINE [1] csortBy #-}\n ctakeWhile = takeWhile\n {-# INLINE [1] ctakeWhile #-}\n cdropWhile = dropWhile\n {-# INLINE [1] cdropWhile #-}\n cspan = span\n {-# INLINE [1] cspan #-}\n cbreak = break\n {-# INLINE [1] cbreak #-}\n cfilter = filter\n {-# INLINE [1] cfilter #-}\n cpartition = List.partition\n {-# INLINE [1] cpartition #-}\n\nfmap concat $ forM\n [''V.Vector, ''U.Vector, ''S.Vector, ''P.Vector]\n $ \\vecTy@(Name _ (NameG _ pkg modl0@(ModName mn))) ->\n let modl = maybe modl0 (ModName . T.unpack)\n $ T.stripSuffix \".Base\" $ T.pack mn\n modFun fun = varE $\n Name (OccName fun) (NameG VarName pkg modl)\n in [d|\n instance CFreeMonoid $(conT vecTy) where\n cbasicFromList = $(modFun \"fromList\")\n {-# INLINE cbasicFromList #-}\n cfromListN = $(modFun \"fromListN\")\n {-# INLINE [1] cfromListN #-}\n ccons = $(modFun \"cons\")\n {-# INLINE [1] ccons #-}\n csnoc = $(modFun \"snoc\")\n {-# INLINE [1] csnoc #-}\n ctake = $(modFun \"take\")\n {-# INLINE [1] ctake #-}\n cdrop = $(modFun \"drop\")\n {-# INLINE [1] cdrop #-}\n cinit = $(modFun \"init\")\n {-# INLINE [1] cinit #-}\n ctail = $(modFun \"tail\")\n {-# INLINE [1] ctail #-}\n csplitAt = $(modFun \"splitAt\")\n {-# INLINE [1] csplitAt #-}\n creplicate = $(modFun \"replicate\")\n {-# INLINE [1] creplicate #-}\n cgenerate = $(modFun \"generate\")\n {-# INLINE [1] cgenerate #-}\n cgenerateM = $(modFun \"generateM\")\n {-# INLINE [1] cgenerateM #-}\n cgenerateA = \\n f ->\n fmap VB.build\n $ getAp $ foldMap (Ap . fmap VB.singleton . f) [0..n-1]\n {-# INLINE [1] cgenerateA #-}\n cuncons = \\xs ->\n if $(modFun \"null\") xs\n then Nothing\n else Just ($(modFun \"head\") xs, $(modFun \"tail\") xs)\n {-# INLINE [1] cuncons #-}\n cunsnoc = \\xs ->\n if $(modFun \"null\") xs\n then Nothing\n else Just ($(modFun \"init\") xs, $(modFun \"last\") xs)\n {-# INLINE [1] cunsnoc #-}\n creverse = $(modFun \"reverse\")\n {-# INLINE [1] creverse #-}\n cnubOrd = $(modFun \"uniq\") . $(modFun \"modify\") AI.sort\n {-# INLINE cnubOrd #-}\n csort = $(modFun \"modify\") AI.sort\n {-# INLINE [1] csort #-}\n csortBy = \\f -> $(modFun \"modify\") $ AI.sortBy f\n {-# INLINE [1] csortBy #-}\n ctakeWhile = $(modFun \"takeWhile\")\n {-# INLINE [1] ctakeWhile #-}\n cdropWhile = $(modFun \"dropWhile\")\n {-# INLINE [1] cdropWhile #-}\n cspan = $(modFun \"span\")\n {-# INLINE [1] cspan #-}\n cbreak = $(modFun \"break\")\n {-# INLINE [1] cbreak #-}\n cfilter = $(modFun \"filter\")\n {-# INLINE [1] cfilter #-}\n cpartition = $(modFun \"partition\")\n {-# INLINE [1] cpartition #-}\n |]\n\ninstance CFreeMonoid PA.PrimArray where\n cbasicFromList = PA.primArrayFromList\n {-# INLINE cbasicFromList #-}\n cfromListN = PA.primArrayFromListN\n {-# INLINE [1] cfromListN #-}\n cgenerate = PA.generatePrimArray\n {-# INLINE [1] cgenerate #-}\n cgenerateM = PA.generatePrimArrayA\n {-# INLINE [1] cgenerateM #-}\n cgenerateA = PA.generatePrimArrayA\n {-# INLINE [1] cgenerateA #-}\n cfilter = PA.filterPrimArray\n {-# INLINE [1] cfilter #-}\n creplicate = PA.replicatePrimArray\n {-# INLINE [1] creplicate #-}\n\ninstance CFreeMonoid SA.SmallArray where\n cbasicFromList = SA.smallArrayFromList\n {-# INLINE cbasicFromList #-}\n cfromListN = SA.smallArrayFromListN\n {-# INLINE [1] cfromListN #-}\n\ninstance CFreeMonoid A.Array where\n cbasicFromList = A.fromList\n {-# INLINE cbasicFromList #-}\n cfromListN = A.fromListN\n {-# INLINE [1] cfromListN #-}\ninstance CFreeMonoid Seq.Seq where\n cbasicFromList = Seq.fromList\n {-# INLINE cbasicFromList #-}\n cfromListN = GHC.fromListN\n {-# INLINE [1] cfromListN #-}\n\ninstance MT.IsSequence mono\n => CFreeMonoid (WrapMono mono) where\n cbasicFromList = coerce $ MT.fromList @mono\n {-# INLINE cbasicFromList #-}\n cfromListN = \\n -> coerce $ MT.take (fromIntegral n) . MT.fromList @mono\n {-# INLINE [1] cfromListN #-}\n ctake = coerce . MT.take @mono . fromIntegral\n {-# INLINE [1] ctake #-}\n cdrop = coerce . MT.drop @mono . fromIntegral\n {-# INLINE [1] cdrop #-}\n ccons = coerce $ MT.cons @mono\n {-# INLINE ccons #-}\n csnoc = coerce $ MT.snoc @mono\n {-# INLINE [1] csnoc #-}\n cuncons = coerce $ MT.uncons @mono\n {-# INLINE [1] cuncons #-}\n cunsnoc = coerce $ MT.unsnoc @mono\n {-# INLINE [1] cunsnoc #-}\n ctail = coerce $ MT.tailEx @mono\n {-# INLINE [1] ctail #-}\n cinit = coerce $ MT.initEx @mono\n {-# INLINE [1] cinit #-}\n csplitAt = coerce $ \\(n :: Int) ->\n MT.splitAt @mono (fromIntegral n :: MT.Index mono)\n {-# INLINE [1] csplitAt #-}\n creplicate = coerce $ \\(n :: Int) ->\n MT.replicate @mono (fromIntegral n :: MT.Index mono)\n {-# INLINE [1] creplicate #-}\n creverse = coerce $ MT.reverse @mono\n {-# INLINE [1] creverse #-}\n cintersperse = coerce $ MT.intersperse @mono\n {-# INLINE [1] cintersperse #-}\n csort = coerce $ MT.sort @mono\n {-# INLINE [1] csort #-}\n csortBy = coerce $ MT.sortBy @mono\n {-# INLINE [1] csortBy #-}\n ctakeWhile = coerce $ MT.takeWhile @mono\n {-# INLINE [1] ctakeWhile #-}\n cdropWhile = coerce $ MT.dropWhile @mono\n {-# INLINE [1] cdropWhile #-}\n cbreak = coerce $ MT.break @mono\n {-# INLINE [1] cbreak #-}\n cspan = coerce $ MT.span @mono\n {-# INLINE [1] cspan #-}\n cfilter = coerce $ MT.filter @mono\n {-# INLINE [1] cfilter #-}\n cpartition = coerce $ MT.partition @mono\n {-# INLINE [1] cpartition #-}\n\ncctraverseFreeMonoid\n :: ( CFreeMonoid t, CApplicative f, CPointed f,\n Dom t a, Dom f (t b), Dom f b, Dom t b,\n Dom f (t b, t b)\n )\n => (a -> f b) -> t a -> f (t b)\ncctraverseFreeMonoid f =\n runCApp . cfoldMap (CApp . cmap cpure . f)\n\ncctraverseZipFreeMonoid\n :: ( CFreeMonoid t, CRepeat f,\n Dom t a, Dom f (t b), Dom f b, Dom t b,\n Dom f (t b, t b)\n )\n => (a -> f b) -> t a -> f (t b)\ncctraverseZipFreeMonoid f =\n runCZippy . cfoldMap (CZippy . cmap cpure . f)\n\n-- | Lifts 'CFoldable' along given function.\n--\n-- @\n-- cfolding :: (CFoldable t, Dom t a) => (s -> t a) -> Fold s a\n-- @\ncfolding\n :: (CFoldable t, Dom t a, Contravariant f, Applicative f)\n => (s -> t a)\n -> (a -> f a) -> s -> f s\n{-# INLINE cfolding #-}\ncfolding = \\sfa agb -> phantom . ctraverse_ agb . sfa\n", "meta": {"hexsha": "8af84911417c7424ececbe28907c80b85dc4ae76", "size": 47788, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "src/Control/Subcategory/Foldable.hs", "max_stars_repo_name": "konn/subcategories", "max_stars_repo_head_hexsha": "2ad473e09bbf674bbe3825849bad3cca7b25f4ac", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 6, "max_stars_repo_stars_event_min_datetime": "2018-07-30T19:14:49.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-16T19:19:37.000Z", "max_issues_repo_path": "src/Control/Subcategory/Foldable.hs", "max_issues_repo_name": "konn/subcategories", "max_issues_repo_head_hexsha": "2ad473e09bbf674bbe3825849bad3cca7b25f4ac", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/Control/Subcategory/Foldable.hs", "max_forks_repo_name": "konn/subcategories", "max_forks_repo_head_hexsha": "2ad473e09bbf674bbe3825849bad3cca7b25f4ac", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 29.7373988799, "max_line_length": 213, "alphanum_fraction": 0.5775089981, "num_tokens": 16026, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO\n\n", "lm_q1_score": 0.6113819874558603, "lm_q2_score": 0.49218813572079556, "lm_q1q2_score": 0.30091496061917467}} {"text": "-------------------------------------------------------------------------------\n-- |\n-- Module : Classifiers.RL.Control.MonadMWCRandom\n-- Copyright : (c) Sentenai 2017\n-- License : BSD3\n-- Maintainer: sam@sentenai.com\n-- Stability : experimental\n-- Portability: non-portable\n--\n-- typeclass to remove extraneous mwc-random functions\n-------------------------------------------------------------------------------\n{-# LANGUAGE InstanceSigs #-}\n{-# LANGUAGE DeriveFunctor #-}\n{-# LANGUAGE TupleSections #-}\n{-# LANGUAGE GeneralizedNewtypeDeriving #-}\n{-# LANGUAGE ConstraintKinds #-}\n{-# LANGUAGE FlexibleInstances #-}\n{-# LANGUAGE UndecidableInstances #-}\nmodule Control.MonadMWCRandom\n ( MonadMWCRandom(..)\n , MonadMWCRandomIO\n , MWCRand\n , MWCRandT(..)\n , runMWCRand\n , runMWCRandT\n -- * re-exports from System.Random.MWC\n , GenIO\n -- * wrappers for System.Random.MWC\n , uniform\n , uniformR\n -- * wrappers for Statistics.Distribution\n , Control.MonadMWCRandom.genContVar\n -- * extras\n , sampleFrom\n , Variate\n , _uniform\n ) where\n\nimport System.Random.MWC (GenIO, Variate)\nimport qualified System.Random.MWC as MWC\nimport qualified Statistics.Distribution as Stats\nimport Control.MonadEnv (MonadEnv(..), Obs, Initial)\nimport Control.Monad.Identity\nimport Control.Monad.IO.Class\nimport Control.Monad.Trans.Reader\nimport Control.Monad.Trans.Writer\nimport Control.Monad.Trans.State\nimport Control.Monad.Trans\nimport Control.Monad.Trans.RWS (RWST)\nimport Control.Exception.Safe\nimport Control.Monad.Primitive (PrimState, PrimMonad)\n\n-- | a convenience helper to reference the underlying System.Random.MWC function\n_uniform :: (PrimMonad m, Variate a) => MWC.Gen (PrimState m) -> m a\n_uniform = MWC.uniform\n\n-- | MonadMWCRandom for public use. FIXME: use with PrimState so that we can use ST\nclass Monad m => MonadMWCRandom m where\n getGen :: m GenIO\n\n-- | A convenience type constraint with MonadMWCRandom and MonadIO.\ntype MonadMWCRandomIO m = (MonadIO m, MonadMWCRandom m)\n\n-------------------------------------------------------------------------------\n\ninstance MonadMWCRandom m => MonadMWCRandom (StateT s m) where\n getGen :: StateT s m GenIO\n getGen = lift getGen\n\ninstance MonadMWCRandom m => MonadMWCRandom (ReaderT s m) where\n getGen :: ReaderT s m GenIO\n getGen = lift getGen\n\ninstance (Monoid w, MonadMWCRandom m) => MonadMWCRandom (WriterT w m) where\n getGen :: WriterT w m GenIO\n getGen = lift getGen\n\ninstance (Monoid w, MonadMWCRandom m) => MonadMWCRandom (RWST r w s m) where\n getGen :: RWST r w s m GenIO\n getGen = lift getGen\n\n\n-- | in the end, we can always use IO to get our generator, but we will create a\n-- new generator on each use.\ninstance MonadMWCRandom IO where\n getGen :: IO GenIO\n getGen = MWC.createSystemRandom\n\n\n-------------------------------------------------------------------------------\n\n-- | uniform referencing MonadMWCRandom's generator\nuniform :: (MonadIO m, MonadMWCRandom m, Variate a) => m a\nuniform = getGen >>= liftIO . MWC.uniform\n\n\n-- | uniformR referencing MonadMWCRandom's generator\nuniformR :: (MonadIO m, MonadMWCRandom m, Variate a) => (a, a) -> m a\nuniformR r = getGen >>= liftIO . MWC.uniformR r\n\n\n-- | genContVar referencing MonadMWCRandom's generator\ngenContVar :: (MonadIO m, MonadMWCRandom m, Stats.ContGen d) => d -> m Double\ngenContVar d = getGen >>= liftIO . Stats.genContVar d\n\n\n-- ========================================================================= --\n-- * Utility functions functions\n\n-- | Sample a single index from a list of weights, converting the list into\n-- a distribution\nsampleFrom :: (MonadIO m, MonadMWCRandom m) => [Double] -> m (Int, [Double])\nsampleFrom xs = fmap ((,dist) . choose) uniform\n where\n dist :: [Double]\n dist = fmap (/ total) xs\n\n total :: Double\n total = sum xs\n\n choose :: Double -> Int\n choose n =\n -- Return the head index (unsafeHead is safe since the last elem's snd must be 1.0)\n fst . head .\n\n -- Drop while the cumulative sum is < the given value\n dropWhile ((< n) . snd) .\n\n -- Pair each elem with its index\n zip [0..] .\n\n -- Transform list of probabilities to cumulative sum\n scanl1 (+) $ dist\n\n\n-- ========================================================================= --\n-- * A concrete type for MonadMWCRandom\n\n-- | a wrapper to share a generator without using reader\nnewtype MWCRandT m a = MWCRandT { getMWCRandT :: ReaderT GenIO m a }\n deriving (Functor, Applicative, Monad, MonadTrans, MonadThrow, MonadIO)\n\n\n-- | unwrap MonadMWCRandom\nrunMWCRandT :: MWCRandT m a -> GenIO -> m a\nrunMWCRandT = runReaderT . getMWCRandT\n\n\n-- | simple type alias for transformer-less variant\ntype MWCRand = MWCRandT Identity\n\n\n-- | run a transformerless MWC-random Monad\nrunMWCRand :: MWCRand a -> GenIO -> a\nrunMWCRand = runMWCRand\n\n\n-- | instance declaration of MonadMWCRandom for MWCRandT\ninstance Monad m => MonadMWCRandom (MWCRandT m) where\n getGen :: MWCRandT m GenIO\n getGen = MWCRandT ask\n\n\n-- | An instance which allows for an environment to hold a reference to a shared\n-- MWC-random generator\ninstance MonadEnv m s a r => MonadEnv (MWCRandT m) s a r where\n reset :: MWCRandT m (Initial s)\n reset = lift reset\n\n step :: a -> MWCRandT m (Obs r s)\n step a = lift $ step a\n", "meta": {"hexsha": "3ab07f2da02dc39185191bdf3958d0e759fcf203", "size": 5281, "ext": "hs", "lang": "Haskell", "max_stars_repo_path": "reinforce/src/Control/MonadMWCRandom.hs", "max_stars_repo_name": "juliendehos/reinforce", "max_stars_repo_head_hexsha": "f503c9b85cf20dbf7443655a5921e5aa58c94ccb", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 35, "max_stars_repo_stars_event_min_datetime": "2017-04-25T19:47:16.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-23T16:48:41.000Z", "max_issues_repo_path": "reinforce/src/Control/MonadMWCRandom.hs", "max_issues_repo_name": "sentenai/reinforce", "max_issues_repo_head_hexsha": "03fdeea14c606f4fe2390863778c99ebe1f0a7ee", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 23, "max_issues_repo_issues_event_min_datetime": "2017-03-17T21:40:34.000Z", "max_issues_repo_issues_event_max_datetime": "2020-06-26T09:58:22.000Z", "max_forks_repo_path": "reinforce/src/Control/MonadMWCRandom.hs", "max_forks_repo_name": "sentenai/reinforce", "max_forks_repo_head_hexsha": "03fdeea14c606f4fe2390863778c99ebe1f0a7ee", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 12, "max_forks_repo_forks_event_min_datetime": "2017-07-31T14:31:02.000Z", "max_forks_repo_forks_event_max_datetime": "2021-03-03T12:03:48.000Z", "avg_line_length": 30.7034883721, "max_line_length": 89, "alphanum_fraction": 0.6470365461, "num_tokens": 1379, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO\n\n", "lm_q1_score": 0.611381973294151, "lm_q2_score": 0.49218813572079556, "lm_q1q2_score": 0.3009149536489494}}