qnikst

gauss  :: [[Double]] -> [Double]
gauss  m = let (m',is) = gauss0 m
           in order is $ gauss2 $ gauss1 m

gauss0 :: [[Double]] -> ([[Double]],[Int])
gauss0 m = let (     mt,is) = foldr choose (trns m,straight) straight
           in  (trns mt,is)
    where choose k  (mt,is) = let row = m !! (k-1)
                                  q   = (+) 1 $ fromJust $ elemIndex (maximum $ init $ drop (k-1) row) row
                              in (swap' k q mt, swap' k q is)

qnikst

{-# LANGUAGE TemplateHaskell #-}
module DeriveADT 
    ( deriveExtract
    , deriveIs
    ) where

import Data.Maybe
import Data.Char

import Language.Haskell.TH

qnikst

import Data.Default
import Debug.Trace

class Magick a where
  magickStorage :: [a] -> String

instance Magick Int where
  magickStorage = const "Int"

instance Magick Char where

qnikst

{-# LANGUAGE BangPatterns #-}
module Main where

import qualified Data.ByteString as BS
import System.IO
import Control.Monad
import Data.Bits
import Data.Word
import Data.Monoid
import Network.Openflow.StrictPut

qnikst

{-# LANGUAGE BangPatterns #-}
import Control.Applicative
import Prelude hiding (minimum, sum)
import Data.List (permutations)
import Control.Monad.ST
import Data.Bifunctor (second)
-- import Control.Monad
-- import Data.Array.ST
-- import Data.Array.Unboxed
import Data.Vector.Unboxed (Vector) 

qnikst

import Data.List
import Control.Monad.ST
import Control.Monad
import Data.Array.ST
import Data.Array.Unboxed

data Exp = IfGt Int Int Block Block -- if a[i] > a[j] then blk1 else blk2
         | Swap Int Int  -- a[i] <-> a[j]  (i,j < 8)
         | Copy Int Int  -- a[i] <- a[j]  (i > 7)
         deriving Show

qnikst

{-# LANGUAGE TemplateHaskell, StandaloneDeriving, MultiParamTypeClasses, TypeFamilies, GeneralizedNewtypeDeriving #-}

import Control.Monad
import Control.Concurrent
import Control.Distributed.Process
import Control.Distributed.Process.Backend.SimpleLocalnet
import Control.Distributed.Process.Closure
import Control.Distributed.Process.Internal.Types (Process(..), LocalProcess)
import Control.Distributed.Process.Node (initRemoteTable)
import Control.Monad.Base (MonadBase(..))

qnikst

{-# LANGUAGE ExistentialQuantification #-}

-- base
import Control.Exception
import Control.Concurrent.MVar
import Control.Monad

import Data.IORef

import System.IO.Unsafe

qnikst

-- stylistic
{-# LANGUAGE LambdaCase #-}
-- singletons
{-# LANGUAGE TemplateHaskell #-}
{-# LANGUAGE Rank2Types #-}
{-# LANGUAGE GADTs #-}
-- main
{-# LANGUAGE DataKinds #-}            -- typelevel programming
{-# LANGUAGE TypeFamilies #-}         -- typelevel programming
{-# LANGUAGE ScopedTypeVariables #-}  -- typelevel programming

qnikst

{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE FunctionalDependencies #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE ExplicitNamespaces #-}
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE UndecidableInstances #-}
module Foo where